More Info
Private Name Tags
ContractCreator
Latest 25 from a total of 8,463 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Withdraw | 65332768 | 65 days ago | IN | 0 POL | 0.0037501 | ||||
Withdraw | 65084869 | 72 days ago | IN | 0 POL | 0.00488997 | ||||
Deposit | 57661542 | 257 days ago | IN | 0 POL | 0.00411859 | ||||
Deposit | 57661539 | 257 days ago | IN | 0 POL | 0.00411897 | ||||
Deposit | 57661536 | 257 days ago | IN | 0 POL | 0.00465368 | ||||
Withdraw | 53800167 | 358 days ago | IN | 0 POL | 0.01200998 | ||||
Deposit | 53289771 | 371 days ago | IN | 0 POL | 0.00531508 | ||||
Deposit | 53289769 | 371 days ago | IN | 0 POL | 0.00600476 | ||||
Deposit | 51991361 | 405 days ago | IN | 0 POL | 0.00450357 | ||||
Deposit | 51559536 | 416 days ago | IN | 0 POL | 0.00477969 | ||||
Deposit | 49829577 | 460 days ago | IN | 0 POL | 0.00889919 | ||||
Deposit | 49829551 | 460 days ago | IN | 0 POL | 0.01083457 | ||||
Withdraw | 47500548 | 520 days ago | IN | 0 POL | 0.01884625 | ||||
Withdraw | 47500537 | 520 days ago | IN | 0 POL | 0.01743782 | ||||
Withdraw | 47500524 | 520 days ago | IN | 0 POL | 0.01788767 | ||||
Withdraw | 47500417 | 520 days ago | IN | 0 POL | 0.01833559 | ||||
Deposit | 45833662 | 561 days ago | IN | 0 POL | 0.00994475 | ||||
Deposit | 45833660 | 561 days ago | IN | 0 POL | 0.0112928 | ||||
Deposit | 44128004 | 605 days ago | IN | 0 POL | 0.02534461 | ||||
Deposit | 42307441 | 652 days ago | IN | 0 POL | 0.04128101 | ||||
Deposit | 40662124 | 694 days ago | IN | 0 POL | 0.01215256 | ||||
Withdraw | 40468164 | 699 days ago | IN | 0 POL | 0.02451579 | ||||
Withdraw | 40468164 | 699 days ago | IN | 0 POL | 0.02266338 | ||||
Deposit | 40468164 | 699 days ago | IN | 0 POL | 0.02068463 | ||||
Deposit | 40468164 | 699 days ago | IN | 0 POL | 0.02066146 |
Loading...
Loading
Contract Name:
MasterChef
Compiler Version
v0.6.12+commit.27d51765
Contract Source Code (Solidity)
/** *Submitted for verification at polygonscan.com on 2021-08-09 */ /** *Submitted for verification at polygonscan.com on 2021-08-06 */ /** *Submitted for verification at polygonscan.com on 2021-07-13 */ // SPDX-License-Identifier: MIT pragma solidity 0.6.12; /** * @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; } } 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; } } 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; } } pragma solidity >=0.6.4; interface IERC20 { /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the token decimals. */ function decimals() external view returns (uint8); /** * @dev Returns the token symbol. */ function symbol() external view returns (string memory); /** * @dev Returns the token name. */ function name() external view returns (string memory); /** * @dev Returns the bep token owner. */ function getOwner() external view returns (address); /** * @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); } pragma solidity >=0.4.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 {BEP20PresetMinterPauser}. * * TIP: For a detailed writeup see our guide * https://forum.zeppelin.solutions/t/how-to-implement-BEP20-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 BEP20 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 BEP20 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; 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 bep token owner. */ function getOwner() external override view returns (address) { return owner(); } /** * @dev Returns the token name. */ function name() public override view returns (string memory) { return _name; } /** * @dev Returns the token decimals. */ function decimals() public override view returns (uint8) { return _decimals; } /** * @dev Returns the token symbol. */ function symbol() public override view returns (string memory) { return _symbol; } /** * @dev See {BEP20-totalSupply}. */ function totalSupply() public override view returns (uint256) { return _totalSupply; } /** * @dev See {BEP20-balanceOf}. */ function balanceOf(address account) public override view returns (uint256) { return _balances[account]; } /** * @dev See {BEP20-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 override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } /** * @dev See {BEP20-allowance}. */ function allowance(address owner, address spender) public override view returns (uint256) { return _allowances[owner][spender]; } /** * @dev See {BEP20-approve}. * * Requirements: * * - `spender` cannot be the zero address. */ function approve(address spender, uint256 amount) public override returns (bool) { _approve(_msgSender(), spender, amount); return true; } /** * @dev See {BEP20-transferFrom}. * * Emits an {Approval} event indicating the updated allowance. This is not * required by the EIP. See the note at the beginning of {BEP20}; * * 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 override returns (bool) { _transfer(sender, recipient, amount); _approve( sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "BEP20: 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 {BEP20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. */ function increaseAllowance(address spender, uint256 addedValue) public 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 {BEP20-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 returns (bool) { _approve( _msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "BEP20: decreased allowance below zero") ); return true; } /** * @dev Creates `amount` tokens and assigns them to `msg.sender`, increasing * the total supply. * * Requirements * * - `msg.sender` must be the token owner */ function mint(uint256 amount) public onlyOwner returns (bool) { _mint(_msgSender(), amount); 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), "BEP20: transfer from the zero address"); require(recipient != address(0), "BEP20: transfer to the zero address"); _balances[sender] = _balances[sender].sub(amount, "BEP20: 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 { require(account != address(0), "BEP20: mint to the zero address"); _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 { require(account != address(0), "BEP20: burn from the zero address"); _balances[account] = _balances[account].sub(amount, "BEP20: 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 { require(owner != address(0), "BEP20: approve from the zero address"); require(spender != address(0), "BEP20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } /** * @dev Destroys `amount` tokens from `account`.`amount` is then deducted * from the caller's allowance. * * See {_burn} and {_approve}. */ function _burnFrom(address account, uint256 amount) internal { _burn(account, amount); _approve( account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "BEP20: burn amount exceeds allowance") ); } } 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) { // This method relies in 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"); 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); } } } } pragma solidity >=0.5.0; interface IUniswapV2Factory { event PairCreated(address indexed token0, address indexed token1, address pair, uint); function feeTo() external view returns (address); function feeToSetter() external view returns (address); function getPair(address tokenA, address tokenB) external view returns (address pair); function allPairs(uint) external view returns (address pair); function allPairsLength() external view returns (uint); function createPair(address tokenA, address tokenB) external returns (address pair); function setFeeTo(address) external; function setFeeToSetter(address) external; } pragma solidity >=0.5.0; interface IUniswapV2Pair { event Approval(address indexed owner, address indexed spender, uint value); event Transfer(address indexed from, address indexed to, uint value); function name() external pure returns (string memory); function symbol() external pure returns (string memory); function decimals() external pure returns (uint8); function totalSupply() external view returns (uint); function balanceOf(address owner) external view returns (uint); function allowance(address owner, address spender) external view returns (uint); function approve(address spender, uint value) external returns (bool); function transfer(address to, uint value) external returns (bool); function transferFrom(address from, address to, uint value) external returns (bool); function DOMAIN_SEPARATOR() external view returns (bytes32); function PERMIT_TYPEHASH() external pure returns (bytes32); function nonces(address owner) external view returns (uint); function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external; event Mint(address indexed sender, uint amount0, uint amount1); event Burn(address indexed sender, uint amount0, uint amount1, address indexed to); event Swap( address indexed sender, uint amount0In, uint amount1In, uint amount0Out, uint amount1Out, address indexed to ); event Sync(uint112 reserve0, uint112 reserve1); function MINIMUM_LIQUIDITY() external pure returns (uint); function factory() external view returns (address); function token0() external view returns (address); function token1() external view returns (address); function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast); function price0CumulativeLast() external view returns (uint); function price1CumulativeLast() external view returns (uint); function kLast() external view returns (uint); function mint(address to) external returns (uint liquidity); function burn(address to) external returns (uint amount0, uint amount1); function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external; function skim(address to) external; function sync() external; function initialize(address, address) external; } pragma solidity >=0.6.2; interface IUniswapV2Router01 { function factory() external pure returns (address); function WETH() external pure returns (address); function addLiquidity( address tokenA, address tokenB, uint amountADesired, uint amountBDesired, uint amountAMin, uint amountBMin, address to, uint deadline ) external returns (uint amountA, uint amountB, uint liquidity); function addLiquidityETH( address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external payable returns (uint amountToken, uint amountETH, uint liquidity); function removeLiquidity( address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline ) external returns (uint amountA, uint amountB); function removeLiquidityETH( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external returns (uint amountToken, uint amountETH); function removeLiquidityWithPermit( address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountA, uint amountB); function removeLiquidityETHWithPermit( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountToken, uint amountETH); function swapExactTokensForTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts); function swapTokensForExactTokens( uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts); function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB); function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut); function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn); function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts); function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts); } pragma solidity >=0.6.2; interface IUniswapV2Router02 is IUniswapV2Router01 { function removeLiquidityETHSupportingFeeOnTransferTokens( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external returns (uint amountETH); function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountETH); function swapExactTokensForTokensSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; function swapExactETHForTokensSupportingFeeOnTransferTokens( uint amountOutMin, address[] calldata path, address to, uint deadline ) external payable; function swapExactTokensForETHSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; } contract SUNSET is BEP20 { // Transfer tax rate in basis points. uint16 public transferTaxRate = 500; // Burn address address public constant BURN_ADDRESS = address(0); uint256 public constant MAX_SUPPLY = 45000 ether; uint256 private maxsuppy_count; // Automatic swap and liquify enabled bool public swapAndLiquifyEnabled = false; // Min amount to liquify. (default 0.1 SUNSET) uint256 public minAmountToLiquify = 1e17; IUniswapV2Router02 public QuickswapRouter; // The trading pair address public SunsetPair; // In swap and liquify bool private _inSwapAndLiquify; // The operator can only update the transfer tax rate address private _operator; // mapping (address=>bool) public excludeaccount; mapping (address => bool) private _isExcluded; // Events event OperatorTransferred(address indexed previousOperator, address indexed newOperator); event TransferTaxRateUpdated(address indexed operator, uint256 previousRate, uint256 newRate); event SwapAndLiquifyEnabledUpdated(address indexed operator, bool enabled); event MinAmountToLiquifyUpdated(address indexed operator, uint256 previousAmount, uint256 newAmount); event SwapAndLiquify(uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiqudity); modifier onlyOperator() { require(_operator == msg.sender, "operator: caller is not the operator"); _; } modifier lockTheSwap { _inSwapAndLiquify = true; _; _inSwapAndLiquify = false; } modifier transferTaxFree { uint16 _transferTaxRate = transferTaxRate; transferTaxRate = 0; _; transferTaxRate = _transferTaxRate; } /** * @notice Constructs the SUNSET contract. */ constructor() public BEP20("Sunset", "SUNSET") { _operator = _msgSender(); QuickswapRouter = IUniswapV2Router02(address(0xa5E0829CaCEd8fFDD4De3c43696c57F7D7A678ff)); emit OperatorTransferred(address(0), _operator); } function isExcluded(address account) public view returns (bool) { return _isExcluded[account]; } function excludeaccount(address _add) public onlyOwner{ _isExcluded[_add]=true; } /// @notice Creates `_amount` token to `_to`. Must only be called by the owner (MasterChef). function mint(address _to, uint256 _amount) public onlyOwner { require(maxsuppy_count<=MAX_SUPPLY,"Max supply reached"); _mint(_to, _amount); maxsuppy_count=maxsuppy_count+_amount; } /// @dev overrides transfer function to meet tokenomics of SUNSET function _transfer(address sender, address recipient, uint256 amount) internal virtual override{ // swap and liquify if ( swapAndLiquifyEnabled == true && _inSwapAndLiquify == false && address(QuickswapRouter) != address(0) && SunsetPair != address(0) && sender != SunsetPair && sender != owner() ) { swapAndLiquify(); } if (recipient == BURN_ADDRESS || transferTaxRate == 0 || isExcluded(recipient)==true || sender==owner()) { super._transfer(sender, recipient, amount); } else { // default tax is 5% of every transfer uint256 taxAmount = amount.mul(transferTaxRate).div(10000); // default 95% of transfer sent to recipient uint256 sendAmount = amount.sub(taxAmount); require(amount == sendAmount + taxAmount, "SUNSET::transfer: Tax value invalid"); super._transfer(sender, address(this), taxAmount); super._transfer(sender, recipient, sendAmount); amount = sendAmount; } } /// @dev Swap and liquify function swapAndLiquify() private lockTheSwap transferTaxFree { uint256 contractTokenBalance = balanceOf(address(this)); if (contractTokenBalance >= minAmountToLiquify) { // only min amount to liquify uint256 liquifyAmount = minAmountToLiquify; // split the liquify amount into halves uint256 half = liquifyAmount.div(2); uint256 otherHalf = liquifyAmount.sub(half); // capture the contract's current ETH balance. // this is so that we can capture exactly the amount of ETH that the // swap creates, and not make the liquidity event include any ETH that // has been manually sent to the contract uint256 initialBalance = address(this).balance; // swap tokens for ETH swapTokensForEth(half); // how much ETH did we just swap into? uint256 newBalance = address(this).balance.sub(initialBalance); // add liquidity addLiquidity(otherHalf, newBalance); emit SwapAndLiquify(half, newBalance, otherHalf); } } /// @dev Swap tokens for eth function swapTokensForEth(uint256 tokenAmount) private { // generate the SUNSET pair path of token -> weth address[] memory path = new address[](2); path[0] = address(this); path[1] = QuickswapRouter.WETH(); _approve(address(this), address(QuickswapRouter), tokenAmount); // make the swap QuickswapRouter.swapExactTokensForETHSupportingFeeOnTransferTokens( tokenAmount, 0, // accept any amount of ETH path, address(this), block.timestamp ); } /// @dev Add liquidity function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private { // approve token transfer to cover all possible scenarios _approve(address(this), address(QuickswapRouter), tokenAmount); // add the liquidity QuickswapRouter.addLiquidityETH{value: ethAmount}( address(this), tokenAmount, 0, // slippage is unavoidable 0, // slippage is unavoidable operator(), block.timestamp ); } // To receive MATIC from QuickswapRouter when swapping receive() external payable {} /** * @dev Update the min amount to liquify. * Can only be called by the current operator. */ function updateMinAmountToLiquify(uint256 _minAmount) public onlyOperator { emit MinAmountToLiquifyUpdated(msg.sender, minAmountToLiquify, _minAmount); minAmountToLiquify = _minAmount; } /** * @dev Update the swapAndLiquifyEnabled. * Can only be called by the current operator. */ function updateSwapAndLiquifyEnabled(bool _enabled) public onlyOperator { emit SwapAndLiquifyEnabledUpdated(msg.sender, _enabled); swapAndLiquifyEnabled = _enabled; } function updateSunsetPair(address _SunsetPair) public onlyOperator { SunsetPair = _SunsetPair; require(SunsetPair != address(0), "SUNSET::updateQuickswapRouter: Invalid pair address."); } /** * @dev Returns the address of the current operator. */ function operator() public view returns (address) { return _operator; } /** * @dev Transfers operator of the contract to a new account (`newOperator`). * Can only be called by the current operator. */ function transferOperator(address newOperator) public onlyOperator { require(newOperator != address(0), "SUNSET::transferOperator: new operator is the zero address"); emit OperatorTransferred(_operator, newOperator); _operator = newOperator; } } 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"); } } } contract ReentrancyGuard { // Booleans are more expensive than uint256 or any type that takes up a full // word because each write operation emits an extra SLOAD to first read the // slot's contents, replace the bits taken up by the boolean, and then write // back. This is the compiler's defense against contract upgrades and // pointer aliasing, and it cannot be disabled. // The values being non-zero value makes deployment a bit more expensive, // but in exchange the refund on every call to nonReentrant will be lower in // amount. Since refunds are capped to a percentage of the total // transaction's gas, it is best to keep them low in cases like this one, to // increase the likelihood of the full refund coming into effect. uint256 private constant _NOT_ENTERED = 1; uint256 private constant _ENTERED = 2; uint256 private _status; constructor () internal { _status = _NOT_ENTERED; } /** * @dev Prevents a contract from calling itself, directly or indirectly. * Calling a `nonReentrant` function from another `nonReentrant` * function is not supported. It is possible to prevent this from happening * by making the `nonReentrant` function external, and make it call a * `private` function that does the actual work. */ modifier nonReentrant() { // On the first call to nonReentrant, _notEntered will be true require(_status != _ENTERED, "ReentrancyGuard: reentrant call"); // Any calls to nonReentrant after this point will fail _status = _ENTERED; _; // By storing the original value once again, a refund is triggered (see // https://eips.ethereum.org/EIPS/eip-2200) _status = _NOT_ENTERED; } } contract MasterChef is Ownable, ReentrancyGuard { 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 rewardDebt; // Reward debt. See explanation below. // // We do some fancy math here. Basically, any point in time, the amount of SUNSET // entitled to a user but is pending to be distributed is: // // pending reward = (user.amount * pool.accSUNSETPerShare) - user.rewardDebt // // Whenever a user deposits or withdraws LP tokens to a pool. Here's what happens: // 1. The pool's `accSUNSETPerShare` (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. uint256 allocPoint; // How many allocation points assigned to this pool. SUNSET to distribute per block. uint256 lastRewardBlock; // Last block number that SUNSET distribution occurs. uint256 accSUNSETPerShare; // Accumulated SUNSET per share, times 1e18. See below. uint16 depositFeeBP; // Deposit fee in basis points } // The SUNSET TOKEN! SUNSET public SUNSETToken; address public devAddress; address public feeAddress1; address public feeAddress2; // SUNSET tokens created per block. uint256 public SUNSETPerBlock = 0.0015 ether; // Info of each pool. PoolInfo[] public poolInfo; // Info of each user that stakes LP tokens. mapping(uint256 => mapping(address => UserInfo)) public userInfo; // Total allocation points. Must be the sum of all allocation points in all pools. uint256 public totalAllocPoint = 0; // The block number when SUNSET mining starts. uint256 public startBlock; 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 SetFeeAddress(address indexed user, address indexed newAddress); event SetDevAddress(address indexed user, address indexed newAddress); event SetVaultAddress(address indexed user, address indexed newAddress); event UpdateEmissionRate(address indexed user, uint256 SUNSETPerBlock); constructor( SUNSET _SUNSET, uint256 _startBlock, address _devAddress, address _feeAddress1, address _feeAddress2 ) public { SUNSETToken = _SUNSET; startBlock = _startBlock; devAddress = _devAddress; feeAddress1 = _feeAddress1; feeAddress2 = _feeAddress2; } function poolLength() external view returns (uint256) { return poolInfo.length; } mapping(IERC20 => bool) public poolExistence; modifier nonDuplicated(IERC20 _lpToken) { require(poolExistence[_lpToken] == false, "nonDuplicated: duplicated"); _; } // Add a new lp to the pool. Can only be called by the owner. function add(uint256 _allocPoint, IERC20 _lpToken, uint16 _depositFeeBP) external onlyOwner nonDuplicated(_lpToken) { require(_depositFeeBP <= 400, "add: invalid deposit fee basis points"); uint256 lastRewardBlock = block.number > startBlock ? block.number : startBlock; totalAllocPoint = totalAllocPoint.add(_allocPoint); poolExistence[_lpToken] = true; poolInfo.push(PoolInfo({ lpToken: _lpToken, allocPoint: _allocPoint, lastRewardBlock: lastRewardBlock, accSUNSETPerShare: 0, depositFeeBP: _depositFeeBP })); } // Update the given pool's SUNSET allocation point and deposit fee. Can only be called by the owner. function set(uint256 _pid, uint256 _allocPoint, uint16 _depositFeeBP) external onlyOwner { require(_depositFeeBP <= 400, "set: invalid deposit fee basis points"); totalAllocPoint = totalAllocPoint.sub(poolInfo[_pid].allocPoint).add(_allocPoint); poolInfo[_pid].allocPoint = _allocPoint; poolInfo[_pid].depositFeeBP = _depositFeeBP; } // Return reward multiplier over the given _from to _to block. function getMultiplier(uint256 _from, uint256 _to) public pure returns (uint256) { return _to.sub(_from); } // View function to see pending SUNSET on frontend. function pendingSUNSET(uint256 _pid, address _user) external view returns (uint256) { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][_user]; uint256 accSUNSETPerShare = pool.accSUNSETPerShare; uint256 lpSupply = pool.lpToken.balanceOf(address(this)); if (block.number > pool.lastRewardBlock && lpSupply != 0) { uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number); uint256 SUNSETReward = multiplier.mul(SUNSETPerBlock).mul(pool.allocPoint).div(totalAllocPoint); accSUNSETPerShare = accSUNSETPerShare.add(SUNSETReward.mul(1e18).div(lpSupply)); } return user.amount.mul(accSUNSETPerShare).div(1e18).sub(user.rewardDebt); } // Update reward variables 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 lpSupply = pool.lpToken.balanceOf(address(this)); if (lpSupply == 0 || pool.allocPoint == 0) { pool.lastRewardBlock = block.number; return; } uint256 multiplier = getMultiplier(pool.lastRewardBlock, block.number); uint256 SUNSETReward = multiplier.mul(SUNSETPerBlock).mul(pool.allocPoint).div(totalAllocPoint); SUNSETToken.mint(address(this), SUNSETReward); SUNSETToken.mint(feeAddress1, SUNSETReward.mul(25).div(1000)); SUNSETToken.mint(feeAddress2, SUNSETReward.mul(25).div(1000)); pool.accSUNSETPerShare = pool.accSUNSETPerShare.add(SUNSETReward.mul(1e18).div(lpSupply)); pool.lastRewardBlock = block.number; } // Deposit LP tokens to MasterChef for SUNSET allocation. function deposit(uint256 _pid, uint256 _amount) public nonReentrant { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; updatePool(_pid); if (user.amount > 0) { uint256 pending = user.amount.mul(pool.accSUNSETPerShare).div(1e18).sub(user.rewardDebt); if (pending > 0) { safeSUNSETTransfer(msg.sender, pending); } } if (_amount > 0) { pool.lpToken.safeTransferFrom(address(msg.sender), address(this), _amount); if (pool.depositFeeBP > 0) { uint256 depositFee = _amount.mul(pool.depositFeeBP).div(10000); pool.lpToken.safeTransfer(feeAddress1, depositFee.div(2)); pool.lpToken.safeTransfer(feeAddress2, depositFee.div(2)); user.amount = user.amount.add(_amount).sub(depositFee); } else { user.amount = user.amount.add(_amount); } } user.rewardDebt = user.amount.mul(pool.accSUNSETPerShare).div(1e18); emit Deposit(msg.sender, _pid, _amount); } // Withdraw LP tokens from MasterChef. function withdraw(uint256 _pid, uint256 _amount) public nonReentrant { 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.accSUNSETPerShare).div(1e18).sub(user.rewardDebt); if (pending > 0) { safeSUNSETTransfer(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.accSUNSETPerShare).div(1e18); emit Withdraw(msg.sender, _pid, _amount); } // Withdraw without caring about rewards. EMERGENCY ONLY. function emergencyWithdraw(uint256 _pid) public nonReentrant { PoolInfo storage pool = poolInfo[_pid]; UserInfo storage user = userInfo[_pid][msg.sender]; uint256 amount = user.amount; user.amount = 0; user.rewardDebt = 0; pool.lpToken.safeTransfer(address(msg.sender), amount); emit EmergencyWithdraw(msg.sender, _pid, amount); } // Safe SUNSET transfer function, just in case if rounding error causes pool to not have enough SUNSET. function safeSUNSETTransfer(address _to, uint256 _amount) internal { uint256 SUNSETBal = SUNSETToken.balanceOf(address(this)); bool transferSuccess = false; if (_amount > SUNSETBal) { transferSuccess = SUNSETToken.transfer(_to, SUNSETBal); } else { transferSuccess = SUNSETToken.transfer(_to, _amount); } require(transferSuccess, "safeSUNSETTransfer: Transfer failed"); } // Update dev address by the previous dev. function setDevAddress(address _devAddress) external onlyOwner { devAddress = _devAddress; emit SetDevAddress(msg.sender, _devAddress); } function setFeeAddress1(address _feeAddress1) external onlyOwner { feeAddress1 = _feeAddress1; emit SetFeeAddress(msg.sender, _feeAddress1); } function updateEmissionRate(uint256 _SUNSETPerBlock) external onlyOwner { massUpdatePools(); SUNSETPerBlock = _SUNSETPerBlock; emit UpdateEmissionRate(msg.sender, _SUNSETPerBlock); } // Only update before start of farm function updateStartBlock(uint256 _startBlock) public onlyOwner { startBlock = _startBlock; } function _exclude(address _add) public onlyOwner{ SUNSETToken.excludeaccount(_add); } function _updateSwapAndLiquifyEnabled(bool _bool) public onlyOwner{ SUNSETToken.updateSwapAndLiquifyEnabled(_bool); } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"contract SUNSET","name":"_SUNSET","type":"address"},{"internalType":"uint256","name":"_startBlock","type":"uint256"},{"internalType":"address","name":"_devAddress","type":"address"},{"internalType":"address","name":"_feeAddress1","type":"address"},{"internalType":"address","name":"_feeAddress2","type":"address"}],"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":"address","name":"newAddress","type":"address"}],"name":"SetDevAddress","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"newAddress","type":"address"}],"name":"SetFeeAddress","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"newAddress","type":"address"}],"name":"SetVaultAddress","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"SUNSETPerBlock","type":"uint256"}],"name":"UpdateEmissionRate","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":"SUNSETPerBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SUNSETToken","outputs":[{"internalType":"contract SUNSET","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_add","type":"address"}],"name":"_exclude","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_bool","type":"bool"}],"name":"_updateSwapAndLiquifyEnabled","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"contract IERC20","name":"_lpToken","type":"address"},{"internalType":"uint16","name":"_depositFeeBP","type":"uint16"}],"name":"add","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":[],"name":"devAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"feeAddress1","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"feeAddress2","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_from","type":"uint256"},{"internalType":"uint256","name":"_to","type":"uint256"}],"name":"getMultiplier","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","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":"pendingSUNSET","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"name":"poolExistence","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":"accSUNSETPerShare","type":"uint256"},{"internalType":"uint16","name":"depositFeeBP","type":"uint16"}],"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":"uint16","name":"_depositFeeBP","type":"uint16"}],"name":"set","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_devAddress","type":"address"}],"name":"setDevAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_feeAddress1","type":"address"}],"name":"setFeeAddress1","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalAllocPoint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_SUNSETPerBlock","type":"uint256"}],"name":"updateEmissionRate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"updatePool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_startBlock","type":"uint256"}],"name":"updateStartBlock","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
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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)
000000000000000000000000254117433901fd06580262f9ec9f7c221148f02400000000000000000000000000000000000000000000000000000000010f8d940000000000000000000000002e6cd5e5c336f89be31cba99b158f07ce89831d70000000000000000000000002e6cd5e5c336f89be31cba99b158f07ce89831d70000000000000000000000002e6cd5e5c336f89be31cba99b158f07ce89831d7
-----Decoded View---------------
Arg [0] : _SUNSET (address): 0x254117433901Fd06580262f9ec9F7C221148F024
Arg [1] : _startBlock (uint256): 17796500
Arg [2] : _devAddress (address): 0x2E6CD5e5c336f89be31cBa99b158f07cE89831D7
Arg [3] : _feeAddress1 (address): 0x2E6CD5e5c336f89be31cBa99b158f07cE89831D7
Arg [4] : _feeAddress2 (address): 0x2E6CD5e5c336f89be31cBa99b158f07cE89831D7
-----Encoded View---------------
5 Constructor Arguments found :
Arg [0] : 000000000000000000000000254117433901fd06580262f9ec9f7c221148f024
Arg [1] : 00000000000000000000000000000000000000000000000000000000010f8d94
Arg [2] : 0000000000000000000000002e6cd5e5c336f89be31cba99b158f07ce89831d7
Arg [3] : 0000000000000000000000002e6cd5e5c336f89be31cba99b158f07ce89831d7
Arg [4] : 0000000000000000000000002e6cd5e5c336f89be31cba99b158f07ce89831d7
Deployed Bytecode Sourcemap
48888:10944:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52291:638;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;51921:95;;;:::i;:::-;;;;;;;;;;;;;;;;;;;59201:214;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;59698:131;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;50629:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50870:34;;;:::i;:::-;;;;;;;;;;;;;;;;;;;50440:26;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;53043:374;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;50408:25;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;56999:761;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;50549:44;;;:::i;:::-;;;;;;;;;;;;;;;;;;;50963:25;;;:::i;:::-;;;;;;;;;;;;;;;;;;;54795:919;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;57831:398;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;50376:25;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;54539:180;;;:::i;:::-;;8119:148;;;:::i;:::-;;7477:79;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;53493:121;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;59026:165;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;50711:64;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;53679:777;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;52024:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;58858:160;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;59587:99;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;55785:1162;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;50473:26;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;8422:244;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;59468:107;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;52291:638;7699:12;:10;:12::i;:::-;7689:22;;:6;;;;;;;;;;:22;;;7681:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52397:8:::1;52161:5;52134:32;;:13;:23;52148:8;52134:23;;;;;;;;;;;;;;;;;;;;;;;;;:32;;;52126:70;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;52443:3:::2;52426:13;:20;;;;52418:70;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52499:23;52540:10;;52525:12;:25;:53;;52568:10;;52525:53;;;52553:12;52525:53;52499:79;;52607:32;52627:11;52607:15;;:19;;:32;;;;:::i;:::-;52589:15;:50;;;;52676:4;52650:13;:23;52664:8;52650:23;;;;;;;;;;;;;;;;:30;;;;;;;;;;;;;;;;;;52691:8;52705:215;;;;;;;;52738:8;52705:215;;;;;;52773:11;52705:215;;;;52816:15;52705:215;;;;52865:1;52705:215;;;;52895:13;52705:215;;;;::::0;52691:230:::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52207:1;7759::::1;52291:638:::0;;;:::o;51921:95::-;51966:7;51993:8;:15;;;;51986:22;;51921:95;:::o;59201:214::-;7699:12;:10;:12::i;:::-;7689:22;;:6;;;;;;;;;;:22;;;7681:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59284:17:::1;:15;:17::i;:::-;59329:15;59312:14;:32;;;;59379:10;59360:47;;;59391:15;59360:47;;;;;;;;;;;;;;;;;;59201:214:::0;:::o;59698:131::-;7699:12;:10;:12::i;:::-;7689:22;;:6;;;;;;;;;;:22;;;7681:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59775:11:::1;;;;;;;;;;;:39;;;59815:5;59775:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;59698:131:::0;:::o;50629:26::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;50870:34::-;;;;:::o;50440:26::-;;;;;;;;;;;;;:::o;53043:374::-;7699:12;:10;:12::i;:::-;7689:22;;:6;;;;;;;;;;:22;;;7681:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53168:3:::1;53151:13;:20;;;;53143:70;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53242:63;53293:11;53242:46;53262:8;53271:4;53262:14;;;;;;;;;;;;;;;;;;:25;;;53242:15;;:19;;:46;;;;:::i;:::-;:50;;:63;;;;:::i;:::-;53224:15;:81;;;;53344:11;53316:8;53325:4;53316:14;;;;;;;;;;;;;;;;;;:25;;:39;;;;53396:13;53366:8;53375:4;53366:14;;;;;;;;;;;;;;;;;;:27;;;:43;;;;;;;;;;;;;;;;;;53043:374:::0;;;:::o;50408:25::-;;;;;;;;;;;;;:::o;56999:761::-;47933:1;48539:7;;:19;;48531:63;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47933:1;48672:7;:18;;;;57079:21:::1;57103:8;57112:4;57103:14;;;;;;;;;;;;;;;;;;57079:38;;57128:21;57152:8;:14;57161:4;57152:14;;;;;;;;;;;:26;57167:10;57152:26;;;;;;;;;;;;;;;57128:50;;57212:7;57197:4;:11;;;:22;;57189:53;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;57253:16;57264:4;57253:10;:16::i;:::-;57280:15;57298:70;57352:4;:15;;;57298:49;57342:4;57298:39;57314:4;:22;;;57298:4;:11;;;:15;;:39;;;;:::i;:::-;:43;;:49;;;;:::i;:::-;:53;;:70;;;;:::i;:::-;57280:88;;57393:1;57383:7;:11;57379:83;;;57411:39;57430:10;57442:7;57411:18;:39::i;:::-;57379:83;57486:1;57476:7;:11;57472:152;;;57518:24;57534:7;57518:4;:11;;;:15;;:24;;;;:::i;:::-;57504:4;:11;;:38;;;;57557:55;57591:10;57604:7;57557:4;:12;;;;;;;;;;;;:25;;;;:55;;;;;:::i;:::-;57472:152;57652:49;57696:4;57652:39;57668:4;:22;;;57652:4;:11;;;:15;;:39;;;;:::i;:::-;:43;;:49;;;;:::i;:::-;57634:4;:15;;:67;;;;57738:4;57726:10;57717:35;;;57744:7;57717:35;;;;;;;;;;;;;;;;;;48703:1;;;47889::::0;48851:7;:22;;;;56999:761;;:::o;50549:44::-;;;;:::o;50963:25::-;;;;:::o;54795:919::-;54847:21;54871:8;54880:4;54871:14;;;;;;;;;;;;;;;;;;54847:38;;54916:4;:20;;;54900:12;:36;54896:75;;54953:7;;;54896:75;54981:16;55000:4;:12;;;;;;;;;;;;:22;;;55031:4;55000:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54981:56;;55064:1;55052:8;:13;:37;;;;55088:1;55069:4;:15;;;:20;55052:37;55048:126;;;55129:12;55106:4;:20;;:35;;;;55156:7;;;;55048:126;55184:18;55205:49;55219:4;:20;;;55241:12;55205:13;:49::i;:::-;55184:70;;55265:20;55288:72;55344:15;;55288:51;55323:4;:15;;;55288:30;55303:14;;55288:10;:14;;:30;;;;:::i;:::-;:34;;:51;;;;:::i;:::-;:55;;:72;;;;:::i;:::-;55265:95;;55371:11;;;;;;;;;;;:16;;;55396:4;55403:12;55371:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55427:11;;;;;;;;;;;:16;;;55444:11;;;;;;;;;;;55457:30;55482:4;55457:20;55474:2;55457:12;:16;;:20;;;;:::i;:::-;:24;;:30;;;;:::i;:::-;55427:61;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55499:11;;;;;;;;;;;:16;;;55516:11;;;;;;;;;;;55529:30;55554:4;55529:20;55546:2;55529:12;:16;;:20;;;;:::i;:::-;:24;;:30;;;;:::i;:::-;55499:61;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55596:64;55623:36;55650:8;55623:22;55640:4;55623:12;:16;;:22;;;;:::i;:::-;:26;;:36;;;;:::i;:::-;55596:4;:22;;;:26;;:64;;;;:::i;:::-;55571:4;:22;;:89;;;;55694:12;55671:4;:20;;:35;;;;54795:919;;;;;;:::o;57831:398::-;47933:1;48539:7;;:19;;48531:63;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47933:1;48672:7;:18;;;;57903:21:::1;57927:8;57936:4;57927:14;;;;;;;;;;;;;;;;;;57903:38;;57952:21;57976:8;:14;57985:4;57976:14;;;;;;;;;;;:26;57991:10;57976:26;;;;;;;;;;;;;;;57952:50;;58013:14;58030:4;:11;;;58013:28;;58066:1;58052:4;:11;;:15;;;;58096:1;58078:4;:15;;:19;;;;58108:54;58142:10;58155:6;58108:4;:12;;;;;;;;;;;;:25;;;;:54;;;;;:::i;:::-;58208:4;58196:10;58178:43;;;58214:6;58178:43;;;;;;;;;;;;;;;;;;48703:1;;;47889::::0;48851:7;:22;;;;57831:398;:::o;50376:25::-;;;;;;;;;;;;;:::o;54539:180::-;54584:14;54601:8;:15;;;;54584:32;;54632:11;54627:85;54655:6;54649:3;:12;54627:85;;;54685:15;54696:3;54685:10;:15::i;:::-;54663:5;;;;;54627:85;;;;54539:180;:::o;8119:148::-;7699:12;:10;:12::i;:::-;7689:22;;:6;;;;;;;;;;:22;;;7681:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8226:1:::1;8189:40;;8210:6;::::0;::::1;;;;;;;;8189:40;;;;;;;;;;;;8257:1;8240:6:::0;::::1;:19;;;;;;;;;;;;;;;;;;8119:148::o:0;7477:79::-;7515:7;7542:6;;;;;;;;;;;7535:13;;7477:79;:::o;53493:121::-;53565:7;53592:14;53600:5;53592:3;:7;;:14;;;;:::i;:::-;53585:21;;53493:121;;;;:::o;59026:165::-;7699:12;:10;:12::i;:::-;7689:22;;:6;;;;;;;;;;:22;;;7681:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59116:12:::1;59102:11;;:26;;;;;;;;;;;;;;;;;;59170:12;59144:39;;59158:10;59144:39;;;;;;;;;;;;59026:165:::0;:::o;50711:64::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;53679:777::-;53754:7;53774:21;53798:8;53807:4;53798:14;;;;;;;;;;;;;;;;;;53774:38;;53823:21;53847:8;:14;53856:4;53847:14;;;;;;;;;;;:21;53862:5;53847:21;;;;;;;;;;;;;;;53823:45;;53879:25;53907:4;:22;;;53879:50;;53940:16;53959:4;:12;;;;;;;;;;;;:22;;;53990:4;53959:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53940:56;;54026:4;:20;;;54011:12;:35;:52;;;;;54062:1;54050:8;:13;;54011:52;54007:359;;;54080:18;54101:49;54115:4;:20;;;54137:12;54101:13;:49::i;:::-;54080:70;;54165:20;54188:72;54244:15;;54188:51;54223:4;:15;;;54188:30;54203:14;;54188:10;:14;;:30;;;;:::i;:::-;:34;;:51;;;;:::i;:::-;:55;;:72;;;;:::i;:::-;54165:95;;54295:59;54317:36;54344:8;54317:22;54334:4;54317:12;:16;;:22;;;;:::i;:::-;:26;;:36;;;;:::i;:::-;54295:17;:21;;:59;;;;:::i;:::-;54275:79;;54007:359;;;54383:65;54432:4;:15;;;54383:44;54422:4;54383:34;54399:17;54383:4;:11;;;:15;;:34;;;;:::i;:::-;:38;;:44;;;;:::i;:::-;:48;;:65;;;;:::i;:::-;54376:72;;;;;;53679:777;;;;:::o;52024:44::-;;;;;;;;;;;;;;;;;;;;;;:::o;58858:160::-;7699:12;:10;:12::i;:::-;7689:22;;:6;;;;;;;;;;:22;;;7681:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58945:11:::1;58932:10;;:24;;;;;;;;;;;;;;;;;;58998:11;58972:38;;58986:10;58972:38;;;;;;;;;;;;58858:160:::0;:::o;59587:99::-;7699:12;:10;:12::i;:::-;7689:22;;:6;;;;;;;;;;:22;;;7681:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59646:11:::1;;;;;;;;;;;:26;;;59673:4;59646:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;59587:99:::0;:::o;55785:1162::-;47933:1;48539:7;;:19;;48531:63;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47933:1;48672:7;:18;;;;55864:21:::1;55888:8;55897:4;55888:14;;;;;;;;;;;;;;;;;;55864:38;;55913:21;55937:8;:14;55946:4;55937:14;;;;;;;;;;;:26;55952:10;55937:26;;;;;;;;;;;;;;;55913:50;;55974:16;55985:4;55974:10;:16::i;:::-;56019:1;56005:4;:11;;;:15;56001:241;;;56037:15;56055:70;56109:4;:15;;;56055:49;56099:4;56055:39;56071:4;:22;;;56055:4;:11;;;:15;;:39;;;;:::i;:::-;:43;;:49;;;;:::i;:::-;:53;;:70;;;;:::i;:::-;56037:88;;56154:1;56144:7;:11;56140:91;;;56176:39;56195:10;56207:7;56176:18;:39::i;:::-;56140:91;56001:241;;56266:1;56256:7;:11;56252:560;;;56284:74;56322:10;56343:4;56350:7;56284:4;:12;;;;;;;;;;;;:29;;;;:74;;;;;;:::i;:::-;56397:1;56377:4;:17;;;;;;;;;;;;:21;;;56373:428;;;56419:18;56440:41;56475:5;56440:30;56452:4;:17;;;;;;;;;;;;56440:30;;:7;:11;;:30;;;;:::i;:::-;:34;;:41;;;;:::i;:::-;56419:62;;56500:57;56526:11;;;;;;;;;;;56539:17;56554:1;56539:10;:14;;:17;;;;:::i;:::-;56500:4;:12;;;;;;;;;;;;:25;;;;:57;;;;;:::i;:::-;56576;56602:11;;;;;;;;;;;56615:17;56630:1;56615:10;:14;;:17;;;;:::i;:::-;56576:4;:12;;;;;;;;;;;;:25;;;;:57;;;;;:::i;:::-;56666:40;56695:10;56666:24;56682:7;56666:4;:11;;;:15;;:24;;;;:::i;:::-;:28;;:40;;;;:::i;:::-;56652:4;:11;;:54;;;;56373:428;;;;56761:24;56777:7;56761:4;:11;;;:15;;:24;;;;:::i;:::-;56747:4;:11;;:38;;;;56373:428;56252:560;56840:49;56884:4;56840:39;56856:4;:22;;;56840:4;:11;;;:15;;:39;;;;:::i;:::-;:43;;:49;;;;:::i;:::-;56822:4;:15;;:67;;;;56925:4;56913:10;56905:34;;;56931:7;56905:34;;;;;;;;;;;;;;;;;;48703:1;;47889::::0;48851:7;:22;;;;55785:1162;;:::o;50473:26::-;;;;;;;;;;;;;:::o;8422:244::-;7699:12;:10;:12::i;:::-;7689:22;;:6;;;;;;;;;;:22;;;7681:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8531:1:::1;8511:22;;:8;:22;;;;8503:73;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8621:8;8592:38;;8613:6;::::0;::::1;;;;;;;;8592:38;;;;;;;;;;;;8650:8;8641:6;::::0;:17:::1;;;;;;;;;;;;;;;;;;8422:244:::0;:::o;59468:107::-;7699:12;:10;:12::i;:::-;7689:22;;:6;;;;;;;;;;:22;;;7681:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59556:11:::1;59543:10;:24;;;;59468:107:::0;:::o;6084:106::-;6137:15;6172:10;6165:17;;6084:106;:::o;1054:181::-;1112:7;1132:9;1148:1;1144;:5;1132:17;;1173:1;1168;:6;;1160:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1226:1;1219:8;;;1054:181;;;;:::o;1518:136::-;1576:7;1603:43;1607:1;1610;1603:43;;;;;;;;;;;;;;;;;:3;:43::i;:::-;1596:50;;1518:136;;;;:::o;2408:471::-;2466:7;2716:1;2711;:6;2707:47;;;2741:1;2734:8;;;;2707:47;2766:9;2782:1;2778;:5;2766:17;;2811:1;2806;2802;:5;;;;;;:10;2794:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2870:1;2863:8;;;2408:471;;;;;:::o;3355:132::-;3413:7;3440:39;3444:1;3447;3440:39;;;;;;;;;;;;;;;;;:3;:39::i;:::-;3433:46;;3355:132;;;;:::o;58346:456::-;58424:17;58444:11;;;;;;;;;;;:21;;;58474:4;58444:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58424:56;;58491:20;58544:9;58534:7;:19;58530:191;;;58588:11;;;;;;;;;;;:20;;;58609:3;58614:9;58588:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58570:54;;58530:191;;;58675:11;;;;;;;;;;;:20;;;58696:3;58701:7;58675:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58657:52;;58530:191;58739:15;58731:63;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58346:456;;;;:::o;43983:177::-;44066:86;44086:5;44116:23;;;44141:2;44145:5;44093:58;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44066:19;:86::i;:::-;43983:177;;;:::o;44168:205::-;44269:96;44289:5;44319:27;;;44348:4;44354:2;44358:5;44296:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44269:19;:96::i;:::-;44168:205;;;;:::o;1957:192::-;2043:7;2076:1;2071;:6;;2079:12;2063:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2103:9;2119:1;2115;:5;2103:17;;2140:1;2133:8;;;1957:192;;;;;:::o;3983:278::-;4069:7;4101:1;4097;:5;4104:12;4089:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4128:9;4144:1;4140;:5;;;;;;4128:17;;4252:1;4245:8;;;3983:278;;;;;:::o;46288:761::-;46712:23;46738:69;46766:4;46738:69;;;;;;;;;;;;;;;;;46746:5;46738:27;;;;:69;;;;;:::i;:::-;46712:95;;46842:1;46822:10;:17;:21;46818:224;;;46964:10;46953:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46945:85;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46818:224;46288:761;;;:::o;25597:196::-;25700:12;25732:53;25755:6;25763:4;25769:1;25772:12;25732:22;:53::i;:::-;25725:60;;25597:196;;;;;:::o;26974:979::-;27104:12;27137:18;27148:6;27137:10;:18::i;:::-;27129:60;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27263:12;27277:23;27304:6;:11;;27324:8;27335:4;27304:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27262:78;;;;27355:7;27351:595;;;27386:10;27379:17;;;;;;27351:595;27520:1;27500:10;:17;:21;27496:439;;;27763:10;27757:17;27824:15;27811:10;27807:2;27803:19;27796:44;27711:148;27906:12;27899:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26974:979;;;;;;;:::o;22679:422::-;22739:4;22947:12;23058:7;23046:20;23038:28;;23092:1;23085:4;:8;23078:15;;;22679:422;;;:::o
Swarm Source
ipfs://a6a589e3fb13577afc49a58478623b7d4bcf9215823230ca6b271fb06635c013
Loading...
Loading
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.