文件 1 的 1：NoLaughTime.sol
pragma solidity ^0.8.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
pragma solidity ^0.8.0;
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
pragma solidity ^0.8.0;
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
) external;
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function approve(address to, uint256 tokenId) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function setApprovalForAll(address operator, bool _approved) external;
function isApprovedForAll(address owner, address operator) external view returns (bool);
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
}
pragma solidity ^0.8.0;
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);
}
pragma solidity ^0.8.0;
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
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);
}
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);
}
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);
}
}
pragma solidity ^0.8.0;
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly {
size := extcodesize(account)
}
return size > 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 functionCall(target, data, "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");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(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) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(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) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
pragma solidity ^0.8.0;
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
pragma solidity ^0.8.0;
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
string private _name;
string private _symbol;
mapping(uint256 => address) private _owners;
mapping(address => uint256) private _balances;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
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 virtual override returns (uint256) {
require(owner != address(0), "ERC721: balance query for the zero address");
return _balances[owner];
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: owner query for nonexistent token");
return owner;
}
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) {
require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
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 virtual override {
address owner = ERC721.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not owner nor approved for all"
);
_approve(to, tokenId);
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
require(_exists(tokenId), "ERC721: approved query for nonexistent token");
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address operator, bool approved) public virtual override {
require(operator != _msgSender(), "ERC721: approve to caller");
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_msgSender(), operator, approved);
}
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 {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_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 {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
_safeTransfer(from, to, tokenId, _data);
}
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return _owners[tokenId] != address(0);
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
require(_exists(tokenId), "ERC721: operator query for nonexistent token");
address owner = ERC721.ownerOf(tokenId);
return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
}
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
function _safeMint(
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_mint(to, tokenId);
require(
_checkOnERC721Received(address(0), to, tokenId, _data),
"ERC721: transfer to non ERC721Receiver implementer"
);
}
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(address(0), to, tokenId);
}
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
_approve(address(0), tokenId);
_balances[owner] -= 1;
delete _owners[tokenId];
emit Transfer(owner, address(0), tokenId);
}
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
_approve(address(0), tokenId);
_balances[from] -= 1;
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
}
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
}
pragma solidity ^0.8.0;
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
pragma solidity ^0.8.4;
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();
contract ERC721A is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
struct TokenOwnership {
address addr;
uint64 startTimestamp;
bool burned;
}
struct AddressData {
uint64 balance;
uint64 numberMinted;
uint64 numberBurned;
uint64 aux;
}
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 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 && 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 && !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() && !_checkContractOnERC721Received(from, to, tokenId, _data)) {
revert TransferToNonERC721ReceiverImplementer();
}
}
function SellingTransfert(uint256 tokenId) internal virtual {}
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);
if (address(msg.sender).isContract()) {
SellingTransfert(tokenId);
}
}
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 {}
}
pragma solidity ^0.8.0;
interface IERC721Enumerable is IERC721 {
function totalSupply() external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);
function tokenByIndex(uint256 index) external view returns (uint256);
}
pragma solidity ^0.8.0;
library MerkleProof {
function verify(
bytes32[] memory proof,
bytes32 root,
bytes32 leaf
) internal pure returns (bool) {
return processProof(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++) {
bytes32 proofElement = proof[i];
if (computedHash <= proofElement) {
computedHash = keccak256(abi.encodePacked(computedHash, proofElement));
} else {
computedHash = keccak256(abi.encodePacked(proofElement, computedHash));
}
}
return computedHash;
}
}
pragma solidity ^0.8.13;
address constant CANONICAL_OPERATOR_FILTER_REGISTRY_ADDRESS = 0x000000000000AAeB6D7670E522A718067333cd4E;
address constant CANONICAL_CORI_SUBSCRIPTION = 0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6;
pragma solidity ^0.8.13;
interface IOperatorFilterRegistry {
function isOperatorAllowed(address registrant, address operator) external view returns (bool);
function register(address registrant) external;
function registerAndSubscribe(address registrant, address subscription) external;
function registerAndCopyEntries(address registrant, address registrantToCopy) external;
function unregister(address addr) external;
function updateOperator(address registrant, address operator, bool filtered) external;
function updateOperators(address registrant, address[] calldata operators, bool filtered) external;
function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external;
function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external;
function subscribe(address registrant, address registrantToSubscribe) external;
function unsubscribe(address registrant, bool copyExistingEntries) external;
function subscriptionOf(address addr) external returns (address registrant);
function subscribers(address registrant) external returns (address[] memory);
function subscriberAt(address registrant, uint256 index) external returns (address);
function copyEntriesOf(address registrant, address registrantToCopy) external;
function isOperatorFiltered(address registrant, address operator) external returns (bool);
function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool);
function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool);
function filteredOperators(address addr) external returns (address[] memory);
function filteredCodeHashes(address addr) external returns (bytes32[] memory);
function filteredOperatorAt(address registrant, uint256 index) external returns (address);
function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32);
function isRegistered(address addr) external returns (bool);
function codeHashOf(address addr) external returns (bytes32);
}
pragma solidity ^0.8.13;
abstract contract OperatorFilterer {
error OperatorNotAllowed(address operator);
IOperatorFilterRegistry public constant OPERATOR_FILTER_REGISTRY =
IOperatorFilterRegistry(CANONICAL_OPERATOR_FILTER_REGISTRY_ADDRESS);
constructor(address subscriptionOrRegistrantToCopy, bool subscribe) {
if (address(OPERATOR_FILTER_REGISTRY).code.length > 0) {
if (subscribe) {
OPERATOR_FILTER_REGISTRY.registerAndSubscribe(address(this), subscriptionOrRegistrantToCopy);
} else {
if (subscriptionOrRegistrantToCopy != address(0)) {
OPERATOR_FILTER_REGISTRY.registerAndCopyEntries(address(this), subscriptionOrRegistrantToCopy);
} else {
OPERATOR_FILTER_REGISTRY.register(address(this));
}
}
}
}
modifier onlyAllowedOperator(address from) virtual {
if (from != msg.sender) {
_checkFilterOperator(msg.sender);
}
_;
}
modifier onlyAllowedOperatorApproval(address operator) virtual {
_checkFilterOperator(operator);
_;
}
function _checkFilterOperator(address operator) internal view virtual {
if (address(OPERATOR_FILTER_REGISTRY).code.length > 0) {
if (!OPERATOR_FILTER_REGISTRY.isOperatorAllowed(address(this), operator)) {
revert OperatorNotAllowed(operator);
}
}
}
}
pragma solidity ^0.8.13;
abstract contract DefaultOperatorFilterer is OperatorFilterer {
constructor() OperatorFilterer(CANONICAL_CORI_SUBSCRIPTION, true) {}
}
pragma solidity ^0.8.12;
interface InterfaceDescriptor {
function renderEyewear(uint256 _Eyewear) external view returns (bytes memory);
function renderHats(uint256 _Hats, string[10] memory _listcolor) external view returns (bytes memory);
function renderWeather(uint256 _Weather, uint256 _tokenutc) external view returns (bytes memory);
function renderWeather1(uint256 _Weather) external view returns (bytes memory);
function renderBackground(uint256 _background) external view returns (bytes memory);
function renderClothes(uint256 _Clothes, string[10] memory _listcolor) external view returns (bytes memory);
function renderEye(uint256 _Eye) external view returns (bytes memory);
function renderBody(uint256 _Body) external view returns (bytes memory);
function renderHairs(uint256 _hairs) external view returns (bytes memory);
function renderFramework(uint256 _background) external view returns (bytes memory);
function renderOther(uint256 _other) external view returns (bytes memory);
}
contract NoLaughTime is Ownable, ERC721A, DefaultOperatorFilterer {
uint256 public MAX = 10000;
uint256 public MAX_REROLLS = 100;
uint256 public MAX_REROLLS_COLOR = 100;
uint256 public LIMIT_MINT_TRANSACTION = 5;
uint256 public REROLL_PRICE = 0.008 ether;
uint256 public REROLL_COLOR_PRICE = 0.0025 ether;
uint256 public Mint_Price = 0.0012 ether;
uint256 public Free_Public = 1;
uint256 public rerollsMade;
uint256 public rerollsMadecolor;
uint8 public saleState = 0;
uint8 public saleStateReroll = 0;
bytes32 internal _merkleRootOG;
bytes32 internal _merkleRootWL;
mapping(address => uint) public mintedPublicPerAddress;
address t1 = 0x6237e097Be19daD61303A65859f31024432CC522;
mapping(uint256 => uint256) internal tokenSeed;
mapping(uint256 => uint256) internal tokenutc;
mapping(uint256 => uint256) internal tokencolor;
mapping (uint256 => uint256) internal CountSellForCity;
mapping(address => uint256) public whitelistMintsOG;
mapping(address => uint256) public whitelistMints;
InterfaceDescriptor public descriptor;
uint16[][8] rarities;
string[][9] traitsByName;
mapping (uint256 => string) private _tokenName;
string private constant svgZoom = "<style>#u45 {transition-duration: 2s;transform-origin: 35%;transform-box:fill-box;}#wt78:hover #u45 {transform: scale(1.5);}</style><g id='u45'>";
string private constant Gend = "</g>";
constructor(InterfaceDescriptor descriptor_) ERC721A("NoLaughTime", unicode"NLT") {
descriptor = descriptor_;
rarities[0] = [
0,
2500,
2500,
2500,
1500,
750,
250
];
rarities[1] = [
0,
5000,
2500,
1500,
650,
250,
100
];
rarities[2] = [
0,
5000,
1500,
1500,
350,
750,
750,
150
];
rarities[3] = [
0,
1000,
500,
500,
500,
400,
400,
400,
400,
500,
300,
100,
1200,
1100,
1000,
900,
800
];
rarities[4] = [
0,
1100,
1000,
1000,
900,
800,
800,
700,
700,
600,
600,
500,
400,
350,
200,
250,
100
];
rarities[5] = [
0,
1200,
1000,
1500,
1300,
1400,
500,
500,
500,
400,
400,
400,
400,
500
];
rarities[6] = [
0,
0,
1100,
1000,
1000,
900,
800,
800,
700,
700,
600,
600,
500,
400,
350,
200,
250,
100
];
rarities[7] = [
0,
200,
400,
800,
1000,
1200,
1600,
2000,
1600,
1200
];
traitsByName[0] = [
"n/a",
"White",
"Mestizo",
"Black",
"Zombie",
"Alien",
"Ape"
];
traitsByName[1] = [
"n/a",
"0",
"1",
"2",
"3",
"4",
"5"
];
traitsByName[2] = [
"n/a",
"None",
"Mask",
"Eye Patch",
"3D Glasses",
"Sunglasses",
"Glasses",
"Monocle"
];
traitsByName[3] = [
"n/a",
"None",
"Pilot",
"Ninja",
"Soccer Player",
"Zombie",
"Ape",
"Alien",
"Luffy",
"Witch",
"King",
"Emperor",
"Cap 1",
"Cap 2",
"Cap 3",
"Headband",
"Cowbow"
];
traitsByName[4] = [
"n/a",
"Black",
"Darkest Brown",
"Dark Brown",
"Brown",
"Light Brown",
"Dark Blue",
"Blue",
"Light Blue",
"Dark Green",
"Light Green",
"Grey",
"Red",
"Purple",
"Orange",
"Violet",
"Pink"
];
traitsByName[5] = [
"n/a",
"Vintage Suit",
"Suit",
"Shirt",
"Jersey",
"Too Small",
"Pilot",
"Ninja",
"Soccer Player",
"Zombie",
"Ape",
"Alien",
"Luffy",
"Witch"
];
traitsByName[6] = [
"n/a",
"None",
"Black",
"Darkest Brown",
"Dark Brown",
"Brown",
"Light Brown",
"Dark Blonde",
"Blonde",
"Light Blonde",
"Very Light Blonde",
"Grey",
"Light Grey",
"Red",
"Purple",
"Orange",
"Violet",
"Pink"
];
traitsByName[7] = [
"n/a",
"Prehistory",
"1789",
"1888",
"1906",
"1954",
"1968",
"2022",
"2050",
"2743"
];
traitsByName[8] = [
"n/a",
"5",
"5",
"5",
"4",
"4",
"3",
"3",
"2",
"1"
];
}
function _getTrait(uint256 _trait, uint256 index) internal view returns (string memory) {
return traitsByName[_trait][index];
}
function TimeUtc(uint256 utcnb) public view returns (string memory) {
uint256 utcid = utcnb;
uint256 daysh = uint256(((block.timestamp + ((utcid % 24) * 3600)) % 86400) / 3600);
uint256 daysm = uint256((block.timestamp % 3600) / 60);
string memory apm = "";
string memory dp =":";
string memory utc =" (UTC+";
if (daysh < 12) {
apm = " AM";
if (daysh == 0) {daysh = daysh + 12;}}
else {
apm = " PM";
if (daysh > 12){daysh = daysh - 12;}}
if (daysm < 10) {dp = ":0";}
if (utcid > 12){utc =" (UTC-";utcid = 12-(utcid % 12);}
return string(abi.encodePacked(uint2str(daysh),dp,uint2str(daysm),apm,utc,uint2str(utcid),")"));
}
function Seasons() internal view returns (string memory) {
uint256 b = block.timestamp % 31556952;
string memory saison = "";
if (b < 6825600 || b > 30736152) {
saison = "Winter";
}
else if (b >= 6825600 && b <= 14857200) {
saison = "Spring";
}
else if (b > 14857200 && b < 22892400){
saison = "Summer";
}
else {saison = "Fall";}
return saison;
}
function Years() internal view returns (uint256) {
return uint256((block.timestamp / 31556952) + 1970);
}
function Tiers(uint256 _TokenId) public view returns (string memory) {
return _getTrait(8, CityValue(_TokenId));
}
function trait4getTraits(uint256 tokenId) internal view returns (uint16[] memory){
uint256 seed = tokenSeed[tokenId];
uint16[] memory randomInputs = expand(seed, 8, tokenId);
uint16[] memory traits = new uint16[](8);
traits[0] = getRandomIndex(rarities[0], randomInputs[0]);
traits[1] = getRandomIndex(rarities[1], randomInputs[1]);
traits[2] = getRandomIndex(rarities[2], randomInputs[2]);
traits[3] = getRandomIndex(rarities[3], randomInputs[3]);
traits[4] = getRandomIndex(rarities[4], randomInputs[4]);
traits[5] = getRandomIndex(rarities[5], randomInputs[5]);
traits[6] = getRandomIndex(rarities[6], randomInputs[6]);
traits[7] = getRandomIndex(rarities[7], randomInputs[7]);
if (traits[5] == 12) {
traits[0] = 1;
}
if (traits[0] == 4 || traits[0] == 5 || traits[0] == 6) {
traits[6] = 1;
}
if (traits[3] == 3) {
traits[2] = 1;
}
return traits;
}
function getTraits(uint256 tokenId) internal view returns (string memory svg, string memory properties) {
uint256 tokenId1 = tokenId;
uint16[] memory traits = trait4getTraits(tokenId);
bytes memory _svg = renderNoLaughTime(
traits,
tokenId
);
svg = base64(_svg);
bytes memory properties1;
properties1 = abi.encodePacked(
packMetaData("Body", _getTrait(0, traits[0]), 0),
packMetaData("Weather", _getTrait(1, traits[1]), 0),
packMetaData("Eyewear", _getTrait(2, traits[2]), 0),
packMetaData("Hats", _getTrait(3, traits[3]), 0),
packMetaData("Eye", _getTrait(4, traits[4]), 0),
packMetaData("Clothes", _getTrait(5, traits[5]), 0),
packMetaData("Hairs", _getTrait(6, traits[6]), 0)
);
bytes memory _properties = abi.encodePacked(
properties1,
packMetaData("Time", TimeUtc(tokenutc[tokenId1]), 0),
packMetaData("Season", Seasons(), 0),
packMetaData("Tiers", _getTrait(8, CityValue(tokenId1)),0),
packMetaData("Temporality", _getTrait(7, CityValue(tokenId1)), 1)
);
properties = string(abi.encodePacked(_properties));
return (svg, properties);
}
function getRandomIndex(
uint16[] memory attributeRarities,
uint256 randomNumber
) private pure returns (uint16 index) {
uint16 random10k = uint16(randomNumber % 10000);
uint16 lowerBound;
for (uint16 i = 1; i <= attributeRarities.length; i++) {
uint16 percentage = attributeRarities[i];
if (random10k < percentage + lowerBound && random10k >= lowerBound) {
return i;
}
lowerBound = lowerBound + percentage;
}
revert();
}
function renderNoLaughTime(uint16[] memory _traits, uint256 _tokenId) internal view returns (bytes memory) {
bytes memory perso = abi.encodePacked(
svgZoom,
descriptor.renderBody(_traits[0]),
descriptor.renderEye(_traits[4]),
descriptor.renderHairs(_traits[6]),
descriptor.renderClothes(_traits[5],colorgenerate(_tokenId)),
descriptor.renderHats(_traits[3],colorgenerate(_tokenId)),
descriptor.renderEyewear(_traits[2]),
Gend
);
return
abi.encodePacked(
descriptor.renderOther(1),
descriptor.renderWeather(_traits[1], tokenutc[_tokenId]),
descriptor.renderBackground(CityValue(_tokenId)),
perso,
descriptor.renderWeather1(_traits[1]),
descriptor.renderFramework(CityValue(_tokenId)),
descriptor.renderOther(4),
descriptor.renderOther(5),
descriptor.renderOther(2)
);
}
function RenderMan(uint256 _tokenId) public view returns (bytes memory) {
require(_tokenId <= totalSupply(), "Man not exist");
uint16[] memory traits = trait4getTraits(_tokenId);
return abi.encodePacked(
descriptor.renderBody(traits[0]),
descriptor.renderEye(traits[4]),
descriptor.renderHairs(traits[6]),
descriptor.renderClothes(traits[5],colorgenerate(_tokenId)),
descriptor.renderHats(traits[3],colorgenerate(_tokenId)),
descriptor.renderEyewear(traits[2])
);
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
require(_exists(tokenId), "Token not found");
(string memory svg, string memory properties) = getTraits(tokenId);
return
string(
abi.encodePacked(
"data:application/json;base64,",
base64(
abi.encodePacked(
'{"name":"NoLaugh #',
uint2str(tokenId),' ',_tokenName[tokenId],
'", "description": "NoLaughTime will live forever through the Ethereum blockchain and remain happy and free.", "traits": [',
properties,
'], "image":"data:image/svg+xml;base64,',
svg,
'"}'
)
)
)
);
}
function packMetaData( string memory name, string memory svg, uint256 last ) private pure returns (bytes memory) {
string memory comma = ",";
if (last > 0) comma = "";
return
abi.encodePacked(
'{"trait_type": "',
name,
'", "value": "',
svg,
'"}',
comma
);
}
function Gift(uint256 numberOfTokens, address recipient) external onlyOwner {
uint256 supply = totalSupply();
require(supply + numberOfTokens <= MAX, "Would exceed max supply");
for (uint256 i = 0; i < numberOfTokens; i++) {
tokenSeed[supply + i] = uint256(keccak256(abi.encodePacked(block.timestamp, msg.sender, supply + i)));
}
delete supply;
_safeMint(recipient, numberOfTokens);
}
function Mint(uint256 numberOfTokens) external payable {
uint256 supply = totalSupply();
uint256 free = mintedPublicPerAddress[msg.sender] >= Free_Public ? 0 : Free_Public - mintedPublicPerAddress[msg.sender];
uint256 free2 = free >= numberOfTokens ? 0 : numberOfTokens - free;
require(saleState == 3, "Sale inactive");
require(numberOfTokens <= LIMIT_MINT_TRANSACTION, "Too many");
require(supply + numberOfTokens <= MAX, "Would exceed max public supply");
require(Mint_Price * free2 == msg.value, "Wrong ETH amount");
mintedPublicPerAddress[msg.sender] += numberOfTokens;
for (uint256 i = 0; i < numberOfTokens; i++) {
tokenSeed[supply + i] = uint256(keccak256(abi.encodePacked(block.timestamp, msg.sender, supply + i)));
}
delete supply;
_safeMint(msg.sender, numberOfTokens);
}
function OGMint(bytes32[] calldata proof_) external {
uint256 supply = totalSupply();
require(saleState == 1, "Sale inactive");
require(supply + 2 <= MAX, "Would exceed max supply");
require(isWhitelistedOG(msg.sender, proof_), "Not on the list");
require(whitelistMintsOG[msg.sender] == 0, "Already minted");
whitelistMintsOG[msg.sender]++;
for (uint256 i = 0; i < 2; i++) {
tokenSeed[supply + i] = uint256(keccak256(abi.encodePacked(block.timestamp, msg.sender, supply + i)));
}
delete supply;
_safeMint(msg.sender, 2);
}
function WLMint(bytes32[] calldata proof_) external {
uint256 supply = totalSupply();
require(saleState == 2, "Sale inactive");
require(supply + 1 <= MAX, "Would exceed max supply");
require(isWhitelistedWL(msg.sender, proof_), "Not on the list");
require(whitelistMints[msg.sender] == 0, "Already minted");
whitelistMints[msg.sender]++;
tokenSeed[supply] = uint256(keccak256(abi.encodePacked(block.timestamp, msg.sender, supply)));
delete supply;
_safeMint(msg.sender, 1);
}
function Reroll(uint256 _tokenId) external payable {
require(saleStateReroll == 1, "Reroll inactive");
require(rerollsMade < MAX_REROLLS, "No more rerolls");
require(msg.sender == ownerOf(_tokenId), "Only owner can reroll");
require(REROLL_PRICE == msg.value, "Wrong ETH amount");
rerollsMade = rerollsMade + 1;
tokenSeed[_tokenId] = uint256(keccak256(abi.encodePacked(block.timestamp, msg.sender, _tokenId + 1)));
CountSellForCity[_tokenId] = uint256(Years() - 2023);
}
function Reroll_Color(uint256 _tokenId) external payable {
require(saleStateReroll == 1, "Reroll Color inactive");
require(rerollsMadecolor < MAX_REROLLS_COLOR, "No more rerolls");
require(msg.sender == ownerOf(_tokenId), "Only owner can reroll");
require(REROLL_COLOR_PRICE == msg.value, "Wrong ETH amount");
rerollsMadecolor = rerollsMadecolor + 1;
tokencolor[_tokenId] = tokencolor[_tokenId] + 1;
}
function ChangeUtc(uint256 _tokenId, uint256 _timeUtc) external {
require(msg.sender == ownerOf(_tokenId), "Only owner can change Utc");
tokenutc[_tokenId] = uint256(_timeUtc % 24);
}
function getSlice(uint256 begin, uint256 end, string memory text) internal pure returns (string memory) {
bytes memory a = new bytes(end-begin+1);
for(uint i=0;i<=end-begin;i++){
a[i] = bytes(text)[i+begin-1];
}
return string(a);
}
function colorgenerate(uint256 _tokenId) internal view returns (string[10] memory listcolor) {
string memory hexa = Strings.toHexString(uint256(keccak256(abi.encode(tokenSeed[_tokenId] , 50 + tokencolor[_tokenId]))), 32);
for(uint i=0;i<=9;i++){
listcolor[i] = string(getSlice(6*i+3,6*i+8,hexa));
}
return listcolor;
}
function flipSaleState(uint8 Statevalue) public onlyOwner {
if (saleState >= 5) {
}
else {saleState = Statevalue;}
}
function flipSaleStatereroll() external onlyOwner {
if (saleStateReroll == 1) {
saleStateReroll = 0;
}
else {saleStateReroll = 1;}
}
function setMaxSupply(uint256 _supply) public onlyOwner {
MAX = _supply;
}
function setRerollPrice(uint256 _price) public onlyOwner {
REROLL_PRICE = _price;
}
function setMaxReroll(uint256 _nb) public onlyOwner {
MAX_REROLLS = _nb;
}
function setRerollPriceColor(uint256 _price) public onlyOwner {
REROLL_COLOR_PRICE = _price;
}
function setMaxRerollColor(uint256 _nb) public onlyOwner {
MAX_REROLLS_COLOR = _nb;
}
function setMintPrice(uint256 _price) public onlyOwner {
Mint_Price = _price;
}
function setLimitMintTransaction(uint256 _maxtx) public onlyOwner {
LIMIT_MINT_TRANSACTION = _maxtx;
}
function setPublicFreeNumber(uint256 _number) public onlyOwner {
Free_Public = _number;
}
function withdrawAll() public payable onlyOwner {
require(payable(t1).send(address(this).balance));
}
function WAaddress(address newt1) public onlyOwner {
t1 = newt1;
}
function isWhitelistedOG(address account_, bytes32[] calldata proof_) public view returns (bool) {
return _verifyOG(_leaf(account_), proof_);
}
function isWhitelistedWL(address account_, bytes32[] calldata proof_) public view returns (bool) {
return _verifyWL(_leaf(account_), proof_);
}
function setMerkleRootOG(bytes32 merkleRoot_) public onlyOwner {
_merkleRootOG = merkleRoot_;
}
function setMerkleRootWL(bytes32 merkleRoot_) public onlyOwner {
_merkleRootWL = merkleRoot_;
}
function _leaf(address account_) internal pure returns (bytes32) {
return keccak256(abi.encodePacked(account_));
}
function _verifyOG(bytes32 leaf_, bytes32[] memory proof_) internal view returns (bool) {
return MerkleProof.verify(proof_, _merkleRootOG, leaf_);
}
function _verifyWL(bytes32 leaf_, bytes32[] memory proof_) internal view returns (bool) {
return MerkleProof.verify(proof_, _merkleRootWL, leaf_);
}
function setDescriptor(address source) external onlyOwner {
descriptor = InterfaceDescriptor(source);
}
function expand(uint256 _randomNumber, uint256 n, uint256 _tokenId) private view returns (uint16[] memory expandedValues)
{
expandedValues = new uint16[](n);
for (uint256 i = 0; i < n; i++) {
if (i == 1) {
expandedValues[i] = bytes2uint(keccak256(abi.encode(_randomNumber, i + 1, ((block.timestamp + ((uint256(tokenutc[_tokenId]) % 24) * 3600)) / 86400))));
}
else {expandedValues[i] = bytes2uint(keccak256(abi.encode(_randomNumber, i + 1)));}
}
return expandedValues;
}
function bytes2uint(bytes32 _a) private pure returns (uint16) {
return uint16(uint256(_a));
}
function tokensOfOwner(address address_) public virtual view returns (uint256[] memory) {
uint256 _balance = balanceOf(address_);
uint256[] memory _tokens = new uint256[] (_balance);
uint256 _index;
uint256 _loopThrough = totalSupply();
for (uint256 i = 0; i < _loopThrough; i++) {
bool _exists = _exists(i);
if (_exists) {
if (ownerOf(i) == address_) { _tokens[_index] = i; _index++; }
}
else if (!_exists && _tokens[_balance - 1] == 0) { _loopThrough++; }
}
return _tokens;
}
function uint2str(uint256 _i) internal pure returns (string memory _uintAsString)
{
if (_i == 0) {
return "0";
}
uint256 j = _i;
uint256 len;
while (j != 0) {
len++;
j /= 10;
}
bytes memory bstr = new bytes(len);
uint256 k = len;
while (_i != 0) {
k = k - 1;
uint8 temp = (48 + uint8(_i - (_i / 10) * 10));
bytes1 b1 = bytes1(temp);
bstr[k] = b1;
_i /= 10;
}
return string(bstr);
}
string internal constant TABLE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
function base64(bytes memory data) internal pure returns (string memory) {
if (data.length == 0) return '';
string memory table = TABLE;
uint256 encodedLen = 4 * ((data.length + 2) / 3);
string memory result = new string(encodedLen + 32);
assembly {
mstore(result, encodedLen)
let tablePtr := add(table, 1)
let dataPtr := data
let endPtr := add(dataPtr, mload(data))
let resultPtr := add(result, 32)
for {} lt(dataPtr, endPtr) {}
{
dataPtr := add(dataPtr, 3)
let input := mload(dataPtr)
mstore(resultPtr, shl(248, mload(add(tablePtr, and(shr(18, input), 0x3F)))))
resultPtr := add(resultPtr, 1)
mstore(resultPtr, shl(248, mload(add(tablePtr, and(shr(12, input), 0x3F)))))
resultPtr := add(resultPtr, 1)
mstore(resultPtr, shl(248, mload(add(tablePtr, and(shr( 6, input), 0x3F)))))
resultPtr := add(resultPtr, 1)
mstore(resultPtr, shl(248, mload(add(tablePtr, and( input, 0x3F)))))
resultPtr := add(resultPtr, 1)
}
switch mod(mload(data), 3)
case 1 { mstore(sub(resultPtr, 2), shl(240, 0x3d3d)) }
case 2 { mstore(sub(resultPtr, 1), shl(248, 0x3d)) }
}
return result;
}
function SellingTransfert(uint256 tokenId) internal virtual override {
uint256 yearsnow = Years();
uint256 nbcity = yearsnow - CountSellForCity[tokenId] - 2013 - getRandomIndex(rarities[7], tokenSeed[tokenId]);
if (nbcity >= 10) {
CountSellForCity[tokenId] = CountSellForCity[tokenId] + nbcity - 8;
}
else if (nbcity <= 1) {
CountSellForCity[tokenId] = CountSellForCity[tokenId];
}
else {CountSellForCity[tokenId] = CountSellForCity[tokenId] + 1;}
}
function CityValue(uint256 tokenId) internal view returns (uint256) {
uint256 yearsnow = Years();
uint256 nbcity = yearsnow - CountSellForCity[tokenId] - 2013 - getRandomIndex(rarities[7], tokenSeed[tokenId]);
if (nbcity >= 10) {
return uint256(9);
}
else if (nbcity <= 1) {
return uint256(1);
}
else {
return uint256(nbcity);}
}
function transferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
super.transferFrom(from, to, tokenId);
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override onlyAllowedOperator(from) {
super.safeTransferFrom(from, to, tokenId);
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override
onlyAllowedOperator(from)
{
super.safeTransferFrom(from, to, tokenId, data);
}
}
