Contract Source Code:
File 1 of 1 : SeaOfDeath
// SPDX-License-Identifier: MIT
// File: erc721a/contracts/IERC721A.sol
// ERC721A Contracts v4.2.0
// Creator: Chiru Labs
pragma solidity ^0.8.4;
/**
* @dev Interface of ERC721A.
*/
interface IERC721A {
/**
* The caller must own the token or be an approved operator.
*/
error ApprovalCallerNotOwnerNorApproved();
/**
* The token does not exist.
*/
error ApprovalQueryForNonexistentToken();
/**
* The caller cannot approve to their own address.
*/
error ApproveToCaller();
/**
* Cannot query the balance for the zero address.
*/
error BalanceQueryForZeroAddress();
/**
* Cannot mint to the zero address.
*/
error MintToZeroAddress();
/**
* The quantity of tokens minted must be more than zero.
*/
error MintZeroQuantity();
/**
* The token does not exist.
*/
error OwnerQueryForNonexistentToken();
/**
* The caller must own the token or be an approved operator.
*/
error TransferCallerNotOwnerNorApproved();
/**
* The token must be owned by `from`.
*/
error TransferFromIncorrectOwner();
/**
* Cannot safely transfer to a contract that does not implement the
* ERC721Receiver interface.
*/
error TransferToNonERC721ReceiverImplementer();
/**
* Cannot transfer to the zero address.
*/
error TransferToZeroAddress();
/**
* The token does not exist.
*/
error URIQueryForNonexistentToken();
/**
* The `quantity` minted with ERC2309 exceeds the safety limit.
*/
error MintERC2309QuantityExceedsLimit();
/**
* The `extraData` cannot be set on an unintialized ownership slot.
*/
error OwnershipNotInitializedForExtraData();
// =============================================================
// STRUCTS
// =============================================================
struct TokenOwnership {
// The address of the owner.
address addr;
// Stores the start time of ownership with minimal overhead for tokenomics.
uint64 startTimestamp;
// Whether the token has been burned.
bool burned;
// Arbitrary data similar to `startTimestamp` that can be set via {_extraData}.
uint24 extraData;
}
// =============================================================
// TOKEN COUNTERS
// =============================================================
/**
* @dev Returns the total number of tokens in existence.
* Burned tokens will reduce the count.
* To get the total number of tokens minted, please see {_totalMinted}.
*/
function totalSupply() external view returns (uint256);
// =============================================================
// IERC165
// =============================================================
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* [EIP section](https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified)
* to learn more about how these ids are created.
*
* This function call must use less than 30000 gas.
*/
function supportsInterface(bytes4 interfaceId) external view returns (bool);
// =============================================================
// IERC721
// =============================================================
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables or disables
* (`approved`) `operator` to manage all of its assets.
*/
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/**
* @dev Returns the number of tokens in `owner`'s account.
*/
function balanceOf(address owner) external view returns (uint256 balance);
/**
* @dev Returns the owner of the `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function ownerOf(uint256 tokenId) external view returns (address owner);
/**
* @dev Safely transfers `tokenId` token from `from` to `to`,
* checking first that contract recipients are aware of the ERC721 protocol
* to prevent tokens from being forever locked.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must be have been allowed to move
* this token by either {approve} or {setApprovalForAll}.
* - If `to` refers to a smart contract, it must implement
* {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
/**
* @dev Equivalent to `safeTransferFrom(from, to, tokenId, '')`.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
/**
* @dev Transfers `tokenId` 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);
// =============================================================
// IERC721Metadata
// =============================================================
/**
* @dev Returns the token collection name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the token collection symbol.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 tokenId) external view returns (string memory);
// =============================================================
// IERC2309
// =============================================================
/**
* @dev Emitted when tokens in `fromTokenId` to `toTokenId`
* (inclusive) is transferred from `from` to `to`, as defined in the
* [ERC2309](https://eips.ethereum.org/EIPS/eip-2309) standard.
*
* See {_mintERC2309} for more details.
*/
event ConsecutiveTransfer(uint256 indexed fromTokenId, uint256 toTokenId, address indexed from, address indexed to);
}
// File: erc721a/contracts/ERC721A.sol
// ERC721A Contracts v4.2.0
// Creator: Chiru Labs
pragma solidity ^0.8.4;
/**
* @dev Interface of ERC721 token receiver.
*/
interface ERC721A__IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
/**
* @title ERC721A
*
* @dev Implementation of the [ERC721](https://eips.ethereum.org/EIPS/eip-721)
* Non-Fungible Token Standard, including the Metadata extension.
* Optimized for lower gas during batch mints.
*
* Token IDs are minted in sequential order (e.g. 0, 1, 2, 3, ...)
* starting from `_startTokenId()`.
*
* Assumptions:
*
* - An owner cannot have more than 2**64 - 1 (max value of uint64) of supply.
* - The maximum token ID cannot exceed 2**256 - 1 (max value of uint256).
*/
contract ERC721A is IERC721A {
// Reference type for token approval.
struct TokenApprovalRef {
address value;
}
// =============================================================
// CONSTANTS
// =============================================================
// Mask of an entry in packed address data.
uint256 private constant _BITMASK_ADDRESS_DATA_ENTRY = (1 << 64) - 1;
// The bit position of `numberMinted` in packed address data.
uint256 private constant _BITPOS_NUMBER_MINTED = 64;
// The bit position of `numberBurned` in packed address data.
uint256 private constant _BITPOS_NUMBER_BURNED = 128;
// The bit position of `aux` in packed address data.
uint256 private constant _BITPOS_AUX = 192;
// Mask of all 256 bits in packed address data except the 64 bits for `aux`.
uint256 private constant _BITMASK_AUX_COMPLEMENT = (1 << 192) - 1;
// The bit position of `startTimestamp` in packed ownership.
uint256 private constant _BITPOS_START_TIMESTAMP = 160;
// The bit mask of the `burned` bit in packed ownership.
uint256 private constant _BITMASK_BURNED = 1 << 224;
// The bit position of the `nextInitialized` bit in packed ownership.
uint256 private constant _BITPOS_NEXT_INITIALIZED = 225;
// The bit mask of the `nextInitialized` bit in packed ownership.
uint256 private constant _BITMASK_NEXT_INITIALIZED = 1 << 225;
// The bit position of `extraData` in packed ownership.
uint256 private constant _BITPOS_EXTRA_DATA = 232;
// Mask of all 256 bits in a packed ownership except the 24 bits for `extraData`.
uint256 private constant _BITMASK_EXTRA_DATA_COMPLEMENT = (1 << 232) - 1;
// The mask of the lower 160 bits for addresses.
uint256 private constant _BITMASK_ADDRESS = (1 << 160) - 1;
// The maximum `quantity` that can be minted with {_mintERC2309}.
// This limit is to prevent overflows on the address data entries.
// For a limit of 5000, a total of 3.689e15 calls to {_mintERC2309}
// is required to cause an overflow, which is unrealistic.
uint256 private constant _MAX_MINT_ERC2309_QUANTITY_LIMIT = 5000;
// The `Transfer` event signature is given by:
// `keccak256(bytes("Transfer(address,address,uint256)"))`.
bytes32 private constant _TRANSFER_EVENT_SIGNATURE =
0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef;
// =============================================================
// STORAGE
// =============================================================
// The next token ID to be minted.
uint256 private _currentIndex;
// The number of tokens burned.
uint256 private _burnCounter;
// Token name
string private _name;
// Token symbol
string private _symbol;
// Mapping from token ID to ownership details
// An empty struct value does not necessarily mean the token is unowned.
// See {_packedOwnershipOf} implementation for details.
//
// Bits Layout:
// - [0..159] `addr`
// - [160..223] `startTimestamp`
// - [224] `burned`
// - [225] `nextInitialized`
// - [232..255] `extraData`
mapping(uint256 => uint256) private _packedOwnerships;
// Mapping owner address to address data.
//
// Bits Layout:
// - [0..63] `balance`
// - [64..127] `numberMinted`
// - [128..191] `numberBurned`
// - [192..255] `aux`
mapping(address => uint256) private _packedAddressData;
// Mapping from token ID to approved address.
mapping(uint256 => TokenApprovalRef) private _tokenApprovals;
// Mapping from owner to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
// =============================================================
// CONSTRUCTOR
// =============================================================
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
_currentIndex = _startTokenId();
}
// =============================================================
// TOKEN COUNTING OPERATIONS
// =============================================================
/**
* @dev Returns the starting token ID.
* To change the starting token ID, please override this function.
*/
function _startTokenId() internal view virtual returns (uint256) {
return 0;
}
/**
* @dev Returns the next token ID to be minted.
*/
function _nextTokenId() internal view virtual returns (uint256) {
return _currentIndex;
}
/**
* @dev Returns the total number of tokens in existence.
* Burned tokens will reduce the count.
* To get the total number of tokens minted, please see {_totalMinted}.
*/
function totalSupply() public view virtual override returns (uint256) {
// Counter underflow is impossible as _burnCounter cannot be incremented
// more than `_currentIndex - _startTokenId()` times.
unchecked {
return _currentIndex - _burnCounter - _startTokenId();
}
}
/**
* @dev Returns the total amount of tokens minted in the contract.
*/
function _totalMinted() internal view virtual returns (uint256) {
// Counter underflow is impossible as `_currentIndex` does not decrement,
// and it is initialized to `_startTokenId()`.
unchecked {
return _currentIndex - _startTokenId();
}
}
/**
* @dev Returns the total number of tokens burned.
*/
function _totalBurned() internal view virtual returns (uint256) {
return _burnCounter;
}
// =============================================================
// ADDRESS DATA OPERATIONS
// =============================================================
/**
* @dev Returns the number of tokens in `owner`'s account.
*/
function balanceOf(address owner) public view virtual override returns (uint256) {
if (owner == address(0)) revert BalanceQueryForZeroAddress();
return _packedAddressData[owner] & _BITMASK_ADDRESS_DATA_ENTRY;
}
/**
* Returns the number of tokens minted by `owner`.
*/
function _numberMinted(address owner) internal view returns (uint256) {
return (_packedAddressData[owner] >> _BITPOS_NUMBER_MINTED) & _BITMASK_ADDRESS_DATA_ENTRY;
}
/**
* Returns the number of tokens burned by or on behalf of `owner`.
*/
function _numberBurned(address owner) internal view returns (uint256) {
return (_packedAddressData[owner] >> _BITPOS_NUMBER_BURNED) & _BITMASK_ADDRESS_DATA_ENTRY;
}
/**
* Returns the auxiliary data for `owner`. (e.g. number of whitelist mint slots used).
*/
function _getAux(address owner) internal view returns (uint64) {
return uint64(_packedAddressData[owner] >> _BITPOS_AUX);
}
/**
* Sets the auxiliary data for `owner`. (e.g. number of whitelist mint slots used).
* If there are multiple variables, please pack them into a uint64.
*/
function _setAux(address owner, uint64 aux) internal virtual {
uint256 packed = _packedAddressData[owner];
uint256 auxCasted;
// Cast `aux` with assembly to avoid redundant masking.
assembly {
auxCasted := aux
}
packed = (packed & _BITMASK_AUX_COMPLEMENT) | (auxCasted << _BITPOS_AUX);
_packedAddressData[owner] = packed;
}
// =============================================================
// IERC165
// =============================================================
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* [EIP section](https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified)
* to learn more about how these ids are created.
*
* This function call must use less than 30000 gas.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
// The interface IDs are constants representing the first 4 bytes
// of the XOR of all function selectors in the interface.
// See: [ERC165](https://eips.ethereum.org/EIPS/eip-165)
// (e.g. `bytes4(i.functionA.selector ^ i.functionB.selector ^ ...)`)
return
interfaceId == 0x01ffc9a7 || // ERC165 interface ID for ERC165.
interfaceId == 0x80ac58cd || // ERC165 interface ID for ERC721.
interfaceId == 0x5b5e139f; // ERC165 interface ID for ERC721Metadata.
}
// =============================================================
// IERC721Metadata
// =============================================================
/**
* @dev Returns the token collection name.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev Returns the token collection symbol.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
if (!_exists(tokenId)) revert URIQueryForNonexistentToken();
string memory baseURI = _baseURI();
return bytes(baseURI).length != 0 ? string(abi.encodePacked(baseURI, _toString(tokenId))) : '';
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, it can be overridden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
return '';
}
// =============================================================
// OWNERSHIPS OPERATIONS
// =============================================================
/**
* @dev Returns the owner of the `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
return address(uint160(_packedOwnershipOf(tokenId)));
}
/**
* @dev Gas spent here starts off proportional to the maximum mint batch size.
* It gradually moves to O(1) as tokens get transferred around over time.
*/
function _ownershipOf(uint256 tokenId) internal view virtual returns (TokenOwnership memory) {
return _unpackedOwnership(_packedOwnershipOf(tokenId));
}
/**
* @dev Returns the unpacked `TokenOwnership` struct at `index`.
*/
function _ownershipAt(uint256 index) internal view virtual returns (TokenOwnership memory) {
return _unpackedOwnership(_packedOwnerships[index]);
}
/**
* @dev Initializes the ownership slot minted at `index` for efficiency purposes.
*/
function _initializeOwnershipAt(uint256 index) internal virtual {
if (_packedOwnerships[index] == 0) {
_packedOwnerships[index] = _packedOwnershipOf(index);
}
}
/**
* Returns the packed ownership data of `tokenId`.
*/
function _packedOwnershipOf(uint256 tokenId) private view returns (uint256) {
uint256 curr = tokenId;
unchecked {
if (_startTokenId() <= curr)
if (curr < _currentIndex) {
uint256 packed = _packedOwnerships[curr];
// If not burned.
if (packed & _BITMASK_BURNED == 0) {
// Invariant:
// There will always be an initialized ownership slot
// (i.e. `ownership.addr != address(0) && ownership.burned == false`)
// before an unintialized ownership slot
// (i.e. `ownership.addr == address(0) && ownership.burned == false`)
// Hence, `curr` will not underflow.
//
// We can directly compare the packed value.
// If the address is zero, packed will be zero.
while (packed == 0) {
packed = _packedOwnerships[--curr];
}
return packed;
}
}
}
revert OwnerQueryForNonexistentToken();
}
/**
* @dev Returns the unpacked `TokenOwnership` struct from `packed`.
*/
function _unpackedOwnership(uint256 packed) private pure returns (TokenOwnership memory ownership) {
ownership.addr = address(uint160(packed));
ownership.startTimestamp = uint64(packed >> _BITPOS_START_TIMESTAMP);
ownership.burned = packed & _BITMASK_BURNED != 0;
ownership.extraData = uint24(packed >> _BITPOS_EXTRA_DATA);
}
/**
* @dev Packs ownership data into a single uint256.
*/
function _packOwnershipData(address owner, uint256 flags) private view returns (uint256 result) {
assembly {
// Mask `owner` to the lower 160 bits, in case the upper bits somehow aren't clean.
owner := and(owner, _BITMASK_ADDRESS)
// `owner | (block.timestamp << _BITPOS_START_TIMESTAMP) | flags`.
result := or(owner, or(shl(_BITPOS_START_TIMESTAMP, timestamp()), flags))
}
}
/**
* @dev Returns the `nextInitialized` flag set if `quantity` equals 1.
*/
function _nextInitializedFlag(uint256 quantity) private pure returns (uint256 result) {
// For branchless setting of the `nextInitialized` flag.
assembly {
// `(quantity == 1) << _BITPOS_NEXT_INITIALIZED`.
result := shl(_BITPOS_NEXT_INITIALIZED, eq(quantity, 1))
}
}
// =============================================================
// APPROVAL OPERATIONS
// =============================================================
/**
* @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) public virtual override {
address owner = ownerOf(tokenId);
if (_msgSenderERC721A() != owner)
if (!isApprovedForAll(owner, _msgSenderERC721A())) {
revert ApprovalCallerNotOwnerNorApproved();
}
_tokenApprovals[tokenId].value = to;
emit Approval(owner, to, tokenId);
}
/**
* @dev Returns the account approved for `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function getApproved(uint256 tokenId) public view virtual override returns (address) {
if (!_exists(tokenId)) revert ApprovalQueryForNonexistentToken();
return _tokenApprovals[tokenId].value;
}
/**
* @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) public virtual override {
if (operator == _msgSenderERC721A()) revert ApproveToCaller();
_operatorApprovals[_msgSenderERC721A()][operator] = approved;
emit ApprovalForAll(_msgSenderERC721A(), operator, approved);
}
/**
* @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
*
* See {setApprovalForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
/**
* @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. See {_mint}.
*/
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return
_startTokenId() <= tokenId &&
tokenId < _currentIndex && // If within bounds,
_packedOwnerships[tokenId] & _BITMASK_BURNED == 0; // and not burned.
}
/**
* @dev Returns whether `msgSender` is equal to `approvedAddress` or `owner`.
*/
function _isSenderApprovedOrOwner(
address approvedAddress,
address owner,
address msgSender
) private pure returns (bool result) {
assembly {
// Mask `owner` to the lower 160 bits, in case the upper bits somehow aren't clean.
owner := and(owner, _BITMASK_ADDRESS)
// Mask `msgSender` to the lower 160 bits, in case the upper bits somehow aren't clean.
msgSender := and(msgSender, _BITMASK_ADDRESS)
// `msgSender == owner || msgSender == approvedAddress`.
result := or(eq(msgSender, owner), eq(msgSender, approvedAddress))
}
}
/**
* @dev Returns the storage slot and value for the approved address of `tokenId`.
*/
function _getApprovedSlotAndAddress(uint256 tokenId)
private
view
returns (uint256 approvedAddressSlot, address approvedAddress)
{
TokenApprovalRef storage tokenApproval = _tokenApprovals[tokenId];
// The following is equivalent to `approvedAddress = _tokenApprovals[tokenId]`.
assembly {
approvedAddressSlot := tokenApproval.slot
approvedAddress := sload(approvedAddressSlot)
}
}
// =============================================================
// TRANSFER OPERATIONS
// =============================================================
/**
* @dev Transfers `tokenId` from `from` to `to`.
*
* 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
) public virtual override {
uint256 prevOwnershipPacked = _packedOwnershipOf(tokenId);
if (address(uint160(prevOwnershipPacked)) != from) revert TransferFromIncorrectOwner();
(uint256 approvedAddressSlot, address approvedAddress) = _getApprovedSlotAndAddress(tokenId);
// The nested ifs save around 20+ gas over a compound boolean condition.
if (!_isSenderApprovedOrOwner(approvedAddress, from, _msgSenderERC721A()))
if (!isApprovedForAll(from, _msgSenderERC721A())) revert TransferCallerNotOwnerNorApproved();
if (to == address(0)) revert TransferToZeroAddress();
_beforeTokenTransfers(from, to, tokenId, 1);
// Clear approvals from the previous owner.
assembly {
if approvedAddress {
// This is equivalent to `delete _tokenApprovals[tokenId]`.
sstore(approvedAddressSlot, 0)
}
}
// Underflow of the sender's balance is impossible because we check for
// ownership above and the recipient's balance can't realistically overflow.
// Counter overflow is incredibly unrealistic as `tokenId` would have to be 2**256.
unchecked {
// We can directly increment and decrement the balances.
--_packedAddressData[from]; // Updates: `balance -= 1`.
++_packedAddressData[to]; // Updates: `balance += 1`.
// Updates:
// - `address` to the next owner.
// - `startTimestamp` to the timestamp of transfering.
// - `burned` to `false`.
// - `nextInitialized` to `true`.
_packedOwnerships[tokenId] = _packOwnershipData(
to,
_BITMASK_NEXT_INITIALIZED | _nextExtraData(from, to, prevOwnershipPacked)
);
// If the next slot may not have been initialized (i.e. `nextInitialized == false`) .
if (prevOwnershipPacked & _BITMASK_NEXT_INITIALIZED == 0) {
uint256 nextTokenId = tokenId + 1;
// If the next slot's address is zero and not burned (i.e. packed value is zero).
if (_packedOwnerships[nextTokenId] == 0) {
// If the next slot is within bounds.
if (nextTokenId != _currentIndex) {
// Initialize the next slot to maintain correctness for `ownerOf(tokenId + 1)`.
_packedOwnerships[nextTokenId] = prevOwnershipPacked;
}
}
}
}
emit Transfer(from, to, tokenId);
_afterTokenTransfers(from, to, tokenId, 1);
}
/**
* @dev Equivalent to `safeTransferFrom(from, to, tokenId, '')`.
*/
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, '');
}
/**
* @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 memory _data
) public virtual override {
transferFrom(from, to, tokenId);
if (to.code.length != 0)
if (!_checkContractOnERC721Received(from, to, tokenId, _data)) {
revert TransferToNonERC721ReceiverImplementer();
}
}
/**
* @dev Hook that is called before a set of serially-ordered token IDs
* are about to be transferred. This includes minting.
* And also called before burning one token.
*
* `startTokenId` - the first token ID to be transferred.
* `quantity` - the amount to be transferred.
*
* 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, `tokenId` will be burned by `from`.
* - `from` and `to` are never both zero.
*/
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
/**
* @dev Hook that is called after a set of serially-ordered token IDs
* have been transferred. This includes minting.
* And also called after one token has been burned.
*
* `startTokenId` - the first token ID to be transferred.
* `quantity` - the amount to be transferred.
*
* Calling conditions:
*
* - When `from` and `to` are both non-zero, `from`'s `tokenId` has been
* transferred to `to`.
* - When `from` is zero, `tokenId` has been minted for `to`.
* - When `to` is zero, `tokenId` has been burned by `from`.
* - `from` and `to` are never both zero.
*/
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
/**
* @dev Private function to invoke {IERC721Receiver-onERC721Received} on a target contract.
*
* `from` - Previous owner of the given token ID.
* `to` - Target address that will receive the token.
* `tokenId` - Token ID to be transferred.
* `_data` - Optional data to send along with the call.
*
* Returns whether the call correctly returned the expected magic value.
*/
function _checkContractOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
try ERC721A__IERC721Receiver(to).onERC721Received(_msgSenderERC721A(), from, tokenId, _data) returns (
bytes4 retval
) {
return retval == ERC721A__IERC721Receiver(to).onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert TransferToNonERC721ReceiverImplementer();
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
}
// =============================================================
// MINT OPERATIONS
// =============================================================
/**
* @dev Mints `quantity` tokens and transfers them to `to`.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `quantity` must be greater than 0.
*
* Emits a {Transfer} event for each mint.
*/
function _mint(address to, uint256 quantity) internal virtual {
uint256 startTokenId = _currentIndex;
if (quantity == 0) revert MintZeroQuantity();
_beforeTokenTransfers(address(0), to, startTokenId, quantity);
// Overflows are incredibly unrealistic.
// `balance` and `numberMinted` have a maximum limit of 2**64.
// `tokenId` has a maximum limit of 2**256.
unchecked {
// Updates:
// - `balance += quantity`.
// - `numberMinted += quantity`.
//
// We can directly add to the `balance` and `numberMinted`.
_packedAddressData[to] += quantity * ((1 << _BITPOS_NUMBER_MINTED) | 1);
// Updates:
// - `address` to the owner.
// - `startTimestamp` to the timestamp of minting.
// - `burned` to `false`.
// - `nextInitialized` to `quantity == 1`.
_packedOwnerships[startTokenId] = _packOwnershipData(
to,
_nextInitializedFlag(quantity) | _nextExtraData(address(0), to, 0)
);
uint256 toMasked;
uint256 end = startTokenId + quantity;
// Use assembly to loop and emit the `Transfer` event for gas savings.
assembly {
// Mask `to` to the lower 160 bits, in case the upper bits somehow aren't clean.
toMasked := and(to, _BITMASK_ADDRESS)
// Emit the `Transfer` event.
log4(
0, // Start of data (0, since no data).
0, // End of data (0, since no data).
_TRANSFER_EVENT_SIGNATURE, // Signature.
0, // `address(0)`.
toMasked, // `to`.
startTokenId // `tokenId`.
)
for {
let tokenId := add(startTokenId, 1)
} iszero(eq(tokenId, end)) {
tokenId := add(tokenId, 1)
} {
// Emit the `Transfer` event. Similar to above.
log4(0, 0, _TRANSFER_EVENT_SIGNATURE, 0, toMasked, tokenId)
}
}
if (toMasked == 0) revert MintToZeroAddress();
_currentIndex = end;
}
_afterTokenTransfers(address(0), to, startTokenId, quantity);
}
/**
* @dev Mints `quantity` tokens and transfers them to `to`.
*
* This function is intended for efficient minting only during contract creation.
*
* It emits only one {ConsecutiveTransfer} as defined in
* [ERC2309](https://eips.ethereum.org/EIPS/eip-2309),
* instead of a sequence of {Transfer} event(s).
*
* Calling this function outside of contract creation WILL make your contract
* non-compliant with the ERC721 standard.
* For full ERC721 compliance, substituting ERC721 {Transfer} event(s) with the ERC2309
* {ConsecutiveTransfer} event is only permissible during contract creation.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `quantity` must be greater than 0.
*
* Emits a {ConsecutiveTransfer} event.
*/
function _mintERC2309(address to, uint256 quantity) internal virtual {
uint256 startTokenId = _currentIndex;
if (to == address(0)) revert MintToZeroAddress();
if (quantity == 0) revert MintZeroQuantity();
if (quantity > _MAX_MINT_ERC2309_QUANTITY_LIMIT) revert MintERC2309QuantityExceedsLimit();
_beforeTokenTransfers(address(0), to, startTokenId, quantity);
// Overflows are unrealistic due to the above check for `quantity` to be below the limit.
unchecked {
// Updates:
// - `balance += quantity`.
// - `numberMinted += quantity`.
//
// We can directly add to the `balance` and `numberMinted`.
_packedAddressData[to] += quantity * ((1 << _BITPOS_NUMBER_MINTED) | 1);
// Updates:
// - `address` to the owner.
// - `startTimestamp` to the timestamp of minting.
// - `burned` to `false`.
// - `nextInitialized` to `quantity == 1`.
_packedOwnerships[startTokenId] = _packOwnershipData(
to,
_nextInitializedFlag(quantity) | _nextExtraData(address(0), to, 0)
);
emit ConsecutiveTransfer(startTokenId, startTokenId + quantity - 1, address(0), to);
_currentIndex = startTokenId + quantity;
}
_afterTokenTransfers(address(0), to, startTokenId, quantity);
}
/**
* @dev Safely mints `quantity` tokens and transfers them to `to`.
*
* Requirements:
*
* - If `to` refers to a smart contract, it must implement
* {IERC721Receiver-onERC721Received}, which is called for each safe transfer.
* - `quantity` must be greater than 0.
*
* See {_mint}.
*
* Emits a {Transfer} event for each mint.
*/
function _safeMint(
address to,
uint256 quantity,
bytes memory _data
) internal virtual {
_mint(to, quantity);
unchecked {
if (to.code.length != 0) {
uint256 end = _currentIndex;
uint256 index = end - quantity;
do {
if (!_checkContractOnERC721Received(address(0), to, index++, _data)) {
revert TransferToNonERC721ReceiverImplementer();
}
} while (index < end);
// Reentrancy protection.
if (_currentIndex != end) revert();
}
}
}
/**
* @dev Equivalent to `_safeMint(to, quantity, '')`.
*/
function _safeMint(address to, uint256 quantity) internal virtual {
_safeMint(to, quantity, '');
}
// =============================================================
// BURN OPERATIONS
// =============================================================
/**
* @dev Equivalent to `_burn(tokenId, false)`.
*/
function _burn(uint256 tokenId) internal virtual {
_burn(tokenId, false);
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId, bool approvalCheck) internal virtual {
uint256 prevOwnershipPacked = _packedOwnershipOf(tokenId);
address from = address(uint160(prevOwnershipPacked));
(uint256 approvedAddressSlot, address approvedAddress) = _getApprovedSlotAndAddress(tokenId);
if (approvalCheck) {
// The nested ifs save around 20+ gas over a compound boolean condition.
if (!_isSenderApprovedOrOwner(approvedAddress, from, _msgSenderERC721A()))
if (!isApprovedForAll(from, _msgSenderERC721A())) revert TransferCallerNotOwnerNorApproved();
}
_beforeTokenTransfers(from, address(0), tokenId, 1);
// Clear approvals from the previous owner.
assembly {
if approvedAddress {
// This is equivalent to `delete _tokenApprovals[tokenId]`.
sstore(approvedAddressSlot, 0)
}
}
// Underflow of the sender's balance is impossible because we check for
// ownership above and the recipient's balance can't realistically overflow.
// Counter overflow is incredibly unrealistic as `tokenId` would have to be 2**256.
unchecked {
// Updates:
// - `balance -= 1`.
// - `numberBurned += 1`.
//
// We can directly decrement the balance, and increment the number burned.
// This is equivalent to `packed -= 1; packed += 1 << _BITPOS_NUMBER_BURNED;`.
_packedAddressData[from] += (1 << _BITPOS_NUMBER_BURNED) - 1;
// Updates:
// - `address` to the last owner.
// - `startTimestamp` to the timestamp of burning.
// - `burned` to `true`.
// - `nextInitialized` to `true`.
_packedOwnerships[tokenId] = _packOwnershipData(
from,
(_BITMASK_BURNED | _BITMASK_NEXT_INITIALIZED) | _nextExtraData(from, address(0), prevOwnershipPacked)
);
// If the next slot may not have been initialized (i.e. `nextInitialized == false`) .
if (prevOwnershipPacked & _BITMASK_NEXT_INITIALIZED == 0) {
uint256 nextTokenId = tokenId + 1;
// If the next slot's address is zero and not burned (i.e. packed value is zero).
if (_packedOwnerships[nextTokenId] == 0) {
// If the next slot is within bounds.
if (nextTokenId != _currentIndex) {
// Initialize the next slot to maintain correctness for `ownerOf(tokenId + 1)`.
_packedOwnerships[nextTokenId] = prevOwnershipPacked;
}
}
}
}
emit Transfer(from, address(0), tokenId);
_afterTokenTransfers(from, address(0), tokenId, 1);
// Overflow not possible, as _burnCounter cannot be exceed _currentIndex times.
unchecked {
_burnCounter++;
}
}
// =============================================================
// EXTRA DATA OPERATIONS
// =============================================================
/**
* @dev Directly sets the extra data for the ownership data `index`.
*/
function _setExtraDataAt(uint256 index, uint24 extraData) internal virtual {
uint256 packed = _packedOwnerships[index];
if (packed == 0) revert OwnershipNotInitializedForExtraData();
uint256 extraDataCasted;
// Cast `extraData` with assembly to avoid redundant masking.
assembly {
extraDataCasted := extraData
}
packed = (packed & _BITMASK_EXTRA_DATA_COMPLEMENT) | (extraDataCasted << _BITPOS_EXTRA_DATA);
_packedOwnerships[index] = packed;
}
/**
* @dev Called during each token transfer to set the 24bit `extraData` field.
* Intended to be overridden by the cosumer contract.
*
* `previousExtraData` - the value of `extraData` before transfer.
*
* 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, `tokenId` will be burned by `from`.
* - `from` and `to` are never both zero.
*/
function _extraData(
address from,
address to,
uint24 previousExtraData
) internal view virtual returns (uint24) {}
/**
* @dev Returns the next extra data for the packed ownership data.
* The returned result is shifted into position.
*/
function _nextExtraData(
address from,
address to,
uint256 prevOwnershipPacked
) private view returns (uint256) {
uint24 extraData = uint24(prevOwnershipPacked >> _BITPOS_EXTRA_DATA);
return uint256(_extraData(from, to, extraData)) << _BITPOS_EXTRA_DATA;
}
// =============================================================
// OTHER OPERATIONS
// =============================================================
/**
* @dev Returns the message sender (defaults to `msg.sender`).
*
* If you are writing GSN compatible contracts, you need to override this function.
*/
function _msgSenderERC721A() internal view virtual returns (address) {
return msg.sender;
}
/**
* @dev Converts a uint256 to its ASCII string decimal representation.
*/
function _toString(uint256 value) internal pure virtual returns (string memory ptr) {
assembly {
// The maximum value of a uint256 contains 78 digits (1 byte per digit),
// but we allocate 128 bytes to keep the free memory pointer 32-byte word aliged.
// We will need 1 32-byte word to store the length,
// and 3 32-byte words to store a maximum of 78 digits. Total: 32 + 3 * 32 = 128.
ptr := add(mload(0x40), 128)
// Update the free memory pointer to allocate.
mstore(0x40, ptr)
// Cache the end of the memory to calculate the length later.
let end := ptr
// We write the string from the rightmost digit to the leftmost digit.
// The following is essentially a do-while loop that also handles the zero case.
// Costs a bit more than early returning for the zero case,
// but cheaper in terms of deployment and overall runtime costs.
for {
// Initialize and perform the first pass without check.
let temp := value
// Move the pointer 1 byte leftwards to point to an empty character slot.
ptr := sub(ptr, 1)
// Write the character to the pointer.
// The ASCII index of the '0' character is 48.
mstore8(ptr, add(48, mod(temp, 10)))
temp := div(temp, 10)
} temp {
// Keep dividing `temp` until zero.
temp := div(temp, 10)
} {
// Body of the for loop.
ptr := sub(ptr, 1)
mstore8(ptr, add(48, mod(temp, 10)))
}
let length := sub(end, ptr)
// Move the pointer 32 bytes leftwards to make room for the length.
ptr := sub(ptr, 32)
// Store the length.
mstore(ptr, length)
}
}
}
// File: erc721a/contracts/extensions/IERC721AQueryable.sol
// ERC721A Contracts v4.2.0
// Creator: Chiru Labs
pragma solidity ^0.8.4;
/**
* @dev Interface of ERC721AQueryable.
*/
interface IERC721AQueryable is IERC721A {
/**
* Invalid query range (`start` >= `stop`).
*/
error InvalidQueryRange();
/**
* @dev Returns the `TokenOwnership` struct at `tokenId` without reverting.
*
* If the `tokenId` is out of bounds:
*
* - `addr = address(0)`
* - `startTimestamp = 0`
* - `burned = false`
* - `extraData = 0`
*
* If the `tokenId` is burned:
*
* - `addr = <Address of owner before token was burned>`
* - `startTimestamp = <Timestamp when token was burned>`
* - `burned = true`
* - `extraData = <Extra data when token was burned>`
*
* Otherwise:
*
* - `addr = <Address of owner>`
* - `startTimestamp = <Timestamp of start of ownership>`
* - `burned = false`
* - `extraData = <Extra data at start of ownership>`
*/
function explicitOwnershipOf(uint256 tokenId) external view returns (TokenOwnership memory);
/**
* @dev Returns an array of `TokenOwnership` structs at `tokenIds` in order.
* See {ERC721AQueryable-explicitOwnershipOf}
*/
function explicitOwnershipsOf(uint256[] memory tokenIds) external view returns (TokenOwnership[] memory);
/**
* @dev Returns an array of token IDs owned by `owner`,
* in the range [`start`, `stop`)
* (i.e. `start <= tokenId < stop`).
*
* This function allows for tokens to be queried if the collection
* grows too big for a single call of {ERC721AQueryable-tokensOfOwner}.
*
* Requirements:
*
* - `start < stop`
*/
function tokensOfOwnerIn(
address owner,
uint256 start,
uint256 stop
) external view returns (uint256[] memory);
/**
* @dev Returns an array of token IDs owned by `owner`.
*
* This function scans the ownership mapping and is O(`totalSupply`) in complexity.
* It is meant to be called off-chain.
*
* See {ERC721AQueryable-tokensOfOwnerIn} for splitting the scan into
* multiple smaller scans if the collection is large enough to cause
* an out-of-gas error (10K collections should be fine).
*/
function tokensOfOwner(address owner) external view returns (uint256[] memory);
}
// File: erc721a/contracts/extensions/ERC721AQueryable.sol
// ERC721A Contracts v4.2.0
// Creator: Chiru Labs
pragma solidity ^0.8.4;
/**
* @title ERC721AQueryable.
*
* @dev ERC721A subclass with convenience query functions.
*/
abstract contract ERC721AQueryable is ERC721A, IERC721AQueryable {
/**
* @dev Returns the `TokenOwnership` struct at `tokenId` without reverting.
*
* If the `tokenId` is out of bounds:
*
* - `addr = address(0)`
* - `startTimestamp = 0`
* - `burned = false`
* - `extraData = 0`
*
* If the `tokenId` is burned:
*
* - `addr = <Address of owner before token was burned>`
* - `startTimestamp = <Timestamp when token was burned>`
* - `burned = true`
* - `extraData = <Extra data when token was burned>`
*
* Otherwise:
*
* - `addr = <Address of owner>`
* - `startTimestamp = <Timestamp of start of ownership>`
* - `burned = false`
* - `extraData = <Extra data at start of ownership>`
*/
function explicitOwnershipOf(uint256 tokenId) public view virtual override returns (TokenOwnership memory) {
TokenOwnership memory ownership;
if (tokenId < _startTokenId() || tokenId >= _nextTokenId()) {
return ownership;
}
ownership = _ownershipAt(tokenId);
if (ownership.burned) {
return ownership;
}
return _ownershipOf(tokenId);
}
/**
* @dev Returns an array of `TokenOwnership` structs at `tokenIds` in order.
* See {ERC721AQueryable-explicitOwnershipOf}
*/
function explicitOwnershipsOf(uint256[] calldata tokenIds)
external
view
virtual
override
returns (TokenOwnership[] memory)
{
unchecked {
uint256 tokenIdsLength = tokenIds.length;
TokenOwnership[] memory ownerships = new TokenOwnership[](tokenIdsLength);
for (uint256 i; i != tokenIdsLength; ++i) {
ownerships[i] = explicitOwnershipOf(tokenIds[i]);
}
return ownerships;
}
}
/**
* @dev Returns an array of token IDs owned by `owner`,
* in the range [`start`, `stop`)
* (i.e. `start <= tokenId < stop`).
*
* This function allows for tokens to be queried if the collection
* grows too big for a single call of {ERC721AQueryable-tokensOfOwner}.
*
* Requirements:
*
* - `start < stop`
*/
function tokensOfOwnerIn(
address owner,
uint256 start,
uint256 stop
) external view virtual override returns (uint256[] memory) {
unchecked {
if (start >= stop) revert InvalidQueryRange();
uint256 tokenIdsIdx;
uint256 stopLimit = _nextTokenId();
// Set `start = max(start, _startTokenId())`.
if (start < _startTokenId()) {
start = _startTokenId();
}
// Set `stop = min(stop, stopLimit)`.
if (stop > stopLimit) {
stop = stopLimit;
}
uint256 tokenIdsMaxLength = balanceOf(owner);
// Set `tokenIdsMaxLength = min(balanceOf(owner), stop - start)`,
// to cater for cases where `balanceOf(owner)` is too big.
if (start < stop) {
uint256 rangeLength = stop - start;
if (rangeLength < tokenIdsMaxLength) {
tokenIdsMaxLength = rangeLength;
}
} else {
tokenIdsMaxLength = 0;
}
uint256[] memory tokenIds = new uint256[](tokenIdsMaxLength);
if (tokenIdsMaxLength == 0) {
return tokenIds;
}
// We need to call `explicitOwnershipOf(start)`,
// because the slot at `start` may not be initialized.
TokenOwnership memory ownership = explicitOwnershipOf(start);
address currOwnershipAddr;
// If the starting slot exists (i.e. not burned), initialize `currOwnershipAddr`.
// `ownership.address` will not be zero, as `start` is clamped to the valid token ID range.
if (!ownership.burned) {
currOwnershipAddr = ownership.addr;
}
for (uint256 i = start; i != stop && tokenIdsIdx != tokenIdsMaxLength; ++i) {
ownership = _ownershipAt(i);
if (ownership.burned) {
continue;
}
if (ownership.addr != address(0)) {
currOwnershipAddr = ownership.addr;
}
if (currOwnershipAddr == owner) {
tokenIds[tokenIdsIdx++] = i;
}
}
// Downsize the array to fit.
assembly {
mstore(tokenIds, tokenIdsIdx)
}
return tokenIds;
}
}
/**
* @dev Returns an array of token IDs owned by `owner`.
*
* This function scans the ownership mapping and is O(`totalSupply`) in complexity.
* It is meant to be called off-chain.
*
* See {ERC721AQueryable-tokensOfOwnerIn} for splitting the scan into
* multiple smaller scans if the collection is large enough to cause
* an out-of-gas error (10K collections should be fine).
*/
function tokensOfOwner(address owner) external view virtual override returns (uint256[] memory) {
unchecked {
uint256 tokenIdsIdx;
address currOwnershipAddr;
uint256 tokenIdsLength = balanceOf(owner);
uint256[] memory tokenIds = new uint256[](tokenIdsLength);
TokenOwnership memory ownership;
for (uint256 i = _startTokenId(); tokenIdsIdx != tokenIdsLength; ++i) {
ownership = _ownershipAt(i);
if (ownership.burned) {
continue;
}
if (ownership.addr != address(0)) {
currOwnershipAddr = ownership.addr;
}
if (currOwnershipAddr == owner) {
tokenIds[tokenIdsIdx++] = i;
}
}
return tokenIds;
}
}
}
// File: @openzeppelin/contracts/utils/Strings.sol
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Strings.sol)
pragma solidity ^0.8.0;
/**
* @dev String operations.
*/
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
// https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
/**
* @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
*/
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
}
// File: @openzeppelin/contracts/utils/math/Math.sol
// OpenZeppelin Contracts (last updated v4.7.0) (utils/math/Math.sol)
pragma solidity ^0.8.0;
/**
* @dev Standard math utilities missing in the Solidity language.
*/
library Math {
enum Rounding {
Down, // Toward negative infinity
Up, // Toward infinity
Zero // Toward zero
}
/**
* @dev Returns the largest of two numbers.
*/
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
/**
* @dev Returns the smallest of two numbers.
*/
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
/**
* @dev Returns the average of two numbers. The result is rounded towards
* zero.
*/
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow.
return (a & b) + (a ^ b) / 2;
}
/**
* @dev Returns the ceiling of the division of two numbers.
*
* This differs from standard division with `/` in that it rounds up instead
* of rounding down.
*/
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b - 1) / b can overflow on addition, so we distribute.
return a == 0 ? 0 : (a - 1) / b + 1;
}
/**
* @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
* @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
* with further edits by Uniswap Labs also under MIT license.
*/
function mulDiv(
uint256 x,
uint256 y,
uint256 denominator
) internal pure returns (uint256 result) {
unchecked {
// 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
// use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
// variables such that product = prod1 * 2^256 + prod0.
uint256 prod0; // Least significant 256 bits of the product
uint256 prod1; // Most significant 256 bits of the product
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
// Handle non-overflow cases, 256 by 256 division.
if (prod1 == 0) {
return prod0 / denominator;
}
// Make sure the result is less than 2^256. Also prevents denominator == 0.
require(denominator > prod1);
///////////////////////////////////////////////
// 512 by 256 division.
///////////////////////////////////////////////
// Make division exact by subtracting the remainder from [prod1 prod0].
uint256 remainder;
assembly {
// Compute remainder using mulmod.
remainder := mulmod(x, y, denominator)
// Subtract 256 bit number from 512 bit number.
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
// Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
// See https://cs.stackexchange.com/q/138556/92363.
// Does not overflow because the denominator cannot be zero at this stage in the function.
uint256 twos = denominator & (~denominator + 1);
assembly {
// Divide denominator by twos.
denominator := div(denominator, twos)
// Divide [prod1 prod0] by twos.
prod0 := div(prod0, twos)
// Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
twos := add(div(sub(0, twos), twos), 1)
}
// Shift in bits from prod1 into prod0.
prod0 |= prod1 * twos;
// Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
// that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
// four bits. That is, denominator * inv = 1 mod 2^4.
uint256 inverse = (3 * denominator) ^ 2;
// Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
// in modular arithmetic, doubling the correct bits in each step.
inverse *= 2 - denominator * inverse; // inverse mod 2^8
inverse *= 2 - denominator * inverse; // inverse mod 2^16
inverse *= 2 - denominator * inverse; // inverse mod 2^32
inverse *= 2 - denominator * inverse; // inverse mod 2^64
inverse *= 2 - denominator * inverse; // inverse mod 2^128
inverse *= 2 - denominator * inverse; // inverse mod 2^256
// Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
// This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
// less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
// is no longer required.
result = prod0 * inverse;
return result;
}
}
/**
* @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
*/
function mulDiv(
uint256 x,
uint256 y,
uint256 denominator,
Rounding rounding
) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
/**
* @dev Returns the square root of a number. It the number is not a perfect square, the value is rounded down.
*
* Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
*/
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
// For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
// We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
// `msb(a) <= a < 2*msb(a)`.
// We also know that `k`, the position of the most significant bit, is such that `msb(a) = 2**k`.
// This gives `2**k < a <= 2**(k+1)` → `2**(k/2) <= sqrt(a) < 2 ** (k/2+1)`.
// Using an algorithm similar to the msb conmputation, we are able to compute `result = 2**(k/2)` which is a
// good first aproximation of `sqrt(a)` with at least 1 correct bit.
uint256 result = 1;
uint256 x = a;
if (x >> 128 > 0) {
x >>= 128;
result <<= 64;
}
if (x >> 64 > 0) {
x >>= 64;
result <<= 32;
}
if (x >> 32 > 0) {
x >>= 32;
result <<= 16;
}
if (x >> 16 > 0) {
x >>= 16;
result <<= 8;
}
if (x >> 8 > 0) {
x >>= 8;
result <<= 4;
}
if (x >> 4 > 0) {
x >>= 4;
result <<= 2;
}
if (x >> 2 > 0) {
result <<= 1;
}
// At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
// since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
// every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
// into the expected uint128 result.
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
/**
* @notice Calculates sqrt(a), following the selected rounding direction.
*/
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
uint256 result = sqrt(a);
if (rounding == Rounding.Up && result * result < a) {
result += 1;
}
return result;
}
}
// File: @openzeppelin/contracts/utils/Arrays.sol
// OpenZeppelin Contracts v4.4.1 (utils/Arrays.sol)
pragma solidity ^0.8.0;
/**
* @dev Collection of functions related to array types.
*/
library Arrays {
/**
* @dev Searches a sorted `array` and returns the first index that contains
* a value greater or equal to `element`. If no such index exists (i.e. all
* values in the array are strictly less than `element`), the array length is
* returned. Time complexity O(log n).
*
* `array` is expected to be sorted in ascending order, and to contain no
* repeated elements.
*/
function findUpperBound(uint256[] storage array, uint256 element) internal view returns (uint256) {
if (array.length == 0) {
return 0;
}
uint256 low = 0;
uint256 high = array.length;
while (low < high) {
uint256 mid = Math.average(low, high);
// Note that mid will always be strictly less than high (i.e. it will be a valid array index)
// because Math.average rounds down (it does integer division with truncation).
if (array[mid] > element) {
high = mid;
} else {
low = mid + 1;
}
}
// At this point `low` is the exclusive upper bound. We will return the inclusive upper bound.
if (low > 0 && array[low - 1] == element) {
return low - 1;
} else {
return low;
}
}
}
// File: @openzeppelin/contracts/utils/Context.sol
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
pragma solidity ^0.8.0;
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
// File: @openzeppelin/contracts/access/Ownable.sol
// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)
pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
_transferOwnership(_msgSender());
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
_checkOwner();
_;
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
return _owner;
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
// File: @openzeppelin/contracts/security/ReentrancyGuard.sol
// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)
pragma solidity ^0.8.0;
/**
* @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 ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_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;
}
}
// File: contracts/SeaOfDeath.sol
pragma solidity >=0.8.13 <0.9.0;
contract SeaOfDeath is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
// ================== Variables Start =======================
string public uri;
string public uriSuffix = ".json";
string public hiddenMetadataUri;
uint256 public cost1 = 0 ether;
uint256 public cost2 = 0.005 ether;
uint256 public supplyLimitPhase1 = 333;
uint256 public supplyLimit = 999;
uint256 public maxMintAmountPerTxPhase1 = 2;
uint256 public maxMintAmountPerTxPhase2 = 3;
uint256 public maxLimitPerWallet = 50;
bool public sale = false;
bool public revealed = false;
bool public premintWhitelistMintStart = false;
address[] listOfWinners = [
0x081B7ca8b7c3c40ea4714391C99eB681568D3220,
0xd42DdA82a5f97665dEC9b916D135919Dc24EA54C,
0x786a3DEA728eE85553374f0D3395d0689065CDCd,
0xa163B3613A1F0c992Ad48C3E78a3Bff8356C2E70,
0x0f2FB4e32e814AE6918818a566CB138210709B96,
0x96Cb84ac416602cec04B6778fa3F8e588e84cc95,
0xE01Be86C5772766470826d60aFCb6E532933bcB0,
0xd2E5CcCDBA0b0DaA407bA5C68F32bbFeF810205F,
0x4e258cC6180E73A69Bb0Ce18621c8901AEd3B792,
0x05012f437dEe5276AC13eE90A10438468c07d6DF,
0xe54DEBc68b0676d8F800Aff820Dfe63E5C854091,
0x79588679927772104022a68b69A13bd107277c19,
0x926FB37146ADf8a5aAC139E142E3029F087d68e4,
0xE8d8B73CCC85dEd891ad41893Ebbb0d684350E04,
0x8D66A426743ffB9b9526fa2EDEC969194a0098b4,
0x6c4221Dcba114631469C74E203E81Cf737BFFC4a,
0xE436BeA44E9734220509E3d1fd501443eBFb2A7C,
0xaD256CF689fF3320C2718a7D253F4bAa0b255d96,
0x6839Fe55fb21f95bec22491921bDaB488a88f433,
0x9b2726AdCF67B20f98e6D34e80370CA25125A845,
0x15af04b6941Bd2e0746aCA5aD3062b61b2317CDe,
0x3499556fF9703fce8bA3F5aCF19EBd5Eb696AD08,
0xFed051fD5c6fc736fdE242E0E185b5E6F19E27BD,
0xB33fb83c645ac2a12b138636Fe59604312092484,
0x97DC3898a13ffFAA13aCFA198021ac7BE3F26644,
0xBC511e020Da7f0DC4866FeaD317F567EfE58f31E,
0x13bC3BDfe82f8d537981e937cee75d55B5211A9f,
0x74d5fC66CF60Ab20c201489D0fE460cB249fE4B0,
0xdE418a36044ea674cc8B29F0C4CF7134858BDb55,
0x070ff394Dd0eC7AB325697fD12bEe1C7ad8af831,
0xAdd03DCeC81e69D562B501446f463B5654716eF1,
0xa6de7f094d426485f1A3c8c7213f3cd856A0277c,
0x5Ee5CB77B6f175952F7307d3d37129E8aB2A23B6,
0xd8f67baEDd64c64De33491c8558c789c3cCFE13E,
0xdA599dEDef2D8C00c01Cd047BBbEDc7399ad5908,
0x79A40758a2b7158DbcAFfAD2c19E8dF0dC85b1CF,
0xBBf343E932de68eFaaf6661D050C9644Ff1EB989,
0x7b2e34038d9706ce488222748f21BC49409c5aC7,
0xFDf1BCF892BAf2DDAA4fcF1a9657460f350823B4,
0x3CB57E3cF8248079AcAe4c5fa813a3470A11f033,
0xCB5c8E5d6fC11a3908A6f8e74D2fd32f55cA0a60,
0x092AC7F06be7e2a4Dd1Bc49D0F6F44a08CAC12f1,
0xc2C8595Dcd17cf0a867013A99DcEB7AC69f659a2,
0x9570c949658Ead91601D34DD2023a82dcbe51434,
0x0e8A9777820Ad4E62fa2688a4842e5bED2e9F00d,
0x3f0fd50BCFf02652249a386e208A46aB9d1Fb3e2,
0xdBCa4af2C6453D591C4AB183B07D3Fa7d1894734,
0x85198ff297782130CC4691B226B284e0D8d5c996,
0x8F387E020c8c972555c8c91464a9AeB6E2ad61FF,
0x54479691301bff7e537982E7566FD14465a0c1F2,
0x3beD7992aC45d31BBCD37d2fD793e2229dDD16aa,
0x9C9f298a86bB0FDd18B3e1f4F86a5f088f514388,
0x8Fe6220b640Dc34280e9df66e290640C1D41216B,
0x4945C459877532Aa28d3aBC3C41983Ac15202ffB,
0x876D3E4Deb5913ad187745cA0328BD7AA57Ba51D,
0xCbBa613Aa7EF42aF5ACA28616a8F89b7FB2dbb07,
0xfeC73CE9F20aEE37cC462A9b99374d912701cf88,
0xa72781a88D5cB4cAa1bA7cDF7Bd3bCE78212D6fF,
0x55a99Ed2773cdF0470C6016d2B3F3aDDAF9Fe551,
0xb50824951D9617B63299749B466322132b913eCE,
0xB34b5462f06D0B2b40dEf2B3344F3355D80CeFBf,
0xA6BFa697507Fc675380cD2a044767b194Cd8189B,
0x0b03A7F0182720639cC4F6fD25bf8E51e543f0B7,
0xF672A5EC6437c2160cE82B7E308BFb3B4a559946,
0x87a5Ee283e602718957fDC1A4A60F1cD290500Ea,
0x9ea3FFcC40E725Da125161161B9573bFEb70c715,
0xAE25BefaDF944a40ceaa987b23b001cCe60EAc61,
0x5986F558b3Ba300d015Fce96655d2325A307A639,
0x370f36866FE8fA2BA0c3b7c431Ed4a0Df62B83d3,
0x89f23BddcB1f6B4D86639fd2B5210132c29E6692,
0x09D611629B0F03A2d8f73C15BF25EF7D288C74e3,
0xbB524F1c9DDE9D1249e21E4a3afFE8134414ECC7,
0xBCAEDC579A3a9624e5E5029efD099470FEE5C54f,
0x1eE300b0600821E0Fd808A872494339C80247d12,
0xDea98753460120DFF3D6d2629C150cf2e7aF82B8,
0x6329d4a63E9C698EB295351de3f9E0A9C6791775,
0x04c940134551598dc8831991dAC824079A2De5e7,
0x86a2F6EAc13b420fc5E8227e02d9dB076d03cD58,
0xad5e2495732e05b36Bb51c8A44F72C2Fc7eA6733,
0xbeFde548e5387BeDDCEE1EF35CA63c801339a2e4,
0x3C36f8DBec7B5e74C1de617133c718C071C22a1e,
0x194d8C8da18A56b4E63fD14D78D7b38b090900CC,
0x60d3FD0f6725C06Bf957915a55CCFa8fDDc8353b,
0x41Ba91DfB59941Ea0Cd1B8B69A2784f9132A32AE,
0x0130C4c5873DF818F2bC21B7fD6e03d4C72dDE8D,
0xddcfAb22098E569890FFCb9C9365B94836AE76d4,
0xdC13aa59A30DF7903Cb357D9C18B6133F3E0f8e8,
0x69744aBdd85dA19fb9aBDaE6225BB5422e4DFca6,
0xf0b32dF3d07b78bA1F1Bb79D81896fBdD7E56567,
0xd5Ea6dA94a71b52247287dbD985ee3aFfeE40AE5,
0x1bB2821d4c58ED5Aa2e1694cfB704d6c7a9A5711,
0x42E0ed786840C219Be223769113AcECD96c2d6eF,
0x64F2c0d99e10073057b5A0366dBA107FA6ae8C08,
0xa57961970eA7beDC36EE143d1885560745A33369,
0xb2A968029778E7c68c30A4A16F97F5805dD7D28F,
0x24CAd7ED3cf32E26a9577A87CEb5130f20BF6582,
0x621d35D4232FCDf25eB410c4E797e5466001b214,
0x83bf1f446F2D92f971B927d71820A6625702CCEC,
0x31eea5bd4a81fD29fAADd45aD9f5E0AB57bF354b,
0x503B4327D0cd6f0bd0E411D8Bc80Ad2bD7e69573,
0xF50f5b30cCD3e62A6D9f6b572D4CF0987404Df43,
0x170a74Bf5f403503b6e5a63e991Fa0797268F74D,
0x5a3DdA91F2c5B41487ad5FD323A83A7157C4F195,
0xA5Ab1d69B3519C02aC5bBB4F5958892568695Ea2,
0xB2e9991E55468278998e4A710A69A004994A019c,
0x93eee2C44B4bd1AA1a8D29cB3Ad9702c919EF092,
0x473e979C93CA7E0581A8873dd94f2dCd7fdfCC97,
0x77098B72b69E84996C093Adb8b770f3743a4Af10,
0xbeB31411F94701D4D090E0B79c7CcE1EEf8c189D,
0x24b6E47c006ad7b58f4cd89d6795B979577d6D19,
0x9E0Cd36105c6796b2d8485fC0F46D8266D093346,
0x398DDBb1c7f7602B4075c3B29139A6Efcbd0eE82,
0x01003A0a8418ef6fC76b0C0Fc4F6639536dB6A25,
0x37E4ED75363607584c3e0A45DaA5bdB2423679d5,
0x743e3D7D88afe26eeD0C5ac7EBFCAfDec6A5f09e,
0x94a435e8eF2136f694c829f2f354c8Ef8a2635CE,
0xe25b0E4E024F87D7e55Be961b5eb6a8C1619Bfc8,
0xBf98386D2f2B2dEc8E0399a164Fe3a6cFF14A2c6,
0xB73B3b20bDbe9c8a9eB46488303828E2095F9696,
0xf53D2a27FF7DA3f60F6a41Cdcb7acB0eBCc8c094,
0x585bD8fa4BF549d51Ee91Bd21e5cB9713A50bAFD,
0x78f162AD81261a1F8b551478611A2f27CD8F972b,
0xa09B151af7d9aF6753044a0B0feA57a7e6C9A108,
0x9B761352490C13cDA86c6aFe7fAE1974F60DF6D7,
0xc64202e2B512c72c3e145776A7B556457075Fe9F,
0x038Dc61d976Ca0875B8Be0E0260e456780260D45,
0x9EF8286006D73A5d687eE10675BD84853a406f4c,
0x50475AA02F78E4f9500b29b52eaE8D112d6157B8,
0xF023A7D4a47CE0858F2883797B8158A02d8f263d,
0x567a0621560624D00a5FC22fEf4c5706389Ab6A3,
0x7f78Ab8bfe25eDCF957ee0fFc620D397e34fD90E,
0x63CD59D81013a1D04E53CDa13065e3124AFB740f,
0xa51Ed51CC874696d3b0A6Ec8BE9EAc25e65F6aE4,
0x3492606E68208B40C96f2F5771EcCF6e49239241,
0xf583c3292f895384E428e70C404Dcc061f8e4924,
0xC841D6DdF66467Af551b35218c0c2e22f9C14b48,
0xB2edFdABCa043DdBD794a0dA76aA4E05c104c6C9,
0x828d70C702ba4D217f333d7f2Cb6A7C768285EA1,
0x731fD2Bf0B4add511A6559ac2dB7FfC18A9AD13A,
0x6E9788Fb2C864c1D91a88630aEdC380CF1C3f2bA,
0xD3867aB38CD62698103dF0c599103E6704FBFC36,
0x47E91F47701aB4279f4259B3d9d0d7D298a07799,
0x410A4823FFE7778D68c1ef11111183eCeA5e9D1e,
0x270e146C6c3c1c8bbBbBbCf2ee38dc915f0F5F35,
0xbFa5228a55D97489a70E5C58639f3cfa327A1901,
0x96BB20Cb30348dD792f0Ac896C23F5B191b5413c,
0xE19b23DbaF2dC2a3b930F1e30BD94B0f96fb08B5,
0x31E07Cab07614A3433A1B974f29F82a29D6E7b5f,
0xc4D0599F107733Bd5c3826aD51363Fe5e1aFca63,
0x74Aa252a1C97777776702D8a6c30de4Ec0E3c772,
0x5555551Fb60055187f8d08E3521d8A6EB534b0b4,
0x1C6E89600fF6e38DB6Be514F57f6ccCCcCF5AECb,
0x58232E884183547Afde1E3444444732a26fc5A24,
0xD784ba50E4AdfF8131D9701b484f45F3Ac99F44f,
0x846A38EeEeEeBD6F3Ca56eEAd39eE2f5b014f735,
0x4693580EcF019478dd6Da3852484DC4dA999999D,
0x6f8401DB41a046b6092C09D88B53C59b679e0Fa1,
0x1854889597E3852915e3df039E5b2977777756fD,
0x84a56448d3796b0553f863b7Bf41C2FE4a5b7338,
0x110a335E20C3b709Bbc79d7DDDdDDCb1f3291412,
0xF15332DDBaAE1f19AEEEc29dbb9Ecd4635Cc355a,
0x58e71a9395712154f2335AC42e38C0bCf4F0e5dB,
0x9B9fF8E92F29B357fD3A547c613877896C86643A,
0x689E58174bC8c0296D478EB845b7Bb7b5591287b,
0xC59f16bADb449774D1E2A22222264e0a1dc05414,
0x3a0B264b2EfAA7dFb8c067Ab3548443f77405D13,
0x2B22222214E5E899EE0aAfD72F10758a98C4b76c,
0xF06a157428BbF83258f1A23e0C60d5e5E6289914,
0x088e43b0201A1ebFE6EFDf451BDd9ed94cCCe68A,
0x853235C3532853E6C0078AC189Ee13A16c7E8D78,
0x62a57e00753cEc36C5743A962e38234870a67344,
0x3eE199e15613e82A0BcC355C2db7EeC2461932DB,
0xf85D5334E80Cf8F2e20a54e35d2d67cE90Cf7E4D,
0xc2d9d549419c67bed7448d7881E4d8A86Ce25Ab9,
0x393D26457C05AAb402465B0C6bC78fde5fFFFfFa,
0x861f465b79A3991CB59F75D409E2f35fea027cbB,
0x7FdF2C4D0277918719fd13b7E537c4a698d2937b,
0x26B7728BEBA00dd63CCD7dbe1FFf0cc8e3357f7B,
0x3366d64bbe6337be3000000a006D75d3e6386C1D,
0x56Ba7233CCE2AaF5A07f3bf240dC8c33f3Cae370,
0xeF6b46ca995283bCC833d0374C3bE21d3B8Cfc69,
0x4cE48A85180213eEF480AE4c517Cb388e399e180,
0x50cDCcA81dE6Aa60A3525b2b5cD55c6317FCF8FD,
0x10C9cE013258ad8827f69A018d825d3B3ddAe89A,
0xc8e022a0f3781fFd3571C5458ce2EEe7a5973409,
0xB052608E4ed4d40C5fcF6BC1E8aE3249376eb6aE,
0x2718e4e21A33D0A0afE740AC731350F5FE914039,
0x5F4bC750432d6EEf261da9C9441c92008fdCcDDF,
0x0Cd7c4fC8930AafC0BC2Ed5Bde525e2ec49f8301,
0x53201FF143AA386449eD2951C91AF2B303512365,
0x98fa3b538fd691Ed727A9493A47F3C74500E1A37,
0x1A6aFb8b5853eEBC9B71c3aE321d1783eB05B187,
0x4F6D14105d9E2cb008e40CA8e790e1920C1684E1,
0xf0c94716e26A46871B109BaB780134CEd87672fb,
0xDf35Bc82294576fD8E21DE2522EFAcC87E05dEd2,
0x36C481F3f9d9a54B180cB65046Cf0552A6ef2Fdd,
0xDa6fd6e857B669F8Df0D75Ea8Cfe7ee5791cbbaF,
0x6adfb36596F3C0eF59B358D89466180d3f9a56c6,
0x5819038F8076982a8F8BbeA4e4Fa260D43041D55,
0x0CdcaB04859f111f60b3FcD0cAB3abf07fBaeE5A,
0x9DE6ffDbF9af29b77983b8341458F0d54C5e8Dbc,
0x9ca66e21C54E4646892Da5f3A106812d5956eE0c,
0xf726211b9198E1f0C9d3261b362A9FA6256Fc0b9,
0x2bde0f20028fFAd066c5fd596D8e4382b480741D,
0xB9b92EFB979b12EE47b18f81BC9C8F4B851D99c3,
0xFC33f01b2aBdc9C4f594c51f508233e993C35c44,
0x45A4ad3D6C9cBBe6AdCA0D44c440c95F8F519312,
0xbb7B5569B0aCEC9907177A9E374Ee1600f7920e2,
0x75D53B57B0DBe901EA49a409Ecbe73362378aA27,
0x99d7f76834E514e1F24957a2c88e911100088859,
0x50D08C48ECCdF9D2fFca8469a3cE4a53488dF2Ca,
0x1BaF16c71Acdc044bD7B6E5805D93A8b2bE90E78,
0x19e4BE273cd231A1a9FB8a3D263A463dfeCCc154,
0x3A1394284c30b5c7e2883E261430bCDE789ffE8a,
0x879fFDc9CAaB6E381d5CDFF8A0F51C10d021141E,
0x9cF6c837011d7049fEe6beda1Ca9B4E1e73d2418,
0x68A80F974C1cd147119Aa685B241b75e93De464b,
0x60B6598823659f6Cd452aeAFA937cD0Fcc38C74c,
0xF1F785207c7E9A390E0d06982d187c33a8E491f4,
0x82d4Cb8f910c0959f4e92383d8C1866ecD49E82E,
0xBaE973407Ac9D4D69dcCb1A911167Eae81fb9dA7,
0x2E5e729ce539D844c0C5ED1422597ce474f59f86,
0xc2fC12b8D8D1Cd5DCbEa66F7e7117d66747514BF,
0x55DB8A1CF90a0D794ff6c4a2aDd9D4b57cFeDEb8,
0xF78A666f8392A7D58c9a3a4EAff72E6E8F44665D,
0xb70EA32146f02716901C06Dba08059a468556BC7,
0x34a87d71E1c15F6039B8Cf25eEe1B062A8D35a3b,
0x9E54852E223C9B62c214c78703885ff90f409056,
0xD8C6b15D231cCA6Da6c515Da8193401979c10ECD,
0x28E64c750B6377F6c62e107780A77202d646C651,
0x297883e3c8f66B7C066442e106371390373ed7b2,
0xB13995C33a9b7419F3cE5D55A9464d41594A3d52,
0xebfC761E3e59C0a8787952b31E6E3c6e76f6D5E3,
0x5ad356e2E5eD9b6Ea469c994d55C3d28D2AD19C0,
0xB56152393f3b4F89fE79ae9CF4D6349FcA448965,
0xfD4902931b74511fEEf8c1Da99F0B5f091a1bFd1,
0x04FdE1cE000129649601bBbd7cBc69912F36ceDb,
0x5d0553bCbc5079FCf044115f37Ef19221772e64E,
0x37e4BB1C173e916b20a74BC312F9A52f88929c5E,
0x3553F5332A5e6207853cbe337A371C350D51f08B,
0x6E8511187Aeb191202741Ff0D2A58A3c174a152d,
0x3587c832E55c8ee5e69f5cff571291d8FfD4e6C6,
0x94ccAF31cE417a5680DeD3C66B542a73AD72E2e5,
0xF9058647918C25076281Ff811529612b13866C69,
0xcb031C306800283FD29aB7912c5E8F11BB9683B8,
0xe004fdb6243Aad09606f15A6B5DF45B84ba11a62,
0xf9A26bF20B7EC5ca5602a859a116413bA4ab8CEc,
0x9b329bdDD11dBa3f7b55444F75D62Fd75E5aEB46,
0x0601DF2b94298DE8a8C01bE806A33154b0584353,
0x9847020a14F6D8Db8c6cdC38311855C7Dc5d0229,
0xE2a9799aF8E06697dAb29e6179f5699A395c2050,
0x07E9cB365e6450500a24Da2E2BAB57C829B9310e,
0x157d605D32109983D2d4D901CBDDD885Fd450229,
0xf97866c22Cfad8E0A3F03cc63a43E459AF520380,
0x0D4E5CB9ff6833E6210154895d19FbD99d832b6a,
0x0055DFA1b22F51B6a87C172d6358765D75a9D22D,
0x657fD473B4e4512ff7C7f4ed495e03E519cF33f7,
0x1cDDcD54D41d45dA496b2c74D3E606BB876EA54E,
0x4031aD85104Def177E04fe1345107B5744D41e6A,
0x240032712B08dC0a4d9D36a058Be58006bac9626,
0xaDBf429175A2D0DCcfbb8aEc631Ae667514BBCf4,
0xA87BfA4A0e762117C71E578C8421486b56B99cf1,
0x99684de2b233144E712D93C26fc7ED87A97B640e,
0x3e07f239EE3E62E1D0109f84CC15071367945C09,
0x57b170063d7C20BEE94Aec0dbcF38Cd84b59d33F,
0x95eccc6d3a93302C95372CAA86487D7015EC4465,
0x082341E8d89E81B733F4B2E69639Ea3837A51629,
0xc3E78B0Ce31Ffb1De38889C1685E6C42cE444419,
0x05265c4695e895177365d9AdCc291eD8ee6cfFbE,
0x153724C8b26D408c7e1E676F9A54DE5Bda577ee2,
0xE44d051440884d16f1Bf54F91897d4b826320AEe,
0x1D65fe919F3e203bA115Af56FFf48f62BCB93A9E,
0x483daBf9066EEC3b7F6AddbE4Db2d04b833A81cF,
0x116A5Ed06D4F895cC51e3d3F2E84Dc0eA2855b13,
0xF7842637593EBFF439605E48f913B92D96Be8f46,
0xcCC7FA6C26c6cc7712bA86ebCd44F491AE608b29,
0x40E7c58744946Ba22baf44634494dbb821680d08,
0x249686E9A37A89E3b857c5E950d1426ee6B5a771,
0x9B784e56EA6b10AF338Fba2d830229f29DcEEc0E,
0xb3F04a2254Ee059b7B98C99147cA44894d65D567,
0x6Da94DDb9BF8D174E13c29Ea815493f1BA99c437,
0xDC8926DAA265E0D37714d4676b2d8bA317aDAc91,
0xA0486CE8b1B1cC4e0eB7db0e423eA725bbAd5940,
0x8fFBFb1A9796F42900a15E82CA239b395b167D3E,
0x25f8f0Db800E6F86444a82Cf2EC10Bbd1e2aa098,
0x470cAc5D6f56ca1d0489B73D9031A61b734a5ff4,
0xa0031483A121ce09b89Cc35395955D89E3B76890,
0x368269f39270991F7260F1791A18b1391ffBd426,
0x51223a9b646ed8946EBB89Cc1398cAb13F735F31,
0xad88F0E7a05fc382a10E2eE29926f67a3f22AaA8,
0xa28C8d0D585d639d0aaD97A3c68deB7491ac3371,
0x79827EDF6E1Fe43aE880031fEB6E07fF67D9259e,
0xF53c7D08B936CB11CA560a08e455878F757D09EB,
0xF532E41e460aB418001D96AEF87987315fFb8057,
0xa475f011670230D85326b4A70Ac4D0c9e254BB62,
0x83e64BB9FEc2C66c587499ED9799360f12878e4a,
0xb50E7037bC19003E143AE5D153Df7De2f6B17FCf,
0x634f9401D5BdbCD60e58E9Db36A555B6d0A96D15,
0x0054FCDdB5bd94820458a30B7d61736373FD8fd7,
0x42344B3c41Ad6a26dE77b8F5FbDE9f2717360042,
0xb64FcF7C489C02B04cee40Ec1d0109BF429522cd,
0x0Ec1C4761838024998baa8393230eE2C7F047Dd2,
0x8Ec42955575A315658a377c88C236208F89D90c1,
0x4359086993cb8C80E801609702229Fd54f59C213,
0x89720F97689c0990811c1618e9C7e2f1A521cF93,
0xaD5F93856F44e3226D12B544A14298D1411aA73C,
0xA0741e4cF4bA2b9b354C544C32486c3701948668,
0x3b0e40b06d3F54A7e0a20dE24CE70fEa4c32C7f0,
0x920fFa02A2591948209D438ea2ADA4999437C9BD,
0x7074E52d34B62532954DB3546e8C887c5752D7e5,
0x31F661Ac3444b8fd52d1556204ee5eC93290767c,
0x9D4969691D5e7d375478B01F4578F9C6373e2a2b,
0xf454056640C32b8314846D8979A1Baf29ee6b282,
0x6861521a99795D035b863510aBdD0E711EBd0eCF,
0xb50FE79B6514Ba1c80D715B0ba4b1eBe90Ae9f34,
0xA8075De3768a2130FeD82F7Da6A38D62dFE5Db5F,
0x4562c9F5C1bC298FFd6Db4E53afb9d0dE9a5c7E1,
0xEcD1A67Be61600cb566eE9D89c054268e071a008,
0xD3a426D3E1ddB5bb1dbDfA9D409132c036bCCdDD,
0x4EBb83dCC321643fC4202Bd19EAff6A520282A65,
0x39f353F61864294Dd73996B530a3412B70681a62,
0x64FC8C50d3Ae974Bf9a32AFb7232AE96bCFBb35B,
0x68466E28973443B24253176648551565b425097F,
0x9F4760E3FfeE4c9668c2E757afEEDD28Caa5A463,
0x650665CFE3A4bF0fb2C56c62527Ecd856c3D7A23,
0x3eb984D80DebB53E26cE77a657eE57F023253a3c,
0x9AB4b0Bf942951C984121d5b6c794D3A7bA0E940,
0xdA76bED16c1c6512Eef73058EF5077Ed516d0aA4,
0x162faCe144ed067ac235EEe9d8330083a0bD5bf3,
0xb8c9aab2BE204f85018BF24CE2Ca720AC97da9d7,
0xACdb6eacd46Ef45289CE20Ad34678521b75aEa00,
0xaB64d0aB88aF8E5fE086FfaBe418C1aAc8628DaD,
0xFf2E1B7dA311C254b8E8E374d271700B4686Fc5A
];
// ================== Variables End =======================
// ================== Constructor Start =======================
constructor(
string memory _uri,
string memory _hiddenMetadataUri
) ERC721A("Sea Of Death", "SODNFT") {
seturi(_uri);
setHiddenMetadataUri(_hiddenMetadataUri);
}
// ================== Mint Functions Start =======================
function UpdateCost(uint256 _mintAmount) internal view returns (uint256 _cost) {
if (balanceOf(msg.sender) + _mintAmount <= maxMintAmountPerTxPhase1 && totalSupply() < supplyLimitPhase1) {
return cost1;
}
if (balanceOf(msg.sender) + _mintAmount <= supplyLimit){
return cost2;
}
}
function Mint(uint256 _mintAmount) public payable {
// Normal requirements
require(sale, 'The Sale is paused!');
require(_mintAmount > 0 && _mintAmount <= maxMintAmountPerTxPhase2, 'Invalid mint amount!');
require(totalSupply() + _mintAmount <= supplyLimit, 'Max supply exceeded!');
require(balanceOf(msg.sender) + _mintAmount <= maxLimitPerWallet, 'Max mint per wallet exceeded!');
require(msg.value >= UpdateCost(_mintAmount) * _mintAmount, 'Insufficient funds!');
_safeMint(_msgSender(), _mintAmount);
}
function Airdrop(uint256 _mintAmount, address _receiver) public onlyOwner {
require(totalSupply() + _mintAmount <= supplyLimit, 'Max supply exceeded!');
_safeMint(_receiver, _mintAmount);
}
function setRevealed(bool _state) public onlyOwner {
revealed = _state;
}
function seturi(string memory _uri) public onlyOwner {
uri = _uri;
}
function setHiddenMetadataUri(string memory _hiddenMetadataUri) public onlyOwner {
hiddenMetadataUri = _hiddenMetadataUri;
}
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
uriSuffix = _uriSuffix;
}
function setSaleStatus(bool _sale) public onlyOwner {
sale = _sale;
}
function setMaxMintAmountPerTxPhase1(uint256 _maxMintAmountPerTxPhase1) public onlyOwner {
maxMintAmountPerTxPhase1 = _maxMintAmountPerTxPhase1;
}
function setMaxMintAmountPerTxPhase2(uint256 _maxMintAmountPerTxPhase2) public onlyOwner {
maxMintAmountPerTxPhase2 = _maxMintAmountPerTxPhase2;
}
function setmaxLimitPerWallet(uint256 _maxLimitPerWallet) public onlyOwner {
maxLimitPerWallet = _maxLimitPerWallet;
}
function setPremintSaleStatus(bool _premintWhitelistMintStart) public onlyOwner {
premintWhitelistMintStart = _premintWhitelistMintStart;
}
function setcost1(uint256 _cost1) public onlyOwner {
cost1 = _cost1;
}
function setcost2(uint256 _cost2) public onlyOwner {
cost2 = _cost2;
}
function setsupplyLimit(uint256 _supplyLimit) public onlyOwner {
supplyLimit = _supplyLimit;
}
function withdraw() public onlyOwner {
(bool hs, ) = payable(0x281E6045A66A005658b842a29B5941f9C24a4702).call{value: address(this).balance * 15 / 100}("");
require(hs);
(bool os, ) = payable(owner()).call{value: address(this).balance}("");
require(os);
}
function price(uint256 _mintAmount) public view returns (uint256){
if (balanceOf(msg.sender) + _mintAmount <= maxMintAmountPerTxPhase1 && totalSupply() <supplyLimitPhase1) {
return cost1;
}
if (balanceOf(msg.sender) + _mintAmount <= supplyLimit && totalSupply() < supplyLimit){
return cost2;
}
return cost2;
}
function tokensOfOwner(address owner) external view returns (uint256[] memory) {
unchecked {
uint256[] memory a = new uint256[](balanceOf(owner));
uint256 end = _nextTokenId();
uint256 tokenIdsIdx;
address currOwnershipAddr;
for (uint256 i; i < end; i++) {
TokenOwnership memory ownership = _ownershipAt(i);
if (ownership.burned) {
continue;
}
if (ownership.addr != address(0)) {
currOwnershipAddr = ownership.addr;
}
if (currOwnershipAddr == owner) {
a[tokenIdsIdx++] = i;
}
}
return a;
}
}
function _startTokenId() internal view virtual override returns (uint256) {
return 1;
}
function tokenURI(uint256 _tokenId) public view virtual override returns (string memory) {
require(_exists(_tokenId), 'ERC721Metadata: URI query for nonexistent token');
if (revealed == false) {
return hiddenMetadataUri;
}
string memory currentBaseURI = _baseURI();
return bytes(currentBaseURI).length > 0
? string(abi.encodePacked(currentBaseURI, _tokenId.toString(), uriSuffix))
: '';
}
function _baseURI() internal view virtual override returns (string memory) {
return uri;
}
}