Address Details
contract
0xA7cBd7ce363f4e3418b574F3E11d472239EbA079
- Contract Name
- AuctionUpgradeable
- Creator
- 0x6d3f1b–09369f at 0x5cd419–e5bb6a
- Balance
- 0 CELO ( )
- Locked CELO Balance
- 0.00 CELO
- Voting CELO Balance
- 0.00 CELO
- Pending Unlocked Gold
- 0.00 CELO
- Tokens
-
Fetching tokens...
- Transactions
- 0 Transactions
- Transfers
- 0 Transfers
- Gas Used
- Fetching gas used...
- Last Balance Update
- 12735059
This contract has been verified via Sourcify.
View contract in Sourcify repository
- Contract name:
- AuctionUpgradeable
- Optimization enabled
- true
- Compiler version
- v0.8.4+commit.c7e474f2
- Optimization runs
- 200
- EVM Version
- istanbul
- Verified at
- 2023-02-06T11:53:31.527189Z
project:/contracts/AuctionUpgradeable.sol
// SPDX-License-Identifier: MIT pragma solidity ^0.8.4; import "@openzeppelin/contracts-upgradeable/utils/math/SafeMathUpgradeable.sol"; import "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol"; import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol"; import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol"; import "./VirtuousTokenServices.sol"; import "./IVirtuousContractFactory.sol"; contract AuctionUpgradeable is Initializable, VirtuousTokenServices, ReentrancyGuardUpgradeable, UUPSUpgradeable { using SafeMathUpgradeable for uint256; IERC20Upgradeable private erc20Token; address private contractFactory; // static uint256 public floorPrice; uint256 public startTime; uint256 public endTime; address private beneficiary; address private salesPerson; uint256 private marketplaceRoyaltyFeePercent; uint256 private salesPersonRoyaltyFeePercent; // state bool public canceled; bool public ended; //bool private fundCollected; uint256 public highestBindingBid; address public highestBidder; address[] private bidders; mapping(address => uint256) public fundsByBidder; // events event LogBid(address bidder, uint256 bid, address highestBidder, uint256 highestBid, uint256 highestBindingBid); event LogWithdrawal(address withdrawalAccount, uint256 amount); event LogCanceled(bool success); event LogRefund(address sender, uint256 amount); //event FundCollected(uint256 merchantFee, uint256 marketplaceRoyalty, uint256 salesPersonRoyalty); event Received(address sender, uint256 amount); /// @custom:oz-upgrades-unsafe-allow constructor constructor() { _disableInitializers(); } function initialize(IERC20Upgradeable _erc20Token, address _beneficiary, uint256 _floorPrice, uint256 _startTime, uint256 _endTime, uint256 _virtuousTokensIssued, uint256 _redeemQty, address _salesPerson, uint256 _marketplaceRoyaltyFeePercent, uint256 _salesPersonRoyaltyFeePercent) initializer public { __ReentrancyGuard_init(); __UUPSUpgradeable_init(); __VirtuousTokenServices_init(_virtuousTokensIssued, _redeemQty); require(_startTime > block.timestamp, 'Auction start timestamp is invalid!'); require(_endTime > block.timestamp && _endTime > _startTime, 'Auction end timestamp can not be the past or invalid!'); require(_beneficiary != address(0x0), 'Beneficiary address is not correct!'); erc20Token = _erc20Token; beneficiary = _beneficiary; salesPerson = _salesPerson; floorPrice = _floorPrice; startTime = _startTime; endTime = _endTime; marketplaceRoyaltyFeePercent = _marketplaceRoyaltyFeePercent; salesPersonRoyaltyFeePercent = _salesPersonRoyaltyFeePercent; contractFactory = msg.sender; } function _authorizeUpgrade(address newImplementation) internal onlyContractFactoryOwner() override {} // bid on NFD function placeBid(uint256 amount) external nonReentrant onlyAfterStart onlyBeforeEnd onlyNotCanceled onlyNotBeneficiary { address _bidder = msg.sender; require(erc20Token.balanceOf(_bidder) >= amount, 'Insufficiant ERC20 token balance!'); // calculate the user's total bid based on the current amount they've sent to the contract // plus whatever has been sent with this transaction uint newBid = fundsByBidder[_bidder].add(amount); // reject payments of less than floor price require(newBid >= floorPrice, 'Bid Token amount too low!, amount should be above floor price'); // if the user isn't even willing to overbid the highest binding bid, there's nothing for us // to do except revert the transaction. if (newBid <= highestBindingBid) revert('overbid the highest binding bid!'); // grab the previous highest bid (before updating fundsByBidder, in case msg.sender is the // highestBidder and is just increasing their maximum bid). uint highestBid = fundsByBidder[highestBidder]; fundsByBidder[_bidder] = newBid; if (newBid <= highestBid) { // if the user has overbid the highestBindingBid but not the highestBid, we simply // increase the highestBindingBid and leave highestBidder alone. // note that this case is impossible if msg.sender == highestBidder because you can never // bid less ETH than you've already bid. highestBindingBid = min(newBid.add(etherToWei(1)), highestBid); } else { // if msg.sender is already the highest bidder, they must simply be wanting to raise // their maximum bid, in which case we shouldn't increase the highestBindingBid. // if the user is NOT highestBidder, and has overbid highestBid completely, we set them // as the new highestBidder and recalculate highestBindingBid. if (_bidder != highestBidder) { highestBidder = _bidder; highestBindingBid = min(newBid, highestBid.add(etherToWei(1))); } highestBid = newBid; } // ERC20 token transfer from bidder to current contract address bool sent = IVirtuousContractFactory(contractFactory).erc20TransferFrom(_bidder, address(this), amount); require(sent, "Fund transfer failed!"); _checkBidder(_bidder); emit LogBid(_bidder, amount, highestBidder, highestBid, highestBindingBid); } function _checkBidder(address bidder) internal virtual { bool alreadyBidder; for (uint256 i = 0; i < bidders.length; i++) { if(msg.sender == bidders[i]) {alreadyBidder = true; break;} } if(!alreadyBidder) bidders.push(bidder); } function min(uint a, uint b) private pure returns (uint) { if (a < b) return a; return b; } function withdraw() external nonReentrant onlyHasCanceled onlyNotBeneficiary onlyBidder { address withdrawalAccount; uint256 withdrawalAmount; withdrawalAccount = msg.sender; withdrawalAmount = fundsByBidder[withdrawalAccount]; require(withdrawalAmount > 0, 'You have already withdrawal your funds!'); fundsByBidder[withdrawalAccount] -= withdrawalAmount; //withdraw the ERC20 tokens paid for bid erc20Token.transfer(withdrawalAccount, withdrawalAmount); emit LogWithdrawal(withdrawalAccount, withdrawalAmount); } function getHighestBid() public view returns (uint256) { return fundsByBidder[highestBidder]; } function getMyBid() public view returns (uint256) { return fundsByBidder[msg.sender]; } function getAuctionStatus() public view returns (string memory ) { if( canceled ) return 'canceled'; if( block.timestamp > endTime ) return 'ended'; if( block.timestamp < startTime ) return 'not-started'; return 'running'; } function getMarketPlaceRoyaltyFeePercent() external onlyContractFactoryOwner view returns (uint256) { return marketplaceRoyaltyFeePercent; } function getSalesPersonRoyaltyFeePercent() external onlyContractFactoryOwner view returns (uint256) { return salesPersonRoyaltyFeePercent; } function tokenList() external override onlyContractFactoryOwner onlyCompleted view returns (uint256[] memory) {} function bidderList() external onlyContractFactoryOwner onlyAfterStart view returns (address[] memory) { return bidders; } function winnerList() public onlyContractFactoryOwner view returns (address[] memory) { address[] memory winners = _winnerList(); return winners; } function _winnerList() internal view returns (address[] memory) { require(bidders.length > 0, 'No bidder found, winner list can not be generate!'); uint256 maxWinners = bidders.length < getVirtuousTokensIssued() ? bidders.length : getVirtuousTokensIssued(); address[] memory winners = new address[](maxWinners); winners[0] = highestBidder; if( maxWinners == 1 ) return winners; return _winnersListPrepare(fundsByBidder[highestBidder], 1, winners, 1); } function _winnersListPrepare( uint256 _lastHighestBidPrice, uint256 _priceMargin, address[] memory _winners, uint256 _winnerIndex) internal view returns (address[] memory) { uint256 priceFilter = fundsByBidder[highestBidder].sub(etherToWei(_priceMargin)); for (uint256 j = 0; j < bidders.length; j++) { if( _winnerIndex == _winners.length ) break; address bidder = bidders[j]; if( fundsByBidder[bidder] >= priceFilter && fundsByBidder[bidder] < _lastHighestBidPrice ){ _winners[_winnerIndex] = bidder; _winnerIndex++; } } if( _winnerIndex == _winners.length ) return _winners; return _winnersListPrepare(priceFilter, _priceMargin.add(1), _winners, _winnerIndex); } function etherToWei(uint valueEther) internal pure returns (uint) { return valueEther*(10**18); } function redeemNFD(uint256 _tokenId) external override virtual onlyContractFactoryOwner onlyCompleted {} function cancelAuction() external nonReentrant onlyContractFactoryOwner onlyBeforeEnd onlyNotCanceled returns (bool success) { canceled = true; emit LogCanceled(true); return true; } function refund() external nonReentrant onlyNotBeneficiary onlyCompleted onlyBidder onlyNonWinner { uint256 withdrawalAmount = fundsByBidder[msg.sender]; require(withdrawalAmount > 0, 'You already have refund back!'); fundsByBidder[msg.sender] -= withdrawalAmount; //refund the ERC20 tokens to bidder, paid for bid but not become winner erc20Token.transfer(msg.sender, withdrawalAmount); emit LogRefund(msg.sender, withdrawalAmount); } function collectToken(uint _tokenId, address _virtuousToken) external override virtual nonReentrant onlyNotBeneficiary onlyCompleted onlyWinner onlyRewardNotCollected {} function contractFactoryOwner() internal view returns(address){ return IVirtuousContractFactory(contractFactory).getContractFactoryOwner(); } function collectFund() external nonReentrant onlyBeneficiaryOrOwner { address[] memory winners = _winnerList(); uint256 merchantFund; uint256 royalty; for( uint256 i = 0; i < winners.length; i++ ) { address winner = winners[i]; uint256 amount = fundsByBidder[winner]; uint256 marketplaceFee = amount.div(100).mul(marketplaceRoyaltyFeePercent); royalty = royalty.add(marketplaceFee); uint256 merchantFee = amount.sub(marketplaceFee); merchantFund = merchantFund.add(merchantFee); fundsByBidder[winner] -= amount; } address marketPlaceRoyaltyReceiver = IVirtuousContractFactory(contractFactory).getMarketPlaceRoyaltyReceiverWallet(); _collectFund(erc20Token, beneficiary, salesPerson, marketPlaceRoyaltyReceiver, merchantFund, royalty, salesPersonRoyaltyFeePercent); } receive() external payable { emit Received(msg.sender, msg.value); } fallback() external payable { emit Received(msg.sender, msg.value); } modifier onlyNotBeneficiary { if (msg.sender == beneficiary) revert('Beneficiary can not perform the action!'); _; } modifier onlyBeneficiaryOrOwner { require( msg.sender == beneficiary || msg.sender == contractFactoryOwner(), 'Beneficiary / Owner can only perform the action!'); _; } modifier onlyAfterStart { if (block.timestamp < startTime) revert('Auction yet not start!'); _; } modifier onlyBeforeEnd { if (block.timestamp > endTime) revert('Auction already ended!'); _; } modifier onlyNotCanceled { if (canceled) revert('Auction already canceled!'); _; } modifier onlyHasCanceled { if (!canceled) revert('Auction is not canceled!'); _; } modifier onlyCompleted { require(block.timestamp > endTime && !canceled, "Auction is not ended yet!"); _; } modifier onlyBidder { require(fundsByBidder[msg.sender] > 0, 'You are not a valid bidder!'); _; } modifier onlyContractFactoryOwner { require(contractFactoryOwner() == msg.sender, "You are not an owner"); _; } modifier onlyNonWinner { address[] memory winners = _winnerList(); for( uint256 i = 0; i < winners.length; i++ ) { if( msg.sender == winners[i] ) revert('You are winner, you can not perform this action!'); } _; } modifier onlyWinner { address[] memory winners = _winnerList(); bool winner; for( uint256 i = 0; i < winners.length; i++ ) { if( msg.sender == winners[i] ){ winner = true; break; } } require(winner, 'You are not a winner!'); _; } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[49] private __gap; }
/_openzeppelin/contracts-upgradeable/interfaces/draft-IERC1822Upgradeable.sol
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol) pragma solidity ^0.8.0; /** * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified * proxy whose upgrades are fully controlled by the current implementation. */ interface IERC1822ProxiableUpgradeable { /** * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation * address. * * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this * function revert if invoked through a proxy. */ function proxiableUUID() external view returns (bytes32); }
/_openzeppelin/contracts-upgradeable/proxy/ERC1967/ERC1967UpgradeUpgradeable.sol
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.5.0) (proxy/ERC1967/ERC1967Upgrade.sol) pragma solidity ^0.8.2; import "../beacon/IBeaconUpgradeable.sol"; import "../../interfaces/draft-IERC1822Upgradeable.sol"; import "../../utils/AddressUpgradeable.sol"; import "../../utils/StorageSlotUpgradeable.sol"; import "../utils/Initializable.sol"; /** * @dev This abstract contract provides getters and event emitting update functions for * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots. * * _Available since v4.1._ * * @custom:oz-upgrades-unsafe-allow delegatecall */ abstract contract ERC1967UpgradeUpgradeable is Initializable { function __ERC1967Upgrade_init() internal onlyInitializing { } function __ERC1967Upgrade_init_unchained() internal onlyInitializing { } // This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1 bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143; /** * @dev Storage slot with the address of the current implementation. * This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is * validated in the constructor. */ bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc; /** * @dev Emitted when the implementation is upgraded. */ event Upgraded(address indexed implementation); /** * @dev Returns the current implementation address. */ function _getImplementation() internal view returns (address) { return StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value; } /** * @dev Stores a new address in the EIP1967 implementation slot. */ function _setImplementation(address newImplementation) private { require(AddressUpgradeable.isContract(newImplementation), "ERC1967: new implementation is not a contract"); StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation; } /** * @dev Perform implementation upgrade * * Emits an {Upgraded} event. */ function _upgradeTo(address newImplementation) internal { _setImplementation(newImplementation); emit Upgraded(newImplementation); } /** * @dev Perform implementation upgrade with additional setup call. * * Emits an {Upgraded} event. */ function _upgradeToAndCall( address newImplementation, bytes memory data, bool forceCall ) internal { _upgradeTo(newImplementation); if (data.length > 0 || forceCall) { _functionDelegateCall(newImplementation, data); } } /** * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call. * * Emits an {Upgraded} event. */ function _upgradeToAndCallUUPS( address newImplementation, bytes memory data, bool forceCall ) internal { // Upgrades from old implementations will perform a rollback test. This test requires the new // implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing // this special case will break upgrade paths from old UUPS implementation to new ones. if (StorageSlotUpgradeable.getBooleanSlot(_ROLLBACK_SLOT).value) { _setImplementation(newImplementation); } else { try IERC1822ProxiableUpgradeable(newImplementation).proxiableUUID() returns (bytes32 slot) { require(slot == _IMPLEMENTATION_SLOT, "ERC1967Upgrade: unsupported proxiableUUID"); } catch { revert("ERC1967Upgrade: new implementation is not UUPS"); } _upgradeToAndCall(newImplementation, data, forceCall); } } /** * @dev Storage slot with the admin of the contract. * This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is * validated in the constructor. */ bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103; /** * @dev Emitted when the admin account has changed. */ event AdminChanged(address previousAdmin, address newAdmin); /** * @dev Returns the current admin. */ function _getAdmin() internal view returns (address) { return StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value; } /** * @dev Stores a new address in the EIP1967 admin slot. */ function _setAdmin(address newAdmin) private { require(newAdmin != address(0), "ERC1967: new admin is the zero address"); StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value = newAdmin; } /** * @dev Changes the admin of the proxy. * * Emits an {AdminChanged} event. */ function _changeAdmin(address newAdmin) internal { emit AdminChanged(_getAdmin(), newAdmin); _setAdmin(newAdmin); } /** * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy. * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor. */ bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50; /** * @dev Emitted when the beacon is upgraded. */ event BeaconUpgraded(address indexed beacon); /** * @dev Returns the current beacon. */ function _getBeacon() internal view returns (address) { return StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value; } /** * @dev Stores a new beacon in the EIP1967 beacon slot. */ function _setBeacon(address newBeacon) private { require(AddressUpgradeable.isContract(newBeacon), "ERC1967: new beacon is not a contract"); require( AddressUpgradeable.isContract(IBeaconUpgradeable(newBeacon).implementation()), "ERC1967: beacon implementation is not a contract" ); StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value = newBeacon; } /** * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that). * * Emits a {BeaconUpgraded} event. */ function _upgradeBeaconToAndCall( address newBeacon, bytes memory data, bool forceCall ) internal { _setBeacon(newBeacon); emit BeaconUpgraded(newBeacon); if (data.length > 0 || forceCall) { _functionDelegateCall(IBeaconUpgradeable(newBeacon).implementation(), data); } } /** * @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) private returns (bytes memory) { require(AddressUpgradeable.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 AddressUpgradeable.verifyCallResult(success, returndata, "Address: low-level delegate call failed"); } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[50] private __gap; }
/_openzeppelin/contracts-upgradeable/proxy/beacon/IBeaconUpgradeable.sol
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol) pragma solidity ^0.8.0; /** * @dev This is the interface that {BeaconProxy} expects of its beacon. */ interface IBeaconUpgradeable { /** * @dev Must return an address that can be used as a delegate call target. * * {BeaconProxy} will check that this address is a contract. */ function implementation() external view returns (address); }
/_openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.6.0) (proxy/utils/Initializable.sol) pragma solidity ^0.8.2; import "../../utils/AddressUpgradeable.sol"; /** * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect. * * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in * case an upgrade adds a module that needs to be initialized. * * For example: * * [.hljs-theme-light.nopadding] * ``` * contract MyToken is ERC20Upgradeable { * function initialize() initializer public { * __ERC20_init("MyToken", "MTK"); * } * } * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable { * function initializeV2() reinitializer(2) public { * __ERC20Permit_init("MyToken"); * } * } * ``` * * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}. * * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity. * * [CAUTION] * ==== * Avoid leaving a contract uninitialized. * * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed: * * [.hljs-theme-light.nopadding] * ``` * /// @custom:oz-upgrades-unsafe-allow constructor * constructor() { * _disableInitializers(); * } * ``` * ==== */ abstract contract Initializable { /** * @dev Indicates that the contract has been initialized. * @custom:oz-retyped-from bool */ uint8 private _initialized; /** * @dev Indicates that the contract is in the process of being initialized. */ bool private _initializing; /** * @dev Triggered when the contract has been initialized or reinitialized. */ event Initialized(uint8 version); /** * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope, * `onlyInitializing` functions can be used to initialize parent contracts. Equivalent to `reinitializer(1)`. */ modifier initializer() { bool isTopLevelCall = _setInitializedVersion(1); if (isTopLevelCall) { _initializing = true; } _; if (isTopLevelCall) { _initializing = false; emit Initialized(1); } } /** * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be * used to initialize parent contracts. * * `initializer` is equivalent to `reinitializer(1)`, so a reinitializer may be used after the original * initialization step. This is essential to configure modules that are added through upgrades and that require * initialization. * * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in * a contract, executing them in the right order is up to the developer or operator. */ modifier reinitializer(uint8 version) { bool isTopLevelCall = _setInitializedVersion(version); if (isTopLevelCall) { _initializing = true; } _; if (isTopLevelCall) { _initializing = false; emit Initialized(version); } } /** * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the * {initializer} and {reinitializer} modifiers, directly or indirectly. */ modifier onlyInitializing() { require(_initializing, "Initializable: contract is not initializing"); _; } /** * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call. * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized * to any version. It is recommended to use this to lock implementation contracts that are designed to be called * through proxies. */ function _disableInitializers() internal virtual { _setInitializedVersion(type(uint8).max); } function _setInitializedVersion(uint8 version) private returns (bool) { // If the contract is initializing we ignore whether _initialized is set in order to support multiple // inheritance patterns, but we only do this in the context of a constructor, and for the lowest level // of initializers, because in other contexts the contract may have been reentered. if (_initializing) { require( version == 1 && !AddressUpgradeable.isContract(address(this)), "Initializable: contract is already initialized" ); return false; } else { require(_initialized < version, "Initializable: contract is already initialized"); _initialized = version; return true; } } }
/_openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.5.0) (proxy/utils/UUPSUpgradeable.sol) pragma solidity ^0.8.0; import "../../interfaces/draft-IERC1822Upgradeable.sol"; import "../ERC1967/ERC1967UpgradeUpgradeable.sol"; import "./Initializable.sol"; /** * @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an * {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy. * * A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is * reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing * `UUPSUpgradeable` with a custom implementation of upgrades. * * The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism. * * _Available since v4.1._ */ abstract contract UUPSUpgradeable is Initializable, IERC1822ProxiableUpgradeable, ERC1967UpgradeUpgradeable { function __UUPSUpgradeable_init() internal onlyInitializing { } function __UUPSUpgradeable_init_unchained() internal onlyInitializing { } /// @custom:oz-upgrades-unsafe-allow state-variable-immutable state-variable-assignment address private immutable __self = address(this); /** * @dev Check that the execution is being performed through a delegatecall call and that the execution context is * a proxy contract with an implementation (as defined in ERC1967) pointing to self. This should only be the case * for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a * function through ERC1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to * fail. */ modifier onlyProxy() { require(address(this) != __self, "Function must be called through delegatecall"); require(_getImplementation() == __self, "Function must be called through active proxy"); _; } /** * @dev Check that the execution is not being performed through a delegate call. This allows a function to be * callable on the implementing contract but not through proxies. */ modifier notDelegated() { require(address(this) == __self, "UUPSUpgradeable: must not be called through delegatecall"); _; } /** * @dev Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the * implementation. It is used to validate that the this implementation remains valid after an upgrade. * * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this * function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier. */ function proxiableUUID() external view virtual override notDelegated returns (bytes32) { return _IMPLEMENTATION_SLOT; } /** * @dev Upgrade the implementation of the proxy to `newImplementation`. * * Calls {_authorizeUpgrade}. * * Emits an {Upgraded} event. */ function upgradeTo(address newImplementation) external virtual onlyProxy { _authorizeUpgrade(newImplementation); _upgradeToAndCallUUPS(newImplementation, new bytes(0), false); } /** * @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call * encoded in `data`. * * Calls {_authorizeUpgrade}. * * Emits an {Upgraded} event. */ function upgradeToAndCall(address newImplementation, bytes memory data) external payable virtual onlyProxy { _authorizeUpgrade(newImplementation); _upgradeToAndCallUUPS(newImplementation, data, true); } /** * @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by * {upgradeTo} and {upgradeToAndCall}. * * Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}. * * ```solidity * function _authorizeUpgrade(address) internal override onlyOwner {} * ``` */ function _authorizeUpgrade(address newImplementation) internal virtual; /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[50] private __gap; }
/_openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol) pragma solidity ^0.8.0; import "../proxy/utils/Initializable.sol"; /** * @dev Contract module that helps prevent reentrant calls to a function. * * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier * available, which can be applied to functions to make sure there are no nested * (reentrant) calls to them. * * Note that because there is a single `nonReentrant` guard, functions marked as * `nonReentrant` may not call one another. This can be worked around by making * those functions `private`, and then adding `external` `nonReentrant` entry * points to them. * * TIP: If you would like to learn more about reentrancy and alternative ways * to protect against it, check out our blog post * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul]. */ abstract contract ReentrancyGuardUpgradeable is Initializable { // Booleans are more expensive than uint256 or any type that takes up a full // word because each write operation emits an extra SLOAD to first read the // slot's contents, replace the bits taken up by the boolean, and then write // back. This is the compiler's defense against contract upgrades and // pointer aliasing, and it cannot be disabled. // The values being non-zero value makes deployment a bit more expensive, // but in exchange the refund on every call to nonReentrant will be lower in // amount. Since refunds are capped to a percentage of the total // transaction's gas, it is best to keep them low in cases like this one, to // increase the likelihood of the full refund coming into effect. uint256 private constant _NOT_ENTERED = 1; uint256 private constant _ENTERED = 2; uint256 private _status; function __ReentrancyGuard_init() internal onlyInitializing { __ReentrancyGuard_init_unchained(); } function __ReentrancyGuard_init_unchained() internal onlyInitializing { _status = _NOT_ENTERED; } /** * @dev Prevents a contract from calling itself, directly or indirectly. * Calling a `nonReentrant` function from another `nonReentrant` * function is not supported. It is possible to prevent this from happening * by making the `nonReentrant` function external, and making it call a * `private` function that does the actual work. */ modifier nonReentrant() { // On the first call to nonReentrant, _notEntered will be true require(_status != _ENTERED, "ReentrancyGuard: reentrant call"); // Any calls to nonReentrant after this point will fail _status = _ENTERED; _; // By storing the original value once again, a refund is triggered (see // https://eips.ethereum.org/EIPS/eip-2200) _status = _NOT_ENTERED; } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[49] private __gap; }
/_openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20Upgradeable { /** * @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); /** * @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 `to`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address to, 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 `from` to `to` 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 from, address to, uint256 amount ) external returns (bool); }
/_openzeppelin/contracts-upgradeable/token/ERC721/IERC721ReceiverUpgradeable.sol
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol) pragma solidity ^0.8.0; /** * @title ERC721 token receiver interface * @dev Interface for any contract that wants to support safeTransfers * from ERC721 asset contracts. */ interface IERC721ReceiverUpgradeable { /** * @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 `IERC721Receiver.onERC721Received.selector`. */ function onERC721Received( address operator, address from, uint256 tokenId, bytes calldata data ) external returns (bytes4); }
/_openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721.sol) pragma solidity ^0.8.0; import "../../utils/introspection/IERC165Upgradeable.sol"; /** * @dev Required interface of an ERC721 compliant contract. */ interface IERC721Upgradeable is IERC165Upgradeable { /** * @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`. * * 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; /** * @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 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 the account approved for `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function getApproved(uint256 tokenId) external view returns (address operator); /** * @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); }
/_openzeppelin/contracts-upgradeable/token/ERC721/utils/ERC721HolderUpgradeable.sol
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (token/ERC721/utils/ERC721Holder.sol) pragma solidity ^0.8.0; import "../IERC721ReceiverUpgradeable.sol"; import "../../../proxy/utils/Initializable.sol"; /** * @dev Implementation of the {IERC721Receiver} interface. * * Accepts all token transfers. * Make sure the contract is able to use its token with {IERC721-safeTransferFrom}, {IERC721-approve} or {IERC721-setApprovalForAll}. */ contract ERC721HolderUpgradeable is Initializable, IERC721ReceiverUpgradeable { function __ERC721Holder_init() internal onlyInitializing { } function __ERC721Holder_init_unchained() internal onlyInitializing { } /** * @dev See {IERC721Receiver-onERC721Received}. * * Always returns `IERC721Receiver.onERC721Received.selector`. */ function onERC721Received( address, address, uint256, bytes memory ) public virtual override returns (bytes4) { return this.onERC721Received.selector; } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[50] private __gap; }
/_openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.5.0) (utils/Address.sol) pragma solidity ^0.8.1; /** * @dev Collection of functions related to the address type */ library AddressUpgradeable { /** * @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 * ==== * * [IMPORTANT] * ==== * You shouldn't rely on `isContract` to protect against flash loan attacks! * * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract * constructor. * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize/address.code.length, which returns 0 // for contracts in construction, since the code is only stored at the end // of the constructor execution. return account.code.length > 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"); (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"); (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"); (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResult(success, returndata, errorMessage); } /** * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal 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 assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } }
/_openzeppelin/contracts-upgradeable/utils/StorageSlotUpgradeable.sol
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/StorageSlot.sol) pragma solidity ^0.8.0; /** * @dev Library for reading and writing primitive types to specific storage slots. * * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts. * This library helps with reading and writing to such slots without the need for inline assembly. * * The functions in this library return Slot structs that contain a `value` member that can be used to read or write. * * Example usage to set ERC1967 implementation slot: * ``` * contract ERC1967 { * bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc; * * function _getImplementation() internal view returns (address) { * return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value; * } * * function _setImplementation(address newImplementation) internal { * require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract"); * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation; * } * } * ``` * * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._ */ library StorageSlotUpgradeable { struct AddressSlot { address value; } struct BooleanSlot { bool value; } struct Bytes32Slot { bytes32 value; } struct Uint256Slot { uint256 value; } /** * @dev Returns an `AddressSlot` with member `value` located at `slot`. */ function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) { assembly { r.slot := slot } } /** * @dev Returns an `BooleanSlot` with member `value` located at `slot`. */ function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) { assembly { r.slot := slot } } /** * @dev Returns an `Bytes32Slot` with member `value` located at `slot`. */ function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) { assembly { r.slot := slot } } /** * @dev Returns an `Uint256Slot` with member `value` located at `slot`. */ function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) { assembly { r.slot := slot } } }
/_openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol) pragma solidity ^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 IERC165Upgradeable { /** * @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); }
/_openzeppelin/contracts-upgradeable/utils/math/SafeMathUpgradeable.sol
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.6.0) (utils/math/SafeMath.sol) pragma solidity ^0.8.0; // CAUTION // This version of SafeMath should only be used with Solidity 0.8 or later, // because it relies on the compiler's built in overflow checks. /** * @dev Wrappers over Solidity's arithmetic operations. * * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler * now has built in overflow checking. */ library SafeMathUpgradeable { /** * @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) { unchecked { uint256 c = a + b; if (c < a) return (false, 0); return (true, c); } } /** * @dev Returns the subtraction of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { 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) { unchecked { // 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) { unchecked { 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) { unchecked { 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) { return a + b; } /** * @dev Returns the subtraction of two unsigned integers, reverting on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { return 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) { return a * b; } /** * @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. * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { 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) { 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) { unchecked { 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. * * 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) { unchecked { 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) { unchecked { require(b > 0, errorMessage); return a % b; } } }
/project_/contracts/IVirtuousContractFactory.sol
// SPDX-License-Identifier: MIT pragma solidity ^0.8.4; interface IVirtuousContractFactory { function erc20TransferFrom(address sender, address recipient, uint256 amount) external returns (bool); function getMarketPlaceRoyaltyReceiverWallet() external view returns (address); function getContractFactoryOwner() external view returns (address); }
/project_/contracts/VirtuousTokenServices.sol
// SPDX-License-Identifier: MIT pragma solidity ^0.8.4; import "@openzeppelin/contracts-upgradeable/utils/math/SafeMathUpgradeable.sol"; import "@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol"; import "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol"; import "@openzeppelin/contracts-upgradeable/token/ERC721/utils/ERC721HolderUpgradeable.sol"; import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol"; abstract contract VirtuousTokenServices is Initializable, ERC721HolderUpgradeable { using SafeMathUpgradeable for uint256; bool private fundCollected; uint256 private redeemQty; uint256 private virtuousTokensIssued; uint256[] private allowedVirtuousTokens; mapping(uint256 => uint256) public redeemed; mapping(address => bool) public rewardCollected; event VirtuousTokenCollected(address winner, uint256 tokenId); event VirtuousTokenRedeemed(uint tokenId, uint256 redeemedTotal); event FundCollected(uint256 merchantFee, uint256 marketplaceRoyalty, uint256 salesPersonRoyalty); function __VirtuousTokenServices_init(uint256 _virtuousTokensIssued, uint256 _redeemQty) internal onlyInitializing { virtuousTokensIssued = _virtuousTokensIssued; redeemQty = _redeemQty; } function getVirtuousTokensIssued() internal view returns(uint256) { return virtuousTokensIssued; } function getVirtuousTokensAllowed() internal view returns(uint256[] memory) { return allowedVirtuousTokens; } function getTokenReddemCount(uint256 _tokenId) public view returns (uint256) { return redeemed[_tokenId]; } function tokenList() external virtual view returns (uint256[] memory) { return getVirtuousTokensAllowed(); } function onERC721Received( address, address, uint256 _tokenId, bytes memory ) public virtual override returns (bytes4) { require(getVirtuousTokensIssued() > getVirtuousTokensAllowed().length, 'Token allowance has reached the maximum!'); allowedVirtuousTokens.push(_tokenId); return this.onERC721Received.selector; } function redeemNFD(uint256 _tokenId) external virtual isTokenAllowed(_tokenId) { if(redeemQty > 0 && redeemQty > redeemed[_tokenId]) { revert("User have reached the maximum allowance!"); } redeemed[_tokenId] = redeemed[_tokenId].add(1); emit VirtuousTokenRedeemed( _tokenId, redeemed[_tokenId]); } function _collectToken(uint _tokenId, address _virtuousToken) internal virtual { IERC721Upgradeable virtuousToken = IERC721Upgradeable(_virtuousToken); require(virtuousToken.ownerOf(_tokenId) == address(this), "This contract is not owner of this NFD token!"); virtuousToken.safeTransferFrom(address(this), msg.sender, _tokenId); } function collectToken(uint _tokenId, address _virtuousToken) external virtual onlyRewardNotCollected { rewardCollected[msg.sender] = true; _collectToken(_tokenId, _virtuousToken); emit VirtuousTokenCollected(msg.sender, _tokenId); } function _collectFund(IERC20Upgradeable erc20Token, address beneficiary, address salesPerson, address marketPlaceRoyaltyReceiver, uint256 merchantFund, uint256 royalty, uint256 salesPersonRoyaltyFeePercent) internal virtual onlyNotCollected { uint256 marketplaceRoyalty; uint256 salesPersonRoyalty; fundCollected = true; //transfer to benefiaciary wallet erc20Token.transfer(beneficiary, merchantFund); if( salesPerson != address(0x0) ){ salesPersonRoyalty = royalty.div(100).mul(salesPersonRoyaltyFeePercent); marketplaceRoyalty = royalty.sub(salesPersonRoyalty); //Transfer sale royalty to sales person wallet address erc20Token.transfer(salesPerson, salesPersonRoyalty); }else{ marketplaceRoyalty = royalty; } //Transfer marketplace royalty to royalty receiver wallet address erc20Token.transfer(marketPlaceRoyaltyReceiver, marketplaceRoyalty); emit FundCollected(merchantFund, marketplaceRoyalty, salesPersonRoyalty); } modifier onlyRewardNotCollected { require(!rewardCollected[msg.sender], 'You have already collected your token!'); _; } modifier onlyNotCollected { require(!fundCollected, "Funds already collected!"); _; } modifier isTokenAllowed(uint256 _tokenId) { bool tokenAllowed; for( uint256 i = 0; i < getVirtuousTokensAllowed().length; i++ ) { if(allowedVirtuousTokens[i] == _tokenId) { tokenAllowed = true; break; } } require(tokenAllowed, 'This Token is not allowed for this NFD!'); _; } /** * @dev This empty reserved space is put in place to allow future versions to add new * variables without shifting down storage in the inheritance chain. * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps */ uint256[49] private __gap; }
Contract ABI
[{"type":"constructor","stateMutability":"nonpayable","inputs":[]},{"type":"event","name":"AdminChanged","inputs":[{"type":"address","name":"previousAdmin","internalType":"address","indexed":false},{"type":"address","name":"newAdmin","internalType":"address","indexed":false}],"anonymous":false},{"type":"event","name":"BeaconUpgraded","inputs":[{"type":"address","name":"beacon","internalType":"address","indexed":true}],"anonymous":false},{"type":"event","name":"FundCollected","inputs":[{"type":"uint256","name":"merchantFee","internalType":"uint256","indexed":false},{"type":"uint256","name":"marketplaceRoyalty","internalType":"uint256","indexed":false},{"type":"uint256","name":"salesPersonRoyalty","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"Initialized","inputs":[{"type":"uint8","name":"version","internalType":"uint8","indexed":false}],"anonymous":false},{"type":"event","name":"LogBid","inputs":[{"type":"address","name":"bidder","internalType":"address","indexed":false},{"type":"uint256","name":"bid","internalType":"uint256","indexed":false},{"type":"address","name":"highestBidder","internalType":"address","indexed":false},{"type":"uint256","name":"highestBid","internalType":"uint256","indexed":false},{"type":"uint256","name":"highestBindingBid","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"LogCanceled","inputs":[{"type":"bool","name":"success","internalType":"bool","indexed":false}],"anonymous":false},{"type":"event","name":"LogRefund","inputs":[{"type":"address","name":"sender","internalType":"address","indexed":false},{"type":"uint256","name":"amount","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"LogWithdrawal","inputs":[{"type":"address","name":"withdrawalAccount","internalType":"address","indexed":false},{"type":"uint256","name":"amount","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"Received","inputs":[{"type":"address","name":"sender","internalType":"address","indexed":false},{"type":"uint256","name":"amount","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"Upgraded","inputs":[{"type":"address","name":"implementation","internalType":"address","indexed":true}],"anonymous":false},{"type":"event","name":"VirtuousTokenCollected","inputs":[{"type":"address","name":"winner","internalType":"address","indexed":false},{"type":"uint256","name":"tokenId","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"VirtuousTokenRedeemed","inputs":[{"type":"uint256","name":"tokenId","internalType":"uint256","indexed":false},{"type":"uint256","name":"redeemedTotal","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"fallback","stateMutability":"payable"},{"type":"function","stateMutability":"view","outputs":[{"type":"address[]","name":"","internalType":"address[]"}],"name":"bidderList","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[{"type":"bool","name":"success","internalType":"bool"}],"name":"cancelAuction","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"canceled","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"collectFund","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"collectToken","inputs":[{"type":"uint256","name":"_tokenId","internalType":"uint256"},{"type":"address","name":"_virtuousToken","internalType":"address"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"endTime","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"ended","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"floorPrice","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"fundsByBidder","inputs":[{"type":"address","name":"","internalType":"address"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"string","name":"","internalType":"string"}],"name":"getAuctionStatus","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"getHighestBid","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"getMarketPlaceRoyaltyFeePercent","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"getMyBid","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"getSalesPersonRoyaltyFeePercent","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"getTokenReddemCount","inputs":[{"type":"uint256","name":"_tokenId","internalType":"uint256"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"address","name":"","internalType":"address"}],"name":"highestBidder","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"highestBindingBid","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"initialize","inputs":[{"type":"address","name":"_erc20Token","internalType":"contract IERC20Upgradeable"},{"type":"address","name":"_beneficiary","internalType":"address"},{"type":"uint256","name":"_floorPrice","internalType":"uint256"},{"type":"uint256","name":"_startTime","internalType":"uint256"},{"type":"uint256","name":"_endTime","internalType":"uint256"},{"type":"uint256","name":"_virtuousTokensIssued","internalType":"uint256"},{"type":"uint256","name":"_redeemQty","internalType":"uint256"},{"type":"address","name":"_salesPerson","internalType":"address"},{"type":"uint256","name":"_marketplaceRoyaltyFeePercent","internalType":"uint256"},{"type":"uint256","name":"_salesPersonRoyaltyFeePercent","internalType":"uint256"}]},{"type":"function","stateMutability":"nonpayable","outputs":[{"type":"bytes4","name":"","internalType":"bytes4"}],"name":"onERC721Received","inputs":[{"type":"address","name":"","internalType":"address"},{"type":"address","name":"","internalType":"address"},{"type":"uint256","name":"_tokenId","internalType":"uint256"},{"type":"bytes","name":"","internalType":"bytes"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"placeBid","inputs":[{"type":"uint256","name":"amount","internalType":"uint256"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"bytes32","name":"","internalType":"bytes32"}],"name":"proxiableUUID","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"redeemNFD","inputs":[{"type":"uint256","name":"_tokenId","internalType":"uint256"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"redeemed","inputs":[{"type":"uint256","name":"","internalType":"uint256"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"refund","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"rewardCollected","inputs":[{"type":"address","name":"","internalType":"address"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"startTime","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256[]","name":"","internalType":"uint256[]"}],"name":"tokenList","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"upgradeTo","inputs":[{"type":"address","name":"newImplementation","internalType":"address"}]},{"type":"function","stateMutability":"payable","outputs":[],"name":"upgradeToAndCall","inputs":[{"type":"address","name":"newImplementation","internalType":"address"},{"type":"bytes","name":"data","internalType":"bytes"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"address[]","name":"","internalType":"address[]"}],"name":"winnerList","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"withdraw","inputs":[]},{"type":"receive","stateMutability":"payable"}]
Contract Creation Code
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
Deployed ByteCode
0x6080604052600436106101dc5760003560e01c8063590e1ae31161010257806391f90157116100955780639e2c58ca116100645780639e2c58ca146105b6578063ce10cf80146105d8578063f28c404014610606578063f5b56c56146106335761021c565b806391f90157146105265780639363c8121461055f5780639912a835146105765780639979ef45146105965761021c565b80637b0e0820116100d15780637b0e0820146104915780637ed0f1c1146104c157806384ddc67f146104ee5780638fa8b790146105115761021c565b8063590e1ae31461043057806369de834714610445578063704416b41461046557806378e979251461047a5761021c565b80633197cbb61161017a5780633f9942ff116101495780633f9942ff146103be5780634979440a146103d95780634f1ef2861461040857806352d1902d1461041b5761021c565b80633197cbb61461035d5780633659cfe6146103745780633711ef04146103945780633ccfd60b146103a95761021c565b8063150b7a02116101b6578063150b7a02146102cb57806315d6af8f1461030457806324d507fd146103265780632e93be301461033b5761021c565b8063026670c5146102515780631257e2791461027957806312fa6feb1461029b5761021c565b3661021c57604080513381523460208201527f88a5966d370b9919b20f3e2c13ff65706f196a4e32cc2c12bf57088f8852587491015b60405180910390a1005b604080513381523460208201527f88a5966d370b9919b20f3e2c13ff65706f196a4e32cc2c12bf57088f885258749101610212565b34801561025d57600080fd5b5061026661064a565b6040519081526020015b60405180910390f35b34801561028557600080fd5b50610299610294366004612d29565b61068d565b005b3480156102a757600080fd5b50610109546102bb90610100900460ff1681565b6040519015158152602001610270565b3480156102d757600080fd5b506102eb6102e6366004612b91565b610848565b6040516001600160e01b03199091168152602001610270565b34801561031057600080fd5b506103196108fb565b6040516102709190612d74565b34801561033257600080fd5b5061029961093c565b34801561034757600080fd5b50610350610ba3565b6040516102709190612df9565b34801561036957600080fd5b506102666101045481565b34801561038057600080fd5b5061029961038f366004612b59565b610c53565b3480156103a057600080fd5b50610266610d33565b3480156103b557600080fd5b50610299610d6c565b3480156103ca57600080fd5b50610109546102bb9060ff1681565b3480156103e557600080fd5b5061010b546001600160a01b0316600090815261010d6020526040902054610266565b610299610416366004612bfb565b610fe0565b34801561042757600080fd5b506102666110b1565b34801561043c57600080fd5b50610299611164565b34801561045157600080fd5b50610299610460366004612d11565b611453565b34801561047157600080fd5b506103196114b4565b34801561048657600080fd5b506102666101035481565b34801561049d57600080fd5b506102bb6104ac366004612b59565b60386020526000908152604090205460ff1681565b3480156104cd57600080fd5b506102666104dc366004612d11565b60376020526000908152604090205481565b3480156104fa57600080fd5b5033600090815261010d6020526040902054610266565b34801561051d57600080fd5b506102bb611592565b34801561053257600080fd5b5061010b54610547906001600160a01b031681565b6040516001600160a01b039091168152602001610270565b34801561056b57600080fd5b506102666101025481565b34801561058257600080fd5b50610299610591366004612c81565b6116d5565b3480156105a257600080fd5b506102996105b1366004612d11565b611905565b3480156105c257600080fd5b506105cb611dfc565b6040516102709190612dc1565b3480156105e457600080fd5b506102666105f3366004612b59565b61010d6020526000908152604090205481565b34801561061257600080fd5b50610266610621366004612d11565b60009081526037602052604090205490565b34801561063f57600080fd5b5061026661010a5481565b600033610655611e6e565b6001600160a01b0316146106845760405162461bcd60e51b815260040161067b90612f90565b60405180910390fd5b50610107545b90565b6002606a5414156106b05760405162461bcd60e51b815260040161067b90613009565b6002606a55610105546001600160a01b03163314156106e15760405162461bcd60e51b815260040161067b90612f49565b61010454421180156106f757506101095460ff16155b6107135760405162461bcd60e51b815260040161067b90612ec4565b600061071d611ef1565b90506000805b82518110156107885782818151811061074c57634e487b7160e01b600052603260045260246000fd5b60200260200101516001600160a01b0316336001600160a01b031614156107765760019150610788565b80610780816130da565b915050610723565b50806107ce5760405162461bcd60e51b8152602060048201526015602482015274596f7520617265206e6f7420612077696e6e65722160581b604482015260640161067b565b3360009081526038602052604090205460ff161561083d5760405162461bcd60e51b815260206004820152602660248201527f596f75206861766520616c726561647920636f6c6c656374656420796f757220604482015265746f6b656e2160d01b606482015260840161067b565b50506001606a555050565b6000610852612066565b51603554116108b45760405162461bcd60e51b815260206004820152602860248201527f546f6b656e20616c6c6f77616e636520686173207265616368656420746865206044820152676d6178696d756d2160c01b606482015260840161067b565b50603680546001810182556000919091527f4a11f94e20a93c79f6ec743a1954ec4fc2c08429ae2122118bf234b2185c81b801829055630a85bd0160e11b5b949350505050565b606033610906611e6e565b6001600160a01b03161461092c5760405162461bcd60e51b815260040161067b90612f90565b6000610936611ef1565b91505090565b6002606a54141561095f5760405162461bcd60e51b815260040161067b90613009565b6002606a55610105546001600160a01b03163314806109965750610981611e6e565b6001600160a01b0316336001600160a01b0316145b6109fb5760405162461bcd60e51b815260206004820152603060248201527f42656e6566696369617279202f204f776e65722063616e206f6e6c792070657260448201526f666f726d2074686520616374696f6e2160801b606482015260840161067b565b6000610a05611ef1565b905060008060005b8351811015610aee576000848281518110610a3857634e487b7160e01b600052603260045260246000fd5b6020908102919091018101516001600160a01b038116600090815261010d9092526040822054610107549193509190610a7c90610a768460646120bd565b906120d2565b9050610a8885826120de565b94506000610a9683836120ea565b9050610aa287826120de565b6001600160a01b038516600090815261010d6020526040812080549299508592909190610ad0908490613097565b92505081905550505050508080610ae6906130da565b915050610a0d565b5061010154604080516340f06db760e01b815290516000926001600160a01b0316916340f06db7916004808301926020929190829003018186803b158015610b3557600080fd5b505afa158015610b49573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610b6d9190612b75565b6101005461010554610106546101085493945061083d936001600160a01b039384169392831692909116908590889088906120f6565b6101095460609060ff1615610bd5575060408051808201909152600881526718d85b98d95b195960c21b602082015290565b61010454421115610c005750604080518082019091526005815264195b99195960da1b602082015290565b61010354421015610c31575060408051808201909152600b81526a1b9bdd0b5cdd185c9d195960aa1b602082015290565b5060408051808201909152600781526672756e6e696e6760c81b602082015290565b306001600160a01b037f000000000000000000000000a7cbd7ce363f4e3418b574f3e11d472239eba079161415610c9c5760405162461bcd60e51b815260040161067b90612e2c565b7f000000000000000000000000a7cbd7ce363f4e3418b574f3e11d472239eba0796001600160a01b0316610ce5600080516020613137833981519152546001600160a01b031690565b6001600160a01b031614610d0b5760405162461bcd60e51b815260040161067b90612e78565b610d1481612367565b60408051600080825260208201909252610d3091839190612396565b50565b600033610d3e611e6e565b6001600160a01b031614610d645760405162461bcd60e51b815260040161067b90612f90565b506101085490565b6002606a541415610d8f5760405162461bcd60e51b815260040161067b90613009565b6002606a556101095460ff16610de75760405162461bcd60e51b815260206004820152601860248201527f41756374696f6e206973206e6f742063616e63656c6564210000000000000000604482015260640161067b565b610105546001600160a01b0316331415610e135760405162461bcd60e51b815260040161067b90612f49565b33600090815261010d6020526040902054610e705760405162461bcd60e51b815260206004820152601b60248201527f596f7520617265206e6f7420612076616c696420626964646572210000000000604482015260640161067b565b33600081815261010d602052604090205480610ede5760405162461bcd60e51b815260206004820152602760248201527f596f75206861766520616c7265616479207769746864726177616c20796f75726044820152662066756e64732160c81b606482015260840161067b565b6001600160a01b038216600090815261010d602052604081208054839290610f07908490613097565b90915550506101005460405163a9059cbb60e01b81526001600160a01b038481166004830152602482018490529091169063a9059cbb90604401602060405180830381600087803b158015610f5b57600080fd5b505af1158015610f6f573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610f939190612c49565b50604080516001600160a01b0384168152602081018390527fb4214c8c54fc7442f36d3682f59aebaf09358a4431835b30efb29d52cf9e1e9191015b60405180910390a150506001606a55565b306001600160a01b037f000000000000000000000000a7cbd7ce363f4e3418b574f3e11d472239eba0791614156110295760405162461bcd60e51b815260040161067b90612e2c565b7f000000000000000000000000a7cbd7ce363f4e3418b574f3e11d472239eba0796001600160a01b0316611072600080516020613137833981519152546001600160a01b031690565b6001600160a01b0316146110985760405162461bcd60e51b815260040161067b90612e78565b6110a182612367565b6110ad82826001612396565b5050565b6000306001600160a01b037f000000000000000000000000a7cbd7ce363f4e3418b574f3e11d472239eba07916146111515760405162461bcd60e51b815260206004820152603860248201527f555550535570677261646561626c653a206d757374206e6f742062652063616c60448201527f6c6564207468726f7567682064656c656761746563616c6c0000000000000000606482015260840161067b565b5060008051602061313783398151915290565b6002606a5414156111875760405162461bcd60e51b815260040161067b90613009565b6002606a55610105546001600160a01b03163314156111b85760405162461bcd60e51b815260040161067b90612f49565b61010454421180156111ce57506101095460ff16155b6111ea5760405162461bcd60e51b815260040161067b90612ec4565b33600090815261010d60205260409020546112475760405162461bcd60e51b815260206004820152601b60248201527f596f7520617265206e6f7420612076616c696420626964646572210000000000604482015260640161067b565b6000611251611ef1565b905060005b81518110156113135781818151811061127f57634e487b7160e01b600052603260045260246000fd5b60200260200101516001600160a01b0316336001600160a01b031614156113015760405162461bcd60e51b815260206004820152603060248201527f596f75206172652077696e6e65722c20796f752063616e206e6f74207065726660448201526f6f726d207468697320616374696f6e2160801b606482015260840161067b565b8061130b816130da565b915050611256565b5033600090815261010d6020526040902054806113725760405162461bcd60e51b815260206004820152601d60248201527f596f7520616c7265616479206861766520726566756e64206261636b21000000604482015260640161067b565b33600090815261010d602052604081208054839290611392908490613097565b90915550506101005460405163a9059cbb60e01b8152336004820152602481018390526001600160a01b039091169063a9059cbb90604401602060405180830381600087803b1580156113e457600080fd5b505af11580156113f8573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061141c9190612c49565b5060408051338152602081018390527fb6c0eca8138e097d71e2dd31e19a1266487f0553f170b7260ffe68bcbe9ff8a79101610fcf565b3361145c611e6e565b6001600160a01b0316146114825760405162461bcd60e51b815260040161067b90612f90565b610104544211801561149857506101095460ff16155b610d305760405162461bcd60e51b815260040161067b90612ec4565b6060336114bf611e6e565b6001600160a01b0316146114e55760405162461bcd60e51b815260040161067b90612f90565b610103544210156115315760405162461bcd60e51b815260206004820152601660248201527541756374696f6e20796574206e6f742073746172742160501b604482015260640161067b565b61010c80548060200260200160405190810160405280929190818152602001828054801561158857602002820191906000526020600020905b81546001600160a01b0316815260019091019060200180831161156a575b5050505050905090565b60006002606a5414156115b75760405162461bcd60e51b815260040161067b90613009565b6002606a55336115c5611e6e565b6001600160a01b0316146115eb5760405162461bcd60e51b815260040161067b90612f90565b610104544211156116375760405162461bcd60e51b815260206004820152601660248201527541756374696f6e20616c726561647920656e6465642160501b604482015260640161067b565b6101095460ff16156116875760405162461bcd60e51b815260206004820152601960248201527841756374696f6e20616c72656164792063616e63656c65642160381b604482015260640161067b565b610109805460ff191660019081179091556040519081527f1fd636bc86322e474244a9366e9b72f9e75d3ba45b442352c7f950c92a9808a59060200160405180910390a150600180606a5590565b60006116e16001612515565b905080156116f9576000805461ff0019166101001790555b61170161259d565b6117096125ce565b61171386866125f5565b42881161176e5760405162461bcd60e51b815260206004820152602360248201527f41756374696f6e2073746172742074696d657374616d7020697320696e76616c60448201526269642160e81b606482015260840161067b565b428711801561177c57508787115b6117e65760405162461bcd60e51b815260206004820152603560248201527f41756374696f6e20656e642074696d657374616d702063616e206e6f74206265604482015274207468652070617374206f7220696e76616c69642160581b606482015260840161067b565b6001600160a01b038a166118485760405162461bcd60e51b815260206004820152602360248201527f42656e65666963696172792061646472657373206973206e6f7420636f72726560448201526263742160e81b606482015260840161067b565b61010080546001600160a01b03808e166001600160a01b03199283161790925561010580548d84169083161790556101068054928716928216929092179091556101028a905561010389905561010488905561010784905561010883905561010180549091163317905580156118f8576000805461ff0019169055604051600181527f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb38474024989060200160405180910390a15b5050505050505050505050565b6002606a5414156119285760405162461bcd60e51b815260040161067b90613009565b6002606a55610103544210156119795760405162461bcd60e51b815260206004820152601660248201527541756374696f6e20796574206e6f742073746172742160501b604482015260640161067b565b610104544211156119c55760405162461bcd60e51b815260206004820152601660248201527541756374696f6e20616c726561647920656e6465642160501b604482015260640161067b565b6101095460ff1615611a155760405162461bcd60e51b815260206004820152601960248201527841756374696f6e20616c72656164792063616e63656c65642160381b604482015260640161067b565b610105546001600160a01b0316331415611a415760405162461bcd60e51b815260040161067b90612f49565b610100546040516370a0823160e01b815233600482018190529183916001600160a01b03909116906370a082319060240160206040518083038186803b158015611a8a57600080fd5b505afa158015611a9e573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611ac29190612c69565b1015611b1a5760405162461bcd60e51b815260206004820152602160248201527f496e73756666696369616e7420455243323020746f6b656e2062616c616e63656044820152602160f81b606482015260840161067b565b6001600160a01b038116600090815261010d6020526040812054611b3e90846120de565b905061010254811015611bb95760405162461bcd60e51b815260206004820152603d60248201527f42696420546f6b656e20616d6f756e7420746f6f206c6f77212c20616d6f756e60448201527f742073686f756c642062652061626f766520666c6f6f72207072696365000000606482015260840161067b565b61010a548111611c0b5760405162461bcd60e51b815260206004820181905260248201527f6f7665726269642074686520686967686573742062696e64696e672062696421604482015260640161067b565b61010b546001600160a01b03908116600090815261010d60205260408082205492851682529020829055808211611c6257611c59611c53611c4c6001612627565b84906120de565b8261263b565b61010a55611cb2565b61010b546001600160a01b03848116911614611caf5761010b80546001600160a01b0319166001600160a01b038516179055611caa82611ca5611c4c6001612627565b61263b565b61010a555b50805b6101015460405163d96ca0b960e01b81526001600160a01b03858116600483015230602483015260448201879052600092169063d96ca0b990606401602060405180830381600087803b158015611d0857600080fd5b505af1158015611d1c573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611d409190612c49565b905080611d875760405162461bcd60e51b815260206004820152601560248201527446756e64207472616e73666572206661696c65642160581b604482015260640161067b565b611d9084612652565b61010b5461010a54604080516001600160a01b038089168252602082018a9052909316908301526060820184905260808201527ff152f4ff5e488c55370a2d53925a55055228ebd8ec95bd0251bbb299e48786b09060a00160405180910390a150506001606a55505050565b606033611e07611e6e565b6001600160a01b031614611e2d5760405162461bcd60e51b815260040161067b90612f90565b6101045442118015611e4357506101095460ff16155b61068a5760405162461bcd60e51b815260040161067b90612ec4565b6001600160a01b03163b151590565b610101546040805163544e486d60e11b815290516000926001600160a01b03169163a89c90da916004808301926020929190829003018186803b158015611eb457600080fd5b505afa158015611ec8573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611eec9190612b75565b905090565b61010c54606090611f5e5760405162461bcd60e51b815260206004820152603160248201527f4e6f2062696464657220666f756e642c2077696e6e6572206c6973742063616e604482015270206e6f742062652067656e65726174652160781b606482015260840161067b565b6000611f6960355490565b61010c5410611f7a57603554611f7f565b61010c545b905060008167ffffffffffffffff811115611faa57634e487b7160e01b600052604160045260246000fd5b604051908082528060200260200182016040528015611fd3578160200160208202803683370190505b5061010b5481519192506001600160a01b031690829060009061200657634e487b7160e01b600052603260045260246000fd5b60200260200101906001600160a01b031690816001600160a01b03168152505081600114156120355792915050565b61010b546001600160a01b0316600090815261010d602052604090205461205f9060018381612712565b9250505090565b6060603680548060200260200160405190810160405280929190818152602001828054801561158857602002820191906000526020600020905b8154815260200190600101908083116120a0575050505050905090565b60006120c98284613058565b90505b92915050565b60006120c98284613078565b60006120c98284613040565b60006120c98284613097565b60335460ff16156121495760405162461bcd60e51b815260206004820152601860248201527f46756e647320616c726561647920636f6c6c6563746564210000000000000000604482015260640161067b565b6033805460ff1916600117905560405163a9059cbb60e01b81526001600160a01b0387811660048301526024820185905260009182918a169063a9059cbb90604401602060405180830381600087803b1580156121a557600080fd5b505af11580156121b9573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906121dd9190612c49565b506001600160a01b03871615612294576121fc83610a768660646120bd565b905061220884826120ea565b60405163a9059cbb60e01b81526001600160a01b03898116600483015260248201849052919350908a169063a9059cbb90604401602060405180830381600087803b15801561225657600080fd5b505af115801561226a573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061228e9190612c49565b50612298565b8391505b60405163a9059cbb60e01b81526001600160a01b038781166004830152602482018490528a169063a9059cbb90604401602060405180830381600087803b1580156122e257600080fd5b505af11580156122f6573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061231a9190612c49565b5060408051868152602081018490529081018290527f6ea5c59900d2287e197ce26928208769c75c08f14c9d14b894eb8afde1185ee69060600160405180910390a1505050505050505050565b33612370611e6e565b6001600160a01b031614610d305760405162461bcd60e51b815260040161067b90612f90565b7f4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd91435460ff16156123ce576123c983612869565b505050565b826001600160a01b03166352d1902d6040518163ffffffff1660e01b815260040160206040518083038186803b15801561240757600080fd5b505afa925050508015612437575060408051601f3d908101601f1916820190925261243491810190612c69565b60015b61249a5760405162461bcd60e51b815260206004820152602e60248201527f45524331393637557067726164653a206e657720696d706c656d656e7461746960448201526d6f6e206973206e6f74205555505360901b606482015260840161067b565b60008051602061313783398151915281146125095760405162461bcd60e51b815260206004820152602960248201527f45524331393637557067726164653a20756e737570706f727465642070726f786044820152681a58589b195555525160ba1b606482015260840161067b565b506123c9838383612905565b60008054610100900460ff161561255c578160ff1660011480156125385750303b155b6125545760405162461bcd60e51b815260040161067b90612efb565b506000919050565b60005460ff8084169116106125835760405162461bcd60e51b815260040161067b90612efb565b506000805460ff191660ff92909216919091179055600190565b600054610100900460ff166125c45760405162461bcd60e51b815260040161067b90612fbe565b6125cc612930565b565b600054610100900460ff166125cc5760405162461bcd60e51b815260040161067b90612fbe565b600054610100900460ff1661261c5760405162461bcd60e51b815260040161067b90612fbe565b603591909155603455565b60006120cc82670de0b6b3a7640000613078565b60008183101561264c5750816120cc565b50919050565b6000805b61010c548110156126ba5761010c818154811061268357634e487b7160e01b600052603260045260246000fd5b6000918252602090912001546001600160a01b03163314156126a857600191506126ba565b806126b2816130da565b915050612656565b50806110ad5761010c80546001810182556000919091527f7bb4d7b0eaf94112c5cb7345d79f45887f7ebc12d67faa4efd6cf1d7c430cd340180546001600160a01b0384166001600160a01b03199091161790555050565b6060600061274561272286612627565b61010b546001600160a01b0316600090815261010d6020526040902054906120ea565b905060005b61010c5481101561283657845184141561276357612836565b600061010c828154811061278757634e487b7160e01b600052603260045260246000fd5b60009182526020808320909101546001600160a01b031680835261010d90915260409091205490915083118015906127d757506001600160a01b038116600090815261010d602052604090205488115b1561282357808686815181106127fd57634e487b7160e01b600052603260045260246000fd5b6001600160a01b03909216602092830291909101909101528461281f816130da565b9550505b508061282e816130da565b91505061274a565b50835183141561284957839150506108f3565b61285f816128588760016120de565b8686612712565b9695505050505050565b6001600160a01b0381163b6128d65760405162461bcd60e51b815260206004820152602d60248201527f455243313936373a206e657720696d706c656d656e746174696f6e206973206e60448201526c1bdd08184818dbdb9d1c9858dd609a1b606482015260840161067b565b60008051602061313783398151915280546001600160a01b0319166001600160a01b0392909216919091179055565b61290e8361295e565b60008251118061291b5750805b156123c95761292a838361299e565b50505050565b600054610100900460ff166129575760405162461bcd60e51b815260040161067b90612fbe565b6001606a55565b61296781612869565b6040516001600160a01b038216907fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b90600090a250565b60606001600160a01b0383163b612a065760405162461bcd60e51b815260206004820152602660248201527f416464726573733a2064656c65676174652063616c6c20746f206e6f6e2d636f6044820152651b9d1c9858dd60d21b606482015260840161067b565b600080846001600160a01b031684604051612a219190612d58565b600060405180830381855af49150503d8060008114612a5c576040519150601f19603f3d011682016040523d82523d6000602084013e612a61565b606091505b5091509150612a89828260405180606001604052806027815260200161315760279139612a92565b95945050505050565b60608315612aa1575081612acb565b825115612ab15782518084602001fd5b8160405162461bcd60e51b815260040161067b9190612df9565b9392505050565b600082601f830112612ae2578081fd5b813567ffffffffffffffff80821115612afd57612afd61310b565b604051601f8301601f19908116603f01168101908282118183101715612b2557612b2561310b565b81604052838152866020858801011115612b3d578485fd5b8360208701602083013792830160200193909352509392505050565b600060208284031215612b6a578081fd5b8135612acb81613121565b600060208284031215612b86578081fd5b8151612acb81613121565b60008060008060808587031215612ba6578283fd5b8435612bb181613121565b93506020850135612bc181613121565b925060408501359150606085013567ffffffffffffffff811115612be3578182fd5b612bef87828801612ad2565b91505092959194509250565b60008060408385031215612c0d578182fd5b8235612c1881613121565b9150602083013567ffffffffffffffff811115612c33578182fd5b612c3f85828601612ad2565b9150509250929050565b600060208284031215612c5a578081fd5b81518015158114612acb578182fd5b600060208284031215612c7a578081fd5b5051919050565b6000806000806000806000806000806101408b8d031215612ca0578586fd5b8a35612cab81613121565b995060208b0135612cbb81613121565b985060408b0135975060608b0135965060808b0135955060a08b0135945060c08b0135935060e08b0135612cee81613121565b809350506101008b013591506101208b013590509295989b9194979a5092959850565b600060208284031215612d22578081fd5b5035919050565b60008060408385031215612d3b578182fd5b823591506020830135612d4d81613121565b809150509250929050565b60008251612d6a8184602087016130ae565b9190910192915050565b6020808252825182820181905260009190848201906040850190845b81811015612db55783516001600160a01b031683529284019291840191600101612d90565b50909695505050505050565b6020808252825182820181905260009190848201906040850190845b81811015612db557835183529284019291840191600101612ddd565b6020815260008251806020840152612e188160408501602087016130ae565b601f01601f19169190910160400192915050565b6020808252602c908201527f46756e6374696f6e206d7573742062652063616c6c6564207468726f7567682060408201526b19195b1959d85d1958d85b1b60a21b606082015260800190565b6020808252602c908201527f46756e6374696f6e206d7573742062652063616c6c6564207468726f7567682060408201526b6163746976652070726f787960a01b606082015260800190565b60208082526019908201527f41756374696f6e206973206e6f7420656e646564207965742100000000000000604082015260600190565b6020808252602e908201527f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160408201526d191e481a5b9a5d1a585b1a5e995960921b606082015260800190565b60208082526027908201527f42656e65666963696172792063616e206e6f7420706572666f726d2074686520604082015266616374696f6e2160c81b606082015260800190565b6020808252601490820152732cb7ba9030b932903737ba1030b71037bbb732b960611b604082015260600190565b6020808252602b908201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960408201526a6e697469616c697a696e6760a81b606082015260800190565b6020808252601f908201527f5265656e7472616e637947756172643a207265656e7472616e742063616c6c00604082015260600190565b60008219821115613053576130536130f5565b500190565b60008261307357634e487b7160e01b81526012600452602481fd5b500490565b6000816000190483118215151615613092576130926130f5565b500290565b6000828210156130a9576130a96130f5565b500390565b60005b838110156130c95781810151838201526020016130b1565b8381111561292a5750506000910152565b60006000198214156130ee576130ee6130f5565b5060010190565b634e487b7160e01b600052601160045260246000fd5b634e487b7160e01b600052604160045260246000fd5b6001600160a01b0381168114610d3057600080fdfe360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc416464726573733a206c6f772d6c6576656c2064656c65676174652063616c6c206661696c6564a26469706673582212204448b841bd78b1b12022c94912d62ab6eac0b152317bf7d31432d4349fa478b564736f6c63430008040033