Feature Tip: Add private address tag to any address under My Name Tag !
More Info
Private Name Tags
ContractCreator
Latest 25 from a total of 4,198 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Withdraw | 18728369 | 303 days ago | IN | 0 ETH | 0.01030943 | ||||
Withdraw | 18678615 | 310 days ago | IN | 0 ETH | 0.00511748 | ||||
Withdraw | 17329987 | 499 days ago | IN | 0 ETH | 0.00781713 | ||||
Emergency Withdr... | 17326938 | 500 days ago | IN | 0 ETH | 0.00248576 | ||||
Withdraw | 16705009 | 588 days ago | IN | 0 ETH | 0.00439215 | ||||
Withdraw | 16490920 | 618 days ago | IN | 0 ETH | 0.00209476 | ||||
Withdraw | 15894006 | 701 days ago | IN | 0 ETH | 0.0018689 | ||||
Withdraw | 15797184 | 714 days ago | IN | 0 ETH | 0.00364909 | ||||
Withdraw | 15529056 | 752 days ago | IN | 0 ETH | 0.00136969 | ||||
Withdraw | 15529056 | 752 days ago | IN | 0 ETH | 0.00102055 | ||||
Deposit | 15528465 | 752 days ago | IN | 0 ETH | 0.00284305 | ||||
Withdraw | 15525390 | 753 days ago | IN | 0 ETH | 0.00199275 | ||||
Deposit | 15340144 | 782 days ago | IN | 0 ETH | 0.00206623 | ||||
Deposit | 15307526 | 788 days ago | IN | 0 ETH | 0.00497009 | ||||
Deposit | 15242520 | 798 days ago | IN | 0 ETH | 0.00057439 | ||||
Withdraw | 15198098 | 805 days ago | IN | 0 ETH | 0.00097625 | ||||
Withdraw | 15159485 | 811 days ago | IN | 0 ETH | 0.0002608 | ||||
Deposit | 15159485 | 811 days ago | IN | 0 ETH | 0.00014225 | ||||
Withdraw | 15123360 | 816 days ago | IN | 0 ETH | 0.00331016 | ||||
Deposit | 15059452 | 826 days ago | IN | 0 ETH | 0.0003689 | ||||
Deposit | 15059452 | 826 days ago | IN | 0 ETH | 0.00186798 | ||||
Withdraw | 14904607 | 853 days ago | IN | 0 ETH | 0.00763956 | ||||
Withdraw | 14902211 | 854 days ago | IN | 0 ETH | 0.00336193 | ||||
Withdraw | 14863503 | 860 days ago | IN | 0 ETH | 0.00131732 | ||||
Transfer | 14836555 | 864 days ago | IN | 0.01822337 ETH | 0.00207084 |
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
Contract Name:
SakeMasterV2
Compiler Version
v0.6.12+commit.27d51765
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2020-10-16 */ // File: @openzeppelin\contracts\token\ERC20\IERC20.sol // SPDX-License-Identifier: MIT 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: node_modules\@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: node_modules\@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: node_modules\@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: contracts\SakeToken.sol pragma solidity 0.6.12; // SakeToken with Governance. contract SakeToken is Context, IERC20, Ownable { 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 = "SakeToken"; string private _symbol = "SAKE"; uint8 private _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); _moveDelegates(_delegates[sender], _delegates[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 { } /// @notice Creates `_amount` token to `_to`. Must only be called by the owner (SakeMaster). 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), "SAKE::delegateBySig: invalid signature"); require(nonce == nonces[signatory]++, "SAKE::delegateBySig: invalid nonce"); require(now <= expiry, "SAKE::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, "SAKE::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 SAKEs (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, "SAKE::_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\SakeMasterV2.sol pragma solidity 0.6.12; // SakeMaster is the master of Sake. He can make Sake 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 SAKE is sufficiently // distributed and the community can show to govern itself. // // Have fun reading it. Hopefully it's bug-free. God bless. contract SakeMasterV2 is Ownable { using SafeMath for uint256; using SafeERC20 for IERC20; // Info of each user. struct UserInfo { uint256 amount; // How many LP tokens the user has provided. uint256 amountStoken; // How many S tokens the user has provided. uint256 amountLPtoken; // How many LP tokens the user has provided. uint256 pengdingSake; // record sake amount when user withdraw lp. uint256 rewardDebt; // Reward debt. See explanation below. uint256 lastWithdrawBlock; // user last withdraw time; // // We do some fancy math here. Basically, any point in time, the amount of SAKEs // entitled to a user but is pending to be distributed is: // // pending reward = (user.amount * pool.accSakePerShare) - user.rewardDebt // // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens: // 1. The pool's `accSakePerShare` (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. } // Info of each pool. struct PoolInfo { IERC20 lpToken; // Address of LP token contract. IERC20 sToken; // Address of S token contract. uint256 allocPoint; // How many allocation points assigned to this pool. SAKEs to distribute per block. uint256 lastRewardBlock; // Last block number that SAKEs distribution occurs. uint256 accSakePerShare; // Accumulated SAKEs per share, times 1e12. See below. uint256 multiplierSToken; // times 1e8; bool sakeLockSwitch; // true-have sake withdraw interval,default 1 months;false-no withdraw interval,but have sake withdraw fee,default 10% } // The SAKE TOKEN! SakeToken public sake; // sakeMaker address. address public sakeMaker; // admin address. address public admin; // receive sake fee address address public sakeFeeAddress; // Block number when trade mining speed up period ends. uint256 public tradeMiningSpeedUpEndBlock; // Block number when phase II yield farming period ends. uint256 public yieldFarmingIIEndBlock; // Block number when trade mining period ends. uint256 public tradeMiningEndBlock; // trade mining speed end block num,about 1 months. uint256 public tradeMiningSpeedUpEndBlockNum = 192000; // phase II yield farming end block num,about 6 months. uint256 public yieldFarmingIIEndBlockNum = 1152000; // trade mining end block num,about 12 months. uint256 public tradeMiningEndBlockNum = 2304000; // SAKE tokens created per block for phase II yield farming. uint256 public sakePerBlockYieldFarming = 5 * 10**18; // SAKE tokens created per block for trade mining. uint256 public sakePerBlockTradeMining = 10 * 10**18; // Bonus muliplier for trade mining. uint256 public constant BONUS_MULTIPLIER = 2; // withdraw block num interval,about 1 months. uint256 public withdrawInterval = 192000; // Total allocation poitns. Must be the sum of all allocation points in all pools. uint256 public totalAllocPoint = 0; // The block number when SAKE mining starts. uint256 public startBlock; // The ratio of withdraw lp fee(default is 0%) uint8 public lpFeeRatio = 0; // The ratio of withdraw sake fee if no withdraw interval(default is 10%) uint8 public sakeFeeRatio = 10; // Info of each pool. PoolInfo[] public poolInfo; // Info of each user that stakes LP tokens and S tokens. mapping(uint256 => mapping(address => UserInfo)) public userInfo; event Deposit(address indexed user, uint256 indexed pid, uint256 amountLPtoken, uint256 amountStoken); event Withdraw(address indexed user, uint256 indexed pid, uint256 amountLPtoken); event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amountLPtoken); constructor( SakeToken _sake, address _admin, address _sakeMaker, address _sakeFeeAddress, uint256 _startBlock ) public { sake = _sake; admin = _admin; sakeMaker = _sakeMaker; sakeFeeAddress = _sakeFeeAddress; startBlock = _startBlock; tradeMiningSpeedUpEndBlock = startBlock.add(tradeMiningSpeedUpEndBlockNum); yieldFarmingIIEndBlock = startBlock.add(yieldFarmingIIEndBlockNum); tradeMiningEndBlock = startBlock.add(tradeMiningEndBlockNum); } function poolLength() external view returns (uint256) { return poolInfo.length; } // XXX DO NOT add the same LP token more than once. function _checkValidity(IERC20 _lpToken, IERC20 _sToken) internal view { for (uint256 i = 0; i < poolInfo.length; i++) { require(poolInfo[i].lpToken != _lpToken && poolInfo[i].sToken != _sToken, "pool exist"); } } // Add a new lp to the pool. Can only be called by the admin. function add( uint256 _allocPoint, uint256 _multiplierSToken, IERC20 _lpToken, IERC20 _sToken, bool _withUpdate ) public { require(msg.sender == admin, "add:Call must come from admin."); if (_withUpdate) { massUpdatePools(); } _checkValidity(_lpToken, _sToken); uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock; totalAllocPoint = totalAllocPoint.add(_allocPoint); poolInfo.push( PoolInfo({ lpToken: _lpToken, sToken: _sToken, allocPoint: _allocPoint, multiplierSToken: _multiplierSToken, lastRewardBlock: lastRewardBlock, accSakePerShare: 0, sakeLockSwitch: true }) ); } // Update the given pool's SAKE allocation point. Can only be called by the admin. function set( uint256 _pid, uint256 _allocPoint, bool _withUpdate ) public { require(msg.sender == admin, "set:Call must come from admin."); if (_withUpdate) { massUpdatePools(); } totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint); poolInfo[_pid].allocPoint = _allocPoint; } function setMultiplierSToken( uint256 _pid, uint256 _multiplierSToken, bool _withUpdate ) public { require(msg.sender == admin, "sms:Call must come from admin."); if (_withUpdate) { massUpdatePools(); } poolInfo[_pid].multiplierSToken = _multiplierSToken; } // set sake withdraw switch. Can only be called by the admin. function setSakeLockSwitch( uint256 _pid, bool _sakeLockSwitch, bool _withUpdate ) public { require(msg.sender == admin, "s:Call must come from admin."); if (_withUpdate) { massUpdatePools(); } poolInfo[_pid].sakeLockSwitch = _sakeLockSwitch; } // Return reward multiplier over the given _from to _to block. function getMultiplier(uint256 _from, uint256 _to) public view returns (uint256 multipY, uint256 multipT) { uint256 _toFinalY = _to > yieldFarmingIIEndBlock ? yieldFarmingIIEndBlock : _to; uint256 _toFinalT = _to > tradeMiningEndBlock ? tradeMiningEndBlock : _to; // phase II yield farming multiplier if (_from >= yieldFarmingIIEndBlock) { multipY = 0; } else { multipY = _toFinalY.sub(_from); } // trade mining multiplier if (_from >= tradeMiningEndBlock) { multipT = 0; } else { if (_toFinalT <= tradeMiningSpeedUpEndBlock) { multipT = _toFinalT.sub(_from).mul(BONUS_MULTIPLIER); } else { if (_from < tradeMiningSpeedUpEndBlock) { multipT = tradeMiningSpeedUpEndBlock.sub(_from).mul(BONUS_MULTIPLIER).add( _toFinalT.sub(tradeMiningSpeedUpEndBlock) ); } else { multipT = _toFinalT.sub(_from); } } } } function getSakePerBlock(uint256 blockNum) public view returns (uint256) { if (blockNum <= tradeMiningSpeedUpEndBlock) { return sakePerBlockYieldFarming.add(sakePerBlockTradeMining.mul(BONUS_MULTIPLIER)); } else if (blockNum > tradeMiningSpeedUpEndBlock && blockNum <= yieldFarmingIIEndBlock) { return sakePerBlockYieldFarming.add(sakePerBlockTradeMining); } else if (blockNum > yieldFarmingIIEndBlock && blockNum <= tradeMiningEndBlock) { return sakePerBlockTradeMining; } else { return 0; } } // Handover the saketoken mintage right. function handoverSakeMintage(address newOwner) public onlyOwner { sake.transferOwnership(newOwner); } // View function to see pending SAKEs on frontend. function pendingSake(uint256 _pid, address _user) external view returns (uint256) { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][_user]; uint256 accSakePerShare = pool.accSakePerShare; uint256 lpTokenSupply = pool.lpToken.balanceOf(address(this)); uint256 sTokenSupply = pool.sToken.balanceOf(address(this)); if (block.number > pool.lastRewardBlock && lpTokenSupply != 0) { uint256 totalSupply = lpTokenSupply.add(sTokenSupply.mul(pool.multiplierSToken).div(1e8)); (uint256 multipY, uint256 multipT) = getMultiplier(pool.lastRewardBlock, block.number); uint256 sakeRewardY = multipY.mul(sakePerBlockYieldFarming).mul(pool.allocPoint).div(totalAllocPoint); uint256 sakeRewardT = multipT.mul(sakePerBlockTradeMining).mul(pool.allocPoint).div(totalAllocPoint); uint256 sakeReward = sakeRewardY.add(sakeRewardT); accSakePerShare = accSakePerShare.add(sakeReward.mul(1e12).div(totalSupply)); } return user.amount.mul(accSakePerShare).div(1e12).add(user.pengdingSake).sub(user.rewardDebt); } // Update reward vairables for all pools. Be careful of gas spending! function massUpdatePools() public { uint256 length = poolInfo.length; for (uint256 pid = 0; pid < length; ++pid) { updatePool(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 lpTokenSupply = pool.lpToken.balanceOf(address(this)); uint256 sTokenSupply = pool.sToken.balanceOf(address(this)); if (lpTokenSupply == 0) { pool.lastRewardBlock = block.number; return; } (uint256 multipY, uint256 multipT) = getMultiplier(pool.lastRewardBlock, block.number); if (multipY == 0 && multipT == 0) { pool.lastRewardBlock = block.number; return; } uint256 sakeRewardY = multipY.mul(sakePerBlockYieldFarming).mul(pool.allocPoint).div(totalAllocPoint); uint256 sakeRewardT = multipT.mul(sakePerBlockTradeMining).mul(pool.allocPoint).div(totalAllocPoint); uint256 sakeReward = sakeRewardY.add(sakeRewardT); uint256 totalSupply = lpTokenSupply.add(sTokenSupply.mul(pool.multiplierSToken).div(1e8)); if (sake.owner() == address(this)) { sake.mint(address(this), sakeRewardT); } pool.accSakePerShare = pool.accSakePerShare.add(sakeReward.mul(1e12).div(totalSupply)); pool.lastRewardBlock = block.number; } // Deposit LP tokens to SakeMasterV2 for SAKE allocation. function deposit( uint256 _pid, uint256 _amountlpToken, uint256 _amountsToken ) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; if (_amountlpToken <= 0 && user.pengdingSake == 0) { require(user.amountLPtoken > 0, "deposit:invalid"); } updatePool(_pid); uint256 pending = user.amount.mul(pool.accSakePerShare).div(1e12).add(user.pengdingSake).sub(user.rewardDebt); uint256 _originAmountStoken = user.amountStoken; user.amountLPtoken = user.amountLPtoken.add(_amountlpToken); user.amountStoken = user.amountStoken.add(_amountsToken); user.amount = user.amount.add(_amountlpToken.add(_amountsToken.mul(pool.multiplierSToken).div(1e8))); user.pengdingSake = pending; if (pool.sakeLockSwitch) { if (block.number > (user.lastWithdrawBlock.add(withdrawInterval))) { user.lastWithdrawBlock = block.number; user.pengdingSake = 0; user.amountStoken = _amountsToken; user.amount = user.amountLPtoken.add(_amountsToken.mul(pool.multiplierSToken).div(1e8)); pool.sToken.safeTransfer(address(1), _originAmountStoken); if (pending > 0) { _safeSakeTransfer(msg.sender, pending); } } } else { user.lastWithdrawBlock = block.number; user.pengdingSake = 0; if (_amountlpToken == 0 && _amountsToken == 0) { user.amountStoken = 0; user.amount = user.amountLPtoken; pool.sToken.safeTransfer(address(1), _originAmountStoken); } if (pending > 0) { uint256 sakeFee = pending.mul(sakeFeeRatio).div(100); uint256 sakeToUser = pending.sub(sakeFee); _safeSakeTransfer(msg.sender, sakeToUser); _safeSakeTransfer(sakeFeeAddress, sakeFee); } } user.rewardDebt = user.amount.mul(pool.accSakePerShare).div(1e12); pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amountlpToken); pool.sToken.safeTransferFrom(address(msg.sender), address(this), _amountsToken); emit Deposit(msg.sender, _pid, _amountlpToken, _amountsToken); } // Withdraw LP tokens from SakeMaster. function withdraw(uint256 _pid, uint256 _amountLPtoken) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; require(user.amountLPtoken >= _amountLPtoken, "withdraw: LP amount not enough"); updatePool(_pid); uint256 pending = user.amount.mul(pool.accSakePerShare).div(1e12).add(user.pengdingSake).sub(user.rewardDebt); user.amountLPtoken = user.amountLPtoken.sub(_amountLPtoken); uint256 _amountStoken = user.amountStoken; user.amountStoken = 0; user.amount = user.amountLPtoken; user.rewardDebt = user.amount.mul(pool.accSakePerShare).div(1e12); if (pool.sakeLockSwitch) { if (block.number > (user.lastWithdrawBlock.add(withdrawInterval))) { user.lastWithdrawBlock = block.number; user.pengdingSake = 0; _safeSakeTransfer(msg.sender, pending); } else { user.pengdingSake = pending; } } else { user.lastWithdrawBlock = block.number; user.pengdingSake = 0; uint256 sakeFee = pending.mul(sakeFeeRatio).div(100); uint256 sakeToUser = pending.sub(sakeFee); _safeSakeTransfer(msg.sender, sakeToUser); _safeSakeTransfer(sakeFeeAddress, sakeFee); } uint256 lpTokenFee; uint256 lpTokenToUser; if (block.number < tradeMiningEndBlock) { lpTokenFee = _amountLPtoken.mul(lpFeeRatio).div(100); pool.lpToken.safeTransfer(sakeMaker, lpTokenFee); } lpTokenToUser = _amountLPtoken.sub(lpTokenFee); pool.lpToken.safeTransfer(address(msg.sender), lpTokenToUser); pool.sToken.safeTransfer(address(1), _amountStoken); emit Withdraw(msg.sender, _pid, lpTokenToUser); } // Withdraw without caring about rewards. EMERGENCY ONLY. function emergencyWithdraw(uint256 _pid) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; require(user.amountLPtoken > 0, "withdraw: LP amount not enough"); uint256 _amountLPtoken = user.amountLPtoken; uint256 _amountStoken = user.amountStoken; user.amount = 0; user.amountLPtoken = 0; user.amountStoken = 0; user.rewardDebt = 0; uint256 lpTokenFee; uint256 lpTokenToUser; if (block.number < tradeMiningEndBlock) { lpTokenFee = _amountLPtoken.mul(lpFeeRatio).div(100); pool.lpToken.safeTransfer(sakeMaker, lpTokenFee); } lpTokenToUser = _amountLPtoken.sub(lpTokenFee); pool.lpToken.safeTransfer(address(msg.sender), lpTokenToUser); pool.sToken.safeTransfer(address(1), _amountStoken); emit EmergencyWithdraw(msg.sender, _pid, lpTokenToUser); } // Safe sake transfer function, just in case if rounding error causes pool to not have enough SAKEs. function _safeSakeTransfer(address _to, uint256 _amount) internal { uint256 sakeBal = sake.balanceOf(address(this)); if (_amount > sakeBal) { sake.transfer(_to, sakeBal); } else { sake.transfer(_to, _amount); } } // Update admin address by owner. function setAdmin(address _adminaddr) public onlyOwner { require(_adminaddr != address(0), "invalid address"); admin = _adminaddr; } // Update sakeMaker address by admin. function setSakeMaker(address _sakeMaker) public { require(msg.sender == admin, "sm:Call must come from admin."); require(_sakeMaker != address(0), "invalid address"); sakeMaker = _sakeMaker; } // Update sakeFee address by admin. function setSakeFeeAddress(address _sakeFeeAddress) public { require(msg.sender == admin, "sf:Call must come from admin."); require(_sakeFeeAddress != address(0), "invalid address"); sakeFeeAddress = _sakeFeeAddress; } // update tradeMiningSpeedUpEndBlock by owner function setTradeMiningSpeedUpEndBlock(uint256 _endBlock) public { require(msg.sender == admin, "tmsu:Call must come from admin."); require(_endBlock > startBlock, "invalid endBlock"); tradeMiningSpeedUpEndBlock = _endBlock; } // update yieldFarmingIIEndBlock by owner function setYieldFarmingIIEndBlock(uint256 _endBlock) public { require(msg.sender == admin, "yf:Call must come from admin."); require(_endBlock > startBlock, "invalid endBlock"); yieldFarmingIIEndBlock = _endBlock; } // update tradeMiningEndBlock by owner function setTradeMiningEndBlock(uint256 _endBlock) public { require(msg.sender == admin, "tm:Call must come from admin."); require(_endBlock > startBlock, "invalid endBlock"); tradeMiningEndBlock = _endBlock; } function setSakeFeeRatio(uint8 newRatio) public { require(msg.sender == admin, "sfr:Call must come from admin."); require(newRatio >= 0 && newRatio <= 100, "invalid ratio"); sakeFeeRatio = newRatio; } function setLpFeeRatio(uint8 newRatio) public { require(msg.sender == admin, "lp:Call must come from admin."); require(newRatio >= 0 && newRatio <= 100, "invalid ratio"); lpFeeRatio = newRatio; } function setWithdrawInterval(uint256 _blockNum) public { require(msg.sender == admin, "i:Call must come from admin."); withdrawInterval = _blockNum; } // set sakePerBlock phase II yield farming function setSakePerBlockYieldFarming(uint256 _sakePerBlockYieldFarming, bool _withUpdate) public { require(msg.sender == admin, "yield:Call must come from admin."); if (_withUpdate) { massUpdatePools(); } sakePerBlockYieldFarming = _sakePerBlockYieldFarming; } // set sakePerBlock trade mining function setSakePerBlockTradeMining(uint256 _sakePerBlockTradeMining, bool _withUpdate) public { require(msg.sender == admin, "trade:Call must come from admin."); if (_withUpdate) { massUpdatePools(); } sakePerBlockTradeMining = _sakePerBlockTradeMining; } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"contract SakeToken","name":"_sake","type":"address"},{"internalType":"address","name":"_admin","type":"address"},{"internalType":"address","name":"_sakeMaker","type":"address"},{"internalType":"address","name":"_sakeFeeAddress","type":"address"},{"internalType":"uint256","name":"_startBlock","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":"amountLPtoken","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amountStoken","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":"amountLPtoken","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":"amountLPtoken","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"BONUS_MULTIPLIER","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"uint256","name":"_multiplierSToken","type":"uint256"},{"internalType":"contract IERC20","name":"_lpToken","type":"address"},{"internalType":"contract IERC20","name":"_sToken","type":"address"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"add","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"admin","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amountlpToken","type":"uint256"},{"internalType":"uint256","name":"_amountsToken","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":"_from","type":"uint256"},{"internalType":"uint256","name":"_to","type":"uint256"}],"name":"getMultiplier","outputs":[{"internalType":"uint256","name":"multipY","type":"uint256"},{"internalType":"uint256","name":"multipT","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"blockNum","type":"uint256"}],"name":"getSakePerBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"handoverSakeMintage","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"lpFeeRatio","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"massUpdatePools","outputs":[],"stateMutability":"nonpayable","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":"pendingSake","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":"contract IERC20","name":"sToken","type":"address"},{"internalType":"uint256","name":"allocPoint","type":"uint256"},{"internalType":"uint256","name":"lastRewardBlock","type":"uint256"},{"internalType":"uint256","name":"accSakePerShare","type":"uint256"},{"internalType":"uint256","name":"multiplierSToken","type":"uint256"},{"internalType":"bool","name":"sakeLockSwitch","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":[],"name":"sake","outputs":[{"internalType":"contract SakeToken","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"sakeFeeAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"sakeFeeRatio","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"sakeMaker","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"sakePerBlockTradeMining","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"sakePerBlockYieldFarming","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","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":"_adminaddr","type":"address"}],"name":"setAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint8","name":"newRatio","type":"uint8"}],"name":"setLpFeeRatio","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_multiplierSToken","type":"uint256"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"setMultiplierSToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_sakeFeeAddress","type":"address"}],"name":"setSakeFeeAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint8","name":"newRatio","type":"uint8"}],"name":"setSakeFeeRatio","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"bool","name":"_sakeLockSwitch","type":"bool"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"setSakeLockSwitch","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_sakeMaker","type":"address"}],"name":"setSakeMaker","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_sakePerBlockTradeMining","type":"uint256"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"setSakePerBlockTradeMining","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_sakePerBlockYieldFarming","type":"uint256"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"setSakePerBlockYieldFarming","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_endBlock","type":"uint256"}],"name":"setTradeMiningEndBlock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_endBlock","type":"uint256"}],"name":"setTradeMiningSpeedUpEndBlock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_blockNum","type":"uint256"}],"name":"setWithdrawInterval","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_endBlock","type":"uint256"}],"name":"setYieldFarmingIIEndBlock","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":[],"name":"tradeMiningEndBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tradeMiningEndBlockNum","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tradeMiningSpeedUpEndBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tradeMiningSpeedUpEndBlockNum","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":"","type":"uint256"},{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"amountStoken","type":"uint256"},{"internalType":"uint256","name":"amountLPtoken","type":"uint256"},{"internalType":"uint256","name":"pengdingSake","type":"uint256"},{"internalType":"uint256","name":"rewardDebt","type":"uint256"},{"internalType":"uint256","name":"lastWithdrawBlock","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amountLPtoken","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawInterval","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"yieldFarmingIIEndBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"yieldFarmingIIEndBlockNum","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","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)
000000000000000000000000066798d9ef0833ccc719076dab77199ecbd178b0000000000000000000000000142151d3b15b8961f2937cf7880bcd10c050800c000000000000000000000000ea3978b82419d5671c14aa6151b7e92fc0b1fd220000000000000000000000005fe808a4889b714496e7b821c8542e26be2f8f670000000000000000000000000000000000000000000000000000000000a8ec88
-----Decoded View---------------
Arg [0] : _sake (address): 0x066798d9ef0833ccc719076Dab77199eCbd178b0
Arg [1] : _admin (address): 0x142151D3b15b8961F2937Cf7880Bcd10c050800C
Arg [2] : _sakeMaker (address): 0xEa3978b82419D5671C14aa6151B7E92fc0b1Fd22
Arg [3] : _sakeFeeAddress (address): 0x5fe808a4889b714496E7b821c8542e26be2f8f67
Arg [4] : _startBlock (uint256): 11070600
-----Encoded View---------------
5 Constructor Arguments found :
Arg [0] : 000000000000000000000000066798d9ef0833ccc719076dab77199ecbd178b0
Arg [1] : 000000000000000000000000142151d3b15b8961f2937cf7880bcd10c050800c
Arg [2] : 000000000000000000000000ea3978b82419d5671c14aa6151b7e92fc0b1fd22
Arg [3] : 0000000000000000000000005fe808a4889b714496e7b821c8542e26be2f8f67
Arg [4] : 0000000000000000000000000000000000000000000000000000000000a8ec88
Deployed Bytecode Sourcemap
48313:21137:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;60543:2435;;;;;;;;;;;;;;;;-1:-1:-1;60543:2435:0;;;;;;;;;;;;:::i;:::-;;51145:52;;;:::i;:::-;;;;;;;;;;;;;;;;52992:95;;;:::i;51260:52::-;;;:::i;51953:26::-;;;;;;;;;;;;;;;;-1:-1:-1;51953:26:0;;:::i;:::-;;;;-1:-1:-1;;;;;51953:26:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51464:40;;;:::i;51599:34::-;;;:::i;55285:330::-;;;;;;;;;;;;;;;;-1:-1:-1;55285:330:0;;;;;;;;;;;;;;;;:::i;56829:596::-;;;;;;;;;;;;;;;;-1:-1:-1;56829:596:0;;:::i;54867:343::-;;;;;;;;;;;;;;;;-1:-1:-1;54867:343:0;;;;;;;;;;;;;;:::i;51887:30::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;68548:173;;;;;;;;;;;;;;;;-1:-1:-1;68548:173:0;;:::i;68073:232::-;;;;;;;;;;;;;;;;-1:-1:-1;68073:232:0;;;;:::i;63030:1899::-;;;;;;;;;;;;;;;;-1:-1:-1;63030:1899:0;;;;;;;:::i;50795:53::-;;;:::i;51690:25::-;;;:::i;68777:314::-;;;;;;;;;;;;;;;;-1:-1:-1;68777:314:0;;;;;;;;;:::i;59171:1301::-;;;;;;;;;;;;;;;;-1:-1:-1;59171:1301:0;;:::i;65000:981::-;;;;;;;;;;;;;;;;-1:-1:-1;65000:981:0;;:::i;67210:258::-;;;;;;;;;;;;;;;;-1:-1:-1;67210:258:0;;:::i;58915:180::-;;;:::i;54458:401::-;;;;;;;;;;;;;;;;-1:-1:-1;54458:401:0;;;;;;;;;;;;;;:::i;50280:24::-;;;:::i;:::-;;;;-1:-1:-1;;;;;50280:24:0;;;;;;;;;;;;;;66421:155;;;;;;;;;;;;;;;;-1:-1:-1;66421:155:0;-1:-1:-1;;;;;66421:155:0;;:::i;28986:148::-;;;:::i;50601:37::-;;;:::i;67823:242::-;;;;;;;;;;;;;;;;-1:-1:-1;67823:242:0;;:::i;51361:44::-;;;:::i;28344:79::-;;;:::i;55691:1130::-;;;;;;;;;;;;;;;;-1:-1:-1;55691:1130:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;52048:64;;;;;;;;;;;;;;;;-1:-1:-1;52048:64:0;;;;;;-1:-1:-1;;;;;52048:64:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57479:115;;;;;;;;;;;;;;;;-1:-1:-1;57479:115:0;-1:-1:-1;;;;;57479:115:0;;:::i;50225:21::-;;;:::i;50916:50::-;;;:::i;50394:29::-;;;:::i;66901:250::-;;;;;;;;;;;;;;;;-1:-1:-1;66901:250:0;-1:-1:-1;;;;;66901:250:0;;:::i;68313:227::-;;;;;;;;;;;;;;;;-1:-1:-1;68313:227:0;;;;:::i;50697:34::-;;;:::i;50491:41::-;;;:::i;57658:1174::-;;;;;;;;;;;;;;;;-1:-1:-1;57658:1174:0;;;;;;-1:-1:-1;;;;;57658:1174:0;;:::i;53476:886::-;;;;;;;;;;;;;;;;-1:-1:-1;53476:886:0;;;;;;;;-1:-1:-1;;;;;53476:886:0;;;;;;;;;;;;;;;;;;;;;:::i;29289:244::-;;;;;;;;;;;;;;;;-1:-1:-1;29289:244:0;-1:-1:-1;;;;;29289:244:0;;:::i;51774:27::-;;;:::i;67523:248::-;;;;;;;;;;;;;;;;-1:-1:-1;67523:248:0;;:::i;50334:20::-;;;:::i;66627:225::-;;;;;;;;;;;;;;;;-1:-1:-1;66627:225:0;-1:-1:-1;;;;;66627:225:0;;:::i;69137:310::-;;;;;;;;;;;;;;;;-1:-1:-1;69137:310:0;;;;;;;;;:::i;51025:47::-;;;:::i;60543:2435::-;60673:21;60697:8;60706:4;60697:14;;;;;;;;;;;;;;;;60746;;;:8;:14;;;;;;60761:10;60746:26;;;;;;;60697:14;;;;;;;;-1:-1:-1;60787:19:0;;;;:45;;-1:-1:-1;60810:17:0;;;;:22;60787:45;60783:128;;;60878:1;60857:4;:18;;;:22;60849:50;;;;;-1:-1:-1;;;60849:50:0;;;;;;;;;;;;-1:-1:-1;;;60849:50:0;;;;;;;;;;;;;;;60921:16;60932:4;60921:10;:16::i;:::-;60948:15;60966:91;61041:4;:15;;;60966:70;61018:4;:17;;;60966:47;61008:4;60966:37;60982:4;:20;;;60966:4;:11;;;:15;;:37;;;;:::i;:::-;:41;;:47::i;:::-;:51;;:70::i;:::-;:74;;:91::i;:::-;61098:17;;;;61147:18;;;;60948:109;;-1:-1:-1;61098:17:0;61147:38;;61170:14;61147:22;:38::i;:::-;61126:18;;;:59;61216:17;;;;:36;;61238:13;61216:21;:36::i;:::-;61196:4;:17;;:56;;;;61277:86;61293:69;61312:49;61357:3;61312:40;61330:4;:21;;;61312:13;:17;;:40;;;;:::i;:49::-;61293:14;;:18;:69::i;:::-;61277:11;;;:15;:86::i;:::-;61263:100;;61374:17;;;:27;;;61416:19;;;;;;61412:1229;;;61499:16;;61472:22;;;;:44;;:26;:44::i;:::-;61456:12;:61;61452:529;;;61563:12;61538:22;;;;:37;;;;61614:1;61594:17;;;:21;61634:17;;;:33;;;61741:21;;;61700:73;;61723:49;;61768:3;;61723:40;;61654:13;;61723:17;:40::i;:49::-;61700:18;;;;;:22;:73::i;:::-;61686:87;;61825:1;61792:11;;;;:57;;-1:-1:-1;;;;;61792:11:0;;;;61829:19;61792:24;:57::i;:::-;61872:11;;61868:98;;61908:38;61926:10;61938:7;61908:17;:38::i;:::-;61412:1229;;;62038:12;62013:22;;;:37;62085:1;62065:17;;;:21;62105:19;;:41;;;;-1:-1:-1;62128:18:0;;62105:41;62101:230;;;62187:1;62167:17;;;;:21;;;;62221:18;;;;62207:32;;62258:11;;;;:57;;-1:-1:-1;;;;;62258:11:0;;;;62295:19;62258:24;:57::i;:::-;62349:11;;62345:285;;62411:12;;62381:15;;62399:34;;62429:3;;62399:25;;:7;;62411:12;;;;;62399:11;:25::i;:34::-;62381:52;-1:-1:-1;62452:18:0;62473:20;:7;62381:52;62473:11;:20::i;:::-;62452:41;;62512;62530:10;62542;62512:17;:41::i;:::-;62590:14;;62572:42;;-1:-1:-1;;;;;62590:14:0;62606:7;62572:17;:42::i;:::-;62345:285;;;62685:20;;;;62669:11;;:47;;62711:4;;62669:37;;:15;:37::i;:47::-;62651:15;;;:65;62727:12;;:81;;-1:-1:-1;;;;;62727:12:0;62765:10;62786:4;62793:14;62727:29;:81::i;:::-;62819:11;;;;:79;;-1:-1:-1;;;;;62819:11:0;62856:10;62877:4;62884:13;62819:28;:79::i;:::-;62914:56;;;;;;;;;;;;;;62934:4;;62922:10;;62914:56;;;;;;;;;;;60543:2435;;;;;;;:::o;51145:52::-;;;;:::o;52992:95::-;53064:8;:15;52992:95;:::o;51260:52::-;;;;:::o;51953:26::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;51953:26:0;;;;-1:-1:-1;51953:26:0;;;;;;;;;;;;;;:::o;51464:40::-;;;;:::o;51599:34::-;;;;:::o;55285:330::-;55440:5;;-1:-1:-1;;;;;55440:5:0;55426:10;:19;55418:60;;;;;-1:-1:-1;;;55418:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;55493:11;55489:61;;;55521:17;:15;:17::i;:::-;55592:15;55560:8;55569:4;55560:14;;;;;;;;;;;;;;;;;;;;;:29;;:47;;-1:-1:-1;;55560:47:0;;;;;;;;;;-1:-1:-1;;;55285:330:0:o;56829:596::-;56893:7;56929:26;;56917:8;:38;56913:505;;57008:23;;56979:75;;57008:45;;51404:1;57008:27;:45::i;:::-;56979:24;;;:28;:75::i;:::-;56972:82;;;;56913:505;57087:26;;57076:8;:37;:75;;;;;57129:22;;57117:8;:34;;57076:75;57072:346;;;57204:23;;57175:24;;:53;;:28;:53::i;57072:346::-;57261:22;;57250:8;:33;:68;;;;;57299:19;;57287:8;:31;;57250:68;57246:172;;;-1:-1:-1;57342:23:0;;57335:30;;57246:172;-1:-1:-1;57405:1:0;57246:172;56829:596;;;:::o;54867:343::-;55029:5;;-1:-1:-1;;;;;55029:5:0;55015:10;:19;55007:62;;;;;-1:-1:-1;;;55007:62:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;55084:11;55080:61;;;55112:17;:15;:17::i;:::-;55185;55151:8;55160:4;55151:14;;;;;;;;;;;;;;;;;;:31;;:51;;;;54867:343;;;:::o;51887:30::-;;;;;;;;;:::o;68548:173::-;68636:5;;-1:-1:-1;;;;;68636:5:0;68622:10;:19;68614:60;;;;;-1:-1:-1;;;68614:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;68685:16;:28;68548:173::o;68073:232::-;68154:5;;-1:-1:-1;;;;;68154:5:0;68140:10;:19;68132:62;;;;;-1:-1:-1;;;68132:62:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;68242:3;68230:8;:15;;;;68205:58;;;;;-1:-1:-1;;;68205:58:0;;;;;;;;;;;;-1:-1:-1;;;68205:58:0;;;;;;;;;;;;;;;68274:12;:23;;;;;;;;-1:-1:-1;;68274:23:0;;;;;;;;;68073:232::o;63030:1899::-;63104:21;63128:8;63137:4;63128:14;;;;;;;;;;;;;;;;63177;;;:8;:14;;;;;;63192:10;63177:26;;;;;;;63222:18;;;;63128:14;;;;;;;;-1:-1:-1;63222:36:0;-1:-1:-1;63222:36:0;63214:79;;;;;-1:-1:-1;;;63214:79:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;63304:16;63315:4;63304:10;:16::i;:::-;63331:15;63349:91;63424:4;:15;;;63349:70;63401:4;:17;;;63349:47;63391:4;63349:37;63365:4;:20;;;63349:4;:11;;;:15;;:37;;;;:::i;:91::-;63472:18;;;;63331:109;;-1:-1:-1;63472:38:0;;63495:14;63472:22;:38::i;:::-;63451:18;;;:59;;;63545:17;;;;;63521:21;63573;;;63605:32;;;63682:20;;;;63545:17;;63666:47;;63708:4;;63666:37;;:15;:37::i;:47::-;63648:15;;;:65;63728:19;;;;;;63724:697;;;63811:16;;63784:22;;;;:44;;:26;:44::i;:::-;63768:12;:61;63764:304;;;63875:12;63850:22;;;:37;63926:1;63906:17;;;:21;63946:38;63964:10;63976:7;63946:17;:38::i;:::-;63764:304;;;64025:17;;;:27;;;63764:304;63724:697;;;64125:12;64100:22;;;:37;64172:1;64152:17;;;:21;;;64218:12;;64206:34;;64236:3;;64206:25;;:7;;64218:12;;;;;64206:11;:25::i;:34::-;64188:52;-1:-1:-1;64255:18:0;64276:20;:7;64188:52;64276:11;:20::i;:::-;64255:41;;64311;64329:10;64341;64311:17;:41::i;:::-;64385:14;;64367:42;;-1:-1:-1;;;;;64385:14:0;64401:7;64367:17;:42::i;:::-;63724:697;;;64431:18;64460:21;64511:19;;64496:12;:34;64492:182;;;64579:10;;64560:39;;64595:3;;64560:30;;:14;;64579:10;;64560:18;:30::i;:39::-;64640:9;;64614:12;;64547:52;;-1:-1:-1;64614:48:0;;-1:-1:-1;;;;;64614:12:0;;;;64640:9;64547:52;64614:25;:48::i;:::-;64700:30;:14;64719:10;64700:18;:30::i;:::-;64741:12;;64684:46;;-1:-1:-1;64741:61:0;;-1:-1:-1;;;;;64741:12:0;64775:10;64684:46;64741:25;:61::i;:::-;64846:1;64813:11;;;;:51;;-1:-1:-1;;;;;64813:11:0;;;;64850:13;64813:24;:51::i;:::-;64880:41;;;;;;;;64901:4;;64889:10;;64880:41;;;;;;;;;63030:1899;;;;;;;;:::o;50795:53::-;;;;:::o;51690:25::-;;;;:::o;68777:314::-;68907:5;;-1:-1:-1;;;;;68907:5:0;68893:10;:19;68885:64;;;;;-1:-1:-1;;;68885:64:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;68964:11;68960:61;;;68992:17;:15;:17::i;:::-;-1:-1:-1;69031:24:0;:52;68777:314::o;59171:1301::-;59223:21;59247:8;59256:4;59247:14;;;;;;;;;;;;;;;;;;59223:38;;59292:4;:20;;;59276:12;:36;59272:75;;59329:7;;;59272:75;59381:12;;:37;;;-1:-1:-1;;;59381:37:0;;59412:4;59381:37;;;;;;59357:21;;-1:-1:-1;;;;;59381:12:0;;:22;;:37;;;;;;;;;;;;;;:12;:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;59381:37:0;59452:11;;;;:36;;;-1:-1:-1;;;59452:36:0;;59482:4;59452:36;;;;;;59381:37;;-1:-1:-1;59429:20:0;;-1:-1:-1;;;;;59452:11:0;;;;:21;;:36;;;;;59381:37;;59452:36;;;;;;;;:11;:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;59452:36:0;;-1:-1:-1;59503:18:0;59499:107;;-1:-1:-1;;59561:12:0;59538:20;;;;:35;59588:7;;59499:107;59617:15;59634;59653:49;59667:4;:20;;;59689:12;59653:13;:49::i;:::-;59616:86;;;;59717:7;59728:1;59717:12;:28;;;;-1:-1:-1;59733:12:0;;59717:28;59713:117;;;59785:12;59762:4;:20;;:35;;;;59812:7;;;;;;;59713:117;59840:19;59862:79;59925:15;;59862:58;59904:4;:15;;;59862:37;59874:24;;59862:7;:11;;:37;;;;:::i;:::-;:41;;:58::i;:79::-;59840:101;;59952:19;59974:78;60036:15;;59974:57;60015:4;:15;;;59974:36;59986:23;;59974:7;:11;;:36;;;;:::i;:78::-;59952:100;-1:-1:-1;60063:18:0;60084:28;:11;59952:100;60084:15;:28::i;:::-;60063:49;;60123:19;60145:67;60163:48;60207:3;60163:39;60180:4;:21;;;60163:12;:16;;:39;;;;:::i;:48::-;60145:13;;:17;:67::i;:::-;60123:89;;60251:4;-1:-1:-1;;;;;60227:29:0;:4;;;;;;;;;-1:-1:-1;;;;;60227:4:0;-1:-1:-1;;;;;60227:10:0;;:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;60227:12:0;-1:-1:-1;;;;;60227:29:0;;60223:99;;;60273:4;;:37;;;-1:-1:-1;;;60273:37:0;;60291:4;60273:37;;;;;;;;;;;;-1:-1:-1;;;;;60273:4:0;;;;:9;;:37;;;;;:4;;:37;;;;;;;;:4;;:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;60223:99;60355:63;60380:37;60405:11;60380:20;:10;60395:4;60380:14;:20::i;:37::-;60355:20;;;;;:24;:63::i;:::-;60332:20;;;:86;-1:-1:-1;;60452:12:0;60429:20;;;;:35;;;;-1:-1:-1;;;;;;59171:1301:0;;:::o;65000:981::-;65059:21;65083:8;65092:4;65083:14;;;;;;;;;;;;;;;;65132;;;:8;:14;;;;;;65147:10;65132:26;;;;;;;65177:18;;;;65083:14;;;;;;;;-1:-1:-1;65169:65:0;;;;;-1:-1:-1;;;65169:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;65270:18;;;;;65323:17;;;;;65245:22;65351:15;;;65377:22;;;;65410:21;;;;65442:15;;;:19;;;65554;;65270:18;;65323:17;;65245:22;;65539:12;:34;65535:182;;;65622:10;;65603:39;;65638:3;;65603:30;;:14;;65622:10;;65603:18;:30::i;:39::-;65683:9;;65657:12;;65590:52;;-1:-1:-1;65657:48:0;;-1:-1:-1;;;;;65657:12:0;;;;65683:9;65590:52;65657:25;:48::i;:::-;65743:30;:14;65762:10;65743:18;:30::i;:::-;65784:12;;65727:46;;-1:-1:-1;65784:61:0;;-1:-1:-1;;;;;65784:12:0;65818:10;65727:46;65784:25;:61::i;:::-;65889:1;65856:11;;;;:51;;-1:-1:-1;;;;;65856:11:0;;;;65893:13;65856:24;:51::i;:::-;65923:50;;;;;;;;65953:4;;65941:10;;65923:50;;;;;;;;;65000:981;;;;;;;:::o;67210:258::-;67308:5;;-1:-1:-1;;;;;67308:5:0;67294:10;:19;67286:63;;;;;-1:-1:-1;;;67286:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;67380:10;;67368:9;:22;67360:51;;;;;-1:-1:-1;;;67360:51:0;;;;;;;;;;;;-1:-1:-1;;;67360:51:0;;;;;;;;;;;;;;;67422:26;:38;67210:258::o;58915:180::-;58977:8;:15;58960:14;59003:85;59031:6;59025:3;:12;59003:85;;;59061:15;59072:3;59061:10;:15::i;:::-;59039:5;;59003:85;;;;58915:180;:::o;54458:401::-;54598:5;;-1:-1:-1;;;;;54598:5:0;54584:10;:19;54576:62;;;;;-1:-1:-1;;;54576:62:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;54653:11;54649:61;;;54681:17;:15;:17::i;:::-;54738:63;54789:11;54738:46;54758:8;54767:4;54758:14;;;;;;;;;;;;;;;;;;:25;;;54738:15;;:19;;:46;;;;:::i;:63::-;54720:15;:81;;;;54840:11;54812:8;54821:4;54812:14;;;;;;;;;;;;;;;;;;:25;;:39;;;;54458:401;;;:::o;50280:24::-;;;-1:-1:-1;;;;;50280:24:0;;:::o;66421:155::-;28566:12;:10;:12::i;:::-;28556:6;;-1:-1:-1;;;;;28556:6:0;;;:22;;;28548:67;;;;;-1:-1:-1;;;28548:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;28548:67:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;66495:24:0;::::1;66487:52;;;::::0;;-1:-1:-1;;;66487:52:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;66487:52:0;;;;;;;;;;;;;::::1;;66550:5;:18:::0;;-1:-1:-1;;;;;;66550:18:0::1;-1:-1:-1::0;;;;;66550:18:0;;;::::1;::::0;;;::::1;::::0;;66421:155::o;28986:148::-;28566:12;:10;:12::i;:::-;28556:6;;-1:-1:-1;;;;;28556:6:0;;;:22;;;28548:67;;;;;-1:-1:-1;;;28548:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;28548:67:0;;;;;;;;;;;;;;;29093:1:::1;29077:6:::0;;29056:40:::1;::::0;-1:-1:-1;;;;;29077:6:0;;::::1;::::0;29056:40:::1;::::0;29093:1;;29056:40:::1;29124:1;29107:19:::0;;-1:-1:-1;;;;;;29107:19:0::1;::::0;;28986:148::o;50601:37::-;;;;:::o;67823:242::-;67914:5;;-1:-1:-1;;;;;67914:5:0;67900:10;:19;67892:61;;;;;-1:-1:-1;;;67892:61:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;67984:10;;67972:9;:22;67964:51;;;;;-1:-1:-1;;;67964:51:0;;;;;;;;;;;;-1:-1:-1;;;67964:51:0;;;;;;;;;;;;;;;68026:19;:31;67823:242::o;51361:44::-;51404:1;51361:44;:::o;28344:79::-;28382:7;28409:6;-1:-1:-1;;;;;28409:6:0;28344:79;:::o;55691:1130::-;55763:15;55780;55808:17;55834:22;;55828:3;:28;:59;;55884:3;55828:59;;;55859:22;;55828:59;55808:79;;55898:17;55924:19;;55918:3;:25;:53;;55968:3;55918:53;;;55946:19;;55918:53;55898:73;;56041:22;;56032:5;:31;56028:138;;56090:1;56080:11;;56028:138;;;56134:20;:9;56148:5;56134:13;:20::i;:::-;56124:30;;56028:138;56225:19;;56216:5;:28;56212:602;;56271:1;56261:11;;56212:602;;;56322:26;;56309:9;:39;56305:498;;56379:42;51404:1;56379:20;:9;56393:5;56379:13;:20::i;:42::-;56369:52;;56305:498;;;56474:26;;56466:5;:34;56462:326;;;56535:154;56625:41;56639:26;;56625:9;:13;;:41;;;;:::i;:::-;56535:59;51404:1;56535:37;56566:5;56535:26;;:30;;:37;;;;:::i;56462:326::-;56748:20;:9;56762:5;56748:13;:20::i;:::-;56738:30;;56462:326;55691:1130;;;;;;;:::o;52048:64::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;57479:115::-;28566:12;:10;:12::i;:::-;28556:6;;-1:-1:-1;;;;;28556:6:0;;;:22;;;28548:67;;;;;-1:-1:-1;;;28548:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;28548:67:0;;;;;;;;;;;;;;;57554:4:::1;::::0;:32:::1;::::0;;-1:-1:-1;;;57554:32:0;;-1:-1:-1;;;;;57554:32:0;;::::1;;::::0;::::1;::::0;;;:4;;;::::1;::::0;:22:::1;::::0;:32;;;;;:4:::1;::::0;:32;;;;;;;:4;;:32;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;57479:115:::0;:::o;50225:21::-;;;-1:-1:-1;;;;;50225:21:0;;:::o;50916:50::-;;;;:::o;50394:29::-;;;-1:-1:-1;;;;;50394:29:0;;:::o;66901:250::-;66993:5;;-1:-1:-1;;;;;66993:5:0;66979:10;:19;66971:61;;;;;-1:-1:-1;;;66971:61:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;67051:29:0;;67043:57;;;;;-1:-1:-1;;;67043:57:0;;;;;;;;;;;;-1:-1:-1;;;67043:57:0;;;;;;;;;;;;;;;67111:14;:32;;-1:-1:-1;;;;;;67111:32:0;-1:-1:-1;;;;;67111:32:0;;;;;;;;;;66901:250::o;68313:227::-;68392:5;;-1:-1:-1;;;;;68392:5:0;68378:10;:19;68370:61;;;;;-1:-1:-1;;;68370:61:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;68479:3;68467:8;:15;;;;68442:58;;;;;-1:-1:-1;;;68442:58:0;;;;;;;;;;;;-1:-1:-1;;;68442:58:0;;;;;;;;;;;;;;;68511:10;:21;;-1:-1:-1;;68511:21:0;;;;;;;;;;;;68313:227::o;50697:34::-;;;;:::o;50491:41::-;;;;:::o;57658:1174::-;57731:7;57751:21;57775:8;57784:4;57775:14;;;;;;;;;;;;;;;;57824;;;:8;:14;;;;;;-1:-1:-1;;;;;57824:21:0;;;;;;;;;;;57775:14;;;;;;;;57882:20;;;;;57937:12;;:37;;-1:-1:-1;;;57937:37:0;;57968:4;57937:37;;;;;;;;;57775:14;;-1:-1:-1;57824:21:0;;57775:14;57937:12;;;;;:22;;:37;;;;;57775:14;;57937:37;;;;;:12;:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;57937:37:0;58008:11;;;;:36;;;-1:-1:-1;;;58008:36:0;;58038:4;58008:36;;;;;;57937:37;;-1:-1:-1;57985:20:0;;-1:-1:-1;;;;;58008:11:0;;;;:21;;:36;;;;;57937:37;;58008:36;;;;;;;;:11;:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;58008:36:0;58074:20;;;;58008:36;;-1:-1:-1;58059:12:0;:35;:57;;;;-1:-1:-1;58098:18:0;;;58059:57;58055:666;;;58133:19;58155:67;58173:48;58217:3;58173:39;58190:4;:21;;;58173:12;:16;;:39;;;;:::i;:48::-;58155:13;;:17;:67::i;:::-;58133:89;;58238:15;58255;58274:49;58288:4;:20;;;58310:12;58274:13;:49::i;:::-;58237:86;;;;58338:19;58360:79;58423:15;;58360:58;58402:4;:15;;;58360:37;58372:24;;58360:7;:11;;:37;;;;:::i;:79::-;58338:101;;58454:19;58476:78;58538:15;;58476:57;58517:4;:15;;;58476:36;58488:23;;58476:7;:11;;:36;;;;:::i;:78::-;58454:100;-1:-1:-1;58569:18:0;58590:28;:11;58454:100;58590:15;:28::i;:::-;58569:49;-1:-1:-1;58651:58:0;58671:37;58696:11;58671:20;58569:49;58686:4;58671:14;:20::i;:37::-;58651:15;;:19;:58::i;:::-;58633:76;;58055:666;;;;;;;58738:86;58808:4;:15;;;58738:65;58785:4;:17;;;58738:42;58775:4;58738:32;58754:15;58738:4;:11;;;:15;;:32;;;;:::i;:86::-;58731:93;;;;;;;57658:1174;;;;;:::o;53476:886::-;53680:5;;-1:-1:-1;;;;;53680:5:0;53666:10;:19;53658:62;;;;;-1:-1:-1;;;53658:62:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;53735:11;53731:61;;;53763:17;:15;:17::i;:::-;53802:33;53817:8;53827:7;53802:14;:33::i;:::-;53846:23;53887:10;;53872:12;:25;:53;;53915:10;;53872:53;;;53900:12;53872:53;53954:15;;53846:79;;-1:-1:-1;53954:32:0;;53974:11;53954:19;:32::i;:::-;53936:15;:50;54025:318;;;;;;;;-1:-1:-1;;;;;54025:318:0;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;54025:318:0;;;;;;;;;;;;54323:4;54025:318;;;;;;53997:8;:357;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;53997:357:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;53997:357:0;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;53997:357:0;;;;;;;;;53476:886::o;29289:244::-;28566:12;:10;:12::i;:::-;28556:6;;-1:-1:-1;;;;;28556:6:0;;;:22;;;28548:67;;;;;-1:-1:-1;;;28548:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;28548:67:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;29378:22:0;::::1;29370:73;;;;-1:-1:-1::0;;;29370:73:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;29480:6;::::0;;29459:38:::1;::::0;-1:-1:-1;;;;;29459:38:0;;::::1;::::0;29480:6;::::1;::::0;29459:38:::1;::::0;::::1;29508:6;:17:::0;;-1:-1:-1;;;;;;29508:17:0::1;-1:-1:-1::0;;;;;29508:17:0;;;::::1;::::0;;;::::1;::::0;;29289:244::o;51774:27::-;;;;;;:::o;67523:248::-;67617:5;;-1:-1:-1;;;;;67617:5:0;67603:10;:19;67595:61;;;;;-1:-1:-1;;;67595:61:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;67687:10;;67675:9;:22;67667:51;;;;;-1:-1:-1;;;67667:51:0;;;;;;;;;;;;-1:-1:-1;;;67667:51:0;;;;;;;;;;;;;;;67729:22;:34;67523:248::o;50334:20::-;;;-1:-1:-1;;;;;50334:20:0;;:::o;66627:225::-;66709:5;;-1:-1:-1;;;;;66709:5:0;66695:10;:19;66687:61;;;;;-1:-1:-1;;;66687:61:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;66767:24:0;;66759:52;;;;;-1:-1:-1;;;66759:52:0;;;;;;;;;;;;-1:-1:-1;;;66759:52:0;;;;;;;;;;;;;;;66822:9;:22;;-1:-1:-1;;;;;;66822:22:0;-1:-1:-1;;;;;66822:22:0;;;;;;;;;;66627:225::o;69137:310::-;69265:5;;-1:-1:-1;;;;;69265:5:0;69251:10;:19;69243:64;;;;;-1:-1:-1;;;69243:64:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;69322:11;69318:61;;;69350:17;:15;:17::i;:::-;-1:-1:-1;69389:23:0;:50;69137:310::o;51025:47::-;;;;:::o;3768:181::-;3826:7;3858:5;;;3882:6;;;;3874:46;;;;;-1:-1:-1;;;3874:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;3940:1;3768:181;-1:-1:-1;;;3768:181:0:o;5122:471::-;5180:7;5425:6;5421:47;;-1:-1:-1;5455:1:0;5448:8;;5421:47;5492:5;;;5496:1;5492;:5;:1;5516:5;;;;;:10;5508:56;;;;-1:-1:-1;;;5508:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6069:132;6127:7;6154:39;6158:1;6161;6154:39;;;;;;;;;;;;;;;;;:3;:39::i;4232:136::-;4290:7;4317:43;4321:1;4324;4317:43;;;;;;;;;;;;;;;;;:3;:43::i;15135:177::-;15245:58;;;-1:-1:-1;;;;;15245:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;15245:58:0;-1:-1:-1;;;15245:58:0;;;15218:86;;15238:5;;15218:19;:86::i;:::-;15135:177;;;:::o;66095:279::-;66190:4;;:29;;;-1:-1:-1;;;66190:29:0;;66213:4;66190:29;;;;;;66172:15;;-1:-1:-1;;;;;66190:4:0;;:14;;:29;;;;;;;;;;;;;;:4;:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;66190:29:0;;-1:-1:-1;66234:17:0;;;66230:137;;;66268:4;;:27;;;-1:-1:-1;;;66268:27:0;;-1:-1:-1;;;;;66268:27:0;;;;;;;;;;;;;;;:4;;;;;:13;;:27;;;;;;;;;;;;;;:4;;:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;66230:137:0;;-1:-1:-1;66230:137:0;;66328:4;;:27;;;-1:-1:-1;;;66328:27:0;;-1:-1:-1;;;;;66328:27:0;;;;;;;;;;;;;;;:4;;;;;:13;;:27;;;;;;;;;;;;;;:4;;:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15320:205;15448:68;;;-1:-1:-1;;;;;15448:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;15448:68:0;-1:-1:-1;;;15448:68:0;;;15421:96;;15441:5;;15421:19;:96::i;:::-;15320:205;;;;:::o;26900:106::-;26988:10;26900:106;:::o;53152:249::-;53239:9;53234:160;53258:8;:15;53254:19;;53234:160;;;53326:8;-1:-1:-1;;;;;53303:31:0;:8;53312:1;53303:11;;;;;;;;;;;;;;;;;;;;;:19;-1:-1:-1;;;;;53303:19:0;:31;;;;:64;;;53360:7;-1:-1:-1;;;;;53338:29:0;:8;53347:1;53338:11;;;;;;;;;;;;;;;;:18;:11;;;;;:18;;-1:-1:-1;;;;;53338:18:0;:29;;53303:64;53295:87;;;;;-1:-1:-1;;;53295:87:0;;;;;;;;;;;;-1:-1:-1;;;53295:87:0;;;;;;;;;;;;;;;53275:3;;53234:160;;6697:278;6783:7;6818:12;6811:5;6803:28;;;;-1:-1:-1;;;6803:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6842:9;6858:1;6854;:5;;;;;;;6697:278;-1:-1:-1;;;;;6697:278:0:o;4671:192::-;4757:7;4793:12;4785:6;;;;4777:29;;;;-1:-1:-1;;;4777:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;4829:5:0;;;4671:192::o;17440:761::-;17864:23;17890:69;17918:4;17890:69;;;;;;;;;;;;;;;;;17898:5;-1:-1:-1;;;;;17890:27:0;;;:69;;;;;:::i;:::-;17974:17;;17864:95;;-1:-1:-1;17974:21:0;17970:224;;18116:10;18105:30;;;;;;;;;;;;;;;-1:-1:-1;18105:30:0;18097:85;;;;-1:-1:-1;;;18097:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12118:196;12221:12;12253:53;12276:6;12284:4;12290:1;12293:12;12253:22;:53::i;:::-;12246:60;12118:196;-1:-1:-1;;;;12118:196:0:o;13495:979::-;13625:12;13658:18;13669:6;13658:10;:18::i;:::-;13650:60;;;;;-1:-1:-1;;;13650:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;13784:12;13798:23;13825:6;-1:-1:-1;;;;;13825:11:0;13845:8;13856:4;13825:36;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;13825:36:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13783:78;;;;13876:7;13872:595;;;13907:10;-1:-1:-1;13900:17:0;;-1:-1:-1;13900:17:0;13872:595;14021:17;;:21;14017:439;;14284:10;14278:17;14345:15;14332:10;14328:2;14324:19;14317:44;14232:148;14420:20;;-1:-1:-1;;;14420:20:0;;;;;;;;;;;;;;;;;14427:12;;14420:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9003:619;9063:4;9531:20;;9374:66;9571:23;;;;;;:42;;-1:-1:-1;;9598:15:0;;;9563:51;-1:-1:-1;;9003:619:0:o
Swarm Source
ipfs://b28a0bac053452a98dff26e9bb408ed9b483e85c36f40b78aef58885dc4c31fb
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 27 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|---|---|---|---|---|
ETH | 100.00% | $0.001088 | 4,834,699.961 | $5,259.09 |
Loading...
Loading
[ 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.