Created
March 20, 2021 19:24
-
-
Save Phineas/ec80121aa2808519025046bbdabf65bd to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/** | |
* @title Waifus contract | |
* @dev Extends ERC721 Non-Fungible Token Standard basic implementation | |
*/ | |
contract Waifus is Context, Ownable, ERC165, IWaifus, IERC721Metadata { | |
using SafeMath for uint256; | |
using Address for address; | |
using EnumerableSet for EnumerableSet.UintSet; | |
using EnumerableMap for EnumerableMap.UintToAddressMap; | |
using Strings for uint256; | |
// Public variables | |
// This is the provenance record of all Waifus artwork in existence | |
string public constant WAIFUS_PROVENANCE = "b9e2ad47185076f3f43847eeec601e7bc4a1cb51a208b34b5eb1c650cf06a546"; | |
uint256 public constant SALE_START_TIMESTAMP = 1614624600; | |
// Time after which waifus are randomized and allotted | |
uint256 public constant REVEAL_TIMESTAMP = SALE_START_TIMESTAMP + (86400 * 14); | |
uint256 public constant NAME_CHANGE_PRICE = 1830 * (10 ** 18); | |
uint256 public constant MAX_NFT_SUPPLY = 16384; | |
uint256 public startingIndexBlock; | |
uint256 public startingIndex; | |
// Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))` | |
// which can be also obtained as `IERC721Receiver(0).onERC721Received.selector` | |
bytes4 private constant _ERC721_RECEIVED = 0x150b7a02; | |
// Mapping from holder address to their (enumerable) set of owned tokens | |
mapping (address => EnumerableSet.UintSet) private _holderTokens; | |
// Enumerable mapping from token ids to their owners | |
EnumerableMap.UintToAddressMap private _tokenOwners; | |
// Mapping from token ID to approved address | |
mapping (uint256 => address) private _tokenApprovals; | |
// Mapping from token ID to name | |
mapping (uint256 => string) private _tokenName; | |
// Mapping if certain name string has already been reserved | |
mapping (string => bool) private _nameReserved; | |
// Mapping from token ID to whether the Waifus was minted before reveal | |
mapping (uint256 => bool) private _mintedBeforeReveal; | |
// Mapping from owner to operator approvals | |
mapping (address => mapping (address => bool)) private _operatorApprovals; | |
// Token name | |
string private _name; | |
// Token symbol | |
string private _symbol; | |
// Waifu Enhancement Token address | |
address private _wetAddress; | |
/* | |
* bytes4(keccak256('balanceOf(address)')) == 0x70a08231 | |
* bytes4(keccak256('ownerOf(uint256)')) == 0x6352211e | |
* bytes4(keccak256('approve(address,uint256)')) == 0x095ea7b3 | |
* bytes4(keccak256('getApproved(uint256)')) == 0x081812fc | |
* bytes4(keccak256('setApprovalForAll(address,bool)')) == 0xa22cb465 | |
* bytes4(keccak256('isApprovedForAll(address,address)')) == 0xe985e9c5 | |
* bytes4(keccak256('transferFrom(address,address,uint256)')) == 0x23b872dd | |
* bytes4(keccak256('safeTransferFrom(address,address,uint256)')) == 0x42842e0e | |
* bytes4(keccak256('safeTransferFrom(address,address,uint256,bytes)')) == 0xb88d4fde | |
* | |
* => 0x70a08231 ^ 0x6352211e ^ 0x095ea7b3 ^ 0x081812fc ^ | |
* 0xa22cb465 ^ 0xe985e9c5 ^ 0x23b872dd ^ 0x42842e0e ^ 0xb88d4fde == 0x80ac58cd | |
*/ | |
bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd; | |
/* | |
* bytes4(keccak256('name()')) == 0x06fdde03 | |
* bytes4(keccak256('symbol()')) == 0x95d89b41 | |
* | |
* => 0x06fdde03 ^ 0x95d89b41 == 0x93254542 | |
*/ | |
bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x93254542; | |
/* | |
* bytes4(keccak256('totalSupply()')) == 0x18160ddd | |
* bytes4(keccak256('tokenOfOwnerByIndex(address,uint256)')) == 0x2f745c59 | |
* bytes4(keccak256('tokenByIndex(uint256)')) == 0x4f6ccce7 | |
* | |
* => 0x18160ddd ^ 0x2f745c59 ^ 0x4f6ccce7 == 0x780e9d63 | |
*/ | |
bytes4 private constant _INTERFACE_ID_ERC721_ENUMERABLE = 0x780e9d63; | |
// Events | |
event NameChange (uint256 indexed maskIndex, string newName); | |
/** | |
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection. | |
*/ | |
constructor (string memory name, string memory symbol, address wetAddress) { | |
_name = name; | |
_symbol = symbol; | |
_wetAddress = wetAddress; | |
// register the supported interfaces to conform to ERC721 via ERC165 | |
_registerInterface(_INTERFACE_ID_ERC721); | |
_registerInterface(_INTERFACE_ID_ERC721_METADATA); | |
_registerInterface(_INTERFACE_ID_ERC721_ENUMERABLE); | |
} | |
/** | |
* @dev See {IERC721-balanceOf}. | |
*/ | |
function balanceOf(address owner) public view override returns (uint256) { | |
require(owner != address(0), "ERC721: balance query for the zero address"); | |
return _holderTokens[owner].length(); | |
} | |
/** | |
* @dev See {IERC721-ownerOf}. | |
*/ | |
function ownerOf(uint256 tokenId) public view override returns (address) { | |
return _tokenOwners.get(tokenId, "ERC721: owner query for nonexistent token"); | |
} | |
/** | |
* @dev See {IERC721Metadata-name}. | |
*/ | |
function name() public view override returns (string memory) { | |
return _name; | |
} | |
/** | |
* @dev See {IERC721Metadata-symbol}. | |
*/ | |
function symbol() public view override returns (string memory) { | |
return _symbol; | |
} | |
/** | |
* @dev See {IERC721Enumerable-tokenOfOwnerByIndex}. | |
*/ | |
function tokenOfOwnerByIndex(address owner, uint256 index) public view override returns (uint256) { | |
return _holderTokens[owner].at(index); | |
} | |
/** | |
* @dev See {IERC721Enumerable-totalSupply}. | |
*/ | |
function totalSupply() public view override returns (uint256) { | |
// _tokenOwners are indexed by tokenIds, so .length() returns the number of tokenIds | |
return _tokenOwners.length(); | |
} | |
/** | |
* @dev See {IERC721Enumerable-tokenByIndex}. | |
*/ | |
function tokenByIndex(uint256 index) public view override returns (uint256) { | |
(uint256 tokenId, ) = _tokenOwners.at(index); | |
return tokenId; | |
} | |
/** | |
* @dev Returns name of the NFT at index. | |
*/ | |
function tokenNameByIndex(uint256 index) public view returns (string memory) { | |
return _tokenName[index]; | |
} | |
/** | |
* @dev Returns if the name has been reserved. | |
*/ | |
function isNameReserved(string memory nameString) public view returns (bool) { | |
return _nameReserved[toLower(nameString)]; | |
} | |
/** | |
* @dev Returns if the NFT has been minted before reveal phase | |
*/ | |
function isMintedBeforeReveal(uint256 index) public view override returns (bool) { | |
return _mintedBeforeReveal[index]; | |
} | |
/** | |
* @dev Gets current Waifus Price | |
*/ | |
function getNFTPrice() public view returns (uint256) { | |
require(block.timestamp >= SALE_START_TIMESTAMP, "Sale has not started"); | |
require(totalSupply() < MAX_NFT_SUPPLY, "Sale has already ended"); | |
uint currentSupply = totalSupply(); | |
if (currentSupply >= 16381) { | |
return 100000000000000000000; // 16381 - 16383 100 ETH | |
} else if (currentSupply >= 16000) { | |
return 2000000000000000000; // 16000 - 16380 2.0 ETH | |
} else if (currentSupply >= 15000) { | |
return 1300000000000000000; // 15000 - 15999 1.3 ETH | |
} else if (currentSupply >= 13000) { | |
return 1100000000000000000; // 13000 - 14999 1.1 ETH | |
} else if (currentSupply >= 11000) { | |
return 900000000000000000; // 11000 - 12999 0.9 ETH | |
} else if (currentSupply >= 9000) { | |
return 700000000000000000; // 9000 - 10999 0.7 ETH | |
} else if (currentSupply >= 7000) { | |
return 500000000000000000; // 7000 - 8999 0.5 ETH | |
} else if (currentSupply >= 5000) { | |
return 400000000000000000; // 5000 - 6999 0.4 ETH | |
} else if (currentSupply >= 3000) { | |
return 300000000000000000; // 3000 - 4999 0.3 ETH | |
} else if (currentSupply >= 1500) { | |
return 200000000000000000; // 1500 - 2999 0.2 ETH | |
} else { | |
return 100000000000000000; // 0 - 1499 0.1 ETH | |
} | |
} | |
/** | |
* @dev Mints Waifus | |
*/ | |
function mintNFT(uint256 numberOfNfts) public payable { | |
require(totalSupply() < MAX_NFT_SUPPLY, "Sale has already ended"); | |
require(numberOfNfts > 0, "numberOfNfts cannot be 0"); | |
require(numberOfNfts <= 20, "You may not buy more than 20 NFTs at once"); | |
require(totalSupply().add(numberOfNfts) <= MAX_NFT_SUPPLY, "Exceeds MAX_NFT_SUPPLY"); | |
require(getNFTPrice().mul(numberOfNfts) == msg.value, "Ether value sent is not correct"); | |
for (uint i = 0; i < numberOfNfts; i++) { | |
uint mintIndex = totalSupply(); | |
if (block.timestamp < REVEAL_TIMESTAMP) { | |
_mintedBeforeReveal[mintIndex] = true; | |
} | |
_safeMint(msg.sender, mintIndex); | |
} | |
/** | |
* Source of randomness. Theoretical miner withhold manipulation possible but should be sufficient in a pragmatic sense | |
*/ | |
if (startingIndexBlock == 0 && (totalSupply() == MAX_NFT_SUPPLY || block.timestamp >= REVEAL_TIMESTAMP)) { | |
startingIndexBlock = block.number; | |
} | |
} | |
/** | |
* @dev Finalize starting index | |
*/ | |
function finalizeStartingIndex() public { | |
require(startingIndex == 0, "Starting index is already set"); | |
require(startingIndexBlock != 0, "Starting index block must be set"); | |
startingIndex = uint(blockhash(startingIndexBlock)) % MAX_NFT_SUPPLY; | |
// Just a sanity case in the worst case if this function is called late (EVM only stores last 256 block hashes) | |
if (block.number.sub(startingIndexBlock) > 255) { | |
startingIndex = uint(blockhash(block.number-1)) % MAX_NFT_SUPPLY; | |
} | |
// Prevent default sequence | |
if (startingIndex == 0) { | |
startingIndex = startingIndex.add(1); | |
} | |
} | |
/** | |
* @dev Changes the name for Waifus tokenId | |
*/ | |
function changeName(uint256 tokenId, string memory newName) public { | |
address owner = ownerOf(tokenId); | |
require(_msgSender() == owner, "ERC721: caller is not the owner"); | |
require(validateName(newName) == true, "Not a valid new name"); | |
require(sha256(bytes(newName)) != sha256(bytes(_tokenName[tokenId])), "New name is same as the current one"); | |
require(isNameReserved(newName) == false, "Name already reserved"); | |
IERC20(_wetAddress).transferFrom(msg.sender, address(this), NAME_CHANGE_PRICE); | |
// If already named, dereserve old name | |
if (bytes(_tokenName[tokenId]).length > 0) { | |
toggleReserveName(_tokenName[tokenId], false); | |
} | |
toggleReserveName(newName, true); | |
_tokenName[tokenId] = newName; | |
IERC20(_wetAddress).burn(NAME_CHANGE_PRICE); | |
emit NameChange(tokenId, newName); | |
} | |
/** | |
* @dev Withdraw ether from this contract (Callable by owner) | |
*/ | |
function withdraw() onlyOwner public { | |
uint balance = address(this).balance; | |
msg.sender.transfer(balance); | |
} | |
/** | |
* @dev See {IERC721-approve}. | |
*/ | |
function approve(address to, uint256 tokenId) public virtual override { | |
address owner = ownerOf(tokenId); | |
require(to != owner, "ERC721: approval to current owner"); | |
require(_msgSender() == owner || isApprovedForAll(owner, _msgSender()), | |
"ERC721: approve caller is not owner nor approved for all" | |
); | |
_approve(to, tokenId); | |
} | |
/** | |
* @dev See {IERC721-getApproved}. | |
*/ | |
function getApproved(uint256 tokenId) public view override returns (address) { | |
require(_exists(tokenId), "ERC721: approved query for nonexistent token"); | |
return _tokenApprovals[tokenId]; | |
} | |
/** | |
* @dev See {IERC721-setApprovalForAll}. | |
*/ | |
function setApprovalForAll(address operator, bool approved) public virtual override { | |
require(operator != _msgSender(), "ERC721: approve to caller"); | |
_operatorApprovals[_msgSender()][operator] = approved; | |
emit ApprovalForAll(_msgSender(), operator, approved); | |
} | |
/** | |
* @dev See {IERC721-isApprovedForAll}. | |
*/ | |
function isApprovedForAll(address owner, address operator) public view override returns (bool) { | |
return _operatorApprovals[owner][operator]; | |
} | |
/** | |
* @dev See {IERC721-transferFrom}. | |
*/ | |
function transferFrom(address from, address to, uint256 tokenId) public virtual override { | |
//solhint-disable-next-line max-line-length | |
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved"); | |
_transfer(from, to, tokenId); | |
} | |
/** | |
* @dev See {IERC721-safeTransferFrom}. | |
*/ | |
function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override { | |
safeTransferFrom(from, to, tokenId, ""); | |
} | |
/** | |
* @dev See {IERC721-safeTransferFrom}. | |
*/ | |
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override { | |
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved"); | |
_safeTransfer(from, to, tokenId, _data); | |
} | |
/** | |
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients | |
* are aware of the ERC721 protocol to prevent tokens from being forever locked. | |
* | |
* `_data` is additional data, it has no specified format and it is sent in call to `to`. | |
* | |
* This internal function is equivalent to {safeTransferFrom}, and can be used to e.g. | |
* implement alternative mechanisms to perform token transfer, such as signature-based. | |
* | |
* Requirements: | |
* | |
* - `from` cannot be the zero address. | |
* - `to` cannot be the zero address. | |
* - `tokenId` token must exist and be owned by `from`. | |
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. | |
* | |
* Emits a {Transfer} event. | |
*/ | |
function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual { | |
_transfer(from, to, tokenId); | |
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer"); | |
} | |
/** | |
* @dev Returns whether `tokenId` exists. | |
* | |
* Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}. | |
* | |
* Tokens start existing when they are minted (`_mint`), | |
* and stop existing when they are burned (`_burn`). | |
*/ | |
function _exists(uint256 tokenId) internal view returns (bool) { | |
return _tokenOwners.contains(tokenId); | |
} | |
/** | |
* @dev Returns whether `spender` is allowed to manage `tokenId`. | |
* | |
* Requirements: | |
* | |
* - `tokenId` must exist. | |
*/ | |
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) { | |
require(_exists(tokenId), "ERC721: operator query for nonexistent token"); | |
address owner = ownerOf(tokenId); | |
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender)); | |
} | |
/** | |
* @dev Safely mints `tokenId` and transfers it to `to`. | |
* | |
* Requirements: | |
d* | |
* - `tokenId` must not exist. | |
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. | |
* | |
* Emits a {Transfer} event. | |
*/ | |
function _safeMint(address to, uint256 tokenId) internal virtual { | |
require(totalSupply() < 16385); | |
_safeMint(to, tokenId, ""); | |
} | |
/** | |
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is | |
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients. | |
*/ | |
function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual { | |
_mint(to, tokenId); | |
require(totalSupply() < 16385); | |
require(_checkOnERC721Received(address(0), to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer"); | |
} | |
/** | |
* @dev Mints `tokenId` and transfers it to `to`. | |
* | |
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible | |
* | |
* Requirements: | |
* | |
* - `tokenId` must not exist. | |
* - `to` cannot be the zero address. | |
* | |
* Emits a {Transfer} event. | |
*/ | |
function _mint(address to, uint256 tokenId) internal virtual { | |
require(to != address(0), "ERC721: mint to the zero address"); | |
require(!_exists(tokenId), "ERC721: token already minted"); | |
_beforeTokenTransfer(address(0), to, tokenId); | |
_holderTokens[to].add(tokenId); | |
_tokenOwners.set(tokenId, to); | |
emit Transfer(address(0), to, tokenId); | |
} | |
/** | |
* @dev Destroys `tokenId`. | |
* The approval is cleared when the token is burned. | |
* | |
* Requirements: | |
* | |
* - `tokenId` must exist. | |
* | |
* Emits a {Transfer} event. | |
*/ | |
function _burn(uint256 tokenId) internal virtual { | |
address owner = ownerOf(tokenId); | |
_beforeTokenTransfer(owner, address(0), tokenId); | |
// Clear approvals | |
_approve(address(0), tokenId); | |
_holderTokens[owner].remove(tokenId); | |
_tokenOwners.remove(tokenId); | |
emit Transfer(owner, address(0), tokenId); | |
} | |
/** | |
* @dev Transfers `tokenId` from `from` to `to`. | |
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender. | |
* | |
* Requirements: | |
* | |
* - `to` cannot be the zero address. | |
* - `tokenId` token must be owned by `from`. | |
* | |
* Emits a {Transfer} event. | |
*/ | |
function _transfer(address from, address to, uint256 tokenId) internal virtual { | |
require(ownerOf(tokenId) == from, "ERC721: transfer of token that is not own"); | |
require(to != address(0), "ERC721: transfer to the zero address"); | |
_beforeTokenTransfer(from, to, tokenId); | |
// Clear approvals from the previous owner | |
_approve(address(0), tokenId); | |
_holderTokens[from].remove(tokenId); | |
_holderTokens[to].add(tokenId); | |
_tokenOwners.set(tokenId, to); | |
emit Transfer(from, to, tokenId); | |
} | |
/** | |
* @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address. | |
* The call is not executed if the target address is not a contract. | |
* | |
* @param from address representing the previous owner of the given token ID | |
* @param to target address that will receive the tokens | |
* @param tokenId uint256 ID of the token to be transferred | |
* @param _data bytes optional data to send along with the call | |
* @return bool whether the call correctly returned the expected magic value | |
*/ | |
function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data) | |
private returns (bool) | |
{ | |
if (!to.isContract()) { | |
return true; | |
} | |
bytes memory returndata = to.functionCall(abi.encodeWithSelector( | |
IERC721Receiver(to).onERC721Received.selector, | |
_msgSender(), | |
from, | |
tokenId, | |
_data | |
), "ERC721: transfer to non ERC721Receiver implementer"); | |
bytes4 retval = abi.decode(returndata, (bytes4)); | |
return (retval == _ERC721_RECEIVED); | |
} | |
function _approve(address to, uint256 tokenId) private { | |
_tokenApprovals[tokenId] = to; | |
emit Approval(ownerOf(tokenId), to, tokenId); | |
} | |
/** | |
* @dev Hook that is called before any token transfer. This includes minting | |
* and burning. | |
* | |
* Calling conditions: | |
* | |
* - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be | |
* transferred to `to`. | |
* - When `from` is zero, `tokenId` will be minted for `to`. | |
* - When `to` is zero, ``from``'s `tokenId` will be burned. | |
* - `from` cannot be the zero address. | |
* - `to` cannot be the zero address. | |
* | |
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. | |
*/ | |
function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { } | |
/** | |
* @dev Reserves the name if isReserve is set to true, de-reserves if set to false | |
*/ | |
function toggleReserveName(string memory str, bool isReserve) internal { | |
_nameReserved[toLower(str)] = isReserve; | |
} | |
/** | |
* @dev Check if the name string is valid (Alphanumeric and spaces without leading or trailing space) | |
*/ | |
function validateName(string memory str) public pure returns (bool){ | |
bytes memory b = bytes(str); | |
if(b.length < 1) return false; | |
if(b.length > 25) return false; // Cannot be longer than 25 characters | |
if(b[0] == 0x20) return false; // Leading space | |
if (b[b.length - 1] == 0x20) return false; // Trailing space | |
bytes1 lastChar = b[0]; | |
for(uint i; i<b.length; i++){ | |
bytes1 char = b[i]; | |
if (char == 0x20 && lastChar == 0x20) return false; // Cannot contain continous spaces | |
if( | |
!(char >= 0x30 && char <= 0x39) && //9-0 | |
!(char >= 0x41 && char <= 0x5A) && //A-Z | |
!(char >= 0x61 && char <= 0x7A) && //a-z | |
!(char == 0x20) //space | |
) | |
return false; | |
lastChar = char; | |
} | |
return true; | |
} | |
/** | |
* @dev Converts the string to lowercase | |
*/ | |
function toLower(string memory str) public pure returns (string memory){ | |
bytes memory bStr = bytes(str); | |
bytes memory bLower = new bytes(bStr.length); | |
for (uint i = 0; i < bStr.length; i++) { | |
// Uppercase character | |
if ((uint8(bStr[i]) >= 65) && (uint8(bStr[i]) <= 90)) { | |
bLower[i] = bytes1(uint8(bStr[i]) + 32); | |
} else { | |
bLower[i] = bStr[i]; | |
} | |
} | |
return string(bLower); | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment