More Info
Private Name Tags
ContractCreator
Latest 25 from a total of 2,313 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Withdraw | 20424317 | 59 days ago | IN | 0 ETH | 0.00050107 | ||||
Withdraw | 20424235 | 59 days ago | IN | 0 ETH | 0.00006034 | ||||
Withdraw | 19852507 | 139 days ago | IN | 0 ETH | 0.00042902 | ||||
Withdraw | 19789555 | 148 days ago | IN | 0 ETH | 0.00086307 | ||||
Withdraw | 19548395 | 182 days ago | IN | 0 ETH | 0.00293941 | ||||
Withdraw | 19450868 | 195 days ago | IN | 0 ETH | 0.00286487 | ||||
Withdraw | 19345503 | 210 days ago | IN | 0 ETH | 0.00491292 | ||||
Withdraw | 19325786 | 213 days ago | IN | 0 ETH | 0.0054054 | ||||
Withdraw | 19294095 | 217 days ago | IN | 0 ETH | 0.00300344 | ||||
Withdraw | 19258368 | 222 days ago | IN | 0 ETH | 0.00064398 | ||||
Withdraw | 19258365 | 222 days ago | IN | 0 ETH | 0.00062864 | ||||
Withdraw | 19258365 | 222 days ago | IN | 0 ETH | 0.00298233 | ||||
Withdraw | 19157831 | 237 days ago | IN | 0 ETH | 0.00207585 | ||||
Claim Reward | 19157818 | 237 days ago | IN | 0 ETH | 0.00169351 | ||||
Claim Reward | 19157818 | 237 days ago | IN | 0 ETH | 0.00125374 | ||||
Withdraw | 19083626 | 247 days ago | IN | 0 ETH | 0.00391611 | ||||
Withdraw | 18936323 | 268 days ago | IN | 0 ETH | 0.0005428 | ||||
Withdraw | 18918079 | 270 days ago | IN | 0 ETH | 0.00165121 | ||||
Withdraw | 18918074 | 270 days ago | IN | 0 ETH | 0.00036733 | ||||
Withdraw | 18918069 | 270 days ago | IN | 0 ETH | 0.00144203 | ||||
Withdraw | 18918066 | 270 days ago | IN | 0 ETH | 0.00172351 | ||||
Claim Reward | 18918061 | 270 days ago | IN | 0 ETH | 0.00153135 | ||||
Withdraw | 18911986 | 271 days ago | IN | 0 ETH | 0.00121396 | ||||
Withdraw | 18901544 | 273 days ago | IN | 0 ETH | 0.00191884 | ||||
Withdraw | 18847019 | 280 days ago | IN | 0 ETH | 0.00235738 |
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
Contract Name:
bBetaMaster
Compiler Version
v0.6.12+commit.27d51765
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2021-05-28 */ // File: @openzeppelin/contracts/token/ERC20/IERC20.sol // SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` tokens from the caller's account to `recipient`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address recipient, uint256 amount) external returns (bool); /** * @dev Returns the remaining number of tokens that `spender` will be * allowed to spend on behalf of `owner` through {transferFrom}. This is * zero by default. * * This value changes when {approve} or {transferFrom} are called. */ function allowance(address owner, address spender) external view returns (uint256); /** * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * IMPORTANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * * Emits an {Approval} event. */ function approve(address spender, uint256 amount) external returns (bool); /** * @dev Moves `amount` tokens from `sender` to `recipient` using the * allowance mechanism. `amount` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); } // File: @openzeppelin/contracts/math/SafeMath.sol pragma solidity >=0.6.0 <0.8.0; /** * @dev Wrappers over Solidity's arithmetic operations with added overflow * checks. * * Arithmetic operations in Solidity wrap on overflow. This can easily result * in bugs, because programmers usually assume that an overflow raises an * error, which is the standard behavior in high level programming languages. * `SafeMath` restores this intuition by reverting the transaction when an * operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. */ library SafeMath { /** * @dev Returns the addition of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) { uint256 c = a + b; if (c < a) return (false, 0); return (true, c); } /** * @dev Returns the substraction of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) { if (b > a) return (false, 0); return (true, a - b); } /** * @dev Returns the multiplication of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryMul(uint256 a, uint256 b) internal pure returns (bool, 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 (true, 0); uint256 c = a * b; if (c / a != b) return (false, 0); return (true, c); } /** * @dev Returns the division of two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) { if (b == 0) return (false, 0); return (true, a / b); } /** * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) { if (b == 0) return (false, 0); return (true, a % b); } /** * @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) { require(b <= a, "SafeMath: subtraction overflow"); return a - b; } /** * @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) { 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, reverting 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) { require(b > 0, "SafeMath: division by zero"); return a / b; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting 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) { require(b > 0, "SafeMath: modulo by zero"); return a % b; } /** * @dev Returns the subtraction of two unsigned integers, reverting with custom message on * overflow (when the result is negative). * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {trySub}. * * 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); return a - b; } /** * @dev Returns the integer division of two unsigned integers, reverting with custom message on * division by zero. The result is rounded towards zero. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryDiv}. * * 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); return a / b; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting with custom message when dividing by zero. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryMod}. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); return a % b; } } // File: @openzeppelin/contracts/utils/Address.sol pragma solidity >=0.6.2 <0.8.0; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success, ) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain`call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: value }(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) { if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } // File: @openzeppelin/contracts/token/ERC20/SafeERC20.sol pragma solidity >=0.6.0 <0.8.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 <0.8.0; /** * @dev Library for managing * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive * types. * * Sets have the following properties: * * - Elements are added, removed, and checked for existence in constant time * (O(1)). * - Elements are enumerated in O(n). No guarantees are made on the ordering. * * ``` * contract Example { * // Add the library methods * using EnumerableSet for EnumerableSet.AddressSet; * * // Declare a set state variable * EnumerableSet.AddressSet private mySet; * } * ``` * * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`) * and `uint256` (`UintSet`) are supported. */ library EnumerableSet { // To implement this library for multiple types with as little code // repetition as possible, we write it in terms of a generic Set type with // bytes32 values. // The Set implementation uses private functions, and user-facing // implementations (such as AddressSet) are just wrappers around the // underlying Set. // This means that we can only create new EnumerableSets for types that fit // in bytes32. struct Set { // Storage of set values bytes32[] _values; // Position of the value in the `values` array, plus 1 because index 0 // means a value is not in the set. mapping (bytes32 => uint256) _indexes; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function _add(Set storage set, bytes32 value) private returns (bool) { if (!_contains(set, value)) { set._values.push(value); // The value is stored at length-1, but we add 1 to all indexes // and use 0 as a sentinel value set._indexes[value] = set._values.length; return true; } else { return false; } } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function _remove(Set storage set, bytes32 value) private returns (bool) { // We read and store the value's index to prevent multiple reads from the same storage slot uint256 valueIndex = set._indexes[value]; if (valueIndex != 0) { // Equivalent to contains(set, value) // To delete an element from the _values array in O(1), we swap the element to delete with the last one in // the array, and then remove the last element (sometimes called as 'swap and pop'). // This modifies the order of the array, as noted in {at}. uint256 toDeleteIndex = valueIndex - 1; uint256 lastIndex = set._values.length - 1; // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement. bytes32 lastvalue = set._values[lastIndex]; // Move the last value to the index where the value to delete is set._values[toDeleteIndex] = lastvalue; // Update the index for the moved value set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based // Delete the slot where the moved value was stored set._values.pop(); // Delete the index for the deleted slot delete set._indexes[value]; return true; } else { return false; } } /** * @dev Returns true if the value is in the set. O(1). */ function _contains(Set storage set, bytes32 value) private view returns (bool) { return set._indexes[value] != 0; } /** * @dev Returns the number of values on the set. O(1). */ function _length(Set storage set) private view returns (uint256) { return set._values.length; } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function _at(Set storage set, uint256 index) private view returns (bytes32) { require(set._values.length > index, "EnumerableSet: index out of bounds"); return set._values[index]; } // Bytes32Set struct Bytes32Set { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _add(set._inner, value); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _remove(set._inner, value); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) { return _contains(set._inner, value); } /** * @dev Returns the number of values in the set. O(1). */ function length(Bytes32Set storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) { return _at(set._inner, index); } // AddressSet struct AddressSet { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(AddressSet storage set, address value) internal returns (bool) { return _add(set._inner, bytes32(uint256(uint160(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(uint160(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(uint160(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(uint160(uint256(_at(set._inner, index)))); } // UintSet struct UintSet { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(UintSet storage set, uint256 value) internal returns (bool) { return _add(set._inner, bytes32(value)); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(UintSet storage set, uint256 value) internal returns (bool) { return _remove(set._inner, bytes32(value)); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(UintSet storage set, uint256 value) internal view returns (bool) { return _contains(set._inner, bytes32(value)); } /** * @dev Returns the number of values on the set. O(1). */ function length(UintSet storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(UintSet storage set, uint256 index) internal view returns (uint256) { return uint256(_at(set._inner, index)); } } // File: @openzeppelin/contracts/utils/Context.sol pragma solidity >=0.6.0 <0.8.0; /* * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with GSN meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address payable) { return msg.sender; } function _msgData() internal view virtual returns (bytes memory) { this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691 return msg.data; } } // File: @openzeppelin/contracts/access/Ownable.sol pragma solidity >=0.6.0 <0.8.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. */ abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor () internal { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { require(owner() == _msgSender(), "Ownable: caller is not the owner"); _; } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions anymore. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby removing any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } // File: @openzeppelin/contracts/token/ERC20/ERC20.sol pragma solidity >=0.6.0 <0.8.0; /** * @dev Implementation of the {IERC20} interface. * * This implementation is agnostic to the way tokens are created. This means * that a supply mechanism has to be added in a derived contract using {_mint}. * For a generic mechanism see {ERC20PresetMinterPauser}. * * TIP: For a detailed writeup see our guide * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How * to implement supply mechanisms]. * * We have followed general OpenZeppelin guidelines: functions revert instead * of returning `false` on failure. This behavior is nonetheless conventional * and does not conflict with the expectations of ERC20 applications. * * Additionally, an {Approval} event is emitted on calls to {transferFrom}. * This allows applications to reconstruct the allowance for all accounts just * by listening to said events. Other implementations of the EIP may not emit * these events, as it isn't required by the specification. * * Finally, the non-standard {decreaseAllowance} and {increaseAllowance} * functions have been added to mitigate the well-known issues around setting * allowances. See {IERC20-approve}. */ contract ERC20 is Context, IERC20 { using SafeMath for uint256; mapping (address => uint256) private _balances; mapping (address => mapping (address => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; uint8 private _decimals; /** * @dev Sets the values for {name} and {symbol}, initializes {decimals} with * a default value of 18. * * To select a different value for {decimals}, use {_setupDecimals}. * * All three of these values are immutable: they can only be set once during * construction. */ constructor (string memory name_, string memory symbol_) public { _name = name_; _symbol = symbol_; _decimals = 18; } /** * @dev Returns the name of the token. */ function name() public view virtual returns (string memory) { return _name; } /** * @dev Returns the symbol of the token, usually a shorter version of the * name. */ function symbol() public view virtual 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 virtual returns (uint8) { return _decimals; } /** * @dev See {IERC20-totalSupply}. */ function totalSupply() public view virtual override returns (uint256) { return _totalSupply; } /** * @dev See {IERC20-balanceOf}. */ function balanceOf(address account) public view virtual override returns (uint256) { return _balances[account]; } /** * @dev See {IERC20-transfer}. * * Requirements: * * - `recipient` cannot be the zero address. * - the caller must have a balance of at least `amount`. */ function transfer(address recipient, uint256 amount) public virtual override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } /** * @dev See {IERC20-allowance}. */ function allowance(address owner, address spender) public view virtual override returns (uint256) { return _allowances[owner][spender]; } /** * @dev See {IERC20-approve}. * * Requirements: * * - `spender` cannot be the zero address. */ function approve(address spender, uint256 amount) public virtual override returns (bool) { _approve(_msgSender(), spender, amount); return true; } /** * @dev See {IERC20-transferFrom}. * * Emits an {Approval} event indicating the updated allowance. This is not * required by the EIP. See the note at the beginning of {ERC20}. * * Requirements: * * - `sender` and `recipient` cannot be the zero address. * - `sender` must have a balance of at least `amount`. * - the caller must have allowance for ``sender``'s tokens of at least * `amount`. */ function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } /** * @dev Atomically increases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. */ function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } /** * @dev Atomically decreases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. * - `spender` must have allowance for the caller of at least * `subtractedValue`. */ function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); return true; } /** * @dev Moves tokens `amount` from `sender` to `recipient`. * * This is internal function is equivalent to {transfer}, and can be used to * e.g. implement automatic token fees, slashing mechanisms, etc. * * Emits a {Transfer} event. * * Requirements: * * - `sender` cannot be the zero address. * - `recipient` cannot be the zero address. * - `sender` must have a balance of at least `amount`. */ function _transfer(address sender, address recipient, uint256 amount) internal virtual { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); _beforeTokenTransfer(sender, recipient, amount); _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance"); _balances[recipient] = _balances[recipient].add(amount); emit Transfer(sender, recipient, amount); } /** @dev Creates `amount` tokens and assigns them to `account`, increasing * the total supply. * * Emits a {Transfer} event with `from` set to the zero address. * * Requirements: * * - `to` cannot be the zero address. */ function _mint(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: mint to the zero address"); _beforeTokenTransfer(address(0), account, amount); _totalSupply = _totalSupply.add(amount); _balances[account] = _balances[account].add(amount); emit Transfer(address(0), account, amount); } /** * @dev Destroys `amount` tokens from `account`, reducing the * total supply. * * Emits a {Transfer} event with `to` set to the zero address. * * Requirements: * * - `account` cannot be the zero address. * - `account` must have at least `amount` tokens. */ function _burn(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: burn from the zero address"); _beforeTokenTransfer(account, address(0), amount); _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance"); _totalSupply = _totalSupply.sub(amount); emit Transfer(account, address(0), amount); } /** * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens. * * This 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 virtual { _decimals = decimals_; } /** * @dev Hook that is called before any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens * will be to transferred to `to`. * - when `from` is zero, `amount` tokens will be minted for `to`. * - when `to` is zero, `amount` of ``from``'s tokens will be burned. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { } } // File: contracts/bBetaToken.sol pragma solidity 0.6.12; contract bBetaToken is ERC20("bBeta", "bBETA"), Ownable { uint256 public cap = 20000e18; address public bBetaMaster; mapping(address => uint) public redeemed; uint256 public startAtBlock; uint256 public NUMBER_BLOCKS_PER_DAY; uint256 constant public DATA_PROVIDER_TOTAL_AMOUNT = 2000e18; uint256 constant public AIRDROP_TOTAL_AMOUNT = 2000e18; uint256 public dataProviderAmount = DATA_PROVIDER_TOTAL_AMOUNT; uint256 public farmingAmount = 16000e18; constructor(address _sendTo, uint256 _startAtBlock, uint256 _numberBlockPerDay) public { startAtBlock = _startAtBlock; NUMBER_BLOCKS_PER_DAY = _numberBlockPerDay == 0 ? 6000 : _numberBlockPerDay; _mint(_sendTo, AIRDROP_TOTAL_AMOUNT); } function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override { super._beforeTokenTransfer(from, to, amount); if (from == address(0)) { require(totalSupply().add(amount) <= cap, "ERC20Capped: cap exceeded"); } } function setMaster(address _bBetaMaster) public onlyOwner { bBetaMaster = _bBetaMaster; } function mint(address _to, uint256 _amount) public { require(msg.sender == bBetaMaster, "bBetaToken: only master farmer can mint"); if (_amount > farmingAmount) { _amount = farmingAmount; } farmingAmount = farmingAmount.sub(_amount); _mint(_to, _amount); } function safeBurn(uint256 _amount) public { uint canBurn = canBurnAmount(msg.sender); uint burnAmount = canBurn > _amount ? _amount : canBurn; redeemed[msg.sender] += burnAmount; _burn(msg.sender, burnAmount); } function burn(uint256 _amount) public { require(redeemed[msg.sender] + _amount <= 1e18, "bBetaToken: cannot burn more than 1 bBeta"); redeemed[msg.sender] += _amount; _burn(msg.sender, _amount); } function canBurnAmount(address _add) public view returns (uint) { return 1e18 - redeemed[_add]; } function mintForDataProvider(address _to) public onlyOwner { require(block.number >= startAtBlock + 14 * NUMBER_BLOCKS_PER_DAY, "bBetaToken: Cannot mint at this time"); require(dataProviderAmount > 0, "bBetaToken: Cannot mint more token for future farming"); _mint(_to, dataProviderAmount); dataProviderAmount = 0; } } // File: contracts/bBetaMaster.sol pragma solidity 0.6.12; contract bBetaMaster is Ownable { using SafeMath for uint256; using SafeERC20 for IERC20; struct UserInfo { uint256 amount; // How many LP tokens the user has provided. uint256 rewardDebt; // Reward debt. See explanation below. } // Info of each pool. struct PoolInfo { IERC20 lpToken; uint256 allocPoint; uint256 lastRewardBlock; uint256 rewardPerShare; } bBetaToken public bBeta; uint256 public REWARD_PER_BLOCK; uint256[] public REWARD_MULTIPLIER = [222, 211, 200, 189, 178, 167, 156, 144, 133, 122, 111, 100, 0]; uint256[] public HALVING_AT_BLOCK; uint256 public FINISH_BONUS_AT_BLOCK; uint256 public START_BLOCK; // Info of each pool. PoolInfo[] public poolInfo; mapping(address => uint256) public poolId1; // poolId1 count from 1, subtraction 1 before using with poolInfo // Info of each user that stakes LP tokens. pid => user address => info mapping (uint256 => mapping (address => UserInfo)) public userInfo; // Total allocation poitns. Must be the sum of all allocation points in all pools. uint256 public totalAllocPoint = 0; event Deposit(address indexed user, uint256 indexed pid, uint256 amount); event Withdraw(address indexed user, uint256 indexed pid, uint256 amount); event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount); event SendReward(address indexed user, uint256 indexed pid, uint256 amount); constructor( bBetaToken _bBeta, uint256 _rewardPerBlock, uint256 _startBlock, uint256 _halvingAfterBlock ) public { bBeta = _bBeta; REWARD_PER_BLOCK = _rewardPerBlock; START_BLOCK = _startBlock; for (uint256 i = 0; i < REWARD_MULTIPLIER.length - 1; i++) { uint256 halvingAtBlock = _halvingAfterBlock.mul(i + 1).add(_startBlock); HALVING_AT_BLOCK.push(halvingAtBlock); } FINISH_BONUS_AT_BLOCK = _halvingAfterBlock.mul(REWARD_MULTIPLIER.length - 1).add(_startBlock); HALVING_AT_BLOCK.push(uint256(-1)); } // -------- For manage pool --------- function add(uint256 _allocPoint, IERC20 _lpToken, bool _withUpdate) public onlyOwner { require(address(_lpToken) != address(0x0), "bBetaMaster::add: wrong lptoken"); require(poolId1[address(_lpToken)] == 0, "bBetaMaster::add: lp is already in pool"); if (_withUpdate) { massUpdatePools(); } uint256 lastRewardBlock = block.number > START_BLOCK ? block.number : START_BLOCK; totalAllocPoint = totalAllocPoint.add(_allocPoint); poolId1[address(_lpToken)] = poolInfo.length + 1; poolInfo.push(PoolInfo({ lpToken: _lpToken, allocPoint: _allocPoint, lastRewardBlock: lastRewardBlock, rewardPerShare: 0 })); } function set(uint256 _pid, uint256 _allocPoint, bool _withUpdate) public onlyOwner { if (_withUpdate) { massUpdatePools(); } totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint); poolInfo[_pid].allocPoint = _allocPoint; } function massUpdatePools() public { uint256 length = poolInfo.length; for (uint256 pid = 0; pid < length; ++pid) { updatePool(pid); } } function updatePool(uint256 _pid) public { PoolInfo storage pool = poolInfo[_pid]; if (block.number <= pool.lastRewardBlock) { return; } uint256 lpSupply = pool.lpToken.balanceOf(address(this)); if (lpSupply == 0) { pool.lastRewardBlock = block.number; return; } uint256 reward = getPoolReward( pool.lastRewardBlock, block.number, pool.allocPoint ); if (reward == 0) { pool.lastRewardBlock = block.number; return; } bBeta.mint(address(this), reward); pool.rewardPerShare = pool.rewardPerShare.add(reward.mul(1e12).div(lpSupply)); pool.lastRewardBlock = block.number; } // --------- For user ---------------- function deposit(uint256 _pid, uint256 _amount) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; updatePool(_pid); if (user.amount > 0) { uint256 pending = user.amount.mul(pool.rewardPerShare).div(1e12).sub(user.rewardDebt); if(pending > 0) { safeTransferReward(msg.sender, pending); } } if(_amount > 0) { pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount); user.amount = user.amount.add(_amount); } user.rewardDebt = user.amount.mul(pool.rewardPerShare).div(1e12); emit Deposit(msg.sender, _pid, _amount); } function withdraw(uint256 _pid, uint256 _amount) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; require(user.amount >= _amount, "withdraw: not good"); updatePool(_pid); uint256 pending = user.amount.mul(pool.rewardPerShare).div(1e12).sub(user.rewardDebt); if(pending > 0) { safeTransferReward(msg.sender, pending); } if(_amount > 0) { user.amount = user.amount.sub(_amount); pool.lpToken.safeTransfer(address(msg.sender), _amount); } user.rewardDebt = user.amount.mul(pool.rewardPerShare).div(1e12); emit Withdraw(msg.sender, _pid, _amount); } function claimReward(uint256 _pid) public { deposit(_pid, 0); } // Withdraw without caring about rewards. EMERGENCY ONLY. function emergencyWithdraw(uint256 _pid) public { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; pool.lpToken.safeTransfer(address(msg.sender), user.amount); emit EmergencyWithdraw(msg.sender, _pid, user.amount); user.amount = 0; user.rewardDebt = 0; } // ----------------------------- function safeTransferReward(address _to, uint256 _amount) internal { uint256 bal = bBeta.balanceOf(address(this)); if (_amount > bal) { bBeta.transfer(_to, bal); } else { bBeta.transfer(_to, _amount); } } // GET INFO for UI function getMultiplier(uint256 _from, uint256 _to) public view returns (uint256) { uint256 result = 0; if (_from < START_BLOCK) return 0; for (uint256 i = 0; i < HALVING_AT_BLOCK.length; i++) { uint256 endBlock = HALVING_AT_BLOCK[i]; if (_to <= endBlock) { uint256 m = _to.sub(_from).mul(REWARD_MULTIPLIER[i]); return result.add(m); } if (_from < endBlock) { uint256 m = endBlock.sub(_from).mul(REWARD_MULTIPLIER[i]); _from = endBlock; result = result.add(m); } } return result; } function getPoolReward(uint256 _from, uint256 _to, uint256 _allocPoint) public view returns (uint) { uint256 multiplier = getMultiplier(_from, _to); uint256 amount = (multiplier.mul(REWARD_PER_BLOCK).mul(_allocPoint).div(totalAllocPoint)).div(100); uint256 amountCanMint = bBeta.farmingAmount(); return amountCanMint < amount ? amountCanMint : amount; } function getRewardPerBlock(uint256 pid1) public view returns (uint256) { uint256 multiplier = getMultiplier(block.number -1, block.number); if (pid1 == 0) { return (multiplier.mul(REWARD_PER_BLOCK)).div(100); } else { return (multiplier .mul(REWARD_PER_BLOCK) .mul(poolInfo[pid1 - 1].allocPoint) .div(totalAllocPoint)) .div(100); } } function pendingReward(uint256 _pid, address _user) public view returns (uint256) { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][_user]; uint256 rewardPerShare = pool.rewardPerShare; uint256 lpSupply = pool.lpToken.balanceOf(address(this)); if (block.number > pool.lastRewardBlock && lpSupply > 0) { uint256 reward = getPoolReward(pool.lastRewardBlock, block.number, pool.allocPoint); rewardPerShare = rewardPerShare.add(reward.mul(1e12).div(lpSupply)); } return user.amount.mul(rewardPerShare).div(1e12).sub(user.rewardDebt); } function poolLength() public view returns (uint256) { return poolInfo.length; } function getStakedAmount(uint _pid, address _user) public view returns (uint256) { UserInfo storage user = userInfo[_pid][_user]; return user.amount; } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"contract bBetaToken","name":"_bBeta","type":"address"},{"internalType":"uint256","name":"_rewardPerBlock","type":"uint256"},{"internalType":"uint256","name":"_startBlock","type":"uint256"},{"internalType":"uint256","name":"_halvingAfterBlock","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"EmergencyWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"SendReward","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"FINISH_BONUS_AT_BLOCK","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"HALVING_AT_BLOCK","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"REWARD_MULTIPLIER","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"REWARD_PER_BLOCK","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"START_BLOCK","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"contract IERC20","name":"_lpToken","type":"address"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"add","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"bBeta","outputs":[{"internalType":"contract bBetaToken","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"claimReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_from","type":"uint256"},{"internalType":"uint256","name":"_to","type":"uint256"}],"name":"getMultiplier","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_from","type":"uint256"},{"internalType":"uint256","name":"_to","type":"uint256"},{"internalType":"uint256","name":"_allocPoint","type":"uint256"}],"name":"getPoolReward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"pid1","type":"uint256"}],"name":"getRewardPerBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"getStakedAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":"pendingReward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"poolId1","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"poolInfo","outputs":[{"internalType":"contract IERC20","name":"lpToken","type":"address"},{"internalType":"uint256","name":"allocPoint","type":"uint256"},{"internalType":"uint256","name":"lastRewardBlock","type":"uint256"},{"internalType":"uint256","name":"rewardPerShare","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"set","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"totalAllocPoint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"updatePool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"rewardDebt","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
61022060405260de608090815260d360a05260c860c05260bd60e05260b26101005260a761012052609c61014052609061016052608561018052607a6101a052606f6101c05260646101e0526000610200526200006190600390600d620002ed565b506000600a553480156200007457600080fd5b5060405162001e3138038062001e31833981810160405260808110156200009a57600080fd5b50805160208201516040830151606090930151919290916000620000bd62000227565b600080546001600160a01b0319166001600160a01b0383169081178255604051929350917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0908290a350600180546001600160a01b0319166001600160a01b0386161790556002839055600682905560005b60035460001901811015620001b957600062000176846200016284600101866200022b60201b620013121790919060201c565b6200029260201b6200136b1790919060201c565b60048054600181810183556000929092527f8a35acfbc15ff81a39ae7d344fd709f28e8600b4aa8c65c6b64bfe7fe36bd19b01919091559190910190506200012f565b50620001e18262000162600160038054905003846200022b60201b620013121790919060201c565b6005555050600480546001810182556000919091526000197f8a35acfbc15ff81a39ae7d344fd709f28e8600b4aa8c65c6b64bfe7fe36bd19b9091015550620003599050565b3390565b6000826200023c575060006200028c565b828202828482816200024a57fe5b0414620002895760405162461bcd60e51b815260040180806020018281038252602181526020018062001e106021913960400191505060405180910390fd5b90505b92915050565b60008282018381101562000289576040805162461bcd60e51b815260206004820152601b60248201527f536166654d6174683a206164646974696f6e206f766572666c6f770000000000604482015290519081900360640190fd5b82805482825590600052602060002090810192821562000330579160200282015b8281111562000330578251829060ff169055916020019190600101906200030e565b506200033e92915062000342565b5090565b5b808211156200033e576000815560010162000343565b611aa780620003696000396000f3fe608060405234801561001057600080fd5b50600436106101a95760003560e01c8063715018a6116100f957806398969e8211610097578063c8ed768011610071578063c8ed768014610463578063ce2529c91461048c578063e2bbb158146104b2578063f2fde38b146104d5576101a9565b806398969e82146104125780639ca5f20e1461043e578063ae169a5014610446576101a9565b80638dbb1e3a116100d35780638dbb1e3a1461039a57806393f1a40b146103bd578063975532dc14610402578063980c2a981461040a576101a9565b8063715018a6146103515780637b550bc9146103595780638da5cb5b14610376576101a9565b80633a71ede81161016657806351eb05a61161014057806351eb05a6146102e45780635312ea8e14610301578063630b5ba11461031e57806364482f7914610326576101a9565b80633a71ede8146102785780634179b4fb146102a4578063441a3e70146102c1576101a9565b8063081e3eda146101ae5780631526fe27146101c857806317caf6f1146102155780631eaaa0451461021d5780632fda77351461025357806339b3e82614610270575b600080fd5b6101b66104fb565b60408051918252519081900360200190f35b6101e5600480360360208110156101de57600080fd5b5035610501565b604080516001600160a01b0390951685526020850193909352838301919091526060830152519081900360800190f35b6101b6610542565b6102516004803603606081101561023357600080fd5b508035906001600160a01b0360208201351690604001351515610548565b005b6101b66004803603602081101561026957600080fd5b5035610791565b6101b66107af565b6101b66004803603604081101561028e57600080fd5b50803590602001356001600160a01b03166107b5565b6101b6600480360360208110156102ba57600080fd5b50356107df565b610251600480360360408110156102d757600080fd5b50803590602001356107ec565b610251600480360360208110156102fa57600080fd5b503561094b565b6102516004803603602081101561031757600080fd5b5035610ad6565b610251610b71565b6102516004803603606081101561033c57600080fd5b50803590602081013590604001351515610b94565b610251610c6f565b6101b66004803603602081101561036f57600080fd5b5035610d1b565b61037e610da4565b604080516001600160a01b039092168252519081900360200190f35b6101b6600480360360408110156103b057600080fd5b5080359060200135610db3565b6103e9600480360360408110156103d357600080fd5b50803590602001356001600160a01b0316610e91565b6040805192835260208301919091528051918290030190f35b6101b6610eb5565b6101b6610ebb565b6101b66004803603604081101561042857600080fd5b50803590602001356001600160a01b0316610ec1565b61037e611001565b6102516004803603602081101561045c57600080fd5b5035611010565b6101b66004803603606081101561047957600080fd5b508035906020810135906040013561101b565b6101b6600480360360208110156104a257600080fd5b50356001600160a01b03166110ec565b610251600480360360408110156104c857600080fd5b50803590602001356110fe565b610251600480360360208110156104eb57600080fd5b50356001600160a01b0316611210565b60075490565b6007818154811061050e57fe5b600091825260209091206004909102018054600182015460028301546003909301546001600160a01b039092169350919084565b600a5481565b6105506113c5565b6001600160a01b0316610561610da4565b6001600160a01b0316146105aa576040805162461bcd60e51b81526020600482018190526024820152600080516020611a28833981519152604482015290519081900360640190fd5b6001600160a01b038216610605576040805162461bcd60e51b815260206004820152601f60248201527f62426574614d61737465723a3a6164643a2077726f6e67206c70746f6b656e00604482015290519081900360640190fd5b6001600160a01b0382166000908152600860205260409020541561065a5760405162461bcd60e51b81526004018080602001828103825260278152602001806119ba6027913960400191505060405180910390fd5b801561066857610668610b71565b6000600654431161067b5760065461067d565b435b600a5490915061068d908561136b565b600a55600780546001600160a01b03948516600081815260086020908152604080832060019586019055805160808101825293845290830198895282019485526060820181815284549384018555939052517fa66cc928b5edb82af9bd49922954155ab7b0942694bea4ce44661d9a8736c688600490920291820180546001600160a01b031916919096161790945593517fa66cc928b5edb82af9bd49922954155ab7b0942694bea4ce44661d9a8736c689840155517fa66cc928b5edb82af9bd49922954155ab7b0942694bea4ce44661d9a8736c68a8301555090517fa66cc928b5edb82af9bd49922954155ab7b0942694bea4ce44661d9a8736c68b90910155565b6003818154811061079e57fe5b600091825260209091200154905081565b60065481565b60008281526009602090815260408083206001600160a01b03851684529091529020545b92915050565b6004818154811061079e57fe5b6000600783815481106107fb57fe5b60009182526020808320868452600982526040808520338652909252922080546004909202909201925083111561086e576040805162461bcd60e51b81526020600482015260126024820152711dda5d1a191c985dce881b9bdd0819dbdbd960721b604482015290519081900360640190fd5b6108778461094b565b60006108b182600101546108ab64e8d4a510006108a58760030154876000015461131290919063ffffffff16565b906113c9565b90611430565b905080156108c3576108c3338261148d565b83156108ed5781546108d59085611430565b825582546108ed906001600160a01b0316338661161e565b600383015482546109089164e8d4a51000916108a591611312565b6001830155604080518581529051869133917ff279e6a1f5e320cca91135676d9cb6e44ca8a08c0b88342bcdb1144f6511b5689181900360200190a35050505050565b60006007828154811061095a57fe5b906000526020600020906004020190508060020154431161097b5750610ad3565b8054604080516370a0823160e01b815230600482015290516000926001600160a01b0316916370a08231916024808301926020929190829003018186803b1580156109c557600080fd5b505afa1580156109d9573d6000803e3d6000fd5b505050506040513d60208110156109ef57600080fd5b5051905080610a05575043600290910155610ad3565b6000610a1a836002015443856001015461101b565b905080610a2f57505043600290910155610ad3565b600154604080516340c10f1960e01b81523060048201526024810184905290516001600160a01b03909216916340c10f199160448082019260009290919082900301818387803b158015610a8257600080fd5b505af1158015610a96573d6000803e3d6000fd5b50505050610ac4610ab9836108a564e8d4a510008561131290919063ffffffff16565b60038501549061136b565b60038401555050436002909101555b50565b600060078281548110610ae557fe5b60009182526020808320858452600982526040808520338087529352909320805460049093029093018054909450610b2a926001600160a01b0391909116919061161e565b80546040805191825251849133917fbb757047c2b5f3974fe26b7c10f732e7bce710b0952a71082702781e62ae05959181900360200190a360008082556001909101555050565b60075460005b81811015610b9057610b888161094b565b600101610b77565b5050565b610b9c6113c5565b6001600160a01b0316610bad610da4565b6001600160a01b031614610bf6576040805162461bcd60e51b81526020600482018190526024820152600080516020611a28833981519152604482015290519081900360640190fd5b8015610c0457610c04610b71565b610c4182610c3b60078681548110610c1857fe5b906000526020600020906004020160010154600a5461143090919063ffffffff16565b9061136b565b600a819055508160078481548110610c5557fe5b906000526020600020906004020160010181905550505050565b610c776113c5565b6001600160a01b0316610c88610da4565b6001600160a01b031614610cd1576040805162461bcd60e51b81526020600482018190526024820152600080516020611a28833981519152604482015290519081900360640190fd5b600080546040516001600160a01b03909116907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0908390a3600080546001600160a01b0319169055565b600080610d2b6001430343610db3565b905082610d5457610d4c60646108a56002548461131290919063ffffffff16565b915050610d9f565b610d4c60646108a5600a546108a560076001890381548110610d7257fe5b906000526020600020906004020160010154610d996002548861131290919063ffffffff16565b90611312565b919050565b6000546001600160a01b031690565b6006546000908190841015610dcc5760009150506107d9565b60005b600454811015610e8957600060048281548110610de857fe5b90600052602060002001549050808511610e3b576000610e2460038481548110610e0e57fe5b600091825260209091200154610d99888a611430565b9050610e30848261136b565b9450505050506107d9565b80861015610e80576000610e6b60038481548110610e5557fe5b600091825260209091200154610d99848a611430565b91965086919050610e7c848261136b565b9350505b50600101610dcf565b509392505050565b60096020908152600092835260408084209091529082529020805460019091015482565b60025481565b60055481565b60008060078481548110610ed157fe5b600091825260208083208784526009825260408085206001600160a01b03898116875290845281862060049586029093016003810154815484516370a0823160e01b81523098810198909852935191985093969395939492909116926370a08231926024808301939192829003018186803b158015610f4f57600080fd5b505afa158015610f63573d6000803e3d6000fd5b505050506040513d6020811015610f7957600080fd5b5051600285015490915043118015610f915750600081115b15610fce576000610fab856002015443876001015461101b565b9050610fca610fc3836108a58464e8d4a51000611312565b849061136b565b9250505b610ff683600101546108ab64e8d4a510006108a586886000015461131290919063ffffffff16565b979650505050505050565b6001546001600160a01b031681565b610ad38160006110fe565b6000806110288585610db3565b9050600061105060646108a5600a546108a588610d996002548961131290919063ffffffff16565b90506000600160009054906101000a90046001600160a01b03166001600160a01b031663de60b89c6040518163ffffffff1660e01b815260040160206040518083038186803b1580156110a257600080fd5b505afa1580156110b6573d6000803e3d6000fd5b505050506040513d60208110156110cc57600080fd5b505190508181106110dd57816110df565b805b93505050505b9392505050565b60086020526000908152604090205481565b60006007838154811061110d57fe5b6000918252602080832086845260098252604080852033865290925292206004909102909101915061113e8461094b565b80541561118757600061117382600101546108ab64e8d4a510006108a58760030154876000015461131290919063ffffffff16565b9050801561118557611185338261148d565b505b82156111b35781546111a4906001600160a01b0316333086611670565b80546111b0908461136b565b81555b600382015481546111ce9164e8d4a51000916108a591611312565b6001820155604080518481529051859133917f90890809c654f11d6e72a28fa60149770a0d11ec6c92319d6ceb2bb0a4ea1a159181900360200190a350505050565b6112186113c5565b6001600160a01b0316611229610da4565b6001600160a01b031614611272576040805162461bcd60e51b81526020600482018190526024820152600080516020611a28833981519152604482015290519081900360640190fd5b6001600160a01b0381166112b75760405162461bcd60e51b81526004018080602001828103825260268152602001806119946026913960400191505060405180910390fd5b600080546040516001600160a01b03808516939216917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e091a3600080546001600160a01b0319166001600160a01b0392909216919091179055565b600082611321575060006107d9565b8282028284828161132e57fe5b04146110e55760405162461bcd60e51b8152600401808060200182810382526021815260200180611a076021913960400191505060405180910390fd5b6000828201838110156110e5576040805162461bcd60e51b815260206004820152601b60248201527f536166654d6174683a206164646974696f6e206f766572666c6f770000000000604482015290519081900360640190fd5b3390565b600080821161141f576040805162461bcd60e51b815260206004820152601a60248201527f536166654d6174683a206469766973696f6e206279207a65726f000000000000604482015290519081900360640190fd5b81838161142857fe5b049392505050565b600082821115611487576040805162461bcd60e51b815260206004820152601e60248201527f536166654d6174683a207375627472616374696f6e206f766572666c6f770000604482015290519081900360640190fd5b50900390565b600154604080516370a0823160e01b815230600482015290516000926001600160a01b0316916370a08231916024808301926020929190829003018186803b1580156114d857600080fd5b505afa1580156114ec573d6000803e3d6000fd5b505050506040513d602081101561150257600080fd5b5051905080821115611596576001546040805163a9059cbb60e01b81526001600160a01b038681166004830152602482018590529151919092169163a9059cbb9160448083019260209291908290030181600087803b15801561156457600080fd5b505af1158015611578573d6000803e3d6000fd5b505050506040513d602081101561158e57600080fd5b506116199050565b6001546040805163a9059cbb60e01b81526001600160a01b038681166004830152602482018690529151919092169163a9059cbb9160448083019260209291908290030181600087803b1580156115ec57600080fd5b505af1158015611600573d6000803e3d6000fd5b505050506040513d602081101561161657600080fd5b50505b505050565b604080516001600160a01b038416602482015260448082018490528251808303909101815260649091019091526020810180516001600160e01b031663a9059cbb60e01b1790526116199084906116d0565b604080516001600160a01b0380861660248301528416604482015260648082018490528251808303909101815260849091019091526020810180516001600160e01b03166323b872dd60e01b1790526116ca9085906116d0565b50505050565b6060611725826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c6564815250856001600160a01b03166117819092919063ffffffff16565b8051909150156116195780806020019051602081101561174457600080fd5b50516116195760405162461bcd60e51b815260040180806020018281038252602a815260200180611a48602a913960400191505060405180910390fd5b60606117908484600085611798565b949350505050565b6060824710156117d95760405162461bcd60e51b81526004018080602001828103825260268152602001806119e16026913960400191505060405180910390fd5b6117e2856118e9565b611833576040805162461bcd60e51b815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000604482015290519081900360640190fd5b60006060866001600160a01b031685876040518082805190602001908083835b602083106118725780518252601f199092019160209182019101611853565b6001836020036101000a03801982511681845116808217855250505050505090500191505060006040518083038185875af1925050503d80600081146118d4576040519150601f19603f3d011682016040523d82523d6000602084013e6118d9565b606091505b5091509150610ff68282866118ef565b3b151590565b606083156118fe5750816110e5565b82511561190e5782518084602001fd5b8160405162461bcd60e51b81526004018080602001828103825283818151815260200191508051906020019080838360005b83811015611958578181015183820152602001611940565b50505050905090810190601f1680156119855780820380516001836020036101000a031916815260200191505b509250505060405180910390fdfe4f776e61626c653a206e6577206f776e657220697320746865207a65726f206164647265737362426574614d61737465723a3a6164643a206c7020697320616c726561647920696e20706f6f6c416464726573733a20696e73756666696369656e742062616c616e636520666f722063616c6c536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f774f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e65725361666545524332303a204552433230206f7065726174696f6e20646964206e6f742073756363656564a2646970667358221220cb303078c41b345abac898d6e5e817e20cd601191230fc34eca90166f45b707964736f6c634300060c0033536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f7700000000000000000000000000e2dde5a0e824740ed4bd2a27d6a6b0d92d8c9900000000000000000000000000000000000000000000000000230504ea80124c0000000000000000000000000000000000000000000000000000000000bf21b00000000000000000000000000000000000000000000000000000000000014820
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
00000000000000000000000000e2dde5a0e824740ed4bd2a27d6a6b0d92d8c9900000000000000000000000000000000000000000000000000230504ea80124c0000000000000000000000000000000000000000000000000000000000bf21b00000000000000000000000000000000000000000000000000000000000014820
-----Decoded View---------------
Arg [0] : _bBeta (address): 0x00e2Dde5a0e824740eD4bd2a27d6a6b0d92D8c99
Arg [1] : _rewardPerBlock (uint256): 9857142857142860
Arg [2] : _startBlock (uint256): 12526000
Arg [3] : _halvingAfterBlock (uint256): 84000
-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 00000000000000000000000000e2dde5a0e824740ed4bd2a27d6a6b0d92d8c99
Arg [1] : 00000000000000000000000000000000000000000000000000230504ea80124c
Arg [2] : 0000000000000000000000000000000000000000000000000000000000bf21b0
Arg [3] : 0000000000000000000000000000000000000000000000000000000000014820
Deployed Bytecode Sourcemap
48795:9235:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57752:93;;;:::i;:::-;;;;;;;;;;;;;;;;49584:26;;;;;;;;;;;;;;;;-1:-1:-1;49584:26:0;;:::i;:::-;;;;-1:-1:-1;;;;;49584:26:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49970:34;;;:::i;51033:755::-;;;;;;;;;;;;;;;;-1:-1:-1;51033:755:0;;;-1:-1:-1;;;;;51033:755:0;;;;;;;;;;;;:::i;:::-;;49330:100;;;;;;;;;;;;;;;;-1:-1:-1;49330:100:0;;:::i;49522:26::-;;;:::i;57853:174::-;;;;;;;;;;;;;;;;-1:-1:-1;57853:174:0;;;;;;-1:-1:-1;;;;;57853:174:0;;:::i;49437:33::-;;;;;;;;;;;;;;;;-1:-1:-1;49437:33:0;;:::i;53904:740::-;;;;;;;;;;;;;;;;-1:-1:-1;53904:740:0;;;;;;;:::i;52296:796::-;;;;;;;;;;;;;;;;-1:-1:-1;52296:796:0;;:::i;54800:356::-;;;;;;;;;;;;;;;;-1:-1:-1;54800:356:0;;:::i;52108:180::-;;;:::i;51796:304::-;;;;;;;;;;;;;;;;-1:-1:-1;51796:304:0;;;;;;;;;;;;;;:::i;34546:148::-;;;:::i;56603:477::-;;;;;;;;;;;;;;;;-1:-1:-1;56603:477:0;;:::i;33895:87::-;;;:::i;:::-;;;;-1:-1:-1;;;;;33895:87:0;;;;;;;;;;;;;;55505:688;;;;;;;;;;;;;;;;-1:-1:-1;55505:688:0;;;;;;;:::i;49809:66::-;;;;;;;;;;;;;;;;-1:-1:-1;49809:66:0;;;;;;-1:-1:-1;;;;;49809:66:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;49292:31;;;:::i;49477:36::-;;;:::i;57088:656::-;;;;;;;;;;;;;;;;-1:-1:-1;57088:656:0;;;;;;-1:-1:-1;;;;;57088:656:0;;:::i;49256:23::-;;;:::i;54652:77::-;;;;;;;;;;;;;;;;-1:-1:-1;54652:77:0;;:::i;56201:394::-;;;;;;;;;;;;;;;;-1:-1:-1;56201:394:0;;;;;;;;;;;;:::i;49617:42::-;;;;;;;;;;;;;;;;-1:-1:-1;49617:42:0;-1:-1:-1;;;;;49617:42:0;;:::i;53144:752::-;;;;;;;;;;;;;;;;-1:-1:-1;53144:752:0;;;;;;;:::i;34849:244::-;;;;;;;;;;;;;;;;-1:-1:-1;34849:244:0;-1:-1:-1;;;;;34849:244:0;;:::i;57752:93::-;57822:8;:15;57752:93;:::o;49584:26::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;49584:26:0;;;;-1:-1:-1;49584:26:0;;;:::o;49970:34::-;;;;:::o;51033:755::-;34126:12;:10;:12::i;:::-;-1:-1:-1;;;;;34115:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;34115:23:0;;34107:68;;;;;-1:-1:-1;;;34107:68:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;34107:68:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;51138:33:0;::::1;51130:77;;;::::0;;-1:-1:-1;;;51130:77:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;-1:-1:-1::0;;;;;51226:26:0;::::1;;::::0;;;:7:::1;:26;::::0;;;;;:31;51218:83:::1;;;;-1:-1:-1::0;;;51218:83:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51316:11;51312:61;;;51344:17;:15;:17::i;:::-;51383:23;51424:11;;51409:12;:26;:55;;51453:11;;51409:55;;;51438:12;51409:55;51493:15;::::0;51383:81;;-1:-1:-1;51493:32:0::1;::::0;51513:11;51493:19:::1;:32::i;:::-;51475:15;:50:::0;51565:8:::1;:15:::0;;-1:-1:-1;;;;;51536:26:0;;::::1;;::::0;;;:7:::1;:26;::::0;;;;;;;51583:1:::1;51565:19:::0;;::::1;51536:48:::0;;51609:170;;::::1;::::0;::::1;::::0;;;;;;;::::1;::::0;;;;;;;;;;;;;;51595:185;;;;::::1;::::0;;;;;;;::::1;::::0;;::::1;::::0;;::::1;::::0;;-1:-1:-1;;;;;;51595:185:0::1;::::0;;;::::1;;::::0;;;;;;;;;;;;;;-1:-1:-1;51595:185:0;;;;;;;51033:755::o;49330:100::-;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;49330:100:0;:::o;49522:26::-;;;;:::o;57853:174::-;57925:7;57969:14;;;:8;:14;;;;;;;;-1:-1:-1;;;;;57969:21:0;;;;;;;;;58008:11;57853:174;;;;;:::o;49437:33::-;;;;;;;;;;53904:740;53971:21;53995:8;54004:4;53995:14;;;;;;;;;;;;;;;;54044;;;:8;:14;;;;;;54059:10;54044:26;;;;;;;54089:11;;53995:14;;;;;;;;-1:-1:-1;54089:22:0;-1:-1:-1;54089:22:0;54081:53;;;;;-1:-1:-1;;;54081:53:0;;;;;;;;;;;;-1:-1:-1;;;54081:53:0;;;;;;;;;;;;;;;54145:16;54156:4;54145:10;:16::i;:::-;54172:15;54190:67;54241:4;:15;;;54190:46;54231:4;54190:36;54206:4;:19;;;54190:4;:11;;;:15;;:36;;;;:::i;:::-;:40;;:46::i;:::-;:50;;:67::i;:::-;54172:85;-1:-1:-1;54271:11:0;;54268:82;;54299:39;54318:10;54330:7;54299:18;:39::i;:::-;54363:11;;54360:151;;54405:11;;:24;;54421:7;54405:15;:24::i;:::-;54391:38;;54444:12;;:55;;-1:-1:-1;;;;;54444:12:0;54478:10;54491:7;54444:25;:55::i;:::-;54555:19;;;;54539:11;;:46;;54580:4;;54539:36;;:15;:36::i;:46::-;54521:15;;;:64;54601:35;;;;;;;;54622:4;;54610:10;;54601:35;;;;;;;;;53904:740;;;;;:::o;52296:796::-;52348:21;52372:8;52381:4;52372:14;;;;;;;;;;;;;;;;;;52348:38;;52417:4;:20;;;52401:12;:36;52397:75;;52454:7;;;52397:75;52501:12;;:37;;;-1:-1:-1;;;52501:37:0;;52532:4;52501:37;;;;;;52482:16;;-1:-1:-1;;;;;52501:12:0;;:22;;:37;;;;;;;;;;;;;;:12;:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;52501:37:0;;-1:-1:-1;52553:13:0;52549:102;;-1:-1:-1;52606:12:0;52583:20;;;;:35;52633:7;;52549:102;52661:14;52678:118;52706:4;:20;;;52742:12;52770:4;:15;;;52678:13;:118::i;:::-;52661:135;-1:-1:-1;52811:11:0;52807:100;;-1:-1:-1;;52862:12:0;52839:20;;;;:35;52889:7;;52807:100;52917:5;;:33;;;-1:-1:-1;;;52917:33:0;;52936:4;52917:33;;;;;;;;;;;;-1:-1:-1;;;;;52917:5:0;;;;:10;;:33;;;;;:5;;:33;;;;;;;;:5;;:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52983:55;53007:30;53028:8;53007:16;53018:4;53007:6;:10;;:16;;;;:::i;:30::-;52983:19;;;;;:23;:55::i;:::-;52961:19;;;:77;-1:-1:-1;;53072:12:0;53049:20;;;;:35;52296:796;;:::o;54800:356::-;54859:21;54883:8;54892:4;54883:14;;;;;;;;;;;;;;;;54932;;;:8;:14;;;;;;54947:10;54932:26;;;;;;;;55016:11;;54883:14;;;;;;;54969:12;;54883:14;;-1:-1:-1;54969:59:0;;-1:-1:-1;;;;;54969:12:0;;;;;54947:10;54969:25;:59::i;:::-;55080:11;;55044:48;;;;;;;55074:4;;55062:10;;55044:48;;;;;;;;;55117:1;55103:15;;;55129;;;;:19;-1:-1:-1;;54800:356:0:o;52108:180::-;52170:8;:15;52153:14;52196:85;52224:6;52218:3;:12;52196:85;;;52254:15;52265:3;52254:10;:15::i;:::-;52232:5;;52196:85;;;;52108:180;:::o;51796:304::-;34126:12;:10;:12::i;:::-;-1:-1:-1;;;;;34115:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;34115:23:0;;34107:68;;;;;-1:-1:-1;;;34107:68:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;34107:68:0;;;;;;;;;;;;;;;51894:11:::1;51890:61;;;51922:17;:15;:17::i;:::-;51979:63;52030:11;51979:46;51999:8;52008:4;51999:14;;;;;;;;;;;;;;;;;;:25;;;51979:15;;:19;;:46;;;;:::i;:::-;:50:::0;::::1;:63::i;:::-;51961:15;:81;;;;52081:11;52053:8;52062:4;52053:14;;;;;;;;;;;;;;;;;;:25;;:39;;;;51796:304:::0;;;:::o;34546:148::-;34126:12;:10;:12::i;:::-;-1:-1:-1;;;;;34115:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;34115:23:0;;34107:68;;;;;-1:-1:-1;;;34107:68:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;34107:68:0;;;;;;;;;;;;;;;34653:1:::1;34637:6:::0;;34616:40:::1;::::0;-1:-1:-1;;;;;34637:6:0;;::::1;::::0;34616:40:::1;::::0;34653:1;;34616:40:::1;34684:1;34667:19:::0;;-1:-1:-1;;;;;;34667:19:0::1;::::0;;34546:148::o;56603:477::-;56665:7;56685:18;56706:44;56734:1;56720:12;:15;56737:12;56706:13;:44::i;:::-;56685:65;-1:-1:-1;56765:9:0;56761:312;;56798:43;56837:3;56799:32;56814:16;;56799:10;:14;;:32;;;;:::i;56798:43::-;56791:50;;;;;56761:312;56890:171;57057:3;56891:142;57017:15;;56891:103;56964:8;56980:1;56973:4;:8;56964:18;;;;;;;;;;;;;;;;;;:29;;;56891:50;56924:16;;56891:10;:32;;:50;;;;:::i;:::-;:72;;:103::i;56603:477::-;;;;:::o;33895:87::-;33941:7;33968:6;-1:-1:-1;;;;;33968:6:0;33895:87;:::o;55505:688::-;55638:11;;55577:7;;;;55630:19;;55626:33;;;55658:1;55651:8;;;;;55626:33;55677:9;55672:488;55696:16;:23;55692:27;;55672:488;;;55741:16;55760;55777:1;55760:19;;;;;;;;;;;;;;;;55741:38;;55807:8;55800:3;:15;55796:147;;55836:9;55848:40;55867:17;55885:1;55867:20;;;;;;;;;;;;;;;;;;55848:14;:3;55856:5;55848:7;:14::i;:40::-;55836:52;-1:-1:-1;55914:13:0;:6;55836:52;55914:10;:13::i;:::-;55907:20;;;;;;;;55796:147;55971:8;55963:5;:16;55959:190;;;56000:9;56012:45;56036:17;56054:1;56036:20;;;;;;;;;;;;;;;;;;56012:19;:8;56025:5;56012:12;:19::i;:45::-;56084:8;;-1:-1:-1;56084:8:0;;56000:57;-1:-1:-1;56120:13:0;:6;56000:57;56120:10;:13::i;:::-;56111:22;;55959:190;;-1:-1:-1;55721:3:0;;55672:488;;;-1:-1:-1;56179:6:0;55505:688;-1:-1:-1;;;55505:688:0:o;49809:66::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;49292:31::-;;;;:::o;49477:36::-;;;;:::o;57088:656::-;57161:7;57181:21;57205:8;57214:4;57205:14;;;;;;;;;;;;;;;;57254;;;:8;:14;;;;;;-1:-1:-1;;;;;57254:21:0;;;;;;;;;;;57205:14;;;;;;;57311:19;;;;57360:12;;:37;;-1:-1:-1;;;57360:37:0;;57391:4;57360:37;;;;;;;;;57205:14;;-1:-1:-1;57254:21:0;;57311:19;;57205:14;;57360:12;;;;;:22;;:37;;;;;57205:14;;57360:37;;;;;:12;:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;57360:37:0;57427:20;;;;57360:37;;-1:-1:-1;57412:12:0;:35;:51;;;;;57462:1;57451:8;:12;57412:51;57408:249;;;57480:14;57497:66;57511:4;:20;;;57533:12;57547:4;:15;;;57497:13;:66::i;:::-;57480:83;-1:-1:-1;57595:50:0;57614:30;57635:8;57614:16;57480:83;57625:4;57614:10;:16::i;:30::-;57595:14;;:18;:50::i;:::-;57578:67;;57408:249;;57674:62;57720:4;:15;;;57674:41;57710:4;57674:31;57690:14;57674:4;:11;;;:15;;:31;;;;:::i;:62::-;57667:69;57088:656;-1:-1:-1;;;;;;;57088:656:0:o;49256:23::-;;;-1:-1:-1;;;;;49256:23:0;;:::o;54652:77::-;54705:16;54713:4;54719:1;54705:7;:16::i;56201:394::-;56294:4;56311:18;56332:25;56346:5;56353:3;56332:13;:25::i;:::-;56311:46;;56368:14;56385:81;56462:3;56386:70;56440:15;;56386:49;56423:11;56386:32;56401:16;;56386:10;:14;;:32;;;;:::i;56385:81::-;56368:98;;56477:21;56501:5;;;;;;;;;-1:-1:-1;;;;;56501:5:0;-1:-1:-1;;;;;56501:19:0;;:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;56501:21:0;;-1:-1:-1;56540:22:0;;;:47;;56581:6;56540:47;;;56565:13;56540:47;56533:54;;;;;56201:394;;;;;;:::o;49617:42::-;;;;;;;;;;;;;:::o;53144:752::-;53210:21;53234:8;53243:4;53234:14;;;;;;;;;;;;;;;;53283;;;:8;:14;;;;;;53298:10;53283:26;;;;;;;53234:14;;;;;;;;-1:-1:-1;53320:16:0;53292:4;53320:10;:16::i;:::-;53351:11;;:15;53347:237;;53383:15;53401:67;53452:4;:15;;;53401:46;53442:4;53401:36;53417:4;:19;;;53401:4;:11;;;:15;;:36;;;;:::i;:67::-;53383:85;-1:-1:-1;53486:11:0;;53483:90;;53518:39;53537:10;53549:7;53518:18;:39::i;:::-;53347:237;;53597:11;;53594:170;;53625:12;;:74;;-1:-1:-1;;;;;53625:12:0;53663:10;53684:4;53691:7;53625:29;:74::i;:::-;53728:11;;:24;;53744:7;53728:15;:24::i;:::-;53714:38;;53594:170;53808:19;;;;53792:11;;:46;;53833:4;;53792:36;;:15;:36::i;:46::-;53774:15;;;:64;53854:34;;;;;;;;53874:4;;53862:10;;53854:34;;;;;;;;;53144:752;;;;:::o;34849:244::-;34126:12;:10;:12::i;:::-;-1:-1:-1;;;;;34115:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;34115:23:0;;34107:68;;;;;-1:-1:-1;;;34107:68:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;34107:68:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;34938:22:0;::::1;34930:73;;;;-1:-1:-1::0;;;34930:73:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;35040:6;::::0;;35019:38:::1;::::0;-1:-1:-1;;;;;35019:38:0;;::::1;::::0;35040:6;::::1;::::0;35019:38:::1;::::0;::::1;35068:6;:17:::0;;-1:-1:-1;;;;;;35068:17:0::1;-1:-1:-1::0;;;;;35068:17:0;;;::::1;::::0;;;::::1;::::0;;34849:244::o;6518:220::-;6576:7;6600:6;6596:20;;-1:-1:-1;6615:1:0;6608:8;;6596:20;6639:5;;;6643:1;6639;:5;:1;6663:5;;;;;:10;6655:56;;;;-1:-1:-1;;;6655:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5639:179;5697:7;5729:5;;;5753:6;;;;5745:46;;;;;-1:-1:-1;;;5745:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;32430:106;32518:10;32430:106;:::o;7216:153::-;7274:7;7306:1;7302;:5;7294:44;;;;;-1:-1:-1;;;7294:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;7360:1;7356;:5;;;;;;;7216:153;-1:-1:-1;;;7216:153:0:o;6101:158::-;6159:7;6192:1;6187;:6;;6179:49;;;;;-1:-1:-1;;;6179:49:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;6246:5:0;;;6101:158::o;55202:271::-;55294:5;;:30;;;-1:-1:-1;;;55294:30:0;;55318:4;55294:30;;;;;;55280:11;;-1:-1:-1;;;;;55294:5:0;;:15;;:30;;;;;;;;;;;;;;:5;:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;55294:30:0;;-1:-1:-1;55339:13:0;;;55335:131;;;55369:5;;:24;;;-1:-1:-1;;;55369:24:0;;-1:-1:-1;;;;;55369:24:0;;;;;;;;;;;;;;;:5;;;;;:14;;:24;;;;;;;;;;;;;;:5;;:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;55335:131:0;;-1:-1:-1;55335:131:0;;55426:5;;:28;;;-1:-1:-1;;;55426:28:0;;-1:-1:-1;;;;;55426:28:0;;;;;;;;;;;;;;;:5;;;;;:14;;:28;;;;;;;;;;;;;;:5;;:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;55335:131:0;55202:271;;;:::o;19005:177::-;19115:58;;;-1:-1:-1;;;;;19115:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;19115:58:0;-1:-1:-1;;;19115:58:0;;;19088:86;;19108:5;;19088:19;:86::i;19190:205::-;19318:68;;;-1:-1:-1;;;;;19318:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;19318:68:0;-1:-1:-1;;;19318:68:0;;;19291:96;;19311:5;;19291:19;:96::i;:::-;19190:205;;;;:::o;21310:761::-;21734:23;21760:69;21788:4;21760:69;;;;;;;;;;;;;;;;;21768:5;-1:-1:-1;;;;;21760:27:0;;;:69;;;;;:::i;:::-;21844:17;;21734:95;;-1:-1:-1;21844:21:0;21840:224;;21986:10;21975:30;;;;;;;;;;;;;;;-1:-1:-1;21975:30:0;21967:85;;;;-1:-1:-1;;;21967:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13998:195;14101:12;14133:52;14155:6;14163:4;14169:1;14172:12;14133:21;:52::i;:::-;14126:59;13998:195;-1:-1:-1;;;;13998:195:0:o;15050:530::-;15177:12;15235:5;15210:21;:30;;15202:81;;;;-1:-1:-1;;;15202:81:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15302:18;15313:6;15302:10;:18::i;:::-;15294:60;;;;;-1:-1:-1;;;15294:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;15428:12;15442:23;15469:6;-1:-1:-1;;;;;15469:11:0;15489:5;15497:4;15469:33;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;15469:33:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15427:75;;;;15520:52;15538:7;15547:10;15559:12;15520:17;:52::i;11080:422::-;11447:20;11486:8;;;11080:422::o;17590:742::-;17705:12;17734:7;17730:595;;;-1:-1:-1;17765:10:0;17758:17;;17730:595;17879:17;;:21;17875:439;;18142:10;18136:17;18203:15;18190:10;18186:2;18182:19;18175:44;18090:148;18285:12;18278:20;;-1:-1:-1;;;18278:20:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
Swarm Source
ipfs://cb303078c41b345abac898d6e5e817e20cd601191230fc34eca90166f45b7079
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 27 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
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.