File 1 of 1: PocketWithLove.sol
pragma solidity ^0.8.20;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
function safeTransferFrom(address from, address to, uint256 tokenId) external;
function transferFrom(address from, address to, uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function setApprovalForAll(address operator, bool approved) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function isApprovedForAll(address owner, address operator) external view returns (bool);
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
interface IERC721A is IERC721, IERC721Metadata {
error ApprovalCallerNotOwnerNorApproved();
error ApprovalQueryForNonexistentToken();
error ApproveToCaller();
error ApprovalToCurrentOwner();
error BalanceQueryForZeroAddress();
error MintToZeroAddress();
error MintZeroQuantity();
error OwnerQueryForNonexistentToken();
error TransferCallerNotOwnerNorApproved();
error TransferFromIncorrectOwner();
error TransferToNonERC721ReceiverImplementer();
error TransferToZeroAddress();
error URIQueryForNonexistentToken();
struct TokenOwnership {
address addr;
uint64 startTimestamp;
bool burned;
}
struct AddressData {
uint64 balance;
uint64 numberMinted;
uint64 numberBurned;
uint64 aux;
}
function totalSupply() external view returns (uint256);
}
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
library Address {
function isContract(address account) internal view returns (bool) {
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
library Math {
enum Rounding {
Down,
Up,
Zero
}
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
return (a & b) + (a ^ b) / 2;
}
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
return a == 0 ? 0 : (a - 1) / b + 1;
}
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
uint256 prod0;
uint256 prod1;
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
if (prod1 == 0) {
return prod0 / denominator;
}
require(denominator > prod1, "Math: mulDiv overflow");
uint256 remainder;
assembly {
remainder := mulmod(x, y, denominator)
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
uint256 twos = denominator & (~denominator + 1);
assembly {
denominator := div(denominator, twos)
prod0 := div(prod0, twos)
twos := add(div(sub(0, twos), twos), 1)
}
prod0 |= prod1 * twos;
uint256 inverse = (3 * denominator) ^ 2;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
result = prod0 * inverse;
return result;
}
}
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;
}
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 result = 1 << (log2(a) >> 1);
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);
}
}
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
}
}
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
}
}
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10 ** 64) {
value /= 10 ** 64;
result += 64;
}
if (value >= 10 ** 32) {
value /= 10 ** 32;
result += 32;
}
if (value >= 10 ** 16) {
value /= 10 ** 16;
result += 16;
}
if (value >= 10 ** 8) {
value /= 10 ** 8;
result += 8;
}
if (value >= 10 ** 4) {
value /= 10 ** 4;
result += 4;
}
if (value >= 10 ** 2) {
value /= 10 ** 2;
result += 2;
}
if (value >= 10 ** 1) {
result += 1;
}
}
return result;
}
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
}
}
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
}
}
}
library SignedMath {
function max(int256 a, int256 b) internal pure returns (int256) {
return a > b ? a : b;
}
function min(int256 a, int256 b) internal pure returns (int256) {
return a < b ? a : b;
}
function average(int256 a, int256 b) internal pure returns (int256) {
int256 x = (a & b) + ((a ^ b) >> 1);
return x + (int256(uint256(x) >> 255) & (a ^ b));
}
function abs(int256 n) internal pure returns (uint256) {
unchecked {
return uint256(n >= 0 ? n : -n);
}
}
}
library Strings {
bytes16 private constant _SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
function toString(uint256 value) internal pure returns (string memory) {
unchecked {
uint256 length = Math.log10(value) + 1;
string memory buffer = new string(length);
uint256 ptr;
assembly {
ptr := add(buffer, add(32, length))
}
while (true) {
ptr--;
assembly {
mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
}
value /= 10;
if (value == 0) break;
}
return buffer;
}
}
function toString(int256 value) internal pure returns (string memory) {
return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value))));
}
function toHexString(uint256 value) internal pure returns (string memory) {
unchecked {
return toHexString(value, Math.log256(value) + 1);
}
}
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] = _SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
function equal(string memory a, string memory b) internal pure returns (bool) {
return keccak256(bytes(a)) == keccak256(bytes(b));
}
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
contract ERC721A is Context, ERC165, IERC721A {
using Address for address;
using Strings for uint256;
uint256 internal _currentIndex;
uint256 internal _burnCounter;
string private _name;
string private _symbol;
mapping(uint256 => TokenOwnership) internal _ownerships;
mapping(address => AddressData) private _addressData;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
_currentIndex = _startTokenId();
}
function _startTokenId() internal view virtual returns (uint256) {
return 0;
}
function totalSupply() public view override returns (uint256) {
unchecked {
return _currentIndex - _burnCounter - _startTokenId();
}
}
function _totalMinted() internal view returns (uint256) {
unchecked {
return _currentIndex - _startTokenId();
}
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
function balanceOf(address owner) public view override returns (uint256) {
if (owner == address(0)) revert BalanceQueryForZeroAddress();
return uint256(_addressData[owner].balance);
}
function _numberMinted(address owner) internal view returns (uint256) {
return uint256(_addressData[owner].numberMinted);
}
function _numberBurned(address owner) internal view returns (uint256) {
return uint256(_addressData[owner].numberBurned);
}
function _getAux(address owner) internal view returns (uint64) {
return _addressData[owner].aux;
}
function _setAux(address owner, uint64 aux) internal {
_addressData[owner].aux = aux;
}
function _ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
uint256 curr = tokenId;
unchecked {
if (_startTokenId() <= curr) if (curr < _currentIndex) {
TokenOwnership memory ownership = _ownerships[curr];
if (!ownership.burned) {
if (ownership.addr != address(0)) {
return ownership;
}
while (true) {
curr--;
ownership = _ownerships[curr];
if (ownership.addr != address(0)) {
return ownership;
}
}
}
}
}
revert OwnerQueryForNonexistentToken();
}
function ownerOf(uint256 tokenId) public view override returns (address) {
return _ownershipOf(tokenId).addr;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
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, tokenId.toString())) : '';
}
function _baseURI() internal view virtual returns (string memory) {
return '';
}
function approve(address to, uint256 tokenId) public override {
address owner = ERC721A.ownerOf(tokenId);
if (to == owner) revert ApprovalToCurrentOwner();
if (_msgSender() != owner) if(!isApprovedForAll(owner, _msgSender())) {
revert ApprovalCallerNotOwnerNorApproved();
}
_approve(to, tokenId, owner);
}
function getApproved(uint256 tokenId) public view override returns (address) {
if (!_exists(tokenId)) revert ApprovalQueryForNonexistentToken();
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address operator, bool approved) public virtual override {
if (operator == _msgSender()) revert ApproveToCaller();
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
_transfer(from, to, tokenId);
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, '');
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public virtual override {
_transfer(from, to, tokenId);
if (to.isContract()) if(!_checkContractOnERC721Received(from, to, tokenId, _data)) {
revert TransferToNonERC721ReceiverImplementer();
}
}
function _exists(uint256 tokenId) internal view returns (bool) {
return _startTokenId() <= tokenId && tokenId < _currentIndex && !_ownerships[tokenId].burned;
}
function _safeMint(address to, uint256 quantity) internal {
_safeMint(to, quantity, '');
}
function _safeMint(
address to,
uint256 quantity,
bytes memory _data
) internal {
uint256 startTokenId = _currentIndex;
if (to == address(0)) revert MintToZeroAddress();
if (quantity == 0) revert MintZeroQuantity();
_beforeTokenTransfers(address(0), to, startTokenId, quantity);
unchecked {
_addressData[to].balance += uint64(quantity);
_addressData[to].numberMinted += uint64(quantity);
_ownerships[startTokenId].addr = to;
_ownerships[startTokenId].startTimestamp = uint64(block.timestamp);
uint256 updatedIndex = startTokenId;
uint256 end = updatedIndex + quantity;
if (to.isContract()) {
do {
emit Transfer(address(0), to, updatedIndex);
if (!_checkContractOnERC721Received(address(0), to, updatedIndex++, _data)) {
revert TransferToNonERC721ReceiverImplementer();
}
} while (updatedIndex < end);
if (_currentIndex != startTokenId) revert();
} else {
do {
emit Transfer(address(0), to, updatedIndex++);
} while (updatedIndex < end);
}
_currentIndex = updatedIndex;
}
_afterTokenTransfers(address(0), to, startTokenId, quantity);
}
function _mint(address to, uint256 quantity) internal {
uint256 startTokenId = _currentIndex;
if (to == address(0)) revert MintToZeroAddress();
if (quantity == 0) revert MintZeroQuantity();
_beforeTokenTransfers(address(0), to, startTokenId, quantity);
unchecked {
_addressData[to].balance += uint64(quantity);
_addressData[to].numberMinted += uint64(quantity);
_ownerships[startTokenId].addr = to;
_ownerships[startTokenId].startTimestamp = uint64(block.timestamp);
uint256 updatedIndex = startTokenId;
uint256 end = updatedIndex + quantity;
do {
emit Transfer(address(0), to, updatedIndex++);
} while (updatedIndex < end);
_currentIndex = updatedIndex;
}
_afterTokenTransfers(address(0), to, startTokenId, quantity);
}
function _transfer(
address from,
address to,
uint256 tokenId
) private {
TokenOwnership memory prevOwnership = _ownershipOf(tokenId);
if (prevOwnership.addr != from) revert TransferFromIncorrectOwner();
bool isApprovedOrOwner = (_msgSender() == from ||
isApprovedForAll(from, _msgSender()) ||
getApproved(tokenId) == _msgSender());
if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
if (to == address(0)) revert TransferToZeroAddress();
_beforeTokenTransfers(from, to, tokenId, 1);
_approve(address(0), tokenId, from);
unchecked {
_addressData[from].balance -= 1;
_addressData[to].balance += 1;
TokenOwnership storage currSlot = _ownerships[tokenId];
currSlot.addr = to;
currSlot.startTimestamp = uint64(block.timestamp);
uint256 nextTokenId = tokenId + 1;
TokenOwnership storage nextSlot = _ownerships[nextTokenId];
if (nextSlot.addr == address(0)) {
if (nextTokenId != _currentIndex) {
nextSlot.addr = from;
nextSlot.startTimestamp = prevOwnership.startTimestamp;
}
}
}
emit Transfer(from, to, tokenId);
_afterTokenTransfers(from, to, tokenId, 1);
}
function _burn(uint256 tokenId) internal virtual {
_burn(tokenId, false);
}
function _burn(uint256 tokenId, bool approvalCheck) internal virtual {
TokenOwnership memory prevOwnership = _ownershipOf(tokenId);
address from = prevOwnership.addr;
if (approvalCheck) {
bool isApprovedOrOwner = (_msgSender() == from ||
isApprovedForAll(from, _msgSender()) ||
getApproved(tokenId) == _msgSender());
if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
}
_beforeTokenTransfers(from, address(0), tokenId, 1);
_approve(address(0), tokenId, from);
unchecked {
AddressData storage addressData = _addressData[from];
addressData.balance -= 1;
addressData.numberBurned += 1;
TokenOwnership storage currSlot = _ownerships[tokenId];
currSlot.addr = from;
currSlot.startTimestamp = uint64(block.timestamp);
currSlot.burned = true;
uint256 nextTokenId = tokenId + 1;
TokenOwnership storage nextSlot = _ownerships[nextTokenId];
if (nextSlot.addr == address(0)) {
if (nextTokenId != _currentIndex) {
nextSlot.addr = from;
nextSlot.startTimestamp = prevOwnership.startTimestamp;
}
}
}
emit Transfer(from, address(0), tokenId);
_afterTokenTransfers(from, address(0), tokenId, 1);
unchecked {
_burnCounter++;
}
}
function _approve(
address to,
uint256 tokenId,
address owner
) private {
_tokenApprovals[tokenId] = to;
emit Approval(owner, to, tokenId);
}
function _checkContractOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver(to).onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert TransferToNonERC721ReceiverImplementer();
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
}
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
_nonReentrantBefore();
_;
_nonReentrantAfter();
}
function _nonReentrantBefore() private {
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
_status = _ENTERED;
}
function _nonReentrantAfter() private {
_status = _NOT_ENTERED;
}
function _reentrancyGuardEntered() internal view returns (bool) {
return _status == _ENTERED;
}
}
library MerkleProof {
function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
return processProof(proof, leaf) == root;
}
function verifyCalldata(bytes32[] calldata proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
return processProofCalldata(proof, leaf) == root;
}
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
bytes32 computedHash = leaf;
for (uint256 i = 0; i < proof.length; i++) {
computedHash = _hashPair(computedHash, proof[i]);
}
return computedHash;
}
function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {
bytes32 computedHash = leaf;
for (uint256 i = 0; i < proof.length; i++) {
computedHash = _hashPair(computedHash, proof[i]);
}
return computedHash;
}
function multiProofVerify(
bytes32[] memory proof,
bool[] memory proofFlags,
bytes32 root,
bytes32[] memory leaves
) internal pure returns (bool) {
return processMultiProof(proof, proofFlags, leaves) == root;
}
function multiProofVerifyCalldata(
bytes32[] calldata proof,
bool[] calldata proofFlags,
bytes32 root,
bytes32[] memory leaves
) internal pure returns (bool) {
return processMultiProofCalldata(proof, proofFlags, leaves) == root;
}
function processMultiProof(
bytes32[] memory proof,
bool[] memory proofFlags,
bytes32[] memory leaves
) internal pure returns (bytes32 merkleRoot) {
uint256 leavesLen = leaves.length;
uint256 totalHashes = proofFlags.length;
require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof");
bytes32[] memory hashes = new bytes32[](totalHashes);
uint256 leafPos = 0;
uint256 hashPos = 0;
uint256 proofPos = 0;
for (uint256 i = 0; i < totalHashes; i++) {
bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
bytes32 b = proofFlags[i]
? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
: proof[proofPos++];
hashes[i] = _hashPair(a, b);
}
if (totalHashes > 0) {
unchecked {
return hashes[totalHashes - 1];
}
} else if (leavesLen > 0) {
return leaves[0];
} else {
return proof[0];
}
}
function processMultiProofCalldata(
bytes32[] calldata proof,
bool[] calldata proofFlags,
bytes32[] memory leaves
) internal pure returns (bytes32 merkleRoot) {
uint256 leavesLen = leaves.length;
uint256 totalHashes = proofFlags.length;
require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof");
bytes32[] memory hashes = new bytes32[](totalHashes);
uint256 leafPos = 0;
uint256 hashPos = 0;
uint256 proofPos = 0;
for (uint256 i = 0; i < totalHashes; i++) {
bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
bytes32 b = proofFlags[i]
? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
: proof[proofPos++];
hashes[i] = _hashPair(a, b);
}
if (totalHashes > 0) {
unchecked {
return hashes[totalHashes - 1];
}
} else if (leavesLen > 0) {
return leaves[0];
} else {
return proof[0];
}
}
function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
return a < b ? _efficientHash(a, b) : _efficientHash(b, a);
}
function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
assembly {
mstore(0x00, a)
mstore(0x20, b)
value := keccak256(0x00, 0x40)
}
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
interface ICantBeEvil {
function getLicenseURI() external view returns (string memory);
function getLicenseName() external view returns (string memory);
}
enum LicenseVersion {
PUBLIC,
EXCLUSIVE,
COMMERCIAL,
COMMERCIAL_NO_HATE,
PERSONAL,
PERSONAL_NO_HATE
}
contract CantBeEvil is ERC165, ICantBeEvil {
using Strings for uint;
string internal constant _BASE_LICENSE_URI = "ar://zmc1WTspIhFyVY82bwfAIcIExLFH5lUcHHUN0wXg4W8/";
LicenseVersion internal licenseVersion;
constructor(LicenseVersion _licenseVersion) {
licenseVersion = _licenseVersion;
}
function getLicenseURI() public view returns (string memory) {
return string.concat(_BASE_LICENSE_URI, uint(licenseVersion).toString());
}
function getLicenseName() public view returns (string memory) {
return _getLicenseVersionKeyByValue(licenseVersion);
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165) returns (bool) {
return
interfaceId == type(ICantBeEvil).interfaceId ||
super.supportsInterface(interfaceId);
}
function _getLicenseVersionKeyByValue(LicenseVersion _licenseVersion) internal pure returns (string memory) {
require(uint8(_licenseVersion) <= 6);
if (LicenseVersion.PUBLIC == _licenseVersion) return "PUBLIC";
if (LicenseVersion.EXCLUSIVE == _licenseVersion) return "EXCLUSIVE";
if (LicenseVersion.COMMERCIAL == _licenseVersion) return "COMMERCIAL";
if (LicenseVersion.COMMERCIAL_NO_HATE == _licenseVersion) return "COMMERCIAL_NO_HATE";
if (LicenseVersion.PERSONAL == _licenseVersion) return "PERSONAL";
else return "PERSONAL_NO_HATE";
}
}
interface IERC6551Registry {
event ERC6551AccountCreated(
address account,
address indexed implementation,
bytes32 salt,
uint256 chainId,
address indexed tokenContract,
uint256 indexed tokenId
);
error AccountCreationFailed();
function createAccount(
address implementation,
bytes32 salt,
uint256 chainId,
address tokenContract,
uint256 tokenId
) external returns (address account);
function account(
address implementation,
bytes32 salt,
uint256 chainId,
address tokenContract,
uint256 tokenId
) external view returns (address account);
}
interface IOperatorAccessControl {
event RoleGranted(
bytes32 indexed role,
address indexed account,
address indexed sender
);
event RoleRevoked(
bytes32 indexed role,
address indexed account,
address indexed sender
);
function hasRole(
bytes32 role,
address account
) external view returns (bool);
function isOperator(address account) external view returns (bool);
function addOperator(address account) external;
function revokeOperator(address account) external;
}
abstract contract OperatorAccessControl is IOperatorAccessControl, Ownable {
struct RoleData {
mapping(address => bool) members;
bytes32 adminRole;
}
mapping(bytes32 => RoleData) private _roles;
bytes32 public constant OPERATOR_ROLE = keccak256("OPERATOR_ROLE");
function hasRole(
bytes32 role,
address account
) public view override returns (bool) {
return _roles[role].members[account];
}
function _grantRole(bytes32 role, address account) private {
if (!hasRole(role, account)) {
_roles[role].members[account] = true;
emit RoleGranted(role, account, _msgSender());
}
}
function _setupRole(bytes32 role, address account) internal virtual {
_grantRole(role, account);
}
function _revokeRole(bytes32 role, address account) private {
if (hasRole(role, account)) {
_roles[role].members[account] = false;
emit RoleRevoked(role, account, _msgSender());
}
}
modifier isOperatorOrOwner() {
address _sender = _msgSender();
require(
isOperator(_sender) || owner() == _sender,
"OperatorAccessControl: caller is not operator or owner"
);
_;
}
modifier onlyOperator() {
require(
isOperator(_msgSender()),
"OperatorAccessControl: caller is not operator"
);
_;
}
function isOperator(address account) public view override returns (bool) {
return hasRole(OPERATOR_ROLE, account);
}
function _addOperator(address account) internal virtual {
_grantRole(OPERATOR_ROLE, account);
}
function addOperator(address account) public override onlyOperator {
_grantRole(OPERATOR_ROLE, account);
}
function revokeOperator(address account) public override onlyOperator {
_revokeRole(OPERATOR_ROLE, account);
}
}
interface IAccountProxy {
function initialize(address implementation) external;
}
contract PocketWithLove is
ERC721A,
OperatorAccessControl,
ReentrancyGuard,
CantBeEvil
{
bytes32 public _kycMintMerkleRoot;
bytes32 public _preMintMerkleRoot;
mapping(uint256 => uint256) private stakeStarted;
mapping(uint256 => uint256) private stakeTotal;
mapping(address => uint256) private addressMintCount;
uint256 private _kycMintLimit = 0;
uint256 private _preMintLimit = 0;
uint256 private _publicMintLimit = 0;
uint256 private _superMintLimit = 0;
uint256 private _addressMintLimit = 0;
uint256 private _kycMintCount;
uint256 private _preMintCount;
uint256 private _publicMintCount;
uint256 private _superMintCount;
uint256 private _kycMintPrice = 0;
uint256 private _preMintPrice = 0;
uint256 private _publicMintPrice = 0;
bool private _kycMintOpen = false;
bool private _preMintOpen = false;
bool private _publicMintOpen = false;
bool private _superMintOpen = false;
uint256 _totalSupply = 2500;
uint256 _totalTokens;
bool private _transferOpen = false;
string private _nftName = "Pocket with Love";
string private _baseUri =
"https://s3.ap-southeast-1.amazonaws.com/traditionow-assets/traditionow-assets/PocketWithLove";
address erc6551RegistryAddress;
address erc6551AccountProxyAddress;
address erc6551ImplementationAddress;
uint256 erc6551ChainId;
constructor()
ERC721A(_nftName, _nftName)
Ownable()
CantBeEvil(LicenseVersion.PUBLIC)
{
_addOperator(_msgSender());
}
function setERC6551Config(
address _erc6551RegistryAddress,
address _erc6551AccountProxyAddress,
address _erc6551ImplementationAddress,
uint256 chainID
) public onlyOperator {
erc6551RegistryAddress = _erc6551RegistryAddress;
erc6551AccountProxyAddress = _erc6551AccountProxyAddress;
erc6551ImplementationAddress = _erc6551ImplementationAddress;
erc6551ChainId = chainID;
}
function createTBA(uint256 tokenId) public returns (address) {
require(
_ownershipOf(tokenId).addr == _msgSender(),
"error:10005 Not owner"
);
address tba = IERC6551Registry(erc6551RegistryAddress).createAccount(
erc6551AccountProxyAddress,
0,
erc6551ChainId,
address(this),
tokenId
);
IAccountProxy(tba).initialize(erc6551ImplementationAddress);
return tba;
}
function getMintCount()
public
view
returns (
uint256 kycMintCount,
uint256 preMintCount,
uint256 publicMintCount,
uint256 superMintCount
)
{
kycMintCount = _kycMintCount;
preMintCount = _preMintCount;
publicMintCount = _publicMintCount;
superMintCount = _superMintCount;
}
function setMerkleRoot(
bytes32 kycMintMerkleRoot,
bytes32 preMintMerkleRoot
) public onlyOperator {
_kycMintMerkleRoot = kycMintMerkleRoot;
_preMintMerkleRoot = preMintMerkleRoot;
}
function isWhitelist(
bytes32[] calldata kycMerkleProof,
bytes32[] calldata preMerkleProof
) public view returns (bool isKycWhitelist, bool isPreWhitelist) {
isKycWhitelist = MerkleProof.verify(
kycMerkleProof,
_kycMintMerkleRoot,
keccak256(abi.encodePacked(msg.sender))
);
isPreWhitelist = MerkleProof.verify(
preMerkleProof,
_preMintMerkleRoot,
keccak256(abi.encodePacked(msg.sender))
);
}
function setMintLimit(
uint256 kycMintLimit,
uint256 preMintLimit,
uint256 publicMintLimit,
uint256 addressMintLimit,
uint256 superMintLimit
) public onlyOperator {
_kycMintLimit = kycMintLimit;
_preMintLimit = preMintLimit;
_publicMintLimit = publicMintLimit;
_addressMintLimit = addressMintLimit;
_superMintLimit = superMintLimit;
}
function getMintLimit()
public
view
returns (
uint256 kycMintLimit,
uint256 preMintLimit,
uint256 publicMintLimit,
uint256 addressMintLimit,
uint256 superMintLimit
)
{
kycMintLimit = _kycMintLimit;
preMintLimit = _preMintLimit;
publicMintLimit = _publicMintLimit;
addressMintLimit = _addressMintLimit;
superMintLimit = _superMintLimit;
}
function setMintPrice(
uint256 kycMintPrice,
uint256 preMintPrice,
uint256 publicMintPrice
) public onlyOperator {
_kycMintPrice = kycMintPrice;
_preMintPrice = preMintPrice;
_publicMintPrice = publicMintPrice;
}
function getMintPrice()
public
view
returns (
uint256 kycMintPrice,
uint256 preMintPrice,
uint256 publicMintPrice
)
{
kycMintPrice = _kycMintPrice;
preMintPrice = _preMintPrice;
publicMintPrice = _publicMintPrice;
}
function setSwith(
bool kycMintOpen,
bool preMintOpen,
bool publicMintOpen,
bool transferOpen,
bool superMintOpen
) public onlyOperator {
_kycMintOpen = kycMintOpen;
_preMintOpen = preMintOpen;
_publicMintOpen = publicMintOpen;
_transferOpen = transferOpen;
_superMintOpen = superMintOpen;
}
function getSwith()
public
view
returns (
bool kycMintOpen,
bool preMintOpen,
bool publicMintOpen,
bool transferOpen,
bool superMintOpen
)
{
kycMintOpen = _kycMintOpen;
preMintOpen = _preMintOpen;
publicMintOpen = _publicMintOpen;
transferOpen = _transferOpen;
superMintOpen = _superMintOpen;
}
function _handleMint(address to) internal {
require(
addressMintCount[to] < _addressMintLimit,
"error:10003 already claimed"
);
require(
_totalTokens < _totalSupply,
"error:10010 Exceeding the total amount"
);
_safeMint(to, 1);
addressMintCount[to] = addressMintCount[to] + 1;
_totalTokens = _totalTokens + 1;
}
function kycMint(
bytes32[] calldata merkleProof,
uint256 count
) public payable nonReentrant {
require(count >= 1, "error:10010 Must be greater than 1");
require(
msg.value == _kycMintPrice * count,
"error:10000 msg.value is incorrect"
);
require(_kycMintOpen, "error:10001 switch off");
require(
MerkleProof.verify(
merkleProof,
_kycMintMerkleRoot,
keccak256(abi.encodePacked(msg.sender))
),
"error:10002 not in the whitelist"
);
for (uint256 i = 0; i < count; i++) {
require(
_kycMintCount < _kycMintLimit,
"error:10004 Reach the limit"
);
_handleMint(_msgSender());
_kycMintCount = _kycMintCount + 1;
}
}
function preMint(
bytes32[] calldata merkleProof,
uint256 count
) public payable nonReentrant {
require(count >= 1, "error:10010 Must be greater than 1");
require(
msg.value == _preMintPrice * count,
"error:10000 msg.value is incorrect"
);
require(_preMintOpen, "error:10001 switch off");
require(
MerkleProof.verify(
merkleProof,
_preMintMerkleRoot,
keccak256(abi.encodePacked(msg.sender))
),
"error:10002 not in the whitelist"
);
for (uint256 i = 0; i < count; i++) {
require(
_preMintCount < _preMintLimit,
"error:10004 Reach the limit"
);
_handleMint(_msgSender());
_preMintCount = _preMintCount + 1;
}
}
function publicMint(uint256 count) public payable nonReentrant {
require(count >= 1, "error:10010 Must be greater than 1");
require(
msg.value == _publicMintPrice * count,
"error:10000 msg.value is incorrect"
);
require(_publicMintOpen, "error:10001 switch off");
for (uint256 i = 0; i < count; i++) {
require(
_publicMintCount < _publicMintLimit,
"error:10004 Reach the limit"
);
_handleMint(_msgSender());
_publicMintCount = _publicMintCount + 1;
}
}
function operatorMint(
address[] memory toAddresses,
uint256[] memory amounts
) public onlyOperator {
require(
toAddresses.length == amounts.length,
"error:10033 toAddresses length does not match amounts length"
);
uint256 _len = toAddresses.length;
for (uint256 _i; _i < _len; _i++) {
address to = toAddresses[_i];
uint256 amount = amounts[_i];
for (uint256 j = 0; j < amount; j++) {
require(
_totalTokens < _totalSupply,
"error:10010 Exceeding the total amount"
);
_safeMint(to, 1);
_totalTokens = _totalTokens + 1;
}
}
}
function getCanMintCount(address user) external view returns (uint256) {
return _addressMintLimit - addressMintCount[user];
}
function stakePeriod(
uint256 tokenId
) external view returns (bool isStake, uint256 current, uint256 total) {
uint256 start = stakeStarted[tokenId];
if (start != 0) {
isStake = true;
current = block.timestamp - start;
}
total = current + stakeTotal[tokenId];
}
function getStakeTime(uint256 tokenId) public view returns (uint256) {
return stakeStarted[tokenId];
}
bool public stakeOpen = false;
function setStakeOpen(bool open) external onlyOperator {
stakeOpen = open;
}
event Staked(uint256 indexed tokenId, uint256 indexed time);
event UnStaked(uint256 indexed tokenId, uint256 indexed time);
function stake(uint256[] calldata tokenIds) external {
require(stakeOpen, "error:10006 stake closed");
uint256 n = tokenIds.length;
for (uint256 i = 0; i < n; ++i) {
uint256 tokenId = tokenIds[i];
require(
_ownershipOf(tokenId).addr == _msgSender(),
"error:10005 Not owner"
);
uint256 start = stakeStarted[tokenId];
if (start == 0) {
stakeStarted[tokenId] = block.timestamp;
emit Staked(tokenId, block.timestamp);
}
}
}
function unStake(uint256[] calldata tokenIds) external {
uint256 n = tokenIds.length;
for (uint256 i = 0; i < n; ++i) {
uint256 tokenId = tokenIds[i];
require(
_ownershipOf(tokenId).addr == _msgSender(),
"error:10005 Not owner"
);
uint256 start = stakeStarted[tokenId];
if (start > 0) {
stakeTotal[tokenId] += block.timestamp - start;
stakeStarted[tokenId] = 0;
emit UnStaked(tokenId, block.timestamp);
}
}
}
function operatorUnStake(
uint256[] calldata tokenIds
) external onlyOperator {
uint256 n = tokenIds.length;
for (uint256 i = 0; i < n; ++i) {
uint256 tokenId = tokenIds[i];
uint256 start = stakeStarted[tokenId];
if (start > 0) {
stakeTotal[tokenId] += block.timestamp - start;
stakeStarted[tokenId] = 0;
emit UnStaked(tokenId, block.timestamp);
}
}
}
uint256 private stakeTransfer = 1;
function safeTransferWhileStake(
address from,
address to,
uint256 tokenId
) external {
require(ownerOf(tokenId) == _msgSender(), "error:10005 Not owner");
stakeTransfer = 2;
safeTransferFrom(from, to, tokenId);
stakeTransfer = 1;
}
function _beforeTokenTransfers(
address,
address,
uint256 startTokenId,
uint256 quantity
) internal view override {
uint256 tokenId = startTokenId;
for (uint256 end = tokenId + quantity; tokenId < end; ++tokenId) {
require(
stakeStarted[tokenId] == 0 ||
stakeTransfer == 2 ||
_transferOpen,
"error:10007 Stake can't transfer"
);
}
}
function setBaseUri(string memory baseUri) public onlyOperator {
_baseUri = baseUri;
}
function tokenURI(
uint256 tokenId
) public view override returns (string memory) {
return
string(abi.encodePacked(_baseUri, "/", toString(tokenId), ".json"));
}
function supply() public view returns (uint256) {
return _totalSupply;
}
function totalMinted() public view returns (uint256) {
return _totalTokens;
}
function withdraw(
address[] memory tokens,
address _to
) public onlyOperator {
for (uint8 i; i < tokens.length; i++) {
IERC20 token = IERC20(tokens[i]);
uint256 b = token.balanceOf(address(this));
if (b > 0) {
token.transfer(_to, b);
}
}
uint256 balance = address(this).balance;
payable(_to).transfer(balance);
}
function toString(uint256 value) internal pure returns (string memory) {
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);
}
mapping(address => mapping(uint256 => uint256)) private superAddressToken;
uint256 private _superMintPrice = 0;
function setSuperMintPrice(uint256 superMintPrice) public onlyOperator {
_superMintPrice = superMintPrice;
}
function getSuperMintPrice() public view returns (uint256) {
return _superMintPrice;
}
mapping(address => uint256) private superAddress;
function setSuperAddress(
address contractAddress,
uint256 count
) public onlyOperator {
superAddress[contractAddress] = count;
}
function getSuperAddress(
address contractAddress
) public view returns (uint256) {
return superAddress[contractAddress];
}
function getTokenCanMintCount(
address contractAddress,
uint256 tokenId
) public view returns (uint256) {
if (superAddress[contractAddress] == 0) {
return 0;
}
return
superAddress[contractAddress] -
superAddressToken[contractAddress][tokenId];
}
function superMint(
address[] memory contracts,
uint256[] memory tokenIds,
uint256[] memory counts
) public payable nonReentrant {
require(
contracts.length == tokenIds.length,
"error: 10000 contracts length does not match tokenIds length"
);
require(
tokenIds.length == counts.length,
"error: 10001 tokenIds length does not match counts length"
);
require(_superMintOpen, "error:10002 switch off");
uint256 totalMintCount = 0;
for (uint256 i = 0; i < tokenIds.length; i++) {
totalMintCount = totalMintCount + counts[i];
}
require(totalMintCount < 30, "error: 10003 Limit 30");
require(
msg.value == _superMintPrice * totalMintCount,
"error:10004 msg.value is incorrect"
);
for (uint256 i = 0; i < tokenIds.length; i++) {
address contractAddress = contracts[i];
uint256 tokenId = tokenIds[i];
uint256 mintCount = counts[i];
require(
IERC721(contractAddress).ownerOf(tokenId) == msg.sender,
"error:10005 No owner"
);
require(
superAddress[contractAddress] > 0,
"error:10006 Contract cannot mint"
);
require(
superAddressToken[contractAddress][tokenId] + mintCount <=
superAddress[contractAddress],
"error:10007 Greater than maximum quantity"
);
require(
_totalTokens + mintCount <= _totalSupply,
"error:10008 Exceeding the total amount"
);
require(
_superMintCount + mintCount <= _superMintLimit,
"error:10009 Reach the limit"
);
for (uint256 j = 0; j < mintCount; j++) {
_safeMint(msg.sender, 1);
}
_superMintCount = _superMintCount + mintCount;
_totalTokens = _totalTokens + mintCount;
superAddressToken[contractAddress][tokenId] =
superAddressToken[contractAddress][tokenId] +
mintCount;
}
}
function supportsInterface(
bytes4 interfaceId
) public view virtual override(CantBeEvil, ERC721A) returns (bool) {
return super.supportsInterface(interfaceId);
}
function batchTransfer(
address to,
uint256[] memory tokenIds
) public virtual {
for (uint256 i = 0; i < tokenIds.length; i++) {
uint256 tokenId = tokenIds[i];
transferFrom(msg.sender, to, tokenId);
}
}
}
