More Info
Private Name Tags
ContractCreator:
Sponsored
Latest 25 from a total of 7,438 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
Value | ||||
---|---|---|---|---|---|---|---|---|---|
Smash Eggs | 17634222 | 967 days ago | IN | 0 MATIC | 0.00014502 | ||||
Smash Eggs | 17634208 | 967 days ago | IN | 0 MATIC | 0.00014502 | ||||
Smash Eggs | 17634194 | 967 days ago | IN | 0 MATIC | 0.00019336 | ||||
Smash Eggs | 17634179 | 967 days ago | IN | 0 MATIC | 0.00014502 | ||||
Smash Eggs | 17634001 | 967 days ago | IN | 0 MATIC | 0.00014502 | ||||
Smash Eggs | 17633880 | 967 days ago | IN | 0 MATIC | 0.00014502 | ||||
Smash Eggs | 17633878 | 967 days ago | IN | 0 MATIC | 0.00012327 | ||||
Smash Eggs | 17633876 | 967 days ago | IN | 0 MATIC | 0.00012327 | ||||
Smash Eggs | 17633874 | 967 days ago | IN | 0 MATIC | 0.00043749 | ||||
Update Smath Egg... | 17633872 | 967 days ago | IN | 0 MATIC | 0.00007253 | ||||
Smash Eggs | 17633872 | 967 days ago | IN | 0 MATIC | 0.00059006 | ||||
Smash Eggs | 17633870 | 967 days ago | IN | 0 MATIC | 0.00016626 | ||||
Smash Eggs | 17633865 | 967 days ago | IN | 0 MATIC | 0.00023146 | ||||
Smash Eggs | 17633863 | 967 days ago | IN | 0 MATIC | 0.00016626 | ||||
Smash Eggs | 17633861 | 967 days ago | IN | 0 MATIC | 0.00036186 | ||||
Smash Eggs | 17633859 | 967 days ago | IN | 0 MATIC | 0.00039478 | ||||
Smash Eggs | 17633856 | 967 days ago | IN | 0 MATIC | 0.00023146 | ||||
Smash Eggs | 17633849 | 967 days ago | IN | 0 MATIC | 0.00042706 | ||||
Smash Eggs | 17633846 | 967 days ago | IN | 0 MATIC | 0.00026406 | ||||
Smash Eggs | 17633842 | 967 days ago | IN | 0 MATIC | 0.00016626 | ||||
Smash Eggs | 17633839 | 967 days ago | IN | 0 MATIC | 0.00016626 | ||||
Smash Eggs | 17633835 | 967 days ago | IN | 0 MATIC | 0.00016626 | ||||
Smash Eggs | 17633832 | 967 days ago | IN | 0 MATIC | 0.00016626 | ||||
Smash Eggs | 17633828 | 967 days ago | IN | 0 MATIC | 0.00016626 | ||||
Smash Eggs | 17633817 | 967 days ago | IN | 0 MATIC | 0.00016626 |
Loading...
Loading
Contract Name:
SmashEggs
Compiler Version
v0.6.6+commit.6c089d02
Contract Source Code (Solidity)
/** *Submitted for verification at polygonscan.com on 2021-08-01 */ // File: @openzeppelin\contracts\math\SafeMath.sol // SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.0; /** * @dev Wrappers over Solidity's arithmetic operations with added overflow * checks. * * Arithmetic operations in Solidity wrap on overflow. This can easily result * in bugs, because programmers usually assume that an overflow raises an * error, which is the standard behavior in high level programming languages. * `SafeMath` restores this intuition by reverting the transaction when an * operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. */ library SafeMath { /** * @dev Returns the addition of two unsigned integers, 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: ..\node_modules\@openzeppelin\contracts\utils\Context.sol // SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.0; /* * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with GSN meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address payable) { return msg.sender; } function _msgData() internal view virtual returns (bytes memory) { this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691 return msg.data; } } // File: ..\node_modules\@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\token\ERC20\ERC20.sol // SPDX-License-Identifier: MIT 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\OwnableContract.sol pragma solidity 0.6.6; contract OwnableContract { address public owner; address public pendingOwner; address public admin; event NewAdmin(address oldAdmin, address newAdmin); event NewOwner(address oldOwner, address newOwner); event NewPendingOwner(address oldPendingOwner, address newPendingOwner); constructor() public { owner = msg.sender; admin = msg.sender; } modifier onlyOwner { require(msg.sender == owner,"onlyOwner"); _; } modifier onlyPendingOwner { require(msg.sender == pendingOwner,"onlyPendingOwner"); _; } modifier onlyAdmin { require(msg.sender == admin || msg.sender == owner,"onlyAdmin"); _; } function transferOwnership(address _pendingOwner) public onlyOwner { emit NewPendingOwner(pendingOwner, _pendingOwner); pendingOwner = _pendingOwner; } function renounceOwnership() public virtual onlyOwner { emit NewOwner(owner, address(0)); emit NewAdmin(admin, address(0)); emit NewPendingOwner(pendingOwner, address(0)); owner = address(0); pendingOwner = address(0); admin = address(0); } function acceptOwner() public onlyPendingOwner { emit NewOwner(owner, pendingOwner); owner = pendingOwner; address newPendingOwner = address(0); emit NewPendingOwner(pendingOwner, newPendingOwner); pendingOwner = newPendingOwner; } function setAdmin(address newAdmin) public onlyOwner { emit NewAdmin(admin, newAdmin); admin = newAdmin; } } // File: contracts\ChickToken.sol pragma solidity 0.6.6; contract ChickToken is ERC20("loserchick", "CHICK"), OwnableContract{ using SafeMath for uint256; address public teamAddr; address public boardAddr; uint256 public dayIndex = 0; mapping(uint256 => uint256) public burnAmountPerDay; mapping(address => uint256) public addUpSwapCchickCountPerUser; uint256 public totalSwapCount = 0; uint256 public chickSwapCchickIndex = 0; event ChickSwapCchick(address userAddress, uint256 amount, uint256 index); constructor(address _teamAddr, address _boardAddr) public { teamAddr = _teamAddr; boardAddr = _boardAddr; _setupDecimals(18); _mint(msg.sender, uint256(13333333).mul(1e18)); } function updateBurnAmount(uint256 amount) internal{ dayIndex = now / 86400; burnAmountPerDay[dayIndex] = amount.add(burnAmountPerDay[dayIndex]); } function getBurnAmountPerDay(uint256 _dayIndex) public view returns(uint256){ return burnAmountPerDay[_dayIndex]; } function getAddUpSwapCchickCountPerUser(address userAddr) public view returns(uint256){ return addUpSwapCchickCountPerUser[userAddr]; } function chickSwapCchick(uint256 floatAmount) public{ require(floatAmount != 0, 'floatAmount cannot be zero'); addUpSwapCchickCountPerUser[msg.sender] = floatAmount.add(addUpSwapCchickCountPerUser[msg.sender]); uint256 amount = floatAmount.mul(1e18); uint256 teamAmount = amount.div(10); // 10 % _transfer(msg.sender, teamAddr, teamAmount); uint256 boardAmount = amount.div(5); // 20 % _transfer(msg.sender, boardAddr, boardAmount); uint256 burnAmount = amount.mul(7).div(10); // 70 % _burn(msg.sender, burnAmount); updateBurnAmount(burnAmount); totalSwapCount = totalSwapCount.add(floatAmount); chickSwapCchickIndex++; emit ChickSwapCchick(msg.sender, floatAmount, chickSwapCchickIndex); } function updateTeamAddr(address _teamAddr) public onlyOwner{ teamAddr = _teamAddr; } function updateBoardAddr(address _boardAddr) public onlyOwner{ boardAddr = _boardAddr; } } // File: contracts\EggToken.sol pragma solidity 0.6.6; pragma experimental ABIEncoderV2; contract EggToken is ERC20("LoserchickEgg", "EGG"), OwnableContract{ using SafeMath for uint256; uint256 public constant MAX_TOTAL_SUPPLY = 7000000 * 1e18; uint256 public dayIndex = 0; uint256 public perUserPerDayLimit; uint256 public marketPerDayLimit; uint256 public addUpClaimCount; uint256 public addUpBurnCount; address public signer1; address public signer2; mapping(uint256 => bool) public claimedOrderId; mapping(uint256 => mapping(address => uint256)) public userClaimCountPerDay; // Maximum per user per day. mapping(uint256 => uint256) public marketClaimCountPerDay; // Maximum market per day. mapping(uint256 => uint256) public burnAmountPerDay; uint256[4] public cChickSwapChickLimit; uint256[4] public ceggSwapEggProportion; mapping(address => uint256) public addUpSwapCeggCountPerUser; ChickToken public chickToken; uint256 public claimIndex = 0; event Claim(uint256 orderId, uint256 amount, address userAddress, address signer, uint256 index); event AleadyClaim(uint256 orderId, uint256 amount, address userAddress); event Burn(address userAddress, uint256 amount); constructor(address _chickAddr) public { chickToken = ChickToken(_chickAddr); mint(msg.sender, 1); _setupDecimals(18); perUserPerDayLimit = 1000; marketPerDayLimit = 100000; cChickSwapChickLimit[0] = 10; cChickSwapChickLimit[1] = 20; cChickSwapChickLimit[2] = 100; cChickSwapChickLimit[3] = 115792089237316195423570985008687907853269984665640564039457584007913129639935; ceggSwapEggProportion[0] = 8; // special case : if addUpSwapCchickCountPerUser[userAddr] <=10 , the max EGG count is 8 // maxEggAmount = chickCount.mul(ceggSwapEggProportion[index]).div(100); ceggSwapEggProportion[1] = 60; ceggSwapEggProportion[2] = 50; ceggSwapEggProportion[3] = 40; } function setDev1(address _signer) public onlyOwner { signer1 = _signer; } function setDev2(address _signer) public onlyOwner { signer2 = _signer; } function getUserClaimCountPerDay(uint256 _dayIndex, address userAddr) public view returns(uint256){ return userClaimCountPerDay[_dayIndex][userAddr]; } function getMarketClaimCountPerDay(uint256 _dayIndex) public view returns(uint256){ return marketClaimCountPerDay[_dayIndex]; } function getBurnAmountPerDay(uint256 _dayIndex) public view returns(uint256){ return burnAmountPerDay[_dayIndex]; } function getInCirculationCount() public view returns(uint256){ return addUpClaimCount.sub(addUpBurnCount); } function getAwaitMiningCount() public view returns(uint256){ return MAX_TOTAL_SUPPLY.div(1e18).sub(addUpClaimCount); } function updateCeggSwapEggProportion(uint256 index, uint256 proportion) public onlyOwner{ require(index < 4, 'Index cannot be greater than 4 !'); ceggSwapEggProportion[index] = proportion; } function updateLimitProportion(uint256 index, uint256 proportion) public onlyOwner{ require(index < 4, 'Index cannot be greater than 4 !'); cChickSwapChickLimit[index] = proportion; } // check to avoid bad base, such as centralized db changed by hacker function checkRestrictions(uint256 userAddUpCchickCount, uint256 userAddUpClaimEggCount) internal view returns(bool){ require(userAddUpClaimEggCount <= userAddUpCchickCount, 'error: userAddUpClaimEggCount > userAddUpCchickCount'); uint256 index = 0; for(uint256 i = 0; i<cChickSwapChickLimit.length; i++){ if(userAddUpCchickCount <= cChickSwapChickLimit[i]){ index = i; break; } } uint256 maxEggAmount; if(index == 0){ maxEggAmount = ceggSwapEggProportion[0]; }else{ maxEggAmount = userAddUpCchickCount.mul(ceggSwapEggProportion[index]).div(100); } require(maxEggAmount >= userAddUpClaimEggCount, 'error: maxEggAmount < userAddUpClaimEggCount'); } function batchClaim(uint256[] memory orderId, uint256[] memory floatAmount, bytes[] memory signature) public{ require(orderId.length == floatAmount.length, "orderId length should eq floatAmount length"); require(floatAmount.length == signature.length, "floatAmount length should eq signature length"); updateDay(); for(uint256 i=0; i<orderId.length; i++){ claim(orderId[i], floatAmount[i], signature[i]); } } function claim(uint256 orderId, uint256 floatAmount, bytes memory signature) internal{ if(claimedOrderId[orderId]){ emit AleadyClaim(orderId, floatAmount, msg.sender); return; } require(userClaimCountPerDay[dayIndex][msg.sender].add(floatAmount) <= perUserPerDayLimit, 'Maximum single day limit exceeded!'); require(marketClaimCountPerDay[dayIndex].add(floatAmount) <= marketPerDayLimit, 'It has exceeded the maximum market quota!'); bytes32 hash1 = keccak256(abi.encode(address(this), msg.sender, orderId, floatAmount)); bytes32 hash2 = keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash1)); address signer = recover(hash2, signature); require(signer == signer1 || signer == signer2, "invalid signer"); uint256 userAddUpcChickCount = chickToken.getAddUpSwapCchickCountPerUser(msg.sender); uint256 useAddUpClaimEggCount = floatAmount.add(addUpSwapCeggCountPerUser[msg.sender]); checkRestrictions(userAddUpcChickCount, useAddUpClaimEggCount); mint(msg.sender, floatAmount); claimedOrderId[orderId] = true; userClaimCountPerDay[dayIndex][msg.sender] = floatAmount.add(userClaimCountPerDay[dayIndex][msg.sender]); marketClaimCountPerDay[dayIndex] = floatAmount.add(marketClaimCountPerDay[dayIndex]); addUpSwapCeggCountPerUser[msg.sender] = useAddUpClaimEggCount; claimIndex++; emit Claim(orderId, floatAmount, msg.sender, signer, claimIndex); } function mint(address _to, uint256 _amount) internal{ uint256 intAmount = _amount.mul(1e18); uint256 totalSupply = totalSupply(); require(totalSupply.add(intAmount) <= MAX_TOTAL_SUPPLY,"invalid _amount"); _mint(_to, intAmount); addUpClaimCount = addUpClaimCount.add(_amount ); } function burn(uint256 amount) public{ require(amount != 0, 'burnAmount cannot be zero'); address deadAddress = 0x000000000000000000000000000000000000dEaD; transfer(deadAddress, amount.mul(1e18)); emit Burn(msg.sender, amount); addUpBurnCount = addUpBurnCount.add(amount); updateDay(); burnAmountPerDay[dayIndex] = amount.add(burnAmountPerDay[dayIndex]); } function setPerUserPerDayLimit(uint _perUserPerDayLimit) public onlyAdmin { perUserPerDayLimit = _perUserPerDayLimit; } function setMarketPerDayLimit(uint _marketPerDayLimit) public onlyAdmin { marketPerDayLimit = _marketPerDayLimit; } /** * @dev Returns the address that signed a hashed message (`hash`) with * `signature`. This address can then be used for verification purposes. * * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures: * this function rejects them by requiring the `s` value to be in the lower * half order, and the `v` value to be either 27 or 28. * * IMPORTANT: `hash` _must_ be the result of a hash operation for the * verification to be secure: it is possible to craft signatures that * recover to arbitrary addresses for non-hashed data. A safe way to ensure * this is by receiving a hash of the original message (which may otherwise * be too long), and then calling {toEthSignedMessageHash} on it. */ function recover(bytes32 hash, bytes memory signature) internal pure returns (address) { // Check the signature length if (signature.length != 65) { revert("ECDSA: invalid signature length"); } // Divide the signature in r, s and v variables bytes32 r; bytes32 s; uint8 v; // ecrecover takes the signature parameters, and the only way to get them // currently is to use assembly. // solhint-disable-next-line no-inline-assembly assembly { r := mload(add(signature, 0x20)) s := mload(add(signature, 0x40)) v := byte(0, mload(add(signature, 0x60))) } return recover(hash, v, r, s); } /** * @dev Overload of {ECDSA-recover-bytes32-bytes-} that receives the `v`, * `r` and `s` signature fields separately. */ function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) { // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines // the valid range for s in (281): 0 < s < secp256k1n ÷ 2 + 1, and for v in (282): v ∈ {27, 28}. Most // signatures from current libraries generate a unique signature with an s-value in the lower half order. // // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept // these malleable signatures as well. require(uint256(s) <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0, "ECDSA: invalid signature 's' value"); require(v == 27 || v == 28, "ECDSA: invalid signature 'v' value"); // If the signature is valid (and not malleable), return the signer address address signer = ecrecover(hash, v, r, s); require(signer != address(0), "ECDSA: invalid signature"); return signer; } function updateDay() internal{ dayIndex = now / 86400; } } // File: ..\node_modules\@openzeppelin\contracts\introspection\IERC165.sol // SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.0; /** * @dev Interface of the ERC165 standard, as defined in the * https://eips.ethereum.org/EIPS/eip-165[EIP]. * * Implementers can declare support of contract interfaces, which can then be * queried by others ({ERC165Checker}). * * For an implementation, see {ERC165}. */ interface IERC165 { /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] * to learn more about how these ids are created. * * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); } // File: @openzeppelin\contracts\introspection\ERC165.sol // SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.0; /** * @dev Implementation of the {IERC165} interface. * * Contracts may inherit from this and call {_registerInterface} to declare * their support of an interface. */ abstract contract ERC165 is IERC165 { /* * bytes4(keccak256('supportsInterface(bytes4)')) == 0x01ffc9a7 */ bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7; /** * @dev Mapping of interface ids to whether or not it's supported. */ mapping(bytes4 => bool) private _supportedInterfaces; constructor () internal { // Derived contracts need only register support for their own interfaces, // we register support for ERC165 itself here _registerInterface(_INTERFACE_ID_ERC165); } /** * @dev See {IERC165-supportsInterface}. * * Time complexity O(1), guaranteed to always use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return _supportedInterfaces[interfaceId]; } /** * @dev Registers the contract as an implementer of the interface defined by * `interfaceId`. Support of the actual ERC165 interface is automatic and * registering its interface id is not required. * * See {IERC165-supportsInterface}. * * Requirements: * * - `interfaceId` cannot be the ERC165 invalid interface (`0xffffffff`). */ function _registerInterface(bytes4 interfaceId) internal virtual { require(interfaceId != 0xffffffff, "ERC165: invalid interface id"); _supportedInterfaces[interfaceId] = true; } } // File: ..\node_modules\@openzeppelin\contracts\token\ERC721\IERC721.sol // SPDX-License-Identifier: MIT pragma solidity >=0.6.2 <0.8.0; /** * @dev Required interface of an ERC721 compliant contract. */ interface IERC721 is IERC165 { /** * @dev Emitted when `tokenId` token is transferred from `from` to `to`. */ event Transfer(address indexed from, address indexed to, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token. */ event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets. */ event ApprovalForAll(address indexed owner, address indexed operator, bool approved); /** * @dev Returns the number of tokens in ``owner``'s account. */ function balanceOf(address owner) external view returns (uint256 balance); /** * @dev Returns the owner of the `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function ownerOf(uint256 tokenId) external view returns (address owner); /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients * are aware of the ERC721 protocol to prevent tokens from being forever locked. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom(address from, address to, uint256 tokenId) external; /** * @dev Transfers `tokenId` token from `from` to `to`. * * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * * Emits a {Transfer} event. */ function transferFrom(address from, address to, uint256 tokenId) external; /** * @dev Gives permission to `to` to transfer `tokenId` token to another account. * The approval is cleared when the token is transferred. * * Only a single account can be approved at a time, so approving the zero address clears previous approvals. * * Requirements: * * - The caller must own the token or be an approved operator. * - `tokenId` must exist. * * Emits an {Approval} event. */ function approve(address to, uint256 tokenId) external; /** * @dev Returns the account approved for `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function getApproved(uint256 tokenId) external view returns (address operator); /** * @dev Approve or remove `operator` as an operator for the caller. * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. * * Requirements: * * - The `operator` cannot be the caller. * * Emits an {ApprovalForAll} event. */ function setApprovalForAll(address operator, bool _approved) external; /** * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`. * * See {setApprovalForAll} */ function isApprovedForAll(address owner, address operator) external view returns (bool); /** * @dev Safely transfers `tokenId` token from `from` to `to`. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external; } // File: ..\node_modules\@openzeppelin\contracts\token\ERC721\IERC721Metadata.sol // SPDX-License-Identifier: MIT pragma solidity >=0.6.2 <0.8.0; /** * @title ERC-721 Non-Fungible Token Standard, optional metadata extension * @dev See https://eips.ethereum.org/EIPS/eip-721 */ interface IERC721Metadata is IERC721 { /** * @dev Returns the token collection name. */ function name() external view returns (string memory); /** * @dev Returns the token collection symbol. */ function symbol() external view returns (string memory); /** * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token. */ function tokenURI(uint256 tokenId) external view returns (string memory); } // File: ..\node_modules\@openzeppelin\contracts\token\ERC721\IERC721Enumerable.sol // SPDX-License-Identifier: MIT pragma solidity >=0.6.2 <0.8.0; /** * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension * @dev See https://eips.ethereum.org/EIPS/eip-721 */ interface IERC721Enumerable is IERC721 { /** * @dev Returns the total amount of tokens stored by the contract. */ function totalSupply() external view returns (uint256); /** * @dev Returns a token ID owned by `owner` at a given `index` of its token list. * Use along with {balanceOf} to enumerate all of ``owner``'s tokens. */ function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId); /** * @dev Returns a token ID at a given `index` of all the tokens stored by the contract. * Use along with {totalSupply} to enumerate all tokens. */ function tokenByIndex(uint256 index) external view returns (uint256); } // File: ..\node_modules\@openzeppelin\contracts\token\ERC721\IERC721Receiver.sol // SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.0; /** * @title ERC721 token receiver interface * @dev Interface for any contract that wants to support safeTransfers * from ERC721 asset contracts. */ interface IERC721Receiver { /** * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom} * by `operator` from `from`, this function is called. * * It must return its Solidity selector to confirm the token transfer. * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted. * * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`. */ function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4); } // File: ..\node_modules\@openzeppelin\contracts\utils\Address.sol // SPDX-License-Identifier: MIT pragma solidity >=0.6.2 <0.8.0; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success, ) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain`call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: value }(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @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: ..\node_modules\@openzeppelin\contracts\utils\EnumerableSet.sol // SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.0; /** * @dev Library for managing * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive * types. * * Sets have the following properties: * * - Elements are added, removed, and checked for existence in constant time * (O(1)). * - Elements are enumerated in O(n). No guarantees are made on the ordering. * * ``` * contract Example { * // Add the library methods * using EnumerableSet for EnumerableSet.AddressSet; * * // Declare a set state variable * EnumerableSet.AddressSet private mySet; * } * ``` * * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`) * and `uint256` (`UintSet`) are supported. */ library EnumerableSet { // To implement this library for multiple types with as little code // repetition as possible, we write it in terms of a generic Set type with // bytes32 values. // The Set implementation uses private functions, and user-facing // implementations (such as AddressSet) are just wrappers around the // underlying Set. // This means that we can only create new EnumerableSets for types that fit // in bytes32. struct Set { // Storage of set values bytes32[] _values; // Position of the value in the `values` array, plus 1 because index 0 // means a value is not in the set. mapping (bytes32 => uint256) _indexes; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function _add(Set storage set, bytes32 value) private returns (bool) { if (!_contains(set, value)) { set._values.push(value); // The value is stored at length-1, but we add 1 to all indexes // and use 0 as a sentinel value set._indexes[value] = set._values.length; return true; } else { return false; } } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function _remove(Set storage set, bytes32 value) private returns (bool) { // We read and store the value's index to prevent multiple reads from the same storage slot uint256 valueIndex = set._indexes[value]; if (valueIndex != 0) { // Equivalent to contains(set, value) // To delete an element from the _values array in O(1), we swap the element to delete with the last one in // the array, and then remove the last element (sometimes called as 'swap and pop'). // This modifies the order of the array, as noted in {at}. uint256 toDeleteIndex = valueIndex - 1; uint256 lastIndex = set._values.length - 1; // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement. bytes32 lastvalue = set._values[lastIndex]; // Move the last value to the index where the value to delete is set._values[toDeleteIndex] = lastvalue; // Update the index for the moved value set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based // Delete the slot where the moved value was stored set._values.pop(); // Delete the index for the deleted slot delete set._indexes[value]; return true; } else { return false; } } /** * @dev Returns true if the value is in the set. O(1). */ function _contains(Set storage set, bytes32 value) private view returns (bool) { return set._indexes[value] != 0; } /** * @dev Returns the number of values on the set. O(1). */ function _length(Set storage set) private view returns (uint256) { return set._values.length; } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function _at(Set storage set, uint256 index) private view returns (bytes32) { require(set._values.length > index, "EnumerableSet: index out of bounds"); return set._values[index]; } // Bytes32Set struct Bytes32Set { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _add(set._inner, value); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _remove(set._inner, value); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) { return _contains(set._inner, value); } /** * @dev Returns the number of values in the set. O(1). */ function length(Bytes32Set storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) { return _at(set._inner, index); } // AddressSet struct AddressSet { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(AddressSet storage set, address value) internal returns (bool) { return _add(set._inner, bytes32(uint256(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: ..\node_modules\@openzeppelin\contracts\utils\EnumerableMap.sol // SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.0; /** * @dev Library for managing an enumerable variant of Solidity's * https://solidity.readthedocs.io/en/latest/types.html#mapping-types[`mapping`] * type. * * Maps have the following properties: * * - Entries are added, removed, and checked for existence in constant time * (O(1)). * - Entries are enumerated in O(n). No guarantees are made on the ordering. * * ``` * contract Example { * // Add the library methods * using EnumerableMap for EnumerableMap.UintToAddressMap; * * // Declare a set state variable * EnumerableMap.UintToAddressMap private myMap; * } * ``` * * As of v3.0.0, only maps of type `uint256 -> address` (`UintToAddressMap`) are * supported. */ library EnumerableMap { // To implement this library for multiple types with as little code // repetition as possible, we write it in terms of a generic Map type with // bytes32 keys and values. // The Map implementation uses private functions, and user-facing // implementations (such as Uint256ToAddressMap) are just wrappers around // the underlying Map. // This means that we can only create new EnumerableMaps for types that fit // in bytes32. struct MapEntry { bytes32 _key; bytes32 _value; } struct Map { // Storage of map keys and values MapEntry[] _entries; // Position of the entry defined by a key in the `entries` array, plus 1 // because index 0 means a key is not in the map. mapping (bytes32 => uint256) _indexes; } /** * @dev Adds a key-value pair to a map, or updates the value for an existing * key. O(1). * * Returns true if the key was added to the map, that is if it was not * already present. */ function _set(Map storage map, bytes32 key, bytes32 value) private returns (bool) { // We read and store the key's index to prevent multiple reads from the same storage slot uint256 keyIndex = map._indexes[key]; if (keyIndex == 0) { // Equivalent to !contains(map, key) map._entries.push(MapEntry({ _key: key, _value: value })); // The entry is stored at length-1, but we add 1 to all indexes // and use 0 as a sentinel value map._indexes[key] = map._entries.length; return true; } else { map._entries[keyIndex - 1]._value = value; return false; } } /** * @dev Removes a key-value pair from a map. O(1). * * Returns true if the key was removed from the map, that is if it was present. */ function _remove(Map storage map, bytes32 key) private returns (bool) { // We read and store the key's index to prevent multiple reads from the same storage slot uint256 keyIndex = map._indexes[key]; if (keyIndex != 0) { // Equivalent to contains(map, key) // To delete a key-value pair from the _entries array in O(1), we swap the entry to delete with the last one // in the array, and then remove the last entry (sometimes called as 'swap and pop'). // This modifies the order of the array, as noted in {at}. uint256 toDeleteIndex = keyIndex - 1; uint256 lastIndex = map._entries.length - 1; // When the entry 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. MapEntry storage lastEntry = map._entries[lastIndex]; // Move the last entry to the index where the entry to delete is map._entries[toDeleteIndex] = lastEntry; // Update the index for the moved entry map._indexes[lastEntry._key] = toDeleteIndex + 1; // All indexes are 1-based // Delete the slot where the moved entry was stored map._entries.pop(); // Delete the index for the deleted slot delete map._indexes[key]; return true; } else { return false; } } /** * @dev Returns true if the key is in the map. O(1). */ function _contains(Map storage map, bytes32 key) private view returns (bool) { return map._indexes[key] != 0; } /** * @dev Returns the number of key-value pairs in the map. O(1). */ function _length(Map storage map) private view returns (uint256) { return map._entries.length; } /** * @dev Returns the key-value pair stored at position `index` in the map. O(1). * * Note that there are no guarantees on the ordering of entries inside the * array, and it may change when more entries are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function _at(Map storage map, uint256 index) private view returns (bytes32, bytes32) { require(map._entries.length > index, "EnumerableMap: index out of bounds"); MapEntry storage entry = map._entries[index]; return (entry._key, entry._value); } /** * @dev Tries to returns the value associated with `key`. O(1). * Does not revert if `key` is not in the map. */ function _tryGet(Map storage map, bytes32 key) private view returns (bool, bytes32) { uint256 keyIndex = map._indexes[key]; if (keyIndex == 0) return (false, 0); // Equivalent to contains(map, key) return (true, map._entries[keyIndex - 1]._value); // All indexes are 1-based } /** * @dev Returns the value associated with `key`. O(1). * * Requirements: * * - `key` must be in the map. */ function _get(Map storage map, bytes32 key) private view returns (bytes32) { uint256 keyIndex = map._indexes[key]; require(keyIndex != 0, "EnumerableMap: nonexistent key"); // Equivalent to contains(map, key) return map._entries[keyIndex - 1]._value; // All indexes are 1-based } /** * @dev Same as {_get}, with a custom error message when `key` is not in the map. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {_tryGet}. */ function _get(Map storage map, bytes32 key, string memory errorMessage) private view returns (bytes32) { uint256 keyIndex = map._indexes[key]; require(keyIndex != 0, errorMessage); // Equivalent to contains(map, key) return map._entries[keyIndex - 1]._value; // All indexes are 1-based } // UintToAddressMap struct UintToAddressMap { Map _inner; } /** * @dev Adds a key-value pair to a map, or updates the value for an existing * key. O(1). * * Returns true if the key was added to the map, that is if it was not * already present. */ function set(UintToAddressMap storage map, uint256 key, address value) internal returns (bool) { return _set(map._inner, bytes32(key), bytes32(uint256(uint160(value)))); } /** * @dev Removes a value from a set. O(1). * * Returns true if the key was removed from the map, that is if it was present. */ function remove(UintToAddressMap storage map, uint256 key) internal returns (bool) { return _remove(map._inner, bytes32(key)); } /** * @dev Returns true if the key is in the map. O(1). */ function contains(UintToAddressMap storage map, uint256 key) internal view returns (bool) { return _contains(map._inner, bytes32(key)); } /** * @dev Returns the number of elements in the map. O(1). */ function length(UintToAddressMap storage map) internal view returns (uint256) { return _length(map._inner); } /** * @dev Returns the element 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(UintToAddressMap storage map, uint256 index) internal view returns (uint256, address) { (bytes32 key, bytes32 value) = _at(map._inner, index); return (uint256(key), address(uint160(uint256(value)))); } /** * @dev Tries to returns the value associated with `key`. O(1). * Does not revert if `key` is not in the map. * * _Available since v3.4._ */ function tryGet(UintToAddressMap storage map, uint256 key) internal view returns (bool, address) { (bool success, bytes32 value) = _tryGet(map._inner, bytes32(key)); return (success, address(uint160(uint256(value)))); } /** * @dev Returns the value associated with `key`. O(1). * * Requirements: * * - `key` must be in the map. */ function get(UintToAddressMap storage map, uint256 key) internal view returns (address) { return address(uint160(uint256(_get(map._inner, bytes32(key))))); } /** * @dev Same as {get}, with a custom error message when `key` is not in the map. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryGet}. */ function get(UintToAddressMap storage map, uint256 key, string memory errorMessage) internal view returns (address) { return address(uint160(uint256(_get(map._inner, bytes32(key), errorMessage)))); } } // File: ..\node_modules\@openzeppelin\contracts\utils\Strings.sol // SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.0; /** * @dev String operations. */ library Strings { /** * @dev Converts a `uint256` to its ASCII `string` representation. */ function toString(uint256 value) internal pure returns (string memory) { // Inspired by OraclizeAPI's implementation - MIT licence // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol if (value == 0) { return "0"; } uint256 temp = value; uint256 digits; while (temp != 0) { digits++; temp /= 10; } bytes memory buffer = new bytes(digits); uint256 index = digits - 1; temp = value; while (temp != 0) { buffer[index--] = bytes1(uint8(48 + temp % 10)); temp /= 10; } return string(buffer); } } // File: @openzeppelin\contracts\token\ERC721\ERC721.sol // SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.0; /** * @title ERC721 Non-Fungible Token Standard basic implementation * @dev see https://eips.ethereum.org/EIPS/eip-721 */ contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable { using SafeMath for uint256; using Address for address; using EnumerableSet for EnumerableSet.UintSet; using EnumerableMap for EnumerableMap.UintToAddressMap; using Strings for uint256; // Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))` // which can be also obtained as `IERC721Receiver(0).onERC721Received.selector` bytes4 private constant _ERC721_RECEIVED = 0x150b7a02; // Mapping from holder address to their (enumerable) set of owned tokens mapping (address => EnumerableSet.UintSet) private _holderTokens; // Enumerable mapping from token ids to their owners EnumerableMap.UintToAddressMap private _tokenOwners; // Mapping from token ID to approved address mapping (uint256 => address) private _tokenApprovals; // Mapping from owner to operator approvals mapping (address => mapping (address => bool)) private _operatorApprovals; // Token name string private _name; // Token symbol string private _symbol; // Optional mapping for token URIs mapping (uint256 => string) private _tokenURIs; // Base URI string private _baseURI; /* * bytes4(keccak256('balanceOf(address)')) == 0x70a08231 * bytes4(keccak256('ownerOf(uint256)')) == 0x6352211e * bytes4(keccak256('approve(address,uint256)')) == 0x095ea7b3 * bytes4(keccak256('getApproved(uint256)')) == 0x081812fc * bytes4(keccak256('setApprovalForAll(address,bool)')) == 0xa22cb465 * bytes4(keccak256('isApprovedForAll(address,address)')) == 0xe985e9c5 * bytes4(keccak256('transferFrom(address,address,uint256)')) == 0x23b872dd * bytes4(keccak256('safeTransferFrom(address,address,uint256)')) == 0x42842e0e * bytes4(keccak256('safeTransferFrom(address,address,uint256,bytes)')) == 0xb88d4fde * * => 0x70a08231 ^ 0x6352211e ^ 0x095ea7b3 ^ 0x081812fc ^ * 0xa22cb465 ^ 0xe985e9c5 ^ 0x23b872dd ^ 0x42842e0e ^ 0xb88d4fde == 0x80ac58cd */ bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd; /* * bytes4(keccak256('name()')) == 0x06fdde03 * bytes4(keccak256('symbol()')) == 0x95d89b41 * bytes4(keccak256('tokenURI(uint256)')) == 0xc87b56dd * * => 0x06fdde03 ^ 0x95d89b41 ^ 0xc87b56dd == 0x5b5e139f */ bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f; /* * bytes4(keccak256('totalSupply()')) == 0x18160ddd * bytes4(keccak256('tokenOfOwnerByIndex(address,uint256)')) == 0x2f745c59 * bytes4(keccak256('tokenByIndex(uint256)')) == 0x4f6ccce7 * * => 0x18160ddd ^ 0x2f745c59 ^ 0x4f6ccce7 == 0x780e9d63 */ bytes4 private constant _INTERFACE_ID_ERC721_ENUMERABLE = 0x780e9d63; /** * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection. */ constructor (string memory name_, string memory symbol_) public { _name = name_; _symbol = symbol_; // register the supported interfaces to conform to ERC721 via ERC165 _registerInterface(_INTERFACE_ID_ERC721); _registerInterface(_INTERFACE_ID_ERC721_METADATA); _registerInterface(_INTERFACE_ID_ERC721_ENUMERABLE); } /** * @dev See {IERC721-balanceOf}. */ function balanceOf(address owner) public view virtual override returns (uint256) { require(owner != address(0), "ERC721: balance query for the zero address"); return _holderTokens[owner].length(); } /** * @dev See {IERC721-ownerOf}. */ function ownerOf(uint256 tokenId) public view virtual override returns (address) { return _tokenOwners.get(tokenId, "ERC721: owner query for nonexistent token"); } /** * @dev See {IERC721Metadata-name}. */ function name() public view virtual override returns (string memory) { return _name; } /** * @dev See {IERC721Metadata-symbol}. */ function symbol() public view virtual override returns (string memory) { return _symbol; } /** * @dev See {IERC721Metadata-tokenURI}. */ function tokenURI(uint256 tokenId) public view virtual override returns (string memory) { require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token"); string memory _tokenURI = _tokenURIs[tokenId]; string memory base = baseURI(); // If there is no base URI, return the token URI. if (bytes(base).length == 0) { return _tokenURI; } // If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked). if (bytes(_tokenURI).length > 0) { return string(abi.encodePacked(base, _tokenURI)); } // If there is a baseURI but no tokenURI, concatenate the tokenID to the baseURI. return string(abi.encodePacked(base, tokenId.toString())); } /** * @dev Returns the base URI set via {_setBaseURI}. This will be * automatically added as a prefix in {tokenURI} to each token's URI, or * to the token ID if no specific URI is set for that token ID. */ function baseURI() public view virtual returns (string memory) { return _baseURI; } /** * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}. */ function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) { return _holderTokens[owner].at(index); } /** * @dev See {IERC721Enumerable-totalSupply}. */ function totalSupply() public view virtual override returns (uint256) { // _tokenOwners are indexed by tokenIds, so .length() returns the number of tokenIds return _tokenOwners.length(); } /** * @dev See {IERC721Enumerable-tokenByIndex}. */ function tokenByIndex(uint256 index) public view virtual override returns (uint256) { (uint256 tokenId, ) = _tokenOwners.at(index); return tokenId; } /** * @dev See {IERC721-approve}. */ function approve(address to, uint256 tokenId) public virtual override { address owner = ERC721.ownerOf(tokenId); require(to != owner, "ERC721: approval to current owner"); require(_msgSender() == owner || ERC721.isApprovedForAll(owner, _msgSender()), "ERC721: approve caller is not owner nor approved for all" ); _approve(to, tokenId); } /** * @dev See {IERC721-getApproved}. */ function getApproved(uint256 tokenId) public view virtual override returns (address) { require(_exists(tokenId), "ERC721: approved query for nonexistent token"); return _tokenApprovals[tokenId]; } /** * @dev See {IERC721-setApprovalForAll}. */ function setApprovalForAll(address operator, bool approved) public virtual override { require(operator != _msgSender(), "ERC721: approve to caller"); _operatorApprovals[_msgSender()][operator] = approved; emit ApprovalForAll(_msgSender(), operator, approved); } /** * @dev See {IERC721-isApprovedForAll}. */ function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) { return _operatorApprovals[owner][operator]; } /** * @dev See {IERC721-transferFrom}. */ function transferFrom(address from, address to, uint256 tokenId) public virtual override { //solhint-disable-next-line max-line-length require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved"); _transfer(from, to, tokenId); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override { safeTransferFrom(from, to, tokenId, ""); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override { require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved"); _safeTransfer(from, to, tokenId, _data); } /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients * are aware of the ERC721 protocol to prevent tokens from being forever locked. * * `_data` is additional data, it has no specified format and it is sent in call to `to`. * * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g. * implement alternative mechanisms to perform token transfer, such as signature-based. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual { _transfer(from, to, tokenId); require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer"); } /** * @dev Returns whether `tokenId` exists. * * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}. * * Tokens start existing when they are minted (`_mint`), * and stop existing when they are burned (`_burn`). */ function _exists(uint256 tokenId) internal view virtual returns (bool) { return _tokenOwners.contains(tokenId); } /** * @dev Returns whether `spender` is allowed to manage `tokenId`. * * Requirements: * * - `tokenId` must exist. */ function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) { require(_exists(tokenId), "ERC721: operator query for nonexistent token"); address owner = ERC721.ownerOf(tokenId); return (spender == owner || getApproved(tokenId) == spender || ERC721.isApprovedForAll(owner, spender)); } /** * @dev Safely mints `tokenId` and transfers it to `to`. * * Requirements: d* * - `tokenId` must not exist. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function _safeMint(address to, uint256 tokenId) internal virtual { _safeMint(to, tokenId, ""); } /** * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is * forwarded in {IERC721Receiver-onERC721Received} to contract recipients. */ function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual { _mint(to, tokenId); require(_checkOnERC721Received(address(0), to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer"); } /** * @dev Mints `tokenId` and transfers it to `to`. * * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible * * Requirements: * * - `tokenId` must not exist. * - `to` cannot be the zero address. * * Emits a {Transfer} event. */ function _mint(address to, uint256 tokenId) internal virtual { require(to != address(0), "ERC721: mint to the zero address"); require(!_exists(tokenId), "ERC721: token already minted"); _beforeTokenTransfer(address(0), to, tokenId); _holderTokens[to].add(tokenId); _tokenOwners.set(tokenId, to); emit Transfer(address(0), to, tokenId); } /** * @dev Destroys `tokenId`. * The approval is cleared when the token is burned. * * Requirements: * * - `tokenId` must exist. * * Emits a {Transfer} event. */ function _burn(uint256 tokenId) internal virtual { address owner = ERC721.ownerOf(tokenId); // internal owner _beforeTokenTransfer(owner, address(0), tokenId); // Clear approvals _approve(address(0), tokenId); // Clear metadata (if any) if (bytes(_tokenURIs[tokenId]).length != 0) { delete _tokenURIs[tokenId]; } _holderTokens[owner].remove(tokenId); _tokenOwners.remove(tokenId); emit Transfer(owner, address(0), tokenId); } /** * @dev Transfers `tokenId` from `from` to `to`. * As opposed to {transferFrom}, this imposes no restrictions on msg.sender. * * Requirements: * * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * * Emits a {Transfer} event. */ function _transfer(address from, address to, uint256 tokenId) internal virtual { require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own"); // internal owner require(to != address(0), "ERC721: transfer to the zero address"); _beforeTokenTransfer(from, to, tokenId); // Clear approvals from the previous owner _approve(address(0), tokenId); _holderTokens[from].remove(tokenId); _holderTokens[to].add(tokenId); _tokenOwners.set(tokenId, to); emit Transfer(from, to, tokenId); } /** * @dev Sets `_tokenURI` as the tokenURI of `tokenId`. * * Requirements: * * - `tokenId` must exist. */ function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual { require(_exists(tokenId), "ERC721Metadata: URI set of nonexistent token"); _tokenURIs[tokenId] = _tokenURI; } /** * @dev Internal function to set the base URI for all token IDs. It is * automatically added as a prefix to the value returned in {tokenURI}, * or to the token ID if {tokenURI} is empty. */ function _setBaseURI(string memory baseURI_) internal virtual { _baseURI = baseURI_; } /** * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address. * The call is not executed if the target address is not a contract. * * @param from address representing the previous owner of the given token ID * @param to target address that will receive the tokens * @param tokenId uint256 ID of the token to be transferred * @param _data bytes optional data to send along with the call * @return bool whether the call correctly returned the expected magic value */ function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data) private returns (bool) { if (!to.isContract()) { return true; } bytes memory returndata = to.functionCall(abi.encodeWithSelector( IERC721Receiver(to).onERC721Received.selector, _msgSender(), from, tokenId, _data ), "ERC721: transfer to non ERC721Receiver implementer"); bytes4 retval = abi.decode(returndata, (bytes4)); return (retval == _ERC721_RECEIVED); } /** * @dev Approve `to` to operate on `tokenId` * * Emits an {Approval} event. */ function _approve(address to, uint256 tokenId) internal virtual { _tokenApprovals[tokenId] = to; emit Approval(ERC721.ownerOf(tokenId), to, tokenId); // internal owner } /** * @dev Hook that is called before any token transfer. This includes minting * and burning. * * Calling conditions: * * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be * transferred to `to`. * - When `from` is zero, `tokenId` will be minted for `to`. * - When `to` is zero, ``from``'s `tokenId` will be burned. * - `from` cannot be the zero address. * - `to` cannot be the zero address. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { } } // File: @openzeppelin\contracts\utils\Counters.sol // SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.0; /** * @title Counters * @author Matt Condon (@shrugs) * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number * of elements in a mapping, issuing ERC721 ids, or counting request ids. * * Include with `using Counters for Counters.Counter;` * Since it is not possible to overflow a 256 bit integer with increments of one, `increment` can skip the {SafeMath} * overflow check, thereby saving gas. This does assume however correct usage, in that the underlying `_value` is never * directly accessed. */ library Counters { using SafeMath for uint256; struct Counter { // This variable should never be directly accessed by users of the library: interactions must be restricted to // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add // this feature: see https://github.com/ethereum/solidity/issues/4637 uint256 _value; // default: 0 } function current(Counter storage counter) internal view returns (uint256) { return counter._value; } function increment(Counter storage counter) internal { // The {SafeMath} overflow check can be skipped here, see the comment at the top counter._value += 1; } function decrement(Counter storage counter) internal { counter._value = counter._value.sub(1); } } // File: contracts\RandomInterface.sol pragma solidity 0.6.6; interface RandomInterface{ function getRandomNumber() external returns(uint256); } // File: contracts\LoserChickNFT.sol pragma solidity 0.6.6; contract LoserChickNFT is OwnableContract, ERC721("TrumpChick", "TrumpChick"){ using Counters for Counters.Counter; struct ChickAttribute{ uint256 jacket; uint256 trousers; uint256 suit; uint256 expression; uint256 hat; uint256 leftHandOrnaments; uint256 rightHandOrnaments; uint256 shoes; uint256 bodyOrnaments; } uint256 public immutable maxSupply; uint256 private seed; address private randomAddr; bool public isLaborChick; // Private fields Counters.Counter private _tokenIds; uint256[7] public jacket = [101, 102, 103, 104, 105, 106, 107]; uint256[8] public trousers = [201, 202, 203, 204, 205, 206, 207, 208]; uint256[3] public suit = [301, 302, 303]; uint256[10] public expression = [401, 402, 403, 404, 405, 406, 407, 408, 409, 410]; uint256[7] public hat = [501, 502, 503, 504, 505, 506, 507]; uint256[11] public leftHandOrnaments = [601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611]; uint256[11] public rightHandOrnaments = [701, 702, 703, 704, 705, 706, 707, 708, 709, 710, 711]; uint256[10] public shoes = [801, 802, 803, 804, 805, 806, 807, 808, 809, 810]; uint256[11] public bodyOrnaments = [901, 902, 903, 904, 905, 906, 907, 908, 909, 910, 911]; mapping(uint256 => ChickAttribute) public tokenIdChickAttribute; // Shrieking Chick、 Lucky Chick、Labor Chick、BOSS Chick、Trump Chick constructor(uint256 _maxSupply, address _randomAddr, bool _isLaborChick) public{ maxSupply = _maxSupply; randomAddr = _randomAddr; isLaborChick = _isLaborChick; } function getTokenIdChickAttribute(uint256 tokenId) public view returns(ChickAttribute memory){ return tokenIdChickAttribute[tokenId]; } function tokenOfOwnerPage(address owner, uint256 pageNumber, uint256 pageSize) external view returns (uint256, uint256[] memory){ uint256 total = balanceOf(owner); uint256 start = pageNumber * pageSize; require(start < total, 'pageNumber input error!'); uint256 end; if(start + pageSize > total){ end = total; }else{ end = start + pageSize; } uint256[] memory tokenIds = new uint256[](end - start); uint256 count = 0; for(uint256 i=start; i<end; i++){ uint256 tokenId = tokenOfOwnerByIndex(owner, i); tokenIds[count] = tokenId; count++; } return (total, tokenIds); } /** * @notice * @param flag If flag is true, it means shriekingChick, otherwise luckyChick. */ function createNFT(address owner) public onlyAdmin returns(uint256){ require(totalSupply() < maxSupply, 'The limit has been reached!'); uint256 tokenId = _mintChick(owner); ChickAttribute memory chickAttribute; RandomInterface randomInterface = RandomInterface(randomAddr); uint256 randomNumber = randomInterface.getRandomNumber(); updateSeed(); bytes32 random = keccak256(abi.encodePacked(now, randomNumber, seed)); uint256 expressionIndex = uint256(random) % 10; uint256 hatIndex = uint256(random) % 7; uint256 leftHandOrnamentsIndex = uint256(random) % 11; uint256 rightHandOrnamentsIndex = uint256(random) % 11; uint256 shoesIndex = uint256(random) % 10; uint256 bodyOrnamentsIndex = uint256(random) % 11; chickAttribute.expression = expression[expressionIndex]; chickAttribute.hat = hat[hatIndex]; chickAttribute.leftHandOrnaments = leftHandOrnaments[leftHandOrnamentsIndex]; chickAttribute.rightHandOrnaments = rightHandOrnaments[rightHandOrnamentsIndex]; chickAttribute.shoes = shoes[shoesIndex]; chickAttribute.bodyOrnaments = bodyOrnaments[bodyOrnamentsIndex]; if(isLaborChick){ uint256 suitIndex = uint256(random) % 3; chickAttribute.suit = suit[suitIndex]; }else{ uint256 isSuitRandom = uint256(random) % 2; if(isSuitRandom == 0){ uint256 suitIndex = uint256(random) % 3; chickAttribute.suit = suit[suitIndex]; }else if(isSuitRandom == 1){ uint256 jacketIndex = uint256(random) % 7; uint256 trousersIndex = uint256(random) % 8; chickAttribute.jacket = jacket[jacketIndex]; chickAttribute.trousers = trousers[trousersIndex]; } } tokenIdChickAttribute[tokenId] = chickAttribute; return tokenId; } // Private Methods function _mintChick(address owner) private returns(uint256){ _tokenIds.increment(); uint256 newItemId = _tokenIds.current(); _mint(owner, newItemId); return newItemId; } function setBaseURI(string memory newBaseURI) public onlyOwner { _setBaseURI(newBaseURI); } function tokenURI(uint256 tokenId) public view virtual override returns (string memory){ require(tokenId > 0 && tokenId <= totalSupply(), "URI query for nonexistent token"); // Fallback to centralised URI return string(abi.encodePacked(baseURI(), 'getUrl?name=', name(), '&tokenId=', tokenId.toString())); } function updateSeed() internal{ seed = seed + now - 5; } function updateRandomAddr(address _randomAddr) public onlyOwner{ randomAddr = _randomAddr; } } // File: contracts\SmashEggs.sol pragma solidity 0.6.6; contract SmashEggs is OwnableContract{ using SafeMath for uint256; uint public constant PRECISION = 1e17; uint256 public constant SECTION_SIZE = 2000; // Length of contract initialization uint256 public constant LUCKY_CHICK_INDEX = 0; uint256 public constant LABOR_CHICK_INDEX = 1; uint256 public constant BOSS_CHICK_INDEX = 2; uint256 public constant TRUMP_CHICK_INDEX = 3; uint256 public constant SHRIEKING_CHICK_INDEX = 4; uint256 public aleadyBrokenEggAmount; // Broken eggs amount address[] public loserChickAddrArray; RandomInterface public randomContract; uint256 public winningProbability; // Get NFT Probability uint256[] public chickProbability; // Per chick Rate, 0 is luckyChick, 1 is laborChick, 2 is bossChick, 3 is trumpChick. EggToken public eggToken; mapping(uint256 => bool) public shriekingChickSection; mapping(uint256 => bool) public sectionHasCreatedShriekingChick; mapping(address => uint256) private loserFailCount; uint256 private seed; uint256 public activityNFTProbability; address public activityNFTAddr; bool public smathEggSwitch = false; mapping(uint256 => mapping(address => bool)) public isUserSmashEggToday; mapping(uint256 => uint256) public smashEggCountPerDay; event SmashEggsEvent(address userAddr, uint256 eggCount, uint256 chickCount, address[] chickAddrArray, uint256[] tokenIdArray); event ActivityEvent(address userAddr, uint256 NFTConut, address NFTAddr); constructor(address _shriekingChickAddr, address _luckyChickAddr, address _laborChickAddr, address _bossChickAddr, address _trumpChickAddr, address _eggTokenAddr, address _randomAddr) public{ loserChickAddrArray = new address[](5); loserChickAddrArray[LUCKY_CHICK_INDEX] = _luckyChickAddr; loserChickAddrArray[LABOR_CHICK_INDEX] = _laborChickAddr; loserChickAddrArray[BOSS_CHICK_INDEX] = _bossChickAddr; loserChickAddrArray[TRUMP_CHICK_INDEX] = _trumpChickAddr; loserChickAddrArray[SHRIEKING_CHICK_INDEX] = _shriekingChickAddr; randomContract = RandomInterface(_randomAddr); eggToken = EggToken(_eggTokenAddr); // chickProbability = new uint256[](4); // chickProbability[LUCKY_CHICK_INDEX] = 99377250806863640; // luckyChick 0.00154093611776619 * 1e17 = 154093611776619 622749193136360 = 0.00622749193136360 = 0.62274919313636% // chickProbability[LABOR_CHICK_INDEX] = 94393076549240510; // laborChick 0.01233288491652890 * 1e17 = 1233288491652890 4984174257623130 = 0.04984174257623130 = 4.98417425762313% // chickProbability[BOSS_CHICK_INDEX] = 74766975289411744; // bossChick 0.04856299874094670 * 1e17 = 4856299874094670 19626101259828766 = 0.19626101259828766 = 19.626101259828766% // chickProbability[TRUMP_CHICK_INDEX] = 0; // trumpChick 0.18500406569673300 * 1e17 = 18500406569673300 74766975289411741 = 0.74766975289411741 = 74.766975289411741% // winningProbability = 24744088547197479; // 154093611776619 + 1233288491652890 + 4856299874094670 + 18500406569673300 chickProbability = new uint256[](4); chickProbability[LUCKY_CHICK_INDEX] = 99926853587174232; // luckyChick 0.000428428571428571 * 1e17 = 42842857142857 0.0007314641282576833 chickProbability[LABOR_CHICK_INDEX] = 99512243426578954; // laborChick 0.002428428571428570 * 1e17 = 242842857142857 0.004146101605952781 chickProbability[BOSS_CHICK_INDEX] = 97561046401020877; // bossChick 0.011428428571428600 * 1e17 = 1142842857142860 0.019511970255580775 chickProbability[TRUMP_CHICK_INDEX] = 0; // trumpChick 0.571428428571429000 * 1e17 = 57142842857142900 0.9756104640102089 winningProbability = 58571371428571464; // 0.571428428571429000 + 0.011428428571428600 + 0.002428428571428570 + 0.000428428571428571 initializationSection(); } function initializationSection() private{ uint8[2] memory sectionArray = [140, 255]; for(uint256 i=0; i<sectionArray.length; i++){ uint256 section = sectionArray[i]; shriekingChickSection[section] = true; } } function updateActivityNFT(address _activityNFTAddr, uint256 _activityNFTProbability) public onlyAdmin{ activityNFTAddr = _activityNFTAddr; activityNFTProbability = _activityNFTProbability; } function updateShriekingChickSection(uint256 section, bool isShriekingChickSection) public onlyAdmin{ shriekingChickSection[section] = isShriekingChickSection; } function updateChickProbability(uint index, uint256 probability) public onlyAdmin{ require(index < 4, 'Index is wrong!'); chickProbability[index] = probability; } function updateTotalProbability(uint256 probability) public onlyAdmin{ winningProbability = probability; } function getSmashEggCountPerDay(uint256 dayIndex) public view returns(uint256){ return smashEggCountPerDay[dayIndex]; } function smashEggs(uint256 amount) public{ require(msg.sender == tx.origin, "invalid msg.sender"); require(smathEggSwitch, "The smash switch is off!"); require(amount <= 10, 'amount should be less than or equal to 10'); uint256 userEggAmount = eggToken.balanceOf(msg.sender); require(amount <= userEggAmount.div(1e18), 'user egg shortage in number!'); eggToken.transferFrom(msg.sender, address(this), amount.mul(1e18)); uint256 dayIndex = now / 86400; if(!isUserSmashEggToday[dayIndex][msg.sender]){ smashEggCountPerDay[dayIndex] = smashEggCountPerDay[dayIndex] + 1; isUserSmashEggToday[dayIndex][msg.sender] = true; } address[] memory chickAddrArray = new address[](10); uint256[] memory tokenIds = new uint256[](10); uint256 count = 0; for(uint256 i=0; i<amount; i++){ aleadyBrokenEggAmount++; if(isWon()){ (uint256 tokenId, address chickAddr) = getOneChickNFT(); chickAddrArray[count] = chickAddr; tokenIds[count] = tokenId; count++; } } if(amount == 10 && count < 5){ uint256 count2 = uint256(5).sub(count); for(uint256 i=0; i<count2; i++){ (uint256 tokenId, address chickAddr) = getOneChickNFT(); chickAddrArray[count] = chickAddr; tokenIds[count] = tokenId; count++; } } eggToken.burn(amount); if(count == 0){ loserFailCount[msg.sender] += amount; }else{ loserFailCount[msg.sender] = 0; } processActivity(); emit SmashEggsEvent(msg.sender, amount, count, chickAddrArray, tokenIds); } /** * @notice Won or not */ function isWon() internal returns(bool){ uint256 random = updateSeed() % PRECISION; if(random < winningProbability){ return true; } } function getOneChickNFT() internal returns(uint256, address){ uint256 random = updateSeed() % PRECISION; uint256 index = TRUMP_CHICK_INDEX; uint256 sectionIndex = aleadyBrokenEggAmount.div(SECTION_SIZE); if(shouldGenerateShriekingChick(sectionIndex)){ index = SHRIEKING_CHICK_INDEX; sectionHasCreatedShriekingChick[sectionIndex] = true; }else{ uint256 startIndex = shriekingChickSection[sectionIndex]? 1: 0; for(uint256 i=startIndex; i<chickProbability.length; i++){ if(random > chickProbability[i]){ index = i; break; } } } address chickAddr = loserChickAddrArray[index]; LoserChickNFT loserChickNFT = LoserChickNFT(chickAddr); uint256 tokenId; if(loserChickNFT.totalSupply() < loserChickNFT.maxSupply()){ tokenId = loserChickNFT.createNFT(msg.sender); } return (tokenId, chickAddr); } function shouldGenerateShriekingChick(uint256 sectionIndex) internal returns(bool){ if(!shriekingChickSection[sectionIndex]){ return false; } if(sectionHasCreatedShriekingChick[sectionIndex]){ return false; } uint256 number = aleadyBrokenEggAmount % SECTION_SIZE + 1; uint256 random = updateSeed() % SECTION_SIZE; return number > random; } function updateRandomAddr(address _randomAddr) public onlyOwner{ randomContract = RandomInterface(_randomAddr); } function updateSeed() internal returns(uint256 random){ seed += randomContract.getRandomNumber(); random = uint256(keccak256(abi.encodePacked(seed))); } function getLoserFailCount(address owner) public view returns(uint256){ return loserFailCount[owner]; } function processActivity() internal{ if(activityNFTProbability == 0){ return; } uint256 NFTCount = 0; uint256 random = updateSeed() % PRECISION; if(activityNFTProbability > random){ ERC721 erc721 = ERC721(activityNFTAddr); uint256 amount = erc721.balanceOf(address(this)); if(amount > 0){ uint256 tokenId = erc721.tokenOfOwnerByIndex(address(this), 0); erc721.transferFrom(address(this), address(msg.sender), tokenId); NFTCount = 1; emit ActivityEvent(msg.sender, NFTCount, activityNFTAddr); } } } function transferActivityNFT(address receiver, uint256 count) external onlyAdmin{ ERC721 erc721 = ERC721(activityNFTAddr); uint256 amount = erc721.balanceOf(address(this)); require(count <= amount, 'Count input error!'); for(uint256 i=0; i<count; i++){ uint256 tokenId = erc721.tokenOfOwnerByIndex(address(this), 0); erc721.transferFrom(address(this), receiver, tokenId); } } function updateLoserChickAddr(uint256 index, address loserChickAddr) public onlyOwner{ loserChickAddrArray[index] = loserChickAddr; } function updateEggToken(address eggTokenAddr) public onlyOwner{ eggToken = EggToken(eggTokenAddr); } function updateSmathEggSwitch(bool _smathEggSwitch) public onlyOwner{ smathEggSwitch = _smathEggSwitch; } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"address","name":"_shriekingChickAddr","type":"address"},{"internalType":"address","name":"_luckyChickAddr","type":"address"},{"internalType":"address","name":"_laborChickAddr","type":"address"},{"internalType":"address","name":"_bossChickAddr","type":"address"},{"internalType":"address","name":"_trumpChickAddr","type":"address"},{"internalType":"address","name":"_eggTokenAddr","type":"address"},{"internalType":"address","name":"_randomAddr","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"userAddr","type":"address"},{"indexed":false,"internalType":"uint256","name":"NFTConut","type":"uint256"},{"indexed":false,"internalType":"address","name":"NFTAddr","type":"address"}],"name":"ActivityEvent","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"oldAdmin","type":"address"},{"indexed":false,"internalType":"address","name":"newAdmin","type":"address"}],"name":"NewAdmin","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"oldOwner","type":"address"},{"indexed":false,"internalType":"address","name":"newOwner","type":"address"}],"name":"NewOwner","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"oldPendingOwner","type":"address"},{"indexed":false,"internalType":"address","name":"newPendingOwner","type":"address"}],"name":"NewPendingOwner","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"userAddr","type":"address"},{"indexed":false,"internalType":"uint256","name":"eggCount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"chickCount","type":"uint256"},{"indexed":false,"internalType":"address[]","name":"chickAddrArray","type":"address[]"},{"indexed":false,"internalType":"uint256[]","name":"tokenIdArray","type":"uint256[]"}],"name":"SmashEggsEvent","type":"event"},{"inputs":[],"name":"BOSS_CHICK_INDEX","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"LABOR_CHICK_INDEX","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"LUCKY_CHICK_INDEX","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PRECISION","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SECTION_SIZE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SHRIEKING_CHICK_INDEX","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TRUMP_CHICK_INDEX","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"acceptOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"activityNFTAddr","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"activityNFTProbability","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"admin","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"aleadyBrokenEggAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"chickProbability","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"eggToken","outputs":[{"internalType":"contract EggToken","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"getLoserFailCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"dayIndex","type":"uint256"}],"name":"getSmashEggCountPerDay","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"}],"name":"isUserSmashEggToday","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"loserChickAddrArray","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"randomContract","outputs":[{"internalType":"contract RandomInterface","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"sectionHasCreatedShriekingChick","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newAdmin","type":"address"}],"name":"setAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"shriekingChickSection","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"smashEggCountPerDay","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"smashEggs","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"smathEggSwitch","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint256","name":"count","type":"uint256"}],"name":"transferActivityNFT","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_pendingOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_activityNFTAddr","type":"address"},{"internalType":"uint256","name":"_activityNFTProbability","type":"uint256"}],"name":"updateActivityNFT","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"},{"internalType":"uint256","name":"probability","type":"uint256"}],"name":"updateChickProbability","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"eggTokenAddr","type":"address"}],"name":"updateEggToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"},{"internalType":"address","name":"loserChickAddr","type":"address"}],"name":"updateLoserChickAddr","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_randomAddr","type":"address"}],"name":"updateRandomAddr","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"section","type":"uint256"},{"internalType":"bool","name":"isShriekingChickSection","type":"bool"}],"name":"updateShriekingChickSection","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_smathEggSwitch","type":"bool"}],"name":"updateSmathEggSwitch","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"probability","type":"uint256"}],"name":"updateTotalProbability","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"winningProbability","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]
Contract Creation Code
60806040526000600e60146101000a81548160ff0219169083151502179055503480156200002c57600080fd5b5060405162003f0a38038062003f0a8339818101604052810190620000529190620006a4565b336000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555033600260006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550600567ffffffffffffffff81118015620000ec57600080fd5b506040519080825280602002602001820160405280156200011c5781602001602082028036833780820191505090505b5060049080519060200190620001349291906200051c565b508560046000815481106200014557fe5b9060005260206000200160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508460046001815481106200019d57fe5b9060005260206000200160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550836004600281548110620001f557fe5b9060005260206000200160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508260046003815481106200024d57fe5b9060005260206000200160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508660048081548110620002a457fe5b9060005260206000200160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555080600560006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555081600860006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550600467ffffffffffffffff811180156200038757600080fd5b50604051908082528060200260200182016040528015620003b75781602001602082028036833780820191505090505b5060079080519060200190620003cf929190620005ab565b5067016302f1a39603586007600081548110620003e857fe5b906000526020600020018190555067016189dbb03e520a60076001815481106200040e57fe5b906000526020600020018190555067015a9b413aa5f3cd60076002815481106200043457fe5b9060005260206000200181905550600060076003815481106200045357fe5b906000526020600020018190555066d0165a1c01e9486006819055506200047f6200048c60201b60201c565b505050505050506200079f565b62000496620005fd565b6040518060400160405280608c60ff16815260200160ff8016815250905060008090505b600281101562000518576000828260028110620004d357fe5b602002015160ff16905060016009600083815260200190815260200160002060006101000a81548160ff021916908315150217905550508080600101915050620004ba565b5050565b82805482825590600052602060002090810192821562000598579160200282015b82811115620005975782518260006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550916020019190600101906200053d565b5b509050620005a791906200061f565b5090565b828054828255906000526020600020908101928215620005ea579160200282015b82811115620005e9578251825591602001919060010190620005cc565b5b509050620005f9919062000665565b5090565b6040518060400160405280600290602082028036833780820191505090505090565b6200066291905b808211156200065e57600081816101000a81549073ffffffffffffffffffffffffffffffffffffffff02191690555060010162000626565b5090565b90565b6200068a91905b80821115620006865760008160009055506001016200066c565b5090565b90565b6000815190506200069e8162000785565b92915050565b600080600080600080600060e0888a031215620006c057600080fd5b6000620006d08a828b016200068d565b9750506020620006e38a828b016200068d565b9650506040620006f68a828b016200068d565b9550506060620007098a828b016200068d565b94505060806200071c8a828b016200068d565b93505060a06200072f8a828b016200068d565b92505060c0620007428a828b016200068d565b91505092959891949750929550565b60006200075e8262000765565b9050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b620007908162000751565b81146200079c57600080fd5b50565b61375b80620007af6000396000f3fe608060405234801561001057600080fd5b506004361061023d5760003560e01c8063aaf5eb681161013b578063d44396f0116100b8578063ecb15d251161007c578063ecb15d2514610692578063f2fde38b146106ae578063f45bc0d5146106ca578063f61820d8146106e8578063f851a440146107065761023d565b8063d44396f014610602578063da5b5c0714610632578063ddd990cf1461064e578063e30c39781461066a578063ebbc4965146106885761023d565b8063b7500ecd116100ff578063b7500ecd1461055e578063b840ff7a1461058e578063b9547882146105aa578063ccf69e9b146105c8578063cf7602cf146105e65761023d565b8063aaf5eb68146104b8578063acd18b3e146104d6578063b1618a50146104f4578063b256776414610510578063b4335d7f146105405761023d565b8063704b6c02116101c95780638beecba21161018d5780638beecba2146104105780638da5cb5b146104405780638fafbdaa1461045e57806399119d221461047c578063a4c313601461049a5761023d565b8063704b6c0214610380578063715018a61461039c5780637df5e912146103a657806382b362b0146103c45780638709e010146103e05761023d565b806331ac67a51161021057806331ac67a5146102c85780634349cf5e146102e657806348ecc620146103165780634c0562121461033457806362d22e69146103645761023d565b806315f4001614610242578063175eb7031461025e57806320e7205a1461027a57806324182acc146102aa575b600080fd5b61025c60048036038101906102579190612cab565b610724565b005b61027860048036038101906102739190612c33565b61086e565b005b610294600480360381019061028f9190612be1565b610957565b6040516102a191906131d8565b60405180910390f35b6102b2610993565b6040516102bf9190613560565b60405180910390f35b6102d0610999565b6040516102dd919061338f565b60405180910390f35b61030060048036038101906102fb9190612b2a565b6109ac565b60405161030d9190613560565b60405180910390f35b61031e6109f5565b60405161032b9190613560565b60405180910390f35b61034e60048036038101906103499190612be1565b6109fa565b60405161035b919061338f565b60405180910390f35b61037e60048036038101906103799190612b53565b610a1a565b005b61039a60048036038101906103959190612b2a565b610d1a565b005b6103a4610e48565b005b6103ae6110b1565b6040516103bb9190613560565b60405180910390f35b6103de60048036038101906103d99190612b53565b6110b6565b005b6103fa60048036038101906103f59190612be1565b6111e9565b604051610407919061338f565b60405180910390f35b61042a60048036038101906104259190612be1565b611209565b6040516104379190613560565b60405180910390f35b610448611221565b60405161045591906131d8565b60405180910390f35b610466611246565b6040516104739190613560565b60405180910390f35b61048461124b565b60405161049191906133aa565b60405180910390f35b6104a2611271565b6040516104af9190613560565b60405180910390f35b6104c0611277565b6040516104cd9190613560565b60405180910390f35b6104de611283565b6040516104eb9190613560565b60405180910390f35b61050e60048036038101906105099190612b2a565b611288565b005b61052a60048036038101906105259190612be1565b61135b565b6040516105379190613560565b60405180910390f35b61054861137c565b6040516105559190613560565b60405180910390f35b61057860048036038101906105739190612be1565b611382565b6040516105859190613560565b60405180910390f35b6105a860048036038101906105a39190612b8f565b61139f565b005b6105b261144b565b6040516105bf91906131d8565b60405180910390f35b6105d0611471565b6040516105dd91906133c5565b60405180910390f35b61060060048036038101906105fb9190612b2a565b611497565b005b61061c60048036038101906106179190612c33565b61156a565b604051610629919061338f565b60405180910390f35b61064c60048036038101906106479190612be1565b611599565b005b61066860048036038101906106639190612c6f565b611d10565b005b610672611e26565b60405161067f91906131d8565b60405180910390f35b610690611e4c565b005b6106ac60048036038101906106a79190612be1565b61205e565b005b6106c860048036038101906106c39190612b2a565b61214f565b005b6106d261227d565b6040516106df9190613560565b60405180910390f35b6106f0612282565b6040516106fd9190613560565b60405180910390f35b61070e612288565b60405161071b91906131d8565b60405180910390f35b600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614806107cc57506000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff16145b61080b576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610802906133e0565b60405180910390fd5b6004821061084e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161084590613500565b60405180910390fd5b806007838154811061085c57fe5b90600052602060002001819055505050565b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff16146108fd576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016108f490613540565b60405180910390fd5b806004838154811061090b57fe5b9060005260206000200160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055505050565b6004818154811061096457fe5b906000526020600020016000915054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b60065481565b600e60149054906101000a900460ff1681565b6000600b60008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050919050565b600281565b60096020528060005260406000206000915054906101000a900460ff1681565b600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161480610ac257506000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff16145b610b01576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610af8906133e0565b60405180910390fd5b6000600e60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905060008173ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b8152600401610b6391906131d8565b60206040518083038186803b158015610b7b57600080fd5b505afa158015610b8f573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610bb39190612c0a565b905080831115610bf8576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610bef906134e0565b60405180910390fd5b60008090505b83811015610d135760008373ffffffffffffffffffffffffffffffffffffffff16632f745c593060006040518363ffffffff1660e01b8152600401610c44929190613366565b60206040518083038186803b158015610c5c57600080fd5b505afa158015610c70573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610c949190612c0a565b90508373ffffffffffffffffffffffffffffffffffffffff166323b872dd3088846040518463ffffffff1660e01b8152600401610cd39392919061332f565b600060405180830381600087803b158015610ced57600080fd5b505af1158015610d01573d6000803e3d6000fd5b50505050508080600101915050610bfe565b5050505050565b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610da9576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610da090613540565b60405180910390fd5b7ff9ffabca9c8276e99321725bcb43fb076a6c66a54b7f21c4e8146d8519b417dc600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1682604051610dfc9291906132dd565b60405180910390a180600260006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610ed7576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610ece90613540565b60405180910390fd5b7f70aea8d848e8a90fb7661b227dc522eb6395c3dac71b63cb59edd5c9899b23646000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff166000604051610f2a929190613306565b60405180910390a17ff9ffabca9c8276e99321725bcb43fb076a6c66a54b7f21c4e8146d8519b417dc600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff166000604051610f86929190613306565b60405180910390a17fb3d55174552271a4f1aaf36b72f50381e892171636b3fb5447fe00e995e7a37b600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff166000604051610fe2929190613306565b60405180910390a160008060006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055506000600160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055506000600260006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550565b600381565b600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff16148061115e57506000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff16145b61119d576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611194906133e0565b60405180910390fd5b81600e60006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555080600d819055505050565b600a6020528060005260406000206000915054906101000a900460ff1681565b60106020528060005260406000206000915090505481565b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b600181565b600860009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b60035481565b67016345785d8a000081565b600081565b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614611317576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161130e90613540565b60405180910390fd5b80600560006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b6007818154811061136857fe5b906000526020600020016000915090505481565b600d5481565b600060106000838152602001908152602001600020549050919050565b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161461142e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161142590613540565b60405180910390fd5b80600e60146101000a81548160ff02191690831515021790555050565b600e60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b600560009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614611526576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161151d90613540565b60405180910390fd5b80600860006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b600f6020528160005260406000206020528060005260406000206000915091509054906101000a900460ff1681565b3273ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614611607576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016115fe90613480565b60405180910390fd5b600e60149054906101000a900460ff16611656576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161164d90613440565b60405180910390fd5b600a81111561169a576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161169190613460565b60405180910390fd5b6000600860009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166370a08231336040518263ffffffff1660e01b81526004016116f791906131f3565b60206040518083038186803b15801561170f57600080fd5b505afa158015611723573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906117479190612c0a565b9050611764670de0b6b3a7640000826122ae90919063ffffffff16565b8211156117a6576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161179d906134a0565b60405180910390fd5b600860009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166323b872dd3330611801670de0b6b3a76400008761230490919063ffffffff16565b6040518463ffffffff1660e01b815260040161181f9392919061320e565b602060405180830381600087803b15801561183957600080fd5b505af115801561184d573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906118719190612bb8565b50600062015180428161188057fe5b049050600f600082815260200190815260200160002060003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900460ff1661197d57600160106000838152602001908152602001600020540160106000838152602001908152602001600020819055506001600f600083815260200190815260200160002060003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006101000a81548160ff0219169083151502179055505b6060600a67ffffffffffffffff8111801561199757600080fd5b506040519080825280602002602001820160405280156119c65781602001602082028036833780820191505090505b5090506060600a67ffffffffffffffff811180156119e357600080fd5b50604051908082528060200260200182016040528015611a125781602001602082028036833780820191505090505b509050600080905060008090505b86811015611ace57600360008154809291906001019190505550611a42612374565b15611ac157600080611a526123ab565b9150915080868581518110611a6357fe5b602002602001019073ffffffffffffffffffffffffffffffffffffffff16908173ffffffffffffffffffffffffffffffffffffffff168152505081858581518110611aaa57fe5b602002602001018181525050838060010194505050505b8080600101915050611a20565b50600a86148015611adf5750600581105b15611b93576000611afa82600561269290919063ffffffff16565b905060008090505b81811015611b9057600080611b156123ab565b9150915080878681518110611b2657fe5b602002602001019073ffffffffffffffffffffffffffffffffffffffff16908173ffffffffffffffffffffffffffffffffffffffff168152505081868681518110611b6d57fe5b602002602001018181525050848060010195505050508080600101915050611b02565b50505b600860009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166342966c68876040518263ffffffff1660e01b8152600401611bee9190613560565b600060405180830381600087803b158015611c0857600080fd5b505af1158015611c1c573d6000803e3d6000fd5b505050506000811415611c7b5785600b60003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008282540192505081905550611cc1565b6000600b60003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055505b611cc96126e2565b7f9236a993e536b46864b1eb8c9f20b2c8b896d275ec98bd0e4bee316d814e80b33387838686604051611d0095949392919061327c565b60405180910390a1505050505050565b600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161480611db857506000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff16145b611df7576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611dee906133e0565b60405180910390fd5b806009600084815260200190815260200160002060006101000a81548160ff0219169083151502179055505050565b600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614611edc576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611ed390613520565b60405180910390fd5b7f70aea8d848e8a90fb7661b227dc522eb6395c3dac71b63cb59edd5c9899b23646000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff16600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16604051611f509291906132dd565b60405180910390a1600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff166000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555060008090507fb3d55174552271a4f1aaf36b72f50381e892171636b3fb5447fe00e995e7a37b600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16826040516120129291906132dd565b60405180910390a180600160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff16148061210657506000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff16145b612145576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161213c906133e0565b60405180910390fd5b8060068190555050565b6000809054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff16146121de576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016121d590613540565b60405180910390fd5b7fb3d55174552271a4f1aaf36b72f50381e892171636b3fb5447fe00e995e7a37b600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16826040516122319291906132dd565b60405180910390a180600160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b600481565b6107d081565b600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b60008082116122f2576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016122e990613420565b60405180910390fd5b8183816122fb57fe5b04905092915050565b600080831415612317576000905061236e565b600082840290508284828161232857fe5b0414612369576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401612360906134c0565b60405180910390fd5b809150505b92915050565b60008067016345785d8a0000612388612945565b8161238f57fe5b0690506006548110156123a65760019150506123a8565b505b90565b600080600067016345785d8a00006123c1612945565b816123c857fe5b06905060006003905060006123ea6107d06003546122ae90919063ffffffff16565b90506123f581612a29565b1561242f57600491506001600a600083815260200190815260200160002060006101000a81548160ff0219169083151502179055506124af565b60006009600083815260200190815260200160002060009054906101000a900460ff1661245d576000612460565b60015b60ff16905060008190505b6007805490508110156124ac576007818154811061248557fe5b906000526020600020015485111561249f578093506124ac565b808060010191505061246b565b50505b6000600483815481106124be57fe5b9060005260206000200160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff169050600081905060008173ffffffffffffffffffffffffffffffffffffffff1663d5abeb016040518163ffffffff1660e01b815260040160206040518083038186803b15801561253857600080fd5b505afa15801561254c573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906125709190612c0a565b8273ffffffffffffffffffffffffffffffffffffffff166318160ddd6040518163ffffffff1660e01b815260040160206040518083038186803b1580156125b657600080fd5b505afa1580156125ca573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906125ee9190612c0a565b1015612682578173ffffffffffffffffffffffffffffffffffffffff166317e5883c336040518263ffffffff1660e01b815260040161262d91906131f3565b602060405180830381600087803b15801561264757600080fd5b505af115801561265b573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061267f9190612c0a565b90505b8083975097505050505050509091565b6000828211156126d7576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016126ce90613400565b60405180910390fd5b818303905092915050565b6000600d5414156126f257612943565b6000809050600067016345785d8a000061270a612945565b8161271157fe5b06905080600d541115612940576000600e60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905060008173ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b815260040161278091906131d8565b60206040518083038186803b15801561279857600080fd5b505afa1580156127ac573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906127d09190612c0a565b9050600081111561293d5760008273ffffffffffffffffffffffffffffffffffffffff16632f745c593060006040518363ffffffff1660e01b8152600401612819929190613366565b60206040518083038186803b15801561283157600080fd5b505afa158015612845573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906128699190612c0a565b90508273ffffffffffffffffffffffffffffffffffffffff166323b872dd3033846040518463ffffffff1660e01b81526004016128a89392919061332f565b600060405180830381600087803b1580156128c257600080fd5b505af11580156128d6573d6000803e3d6000fd5b50505050600194507ff465fa07bd90649488109a0615543190cabe8db0fbed07b39aa8e276369f6bec3386600e60009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1660405161293393929190613245565b60405180910390a1505b50505b50505b565b6000600560009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663dbdff2c16040518163ffffffff1660e01b8152600401602060405180830381600087803b1580156129b157600080fd5b505af11580156129c5573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906129e99190612c0a565b600c60008282540192505081905550600c54604051602001612a0b91906131bd565b6040516020818303038152906040528051906020012060001c905090565b60006009600083815260200190815260200160002060009054906101000a900460ff16612a595760009050612abc565b600a600083815260200190815260200160002060009054906101000a900460ff1615612a885760009050612abc565b600060016107d060035481612a9957fe5b0601905060006107d0612aaa612945565b81612ab157fe5b069050808211925050505b919050565b600081359050612ad0816136e0565b92915050565b600081359050612ae5816136f7565b92915050565b600081519050612afa816136f7565b92915050565b600081359050612b0f8161370e565b92915050565b600081519050612b248161370e565b92915050565b600060208284031215612b3c57600080fd5b6000612b4a84828501612ac1565b91505092915050565b60008060408385031215612b6657600080fd5b6000612b7485828601612ac1565b9250506020612b8585828601612b00565b9150509250929050565b600060208284031215612ba157600080fd5b6000612baf84828501612ad6565b91505092915050565b600060208284031215612bca57600080fd5b6000612bd884828501612aeb565b91505092915050565b600060208284031215612bf357600080fd5b6000612c0184828501612b00565b91505092915050565b600060208284031215612c1c57600080fd5b6000612c2a84828501612b15565b91505092915050565b60008060408385031215612c4657600080fd5b6000612c5485828601612b00565b9250506020612c6585828601612ac1565b9150509250929050565b60008060408385031215612c8257600080fd5b6000612c9085828601612b00565b9250506020612ca185828601612ad6565b9150509250929050565b60008060408385031215612cbe57600080fd5b6000612ccc85828601612b00565b9250506020612cdd85828601612b00565b9150509250929050565b6000612cf38383612d26565b60208301905092915050565b6000612d0b8383613188565b60208301905092915050565b612d2081613646565b82525050565b612d2f816135fe565b82525050565b612d3e816135fe565b82525050565b6000612d4f8261359b565b612d5981856135cb565b9350612d648361357b565b8060005b83811015612d95578151612d7c8882612ce7565b9750612d87836135b1565b925050600181019050612d68565b5085935050505092915050565b6000612dad826135a6565b612db781856135dc565b9350612dc28361358b565b8060005b83811015612df3578151612dda8882612cff565b9750612de5836135be565b925050600181019050612dc6565b5085935050505092915050565b612e0981613610565b82525050565b612e1881613658565b82525050565b612e278161367c565b82525050565b612e36816136a0565b82525050565b6000612e496009836135ed565b91507f6f6e6c7941646d696e00000000000000000000000000000000000000000000006000830152602082019050919050565b6000612e89601e836135ed565b91507f536166654d6174683a207375627472616374696f6e206f766572666c6f7700006000830152602082019050919050565b6000612ec9601a836135ed565b91507f536166654d6174683a206469766973696f6e206279207a65726f0000000000006000830152602082019050919050565b6000612f096018836135ed565b91507f54686520736d61736820737769746368206973206f66662100000000000000006000830152602082019050919050565b6000612f496029836135ed565b91507f616d6f756e742073686f756c64206265206c657373207468616e206f7220657160008301527f75616c20746f20313000000000000000000000000000000000000000000000006020830152604082019050919050565b6000612faf6012836135ed565b91507f696e76616c6964206d73672e73656e64657200000000000000000000000000006000830152602082019050919050565b6000612fef601c836135ed565b91507f75736572206567672073686f727461676520696e206e756d62657221000000006000830152602082019050919050565b600061302f6021836135ed565b91507f536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f60008301527f77000000000000000000000000000000000000000000000000000000000000006020830152604082019050919050565b60006130956012836135ed565b91507f436f756e7420696e707574206572726f722100000000000000000000000000006000830152602082019050919050565b60006130d5600f836135ed565b91507f496e6465782069732077726f6e672100000000000000000000000000000000006000830152602082019050919050565b60006131156010836135ed565b91507f6f6e6c7950656e64696e674f776e6572000000000000000000000000000000006000830152602082019050919050565b60006131556009836135ed565b91507f6f6e6c794f776e657200000000000000000000000000000000000000000000006000830152602082019050919050565b6131918161363c565b82525050565b6131a08161363c565b82525050565b6131b76131b28261363c565b6136d6565b82525050565b60006131c982846131a6565b60208201915081905092915050565b60006020820190506131ed6000830184612d35565b92915050565b60006020820190506132086000830184612d17565b92915050565b60006060820190506132236000830186612d17565b6132306020830185612d35565b61323d6040830184613197565b949350505050565b600060608201905061325a6000830186612d17565b6132676020830185613197565b6132746040830184612d35565b949350505050565b600060a0820190506132916000830188612d17565b61329e6020830187613197565b6132ab6040830186613197565b81810360608301526132bd8185612d44565b905081810360808301526132d18184612da2565b90509695505050505050565b60006040820190506132f26000830185612d35565b6132ff6020830184612d35565b9392505050565b600060408201905061331b6000830185612d35565b6133286020830184612d17565b9392505050565b60006060820190506133446000830186612d35565b6133516020830185612d35565b61335e6040830184613197565b949350505050565b600060408201905061337b6000830185612d35565b6133886020830184612e2d565b9392505050565b60006020820190506133a46000830184612e00565b92915050565b60006020820190506133bf6000830184612e0f565b92915050565b60006020820190506133da6000830184612e1e565b92915050565b600060208201905081810360008301526133f981612e3c565b9050919050565b6000602082019050818103600083015261341981612e7c565b9050919050565b6000602082019050818103600083015261343981612ebc565b9050919050565b6000602082019050818103600083015261345981612efc565b9050919050565b6000602082019050818103600083015261347981612f3c565b9050919050565b6000602082019050818103600083015261349981612fa2565b9050919050565b600060208201905081810360008301526134b981612fe2565b9050919050565b600060208201905081810360008301526134d981613022565b9050919050565b600060208201905081810360008301526134f981613088565b9050919050565b60006020820190508181036000830152613519816130c8565b9050919050565b6000602082019050818103600083015261353981613108565b9050919050565b6000602082019050818103600083015261355981613148565b9050919050565b60006020820190506135756000830184613197565b92915050565b6000819050602082019050919050565b6000819050602082019050919050565b600081519050919050565b600081519050919050565b6000602082019050919050565b6000602082019050919050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b60006136098261361c565b9050919050565b60008115159050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b6000613651826136b2565b9050919050565b60006136638261366a565b9050919050565b60006136758261361c565b9050919050565b60006136878261368e565b9050919050565b60006136998261361c565b9050919050565b60006136ab8261363c565b9050919050565b60006136bd826136c4565b9050919050565b60006136cf8261361c565b9050919050565b6000819050919050565b6136e9816135fe565b81146136f457600080fd5b50565b61370081613610565b811461370b57600080fd5b50565b6137178161363c565b811461372257600080fd5b5056fea26469706673582212203c6102789312aa7ef3ef52d52d125d26021a06f9956559ae8df8c67e20aff56164736f6c63430006060033000000000000000000000000e50b1f6e58a0a77b0a41aedc085190808d25d7060000000000000000000000008580a90f6e378db283ddb8af06356a962551e89a000000000000000000000000388eb34b54fe92e944b81a23f8e60146ca8381800000000000000000000000004f1e6318acc9ee33c88f0e3e3578d5ad62e192850000000000000000000000004f17c6514b9ca3abccfdefd12df2dfa195a76dc4000000000000000000000000245e5ddb65efea6522fa913229df1f4957fb2e210000000000000000000000003bc29ee3268856e9f4316628a9fe883b678f6114
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
000000000000000000000000e50b1f6e58a0a77b0a41aedc085190808d25d7060000000000000000000000008580a90f6e378db283ddb8af06356a962551e89a000000000000000000000000388eb34b54fe92e944b81a23f8e60146ca8381800000000000000000000000004f1e6318acc9ee33c88f0e3e3578d5ad62e192850000000000000000000000004f17c6514b9ca3abccfdefd12df2dfa195a76dc4000000000000000000000000245e5ddb65efea6522fa913229df1f4957fb2e210000000000000000000000003bc29ee3268856e9f4316628a9fe883b678f6114
-----Decoded View---------------
Arg [0] : _shriekingChickAddr (address): 0xE50B1F6E58A0A77B0a41aedc085190808D25D706
Arg [1] : _luckyChickAddr (address): 0x8580a90f6E378dB283ddb8af06356a962551e89A
Arg [2] : _laborChickAddr (address): 0x388EB34b54fE92e944b81A23f8e60146cA838180
Arg [3] : _bossChickAddr (address): 0x4F1e6318aCc9Ee33c88f0E3E3578D5aD62E19285
Arg [4] : _trumpChickAddr (address): 0x4f17c6514B9Ca3aBccfDefd12DF2dfA195A76dC4
Arg [5] : _eggTokenAddr (address): 0x245e5ddb65eFea6522Fa913229dF1f4957fB2e21
Arg [6] : _randomAddr (address): 0x3bc29EE3268856e9F4316628A9fE883B678F6114
-----Encoded View---------------
7 Constructor Arguments found :
Arg [0] : 000000000000000000000000e50b1f6e58a0a77b0a41aedc085190808d25d706
Arg [1] : 0000000000000000000000008580a90f6e378db283ddb8af06356a962551e89a
Arg [2] : 000000000000000000000000388eb34b54fe92e944b81a23f8e60146ca838180
Arg [3] : 0000000000000000000000004f1e6318acc9ee33c88f0e3e3578d5ad62e19285
Arg [4] : 0000000000000000000000004f17c6514b9ca3abccfdefd12df2dfa195a76dc4
Arg [5] : 000000000000000000000000245e5ddb65efea6522fa913229df1f4957fb2e21
Arg [6] : 0000000000000000000000003bc29ee3268856e9f4316628a9fe883b678f6114
Deployed Bytecode Sourcemap
101413:10837:0:-:0;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;101413:10837:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12:1:-1;9;2:12;106153:185:0;;;;;;;;;;;;;;;;:::i;:::-;;111851:147;;;;;;;;;;;;;;;;:::i;:::-;;101961:36;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;102052:33;;;:::i;:::-;;;;;;;;;;;;;;;;102585:34;;;:::i;:::-;;;;;;;;;;;;;;;;110562:117;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;101733:44;;;:::i;:::-;;;;;;;;;;;;;;;;102278:53;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;111392:451;;;;;;;;;;;;;;;;:::i;:::-;;24080:129;;;;;;;;;;;;;;;;:::i;:::-;;23468:301;;;:::i;:::-;;101784:45;;;:::i;:::-;;;;;;;;;;;;;;;;105748:214;;;;;;;;;;;;;;;;:::i;:::-;;102340:63;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;102708:54;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;22564:20;;;:::i;:::-;;;;;;;;;;;;;;;;101681:45;;;:::i;:::-;;;;;;;;;;;;;;;;102245:24;;;:::i;:::-;;;;;;;;;;;;;;;;101894:36;;;:::i;:::-;;;;;;;;;;;;;;;;101494:37;;;:::i;:::-;;;;;;;;;;;;;;;;101629:45;;;:::i;:::-;;;;;;;;;;;;;;;;110236:127;;;;;;;;;;;;;;;;:::i;:::-;;102117:33;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;102500:37;;;:::i;:::-;;;;;;;;;;;;;;;;106474:133;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;112128:119;;;;;;;;;;;;;;;;:::i;:::-;;102546:30;;;:::i;:::-;;;;;;;;;;;;;;;;102006:37;;;:::i;:::-;;;;;;;;;;;;;;;;112006:114;;;;;;;;;;;;;;;;:::i;:::-;;102628:71;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;106615:1874;;;;;;;;;;;;;;;;:::i;:::-;;105970:175;;;;;;;;;;;;;;;;:::i;:::-;;22591:27;;;:::i;:::-;;;;;;;;;;;;;;;;23781:283;;;:::i;:::-;;106346:120;;;;;;;;;;;;;;;;:::i;:::-;;23286:174;;;;;;;;;;;;;;;;:::i;:::-;;101836:49;;;:::i;:::-;;;;;;;;;;;;;;;;101540:43;;;:::i;:::-;;;;;;;;;;;;;;;;22625:20;;;:::i;:::-;;;;;;;;;;;;;;;;106153:185;23212:5;;;;;;;;;;;23198:19;;:10;:19;;;:42;;;;23235:5;;;;;;;;;;;23221:19;;:10;:19;;;23198:42;23190:63;;;;;;;;;;;;;;;;;;;;;;106261:1:::1;106253:5;:9;106245:37;;;;;;;;;;;;;;;;;;;;;;106319:11;106293:16;106310:5;106293:23;;;;;;;;;;;;;;;:37;;;;106153:185:::0;;:::o;111851:147::-;22995:5;;;;;;;;;;;22981:19;;:10;:19;;;22973:40;;;;;;;;;;;;;;;;;;;;;;111976:14:::1;111947:19;111967:5;111947:26;;;;;;;;;;;;;;;;:43;;;;;;;;;;;;;;;;;;111851:147:::0;;:::o;101961:36::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;102052:33::-;;;;:::o;102585:34::-;;;;;;;;;;;;;:::o;110562:117::-;110624:7;110650:14;:21;110665:5;110650:21;;;;;;;;;;;;;;;;110643:28;;110562:117;;;:::o;101733:44::-;101776:1;101733:44;:::o;102278:53::-;;;;;;;;;;;;;;;;;;;;;;:::o;111392:451::-;23212:5;;;;;;;;;;;23198:19;;:10;:19;;;:42;;;;23235:5;;;;;;;;;;;23221:19;;:10;:19;;;23198:42;23190:63;;;;;;;;;;;;;;;;;;;;;;111483:13:::1;111506:15;;;;;;;;;;;111483:39;;111533:14;111550:6;:16;;;111575:4;111550:31;;;;;;;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24::::0;17:12:::1;2:2;111550:31:0;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::1;77:16;74:1;67:27;5:2;111550:31:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;111550:31:0;;;;;;;;;111533:48;;111609:6;111600:5;:15;;111592:46;;;;;;;;;;;;;;;;;;;;;;111653:9;111663:1:::0;111653:11:::1;;111649:187;111668:5;111666:1;:7;111649:187;;;111694:15;111712:6;:26;;;111747:4;111754:1;111712:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24::::0;17:12:::1;2:2;111712:44:0;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::1;77:16;74:1;67:27;5:2;111712:44:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;111712:44:0;;;;;;;;;111694:62;;111771:6;:19;;;111799:4;111806:8;111816:7;111771:53;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24::::0;17:12:::1;2:2;111771:53:0;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::1;77:16;74:1;67:27;5:2;111771:53:0;;;;111649:187;111675:3;;;;;;;111649:187;;;;23264:1;;111392:451:::0;;:::o;24080:129::-;22995:5;;;;;;;;;;;22981:19;;:10;:19;;;22973:40;;;;;;;;;;;;;;;;;;;;;;24149:25:::1;24158:5;;;;;;;;;;;24165:8;24149:25;;;;;;;;;;;;;;;;24193:8;24185:5;;:16;;;;;;;;;;;;;;;;;;24080:129:::0;:::o;23468:301::-;22995:5;;;;;;;;;;;22981:19;;:10;:19;;;22973:40;;;;;;;;;;;;;;;;;;;;;;23538:27:::1;23547:5;::::0;::::1;;;;;;;;;23562:1;23538:27;;;;;;;;;;;;;;;;23581;23590:5;;;;;;;;;;;23605:1;23581:27;;;;;;;;;;;;;;;;23624:41;23640:12;;;;;;;;;;;23662:1;23624:41;;;;;;;;;;;;;;;;23694:1;23678:5:::0;::::1;:18;;;;;;;;;;;;;;;;;;23730:1;23707:12;;:25;;;;;;;;;;;;;;;;;;23759:1;23743:5;;:18;;;;;;;;;;;;;;;;;;23468:301::o:0;101784:45::-;101828:1;101784:45;:::o;105748:214::-;23212:5;;;;;;;;;;;23198:19;;:10;:19;;;:42;;;;23235:5;;;;;;;;;;;23221:19;;:10;:19;;;23198:42;23190:63;;;;;;;;;;;;;;;;;;;;;;105879:16:::1;105861:15;;:34;;;;;;;;;;;;;;;;;;105931:23;105906:22;:48;;;;105748:214:::0;;:::o;102340:63::-;;;;;;;;;;;;;;;;;;;;;;:::o;102708:54::-;;;;;;;;;;;;;;;;;:::o;22564:20::-;;;;;;;;;;;;;:::o;101681:45::-;101725:1;101681:45;:::o;102245:24::-;;;;;;;;;;;;;:::o;101894:36::-;;;;:::o;101494:37::-;101527:4;101494:37;:::o;101629:45::-;101673:1;101629:45;:::o;110236:127::-;22995:5;;;;;;;;;;;22981:19;;:10;:19;;;22973:40;;;;;;;;;;;;;;;;;;;;;;110343:11:::1;110310:14;;:45;;;;;;;;;;;;;;;;;;110236:127:::0;:::o;102117:33::-;;;;;;;;;;;;;;;;;;;;;;;;;:::o;102500:37::-;;;;:::o;106474:133::-;106544:7;106570:19;:29;106590:8;106570:29;;;;;;;;;;;;106563:36;;106474:133;;;:::o;112128:119::-;22995:5;;;;;;;;;;;22981:19;;:10;:19;;;22973:40;;;;;;;;;;;;;;;;;;;;;;112224:15:::1;112207:14;;:32;;;;;;;;;;;;;;;;;;112128:119:::0;:::o;102546:30::-;;;;;;;;;;;;;:::o;102006:37::-;;;;;;;;;;;;;:::o;112006:114::-;22995:5;;;;;;;;;;;22981:19;;:10;:19;;;22973:40;;;;;;;;;;;;;;;;;;;;;;112099:12:::1;112079:8;;:33;;;;;;;;;;;;;;;;;;112006:114:::0;:::o;102628:71::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;106615:1874::-;106689:9;106675:23;;:10;:23;;;106667:54;;;;;;;;;;;;;;;;;;;;;;106740:14;;;;;;;;;;;106732:51;;;;;;;;;;;;;;;;;;;;;;106812:2;106802:6;:12;;106794:66;;;;;;;;;;;;;;;;;;;;;;106871:21;106895:8;;;;;;;;;;;:18;;;106914:10;106895:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;106895:30:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;106895:30:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;106895:30:0;;;;;;;;;106871:54;;106954:23;106972:4;106954:13;:17;;:23;;;;:::i;:::-;106944:6;:33;;106936:74;;;;;;;;;;;;;;;;;;;;;;107021:8;;;;;;;;;;;:21;;;107043:10;107063:4;107070:16;107081:4;107070:6;:10;;:16;;;;:::i;:::-;107021:66;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;107021:66:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;107021:66:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;107021:66:0;;;;;;;;;;107100:16;107125:5;107119:3;:11;;;;;;107100:30;;107145:19;:29;107165:8;107145:29;;;;;;;;;;;:41;107175:10;107145:41;;;;;;;;;;;;;;;;;;;;;;;;;107141:201;;107266:1;107234:19;:29;107254:8;107234:29;;;;;;;;;;;;:33;107202:19;:29;107222:8;107202:29;;;;;;;;;;;:65;;;;107326:4;107282:19;:29;107302:8;107282:29;;;;;;;;;;;:41;107312:10;107282:41;;;;;;;;;;;;;;;;:48;;;;;;;;;;;;;;;;;;107141:201;107354:31;107402:2;107388:17;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;107388:17:0;;;;;;;;;;;;;;;;;;;;;;;29:2:-1;21:6;17:15;125:4;109:14;101:6;88:42;156:4;148:6;144:17;134:27;;0:165;107388:17:0;;;;107354:51;;107416:25;107458:2;107444:17;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;107444:17:0;;;;;;;;;;;;;;;;;;;;;;;29:2:-1;21:6;17:15;125:4;109:14;101:6;88:42;156:4;148:6;144:17;134:27;;0:165;107444:17:0;;;;107416:45;;107472:13;107488:1;107472:17;;107504:9;107514:1;107504:11;;107500:320;107519:6;107517:1;:8;107500:320;;;107546:21;;:23;;;;;;;;;;;;;107587:7;:5;:7::i;:::-;107584:225;;;107615:15;107632:17;107653:16;:14;:16::i;:::-;107614:55;;;;107712:9;107688:14;107703:5;107688:21;;;;;;;;;;;;;:33;;;;;;;;;;;107758:7;107740:8;107749:5;107740:15;;;;;;;;;;;;;:25;;;;;107786:7;;;;;;;107584:225;;;107527:3;;;;;;;107500:320;;;;107845:2;107835:6;:12;:25;;;;;107859:1;107851:5;:9;107835:25;107832:353;;;107876:14;107893:21;107908:5;107901:1;107893:14;;:21;;;;:::i;:::-;107876:38;;107933:9;107943:1;107933:11;;107929:245;107948:6;107946:1;:8;107929:245;;;107980:15;107997:17;108018:16;:14;:16::i;:::-;107979:55;;;;108077:9;108053:14;108068:5;108053:21;;;;;;;;;;;;;:33;;;;;;;;;;;108123:7;108105:8;108114:5;108105:15;;;;;;;;;;;;;:25;;;;;108151:7;;;;;;;107929:245;;107956:3;;;;;;;107929:245;;;;107832:353;;108195:8;;;;;;;;;;;:13;;;108209:6;108195:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;108195:21:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;108195:21:0;;;;108241:1;108232:5;:10;108229:138;;;108288:6;108258:14;:26;108273:10;108258:26;;;;;;;;;;;;;;;;:36;;;;;;;;;;;108229:138;;;108354:1;108325:14;:26;108340:10;108325:26;;;;;;;;;;;;;;;:30;;;;108229:138;108379:17;:15;:17::i;:::-;108414:67;108429:10;108441:6;108449:5;108456:14;108472:8;108414:67;;;;;;;;;;;;;;;;;;;106615:1874;;;;;;:::o;105970:175::-;23212:5;;;;;;;;;;;23198:19;;:10;:19;;;:42;;;;23235:5;;;;;;;;;;;23221:19;;:10;:19;;;23198:42;23190:63;;;;;;;;;;;;;;;;;;;;;;106114:23:::1;106081:21;:30;106103:7;106081:30;;;;;;;;;;;;:56;;;;;;;;;;;;;;;;;;105970:175:::0;;:::o;22591:27::-;;;;;;;;;;;;;:::o;23781:283::-;23100:12;;;;;;;;;;;23086:26;;:10;:26;;;23078:54;;;;;;;;;;;;;;;;;;;;;;23844:29:::1;23853:5;::::0;::::1;;;;;;;;;23860:12;;;;;;;;;;;23844:29;;;;;;;;;;;;;;;;23892:12;;;;;;;;;;;23884:5;::::0;:20:::1;;;;;;;;;;;;;;;;;;23917:23;23951:1:::0;23917:36:::1;;23969:46;23985:12;;;;;;;;;;;23999:15;23969:46;;;;;;;;;;;;;;;;24041:15;24026:12;;:30;;;;;;;;;;;;;;;;;;23143:1;23781:283::o:0;106346:120::-;23212:5;;;;;;;;;;;23198:19;;:10;:19;;;:42;;;;23235:5;;;;;;;;;;;23221:19;;:10;:19;;;23198:42;23190:63;;;;;;;;;;;;;;;;;;;;;;106447:11:::1;106426:18;:32;;;;106346:120:::0;:::o;23286:174::-;22995:5;;;;;;;;;;;22981:19;;:10;:19;;;22973:40;;;;;;;;;;;;;;;;;;;;;;23369:44:::1;23385:12;;;;;;;;;;;23399:13;23369:44;;;;;;;;;;;;;;;;23439:13;23424:12;;:28;;;;;;;;;;;;;;;;;;23286:174:::0;:::o;101836:49::-;101884:1;101836:49;:::o;101540:43::-;101579:4;101540:43;:::o;22625:20::-;;;;;;;;;;;;;:::o;4405:153::-;4463:7;4495:1;4491;:5;4483:44;;;;;;;;;;;;;;;;;;;;;;4549:1;4545;:5;;;;;;4538:12;;4405:153;;;;:::o;3707:220::-;3765:7;3794:1;3789;:6;3785:20;;;3804:1;3797:8;;;;3785:20;3816:9;3832:1;3828;:5;3816:17;;3861:1;3856;3852;:5;;;;;;:10;3844:56;;;;;;;;;;;;;;;;;;;;;;3918:1;3911:8;;;3707:220;;;;;:::o;108542:178::-;108576:4;108592:14;101527:4;108609:12;:10;:12::i;:::-;:24;;;;;;108592:41;;108656:18;;108647:6;:27;108644:69;;;108697:4;108690:11;;;;;108644:69;108542:178;;;:::o;108728:1059::-;108771:7;108780;108799:14;101527:4;108816:12;:10;:12::i;:::-;:24;;;;;;108799:41;;108851:13;101828:1;108851:33;;108895:20;108918:39;101579:4;108918:21;;:25;;:39;;;;:::i;:::-;108895:62;;108973:42;109002:12;108973:28;:42::i;:::-;108970:479;;;101884:1;109031:29;;109123:4;109075:31;:45;109107:12;109075:45;;;;;;;;;;;;:52;;;;;;;;;;;;;;;;;;108970:479;;;109158:18;109179:21;:35;109201:12;109179:35;;;;;;;;;;;;;;;;;;;;;:41;;109219:1;109179:41;;;109216:1;109179:41;109158:62;;;;109239:9;109249:10;109239:20;;109235:203;109263:16;:23;;;;109261:1;:25;109235:203;;;109323:16;109340:1;109323:19;;;;;;;;;;;;;;;;109314:6;:28;109311:112;;;109374:1;109366:9;;109398:5;;109311:112;109288:3;;;;;;;109235:203;;;;108970:479;;109461:17;109481:19;109501:5;109481:26;;;;;;;;;;;;;;;;;;;;;;;;;109461:46;;109518:27;109562:9;109518:54;;109585:15;109644:13;:23;;;:25;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;109644:25:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;109644:25:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;109644:25:0;;;;;;;;;109614:13;:25;;;:27;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;109614:27:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;109614:27:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;109614:27:0;;;;;;;;;:55;109611:131;;;109695:13;:23;;;109719:10;109695:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;109695:35:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;109695:35:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;109695:35:0;;;;;;;;;109685:45;;109611:131;109760:7;109769:9;109752:27;;;;;;;;;;108728:1059;;:::o;3290:158::-;3348:7;3381:1;3376;:6;;3368:49;;;;;;;;;;;;;;;;;;;;;;3439:1;3435;:5;3428:12;;3290:158;;;;:::o;110687:697::-;110762:1;110736:22;;:27;110733:64;;;110779:7;;110733:64;110807:16;110826:1;110807:20;;110838:14;101527:4;110855:12;:10;:12::i;:::-;:24;;;;;;110838:41;;110918:6;110893:22;;:31;110890:479;;;110940:13;110963:15;;;;;;;;;;;110940:39;;110994:14;111011:6;:16;;;111036:4;111011:31;;;;;;;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;111011:31:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;111011:31:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;111011:31:0;;;;;;;;;110994:48;;111069:1;111060:6;:10;111057:301;;;111090:15;111108:6;:26;;;111143:4;111150:1;111108:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;111108:44:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;111108:44:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;111108:44:0;;;;;;;;;111090:62;;111171:6;:19;;;111199:4;111214:10;111227:7;111171:64;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;111171:64:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;111171:64:0;;;;111265:1;111254:12;;111290:52;111304:10;111316:8;111326:15;;;;;;;;;;;111290:52;;;;;;;;;;;;;;;;;111057:301;;110890:479;;;110687:697;;;:::o;110371:183::-;110410:14;110444;;;;;;;;;;;:30;;;:32;;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;110444:32:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;110444:32:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;110444:32:0;;;;;;;;;110436:4;;:40;;;;;;;;;;;110539:4;;110522:22;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;110522:22:0;;;110512:33;;;;;;110504:42;;110495:51;;110371:183;:::o;109795:433::-;109872:4;109892:21;:35;109914:12;109892:35;;;;;;;;;;;;;;;;;;;;;109888:79;;109950:5;109943:12;;;;109888:79;109980:31;:45;110012:12;109980:45;;;;;;;;;;;;;;;;;;;;;109977:88;;;110048:5;110041:12;;;;109977:88;110075:14;110131:1;101579:4;110092:21;;:36;;;;;;:40;110075:57;;110143:14;101579:4;110160:12;:10;:12::i;:::-;:27;;;;;;110143:44;;110214:6;110205;:15;110198:22;;;;109795:433;;;;:::o;5:130:-1:-;;85:6;72:20;63:29;;97:33;124:5;97:33;;;57:78;;;;;142:124;;219:6;206:20;197:29;;231:30;255:5;231:30;;;191:75;;;;;273:128;;354:6;348:13;339:22;;366:30;390:5;366:30;;;333:68;;;;;408:130;;488:6;475:20;466:29;;500:33;527:5;500:33;;;460:78;;;;;545:134;;629:6;623:13;614:22;;641:33;668:5;641:33;;;608:71;;;;;686:241;;790:2;778:9;769:7;765:23;761:32;758:2;;;806:1;803;796:12;758:2;841:1;858:53;903:7;894:6;883:9;879:22;858:53;;;848:63;;820:97;752:175;;;;;934:366;;;1055:2;1043:9;1034:7;1030:23;1026:32;1023:2;;;1071:1;1068;1061:12;1023:2;1106:1;1123:53;1168:7;1159:6;1148:9;1144:22;1123:53;;;1113:63;;1085:97;1213:2;1231:53;1276:7;1267:6;1256:9;1252:22;1231:53;;;1221:63;;1192:98;1017:283;;;;;;1307:235;;1408:2;1396:9;1387:7;1383:23;1379:32;1376:2;;;1424:1;1421;1414:12;1376:2;1459:1;1476:50;1518:7;1509:6;1498:9;1494:22;1476:50;;;1466:60;;1438:94;1370:172;;;;;1549:257;;1661:2;1649:9;1640:7;1636:23;1632:32;1629:2;;;1677:1;1674;1667:12;1629:2;1712:1;1729:61;1782:7;1773:6;1762:9;1758:22;1729:61;;;1719:71;;1691:105;1623:183;;;;;1813:241;;1917:2;1905:9;1896:7;1892:23;1888:32;1885:2;;;1933:1;1930;1923:12;1885:2;1968:1;1985:53;2030:7;2021:6;2010:9;2006:22;1985:53;;;1975:63;;1947:97;1879:175;;;;;2061:263;;2176:2;2164:9;2155:7;2151:23;2147:32;2144:2;;;2192:1;2189;2182:12;2144:2;2227:1;2244:64;2300:7;2291:6;2280:9;2276:22;2244:64;;;2234:74;;2206:108;2138:186;;;;;2331:366;;;2452:2;2440:9;2431:7;2427:23;2423:32;2420:2;;;2468:1;2465;2458:12;2420:2;2503:1;2520:53;2565:7;2556:6;2545:9;2541:22;2520:53;;;2510:63;;2482:97;2610:2;2628:53;2673:7;2664:6;2653:9;2649:22;2628:53;;;2618:63;;2589:98;2414:283;;;;;;2704:360;;;2822:2;2810:9;2801:7;2797:23;2793:32;2790:2;;;2838:1;2835;2828:12;2790:2;2873:1;2890:53;2935:7;2926:6;2915:9;2911:22;2890:53;;;2880:63;;2852:97;2980:2;2998:50;3040:7;3031:6;3020:9;3016:22;2998:50;;;2988:60;;2959:95;2784:280;;;;;;3071:366;;;3192:2;3180:9;3171:7;3167:23;3163:32;3160:2;;;3208:1;3205;3198:12;3160:2;3243:1;3260:53;3305:7;3296:6;3285:9;3281:22;3260:53;;;3250:63;;3222:97;3350:2;3368:53;3413:7;3404:6;3393:9;3389:22;3368:53;;;3358:63;;3329:98;3154:283;;;;;;3445:173;;3532:46;3574:3;3566:6;3532:46;;;3607:4;3602:3;3598:14;3584:28;;3525:93;;;;;3627:173;;3714:46;3756:3;3748:6;3714:46;;;3789:4;3784:3;3780:14;3766:28;;3707:93;;;;;3808:142;3899:45;3938:5;3899:45;;;3894:3;3887:58;3881:69;;;3957:103;4030:24;4048:5;4030:24;;;4025:3;4018:37;4012:48;;;4067:113;4150:24;4168:5;4150:24;;;4145:3;4138:37;4132:48;;;4218:690;;4363:54;4411:5;4363:54;;;4430:86;4509:6;4504:3;4430:86;;;4423:93;;4537:56;4587:5;4537:56;;;4613:7;4641:1;4626:260;4651:6;4648:1;4645:13;4626:260;;;4718:6;4712:13;4739:63;4798:3;4783:13;4739:63;;;4732:70;;4819:60;4872:6;4819:60;;;4809:70;;4683:203;4673:1;4670;4666:9;4661:14;;4626:260;;;4630:14;4899:3;4892:10;;4342:566;;;;;;;;4947:690;;5092:54;5140:5;5092:54;;;5159:86;5238:6;5233:3;5159:86;;;5152:93;;5266:56;5316:5;5266:56;;;5342:7;5370:1;5355:260;5380:6;5377:1;5374:13;5355:260;;;5447:6;5441:13;5468:63;5527:3;5512:13;5468:63;;;5461:70;;5548:60;5601:6;5548:60;;;5538:70;;5412:203;5402:1;5399;5395:9;5390:14;;5355:260;;;5359:14;5628:3;5621:10;;5071:566;;;;;;;;5645:104;5722:21;5737:5;5722:21;;;5717:3;5710:34;5704:45;;;5756:160;5856:54;5904:5;5856:54;;;5851:3;5844:67;5838:78;;;5923:174;6030:61;6085:5;6030:61;;;6025:3;6018:74;6012:85;;;6104:142;6195:45;6234:5;6195:45;;;6190:3;6183:58;6177:69;;;6254:308;;6414:66;6478:1;6473:3;6414:66;;;6407:73;;6513:11;6509:1;6504:3;6500:11;6493:32;6553:2;6548:3;6544:12;6537:19;;6400:162;;;;6571:330;;6731:67;6795:2;6790:3;6731:67;;;6724:74;;6831:32;6827:1;6822:3;6818:11;6811:53;6892:2;6887:3;6883:12;6876:19;;6717:184;;;;6910:326;;7070:67;7134:2;7129:3;7070:67;;;7063:74;;7170:28;7166:1;7161:3;7157:11;7150:49;7227:2;7222:3;7218:12;7211:19;;7056:180;;;;7245:324;;7405:67;7469:2;7464:3;7405:67;;;7398:74;;7505:26;7501:1;7496:3;7492:11;7485:47;7560:2;7555:3;7551:12;7544:19;;7391:178;;;;7578:378;;7738:67;7802:2;7797:3;7738:67;;;7731:74;;7838:34;7834:1;7829:3;7825:11;7818:55;7907:11;7902:2;7897:3;7893:12;7886:33;7947:2;7942:3;7938:12;7931:19;;7724:232;;;;7965:318;;8125:67;8189:2;8184:3;8125:67;;;8118:74;;8225:20;8221:1;8216:3;8212:11;8205:41;8274:2;8269:3;8265:12;8258:19;;8111:172;;;;8292:328;;8452:67;8516:2;8511:3;8452:67;;;8445:74;;8552:30;8548:1;8543:3;8539:11;8532:51;8611:2;8606:3;8602:12;8595:19;;8438:182;;;;8629:370;;8789:67;8853:2;8848:3;8789:67;;;8782:74;;8889:34;8885:1;8880:3;8876:11;8869:55;8958:3;8953:2;8948:3;8944:12;8937:25;8990:2;8985:3;8981:12;8974:19;;8775:224;;;;9008:318;;9168:67;9232:2;9227:3;9168:67;;;9161:74;;9268:20;9264:1;9259:3;9255:11;9248:41;9317:2;9312:3;9308:12;9301:19;;9154:172;;;;9335:315;;9495:67;9559:2;9554:3;9495:67;;;9488:74;;9595:17;9591:1;9586:3;9582:11;9575:38;9641:2;9636:3;9632:12;9625:19;;9481:169;;;;9659:316;;9819:67;9883:2;9878:3;9819:67;;;9812:74;;9919:18;9915:1;9910:3;9906:11;9899:39;9966:2;9961:3;9957:12;9950:19;;9805:170;;;;9984:308;;10144:66;10208:1;10203:3;10144:66;;;10137:73;;10243:11;10239:1;10234:3;10230:11;10223:32;10283:2;10278:3;10274:12;10267:19;;10130:162;;;;10300:103;10373:24;10391:5;10373:24;;;10368:3;10361:37;10355:48;;;10410:113;10493:24;10511:5;10493:24;;;10488:3;10481:37;10475:48;;;10530:152;10631:45;10651:24;10669:5;10651:24;;;10631:45;;;10626:3;10619:58;10613:69;;;10689:244;;10808:75;10879:3;10870:6;10808:75;;;10905:2;10900:3;10896:12;10889:19;;10925:3;10918:10;;10796:137;;;;;10940:213;;11058:2;11047:9;11043:18;11035:26;;11072:71;11140:1;11129:9;11125:17;11116:6;11072:71;;;11029:124;;;;;11160:229;;11286:2;11275:9;11271:18;11263:26;;11300:79;11376:1;11365:9;11361:17;11352:6;11300:79;;;11257:132;;;;;11396:451;;11578:2;11567:9;11563:18;11555:26;;11592:79;11668:1;11657:9;11653:17;11644:6;11592:79;;;11682:72;11750:2;11739:9;11735:18;11726:6;11682:72;;;11765;11833:2;11822:9;11818:18;11809:6;11765:72;;;11549:298;;;;;;;11854:451;;12036:2;12025:9;12021:18;12013:26;;12050:79;12126:1;12115:9;12111:17;12102:6;12050:79;;;12140:72;12208:2;12197:9;12193:18;12184:6;12140:72;;;12223;12291:2;12280:9;12276:18;12267:6;12223:72;;;12007:298;;;;;;;12312:971;;12650:3;12639:9;12635:19;12627:27;;12665:79;12741:1;12730:9;12726:17;12717:6;12665:79;;;12755:72;12823:2;12812:9;12808:18;12799:6;12755:72;;;12838;12906:2;12895:9;12891:18;12882:6;12838:72;;;12958:9;12952:4;12948:20;12943:2;12932:9;12928:18;12921:48;12983:108;13086:4;13077:6;12983:108;;;12975:116;;13140:9;13134:4;13130:20;13124:3;13113:9;13109:19;13102:49;13165:108;13268:4;13259:6;13165:108;;;13157:116;;12621:662;;;;;;;;;13290:324;;13436:2;13425:9;13421:18;13413:26;;13450:71;13518:1;13507:9;13503:17;13494:6;13450:71;;;13532:72;13600:2;13589:9;13585:18;13576:6;13532:72;;;13407:207;;;;;;13621:340;;13775:2;13764:9;13760:18;13752:26;;13789:71;13857:1;13846:9;13842:17;13833:6;13789:71;;;13871:80;13947:2;13936:9;13932:18;13923:6;13871:80;;;13746:215;;;;;;13968:435;;14142:2;14131:9;14127:18;14119:26;;14156:71;14224:1;14213:9;14209:17;14200:6;14156:71;;;14238:72;14306:2;14295:9;14291:18;14282:6;14238:72;;;14321;14389:2;14378:9;14374:18;14365:6;14321:72;;;14113:290;;;;;;;14410:340;;14564:2;14553:9;14549:18;14541:26;;14578:71;14646:1;14635:9;14631:17;14622:6;14578:71;;;14660:80;14736:2;14725:9;14721:18;14712:6;14660:80;;;14535:215;;;;;;14757:201;;14869:2;14858:9;14854:18;14846:26;;14883:65;14945:1;14934:9;14930:17;14921:6;14883:65;;;14840:118;;;;;14965:247;;15100:2;15089:9;15085:18;15077:26;;15114:88;15199:1;15188:9;15184:17;15175:6;15114:88;;;15071:141;;;;;15219:261;;15361:2;15350:9;15346:18;15338:26;;15375:95;15467:1;15456:9;15452:17;15443:6;15375:95;;;15332:148;;;;;15487:407;;15678:2;15667:9;15663:18;15655:26;;15728:9;15722:4;15718:20;15714:1;15703:9;15699:17;15692:47;15753:131;15879:4;15753:131;;;15745:139;;15649:245;;;;15901:407;;16092:2;16081:9;16077:18;16069:26;;16142:9;16136:4;16132:20;16128:1;16117:9;16113:17;16106:47;16167:131;16293:4;16167:131;;;16159:139;;16063:245;;;;16315:407;;16506:2;16495:9;16491:18;16483:26;;16556:9;16550:4;16546:20;16542:1;16531:9;16527:17;16520:47;16581:131;16707:4;16581:131;;;16573:139;;16477:245;;;;16729:407;;16920:2;16909:9;16905:18;16897:26;;16970:9;16964:4;16960:20;16956:1;16945:9;16941:17;16934:47;16995:131;17121:4;16995:131;;;16987:139;;16891:245;;;;17143:407;;17334:2;17323:9;17319:18;17311:26;;17384:9;17378:4;17374:20;17370:1;17359:9;17355:17;17348:47;17409:131;17535:4;17409:131;;;17401:139;;17305:245;;;;17557:407;;17748:2;17737:9;17733:18;17725:26;;17798:9;17792:4;17788:20;17784:1;17773:9;17769:17;17762:47;17823:131;17949:4;17823:131;;;17815:139;;17719:245;;;;17971:407;;18162:2;18151:9;18147:18;18139:26;;18212:9;18206:4;18202:20;18198:1;18187:9;18183:17;18176:47;18237:131;18363:4;18237:131;;;18229:139;;18133:245;;;;18385:407;;18576:2;18565:9;18561:18;18553:26;;18626:9;18620:4;18616:20;18612:1;18601:9;18597:17;18590:47;18651:131;18777:4;18651:131;;;18643:139;;18547:245;;;;18799:407;;18990:2;18979:9;18975:18;18967:26;;19040:9;19034:4;19030:20;19026:1;19015:9;19011:17;19004:47;19065:131;19191:4;19065:131;;;19057:139;;18961:245;;;;19213:407;;19404:2;19393:9;19389:18;19381:26;;19454:9;19448:4;19444:20;19440:1;19429:9;19425:17;19418:47;19479:131;19605:4;19479:131;;;19471:139;;19375:245;;;;19627:407;;19818:2;19807:9;19803:18;19795:26;;19868:9;19862:4;19858:20;19854:1;19843:9;19839:17;19832:47;19893:131;20019:4;19893:131;;;19885:139;;19789:245;;;;20041:407;;20232:2;20221:9;20217:18;20209:26;;20282:9;20276:4;20272:20;20268:1;20257:9;20253:17;20246:47;20307:131;20433:4;20307:131;;;20299:139;;20203:245;;;;20455:213;;20573:2;20562:9;20558:18;20550:26;;20587:71;20655:1;20644:9;20640:17;20631:6;20587:71;;;20544:124;;;;;20675:151;;20761:3;20753:11;;20799:4;20794:3;20790:14;20782:22;;20747:79;;;;20833:151;;20919:3;20911:11;;20957:4;20952:3;20948:14;20940:22;;20905:79;;;;20991:137;;21100:5;21094:12;21084:22;;21065:63;;;;21135:137;;21244:5;21238:12;21228:22;;21209:63;;;;21279:108;;21377:4;21372:3;21368:14;21360:22;;21354:33;;;;21394:108;;21492:4;21487:3;21483:14;21475:22;;21469:33;;;;21510:178;;21640:6;21635:3;21628:19;21677:4;21672:3;21668:14;21653:29;;21621:67;;;;;21697:178;;21827:6;21822:3;21815:19;21864:4;21859:3;21855:14;21840:29;;21808:67;;;;;21884:163;;21999:6;21994:3;21987:19;22036:4;22031:3;22027:14;22012:29;;21980:67;;;;;22055:91;;22117:24;22135:5;22117:24;;;22106:35;;22100:46;;;;22153:85;;22226:5;22219:13;22212:21;22201:32;;22195:43;;;;22245:121;;22318:42;22311:5;22307:54;22296:65;;22290:76;;;;22373:72;;22435:5;22424:16;;22418:27;;;;22452:129;;22539:37;22570:5;22539:37;;;22526:50;;22520:61;;;;22588:155;;22684:54;22732:5;22684:54;;;22671:67;;22665:78;;;;22750:125;;22846:24;22864:5;22846:24;;;22833:37;;22827:48;;;;22882:169;;22985:61;23040:5;22985:61;;;22972:74;;22966:85;;;;23058:132;;23161:24;23179:5;23161:24;;;23148:37;;23142:48;;;;23197:116;;23284:24;23302:5;23284:24;;;23271:37;;23265:48;;;;23320:121;;23399:37;23430:5;23399:37;;;23386:50;;23380:61;;;;23448:108;;23527:24;23545:5;23527:24;;;23514:37;;23508:48;;;;23563:74;;23627:5;23616:16;;23610:27;;;;23644:117;23713:24;23731:5;23713:24;;;23706:5;23703:35;23693:2;;23752:1;23749;23742:12;23693:2;23687:74;;23768:111;23834:21;23849:5;23834:21;;;23827:5;23824:32;23814:2;;23870:1;23867;23860:12;23814:2;23808:71;;23886:117;23955:24;23973:5;23955:24;;;23948:5;23945:35;23935:2;;23994:1;23991;23984:12;23935:2;23929:74;
Swarm Source
ipfs://3c6102789312aa7ef3ef52d52d125d26021a06f9956559ae8df8c67e20aff561
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.