文件 1 的 1：megafknwizards.sol
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.4;
abstract contract OwnablePermissions is Context {
function _requireCallerIsContractOwner() internal view virtual;
}
pragma solidity ^0.8.4;
abstract contract AutomaticValidatorTransferApproval is OwnablePermissions {
event AutomaticApprovalOfTransferValidatorSet(bool autoApproved);
bool public autoApproveTransfersFromValidator;
function setAutomaticApprovalOfTransfersFromValidator(bool autoApprove) external {
_requireCallerIsContractOwner();
autoApproveTransfersFromValidator = autoApprove;
emit AutomaticApprovalOfTransferValidatorSet(autoApprove);
}
}
pragma solidity ^0.8.4;
interface ICreatorToken {
event TransferValidatorUpdated(address oldValidator, address newValidator);
function getTransferValidator() external view returns (address validator);
function setTransferValidator(address validator) external;
function getTransferValidationFunction() external view returns (bytes4 functionSignature, bool isViewFunction);
}
pragma solidity ^0.8.4;
interface ICreatorTokenLegacy {
event TransferValidatorUpdated(address oldValidator, address newValidator);
function getTransferValidator() external view returns (address validator);
function setTransferValidator(address validator) external;
}
pragma solidity ^0.8.4;
interface ITransferValidator {
function applyCollectionTransferPolicy(address caller, address from, address to) external view;
function validateTransfer(address caller, address from, address to) external view;
function validateTransfer(address caller, address from, address to, uint256 tokenId) external view;
function validateTransfer(address caller, address from, address to, uint256 tokenId, uint256 amount) external;
function beforeAuthorizedTransfer(address operator, address token, uint256 tokenId) external;
function afterAuthorizedTransfer(address token, uint256 tokenId) external;
function beforeAuthorizedTransfer(address operator, address token) external;
function afterAuthorizedTransfer(address token) external;
function beforeAuthorizedTransfer(address token, uint256 tokenId) external;
function beforeAuthorizedTransferWithAmount(address token, uint256 tokenId, uint256 amount) external;
function afterAuthorizedTransferWithAmount(address token, uint256 tokenId) external;
}
pragma solidity ^0.8.4;
interface ITransferValidatorSetTokenType {
function setTokenTypeOfCollection(address collection, uint16 tokenType) external;
}
pragma solidity ^0.8.4;
abstract contract TransferValidation is Context {
error ShouldNotMintToBurnAddress();
function _validateBeforeTransfer(address from, address to, uint256 tokenId) internal virtual {
bool fromZeroAddress = from == address(0);
bool toZeroAddress = to == address(0);
if(fromZeroAddress && toZeroAddress) {
revert ShouldNotMintToBurnAddress();
} else if(fromZeroAddress) {
_preValidateMint(_msgSender(), to, tokenId, msg.value);
} else if(toZeroAddress) {
_preValidateBurn(_msgSender(), from, tokenId, msg.value);
} else {
_preValidateTransfer(_msgSender(), from, to, tokenId, msg.value);
}
}
function _validateAfterTransfer(address from, address to, uint256 tokenId) internal virtual {
bool fromZeroAddress = from == address(0);
bool toZeroAddress = to == address(0);
if(fromZeroAddress && toZeroAddress) {
revert ShouldNotMintToBurnAddress();
} else if(fromZeroAddress) {
_postValidateMint(_msgSender(), to, tokenId, msg.value);
} else if(toZeroAddress) {
_postValidateBurn(_msgSender(), from, tokenId, msg.value);
} else {
_postValidateTransfer(_msgSender(), from, to, tokenId, msg.value);
}
}
function _preValidateMint(address caller, address to, uint256 tokenId, uint256 value) internal virtual {}
function _postValidateMint(address caller, address to, uint256 tokenId, uint256 value) internal virtual {}
function _preValidateBurn(address caller, address from, uint256 tokenId, uint256 value) internal virtual {}
function _postValidateBurn(address caller, address from, uint256 tokenId, uint256 value) internal virtual {}
function _preValidateTransfer(address caller, address from, address to, uint256 tokenId, uint256 value) internal virtual {}
function _postValidateTransfer(address caller, address from, address to, uint256 tokenId, uint256 value) internal virtual {}
function _validateBeforeTransfer(address from, address to, uint256 tokenId, uint256 amount) internal virtual {
bool fromZeroAddress = from == address(0);
bool toZeroAddress = to == address(0);
if(fromZeroAddress && toZeroAddress) {
revert ShouldNotMintToBurnAddress();
} else if(fromZeroAddress) {
_preValidateMint(_msgSender(), to, tokenId, amount, msg.value);
} else if(toZeroAddress) {
_preValidateBurn(_msgSender(), from, tokenId, amount, msg.value);
} else {
_preValidateTransfer(_msgSender(), from, to, tokenId, amount, msg.value);
}
}
function _validateAfterTransfer(address from, address to, uint256 tokenId, uint256 amount) internal virtual {
bool fromZeroAddress = from == address(0);
bool toZeroAddress = to == address(0);
if(fromZeroAddress && toZeroAddress) {
revert ShouldNotMintToBurnAddress();
} else if(fromZeroAddress) {
_postValidateMint(_msgSender(), to, tokenId, amount, msg.value);
} else if(toZeroAddress) {
_postValidateBurn(_msgSender(), from, tokenId, amount, msg.value);
} else {
_postValidateTransfer(_msgSender(), from, to, tokenId, amount, msg.value);
}
}
function _preValidateMint(address caller, address to, uint256 tokenId, uint256 amount, uint256 value) internal virtual {}
function _postValidateMint(address caller, address to, uint256 tokenId, uint256 amount, uint256 value) internal virtual {}
function _preValidateBurn(address caller, address from, uint256 tokenId, uint256 amount, uint256 value) internal virtual {}
function _postValidateBurn(address caller, address from, uint256 tokenId, uint256 amount, uint256 value) internal virtual {}
function _preValidateTransfer(address caller, address from, address to, uint256 tokenId, uint256 amount, uint256 value) internal virtual {}
function _postValidateTransfer(address caller, address from, address to, uint256 tokenId, uint256 amount, uint256 value) internal virtual {}
}
pragma solidity ^0.8.4;
abstract contract CreatorTokenBase is OwnablePermissions, TransferValidation, ICreatorToken {
error CreatorTokenBase__InvalidTransferValidatorContract();
address public constant DEFAULT_TRANSFER_VALIDATOR = address(0x721C008fdff27BF06E7E123956E2Fe03B63342e3);
bool private isValidatorInitialized;
address private transferValidator;
constructor() {
_emitDefaultTransferValidator();
_registerTokenType(DEFAULT_TRANSFER_VALIDATOR);
}
function setTransferValidator(address transferValidator_) public {
_requireCallerIsContractOwner();
bool isValidTransferValidator = transferValidator_.code.length > 0;
if(transferValidator_ != address(0) && !isValidTransferValidator) {
revert CreatorTokenBase__InvalidTransferValidatorContract();
}
emit TransferValidatorUpdated(address(getTransferValidator()), transferValidator_);
isValidatorInitialized = true;
transferValidator = transferValidator_;
_registerTokenType(transferValidator_);
}
function getTransferValidator() public view override returns (address validator) {
validator = transferValidator;
if (validator == address(0)) {
if (!isValidatorInitialized) {
validator = DEFAULT_TRANSFER_VALIDATOR;
}
}
}
function _preValidateTransfer(
address caller,
address from,
address to,
uint256 tokenId,
uint256 ) internal virtual override {
address validator = getTransferValidator();
if (validator != address(0)) {
if (msg.sender == validator) {
return;
}
ITransferValidator(validator).validateTransfer(caller, from, to, tokenId);
}
}
function _preValidateTransfer(
address caller,
address from,
address to,
uint256 tokenId,
uint256 amount,
uint256 ) internal virtual override {
address validator = getTransferValidator();
if (validator != address(0)) {
if (msg.sender == validator) {
return;
}
ITransferValidator(validator).validateTransfer(caller, from, to, tokenId, amount);
}
}
function _tokenType() internal virtual pure returns(uint16);
function _registerTokenType(address validator) internal {
if (validator != address(0)) {
uint256 validatorCodeSize;
assembly {
validatorCodeSize := extcodesize(validator)
}
if(validatorCodeSize > 0) {
try ITransferValidatorSetTokenType(validator).setTokenTypeOfCollection(address(this), _tokenType()) {
} catch { }
}
}
}
function _emitDefaultTransferValidator() internal {
emit TransferValidatorUpdated(address(0), DEFAULT_TRANSFER_VALIDATOR);
}
}
pragma solidity ^0.8.4;
bytes32 constant ZERO_BYTES32 = bytes32(0);
uint256 constant ZERO = 0;
uint256 constant ONE = 1;
uint8 constant ORDER_STATE_OPEN = 0;
uint8 constant ORDER_STATE_FILLED = 1;
uint8 constant ORDER_STATE_CANCELLED = 2;
uint256 constant TOKEN_TYPE_ERC721 = 721;
uint256 constant TOKEN_TYPE_ERC1155 = 1155;
uint256 constant TOKEN_TYPE_ERC20 = 20;
bytes32 constant UPPER_BIT_MASK = 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
bytes32 constant UPDATE_APPROVAL_TYPEHASH =
keccak256("UpdateApprovalBySignature(uint256 tokenType,address token,uint256 id,uint256 amount,uint256 nonce,address operator,uint256 approvalExpiration,uint256 sigDeadline,uint256 masterNonce)");
bytes32 constant SINGLE_USE_PERMIT_TYPEHASH =
keccak256("PermitTransferFrom(uint256 tokenType,address token,uint256 id,uint256 amount,uint256 nonce,address operator,uint256 expiration,uint256 masterNonce)");
string constant SINGLE_USE_PERMIT_TRANSFER_ADVANCED_TYPEHASH_STUB =
"PermitTransferFromWithAdditionalData(uint256 tokenType,address token,uint256 id,uint256 amount,uint256 nonce,address operator,uint256 expiration,uint256 masterNonce,";
string constant PERMIT_ORDER_ADVANCED_TYPEHASH_STUB =
"PermitOrderWithAdditionalData(uint256 tokenType,address token,uint256 id,uint256 amount,uint256 salt,address operator,uint256 expiration,uint256 masterNonce,";
uint256 constant PAUSABLE_APPROVAL_TRANSFER_FROM_ERC721 = 1 << 0;
uint256 constant PAUSABLE_APPROVAL_TRANSFER_FROM_ERC1155 = 1 << 1;
uint256 constant PAUSABLE_APPROVAL_TRANSFER_FROM_ERC20 = 1 << 2;
uint256 constant PAUSABLE_PERMITTED_TRANSFER_FROM_ERC721 = 1 << 3;
uint256 constant PAUSABLE_PERMITTED_TRANSFER_FROM_ERC1155 = 1 << 4;
uint256 constant PAUSABLE_PERMITTED_TRANSFER_FROM_ERC20 = 1 << 5;
uint256 constant PAUSABLE_ORDER_TRANSFER_FROM_ERC1155 = 1 << 6;
uint256 constant PAUSABLE_ORDER_TRANSFER_FROM_ERC20 = 1 << 7;
pragma solidity ^0.8.4;
interface IERC721A {
error ApprovalCallerNotOwnerNorApproved();
error ApprovalQueryForNonexistentToken();
error BalanceQueryForZeroAddress();
error MintToZeroAddress();
error MintZeroQuantity();
error OwnerQueryForNonexistentToken();
error TransferCallerNotOwnerNorApproved();
error TransferFromIncorrectOwner();
error TransferToNonERC721ReceiverImplementer();
error TransferToZeroAddress();
error URIQueryForNonexistentToken();
error MintERC2309QuantityExceedsLimit();
error OwnershipNotInitializedForExtraData();
struct TokenOwnership {
address addr;
uint64 startTimestamp;
bool burned;
uint24 extraData;
}
function totalSupply() external view returns (uint256);
function supportsInterface(bytes4 interfaceId) external view returns (bool);
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 payable;
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external payable;
function transferFrom(
address from,
address to,
uint256 tokenId
) external payable;
function approve(address to, uint256 tokenId) external payable;
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);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
event ConsecutiveTransfer(uint256 indexed fromTokenId, uint256 toTokenId, address indexed from, address indexed to);
}
pragma solidity ^0.8.4;
interface ERC721A__IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
contract ERC721A is IERC721A {
struct TokenApprovalRef {
address value;
}
uint256 private constant _BITMASK_ADDRESS_DATA_ENTRY = (1 << 64) - 1;
uint256 private constant _BITPOS_NUMBER_MINTED = 64;
uint256 private constant _BITPOS_NUMBER_BURNED = 128;
uint256 private constant _BITPOS_AUX = 192;
uint256 private constant _BITMASK_AUX_COMPLEMENT = (1 << 192) - 1;
uint256 private constant _BITPOS_START_TIMESTAMP = 160;
uint256 private constant _BITMASK_BURNED = 1 << 224;
uint256 private constant _BITPOS_NEXT_INITIALIZED = 225;
uint256 private constant _BITMASK_NEXT_INITIALIZED = 1 << 225;
uint256 private constant _BITPOS_EXTRA_DATA = 232;
uint256 private constant _BITMASK_EXTRA_DATA_COMPLEMENT = (1 << 232) - 1;
uint256 private constant _BITMASK_ADDRESS = (1 << 160) - 1;
uint256 private constant _MAX_MINT_ERC2309_QUANTITY_LIMIT = 5000;
bytes32 private constant _TRANSFER_EVENT_SIGNATURE =
0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef;
uint256 private _currentIndex;
uint256 private _burnCounter;
string private _name;
string private _symbol;
mapping(uint256 => uint256) private _packedOwnerships;
mapping(address => uint256) private _packedAddressData;
mapping(uint256 => TokenApprovalRef) 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 _nextTokenId() internal view virtual returns (uint256) {
return _currentIndex;
}
function totalSupply() public view virtual override returns (uint256) {
unchecked {
return _currentIndex - _burnCounter - _startTokenId();
}
}
function _totalMinted() internal view virtual returns (uint256) {
unchecked {
return _currentIndex - _startTokenId();
}
}
function _totalBurned() internal view virtual returns (uint256) {
return _burnCounter;
}
function balanceOf(address owner) public view virtual override returns (uint256) {
if (owner == address(0)) revert BalanceQueryForZeroAddress();
return _packedAddressData[owner] & _BITMASK_ADDRESS_DATA_ENTRY;
}
function _numberMinted(address owner) internal view returns (uint256) {
return (_packedAddressData[owner] >> _BITPOS_NUMBER_MINTED) & _BITMASK_ADDRESS_DATA_ENTRY;
}
function _numberBurned(address owner) internal view returns (uint256) {
return (_packedAddressData[owner] >> _BITPOS_NUMBER_BURNED) & _BITMASK_ADDRESS_DATA_ENTRY;
}
function _getAux(address owner) internal view returns (uint64) {
return uint64(_packedAddressData[owner] >> _BITPOS_AUX);
}
function _setAux(address owner, uint64 aux) internal virtual {
uint256 packed = _packedAddressData[owner];
uint256 auxCasted;
assembly {
auxCasted := aux
}
packed = (packed & _BITMASK_AUX_COMPLEMENT) | (auxCasted << _BITPOS_AUX);
_packedAddressData[owner] = packed;
}
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return
interfaceId == 0x01ffc9a7 ||
interfaceId == 0x80ac58cd ||
interfaceId == 0x5b5e139f;
}
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, _toString(tokenId))) : '';
}
function _baseURI() internal view virtual returns (string memory) {
return '';
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
return address(uint160(_packedOwnershipOf(tokenId)));
}
function _ownershipOf(uint256 tokenId) internal view virtual returns (TokenOwnership memory) {
return _unpackedOwnership(_packedOwnershipOf(tokenId));
}
function _ownershipAt(uint256 index) internal view virtual returns (TokenOwnership memory) {
return _unpackedOwnership(_packedOwnerships[index]);
}
function _initializeOwnershipAt(uint256 index) internal virtual {
if (_packedOwnerships[index] == 0) {
_packedOwnerships[index] = _packedOwnershipOf(index);
}
}
function _packedOwnershipOf(uint256 tokenId) private view returns (uint256) {
uint256 curr = tokenId;
unchecked {
if (_startTokenId() <= curr)
if (curr < _currentIndex) {
uint256 packed = _packedOwnerships[curr];
if (packed & _BITMASK_BURNED == 0) {
while (packed == 0) {
packed = _packedOwnerships[--curr];
}
return packed;
}
}
}
revert OwnerQueryForNonexistentToken();
}
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);
}
function _packOwnershipData(address owner, uint256 flags) private view returns (uint256 result) {
assembly {
owner := and(owner, _BITMASK_ADDRESS)
result := or(owner, or(shl(_BITPOS_START_TIMESTAMP, timestamp()), flags))
}
}
function _nextInitializedFlag(uint256 quantity) private pure returns (uint256 result) {
assembly {
result := shl(_BITPOS_NEXT_INITIALIZED, eq(quantity, 1))
}
}
function approve(address to, uint256 tokenId) public payable virtual override {
address owner = ownerOf(tokenId);
if (_msgSenderERC721A() != owner)
if (!isApprovedForAll(owner, _msgSenderERC721A())) {
revert ApprovalCallerNotOwnerNorApproved();
}
_tokenApprovals[tokenId].value = to;
emit Approval(owner, to, tokenId);
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
if (!_exists(tokenId)) revert ApprovalQueryForNonexistentToken();
return _tokenApprovals[tokenId].value;
}
function setApprovalForAll(address operator, bool approved) public virtual override {
_operatorApprovals[_msgSenderERC721A()][operator] = approved;
emit ApprovalForAll(_msgSenderERC721A(), operator, approved);
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return
_startTokenId() <= tokenId &&
tokenId < _currentIndex &&
_packedOwnerships[tokenId] & _BITMASK_BURNED == 0;
}
function _isSenderApprovedOrOwner(
address approvedAddress,
address owner,
address msgSender
) private pure returns (bool result) {
assembly {
owner := and(owner, _BITMASK_ADDRESS)
msgSender := and(msgSender, _BITMASK_ADDRESS)
result := or(eq(msgSender, owner), eq(msgSender, approvedAddress))
}
}
function _getApprovedSlotAndAddress(uint256 tokenId)
private
view
returns (uint256 approvedAddressSlot, address approvedAddress)
{
TokenApprovalRef storage tokenApproval = _tokenApprovals[tokenId];
assembly {
approvedAddressSlot := tokenApproval.slot
approvedAddress := sload(approvedAddressSlot)
}
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable virtual override {
uint256 prevOwnershipPacked = _packedOwnershipOf(tokenId);
if (address(uint160(prevOwnershipPacked)) != from) revert TransferFromIncorrectOwner();
(uint256 approvedAddressSlot, address approvedAddress) = _getApprovedSlotAndAddress(tokenId);
if (!_isSenderApprovedOrOwner(approvedAddress, from, _msgSenderERC721A()))
if (!isApprovedForAll(from, _msgSenderERC721A())) revert TransferCallerNotOwnerNorApproved();
if (to == address(0)) revert TransferToZeroAddress();
_beforeTokenTransfers(from, to, tokenId, 1);
assembly {
if approvedAddress {
sstore(approvedAddressSlot, 0)
}
}
unchecked {
--_packedAddressData[from];
++_packedAddressData[to];
_packedOwnerships[tokenId] = _packOwnershipData(
to,
_BITMASK_NEXT_INITIALIZED | _nextExtraData(from, to, prevOwnershipPacked)
);
if (prevOwnershipPacked & _BITMASK_NEXT_INITIALIZED == 0) {
uint256 nextTokenId = tokenId + 1;
if (_packedOwnerships[nextTokenId] == 0) {
if (nextTokenId != _currentIndex) {
_packedOwnerships[nextTokenId] = prevOwnershipPacked;
}
}
}
}
emit Transfer(from, to, tokenId);
_afterTokenTransfers(from, to, tokenId, 1);
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable virtual override {
safeTransferFrom(from, to, tokenId, '');
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public payable virtual override {
transferFrom(from, to, tokenId);
if (to.code.length != 0)
if (!_checkContractOnERC721Received(from, to, tokenId, _data)) {
revert TransferToNonERC721ReceiverImplementer();
}
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
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))
}
}
}
}
function _mint(address to, uint256 quantity) internal virtual {
uint256 startTokenId = _currentIndex;
if (quantity == 0) revert MintZeroQuantity();
_beforeTokenTransfers(address(0), to, startTokenId, quantity);
unchecked {
_packedAddressData[to] += quantity * ((1 << _BITPOS_NUMBER_MINTED) | 1);
_packedOwnerships[startTokenId] = _packOwnershipData(
to,
_nextInitializedFlag(quantity) | _nextExtraData(address(0), to, 0)
);
uint256 toMasked;
uint256 end = startTokenId + quantity;
assembly {
toMasked := and(to, _BITMASK_ADDRESS)
log4(
0,
0,
_TRANSFER_EVENT_SIGNATURE,
0,
toMasked,
startTokenId
)
for {
let tokenId := add(startTokenId, 1)
} iszero(eq(tokenId, end)) {
tokenId := add(tokenId, 1)
} {
log4(0, 0, _TRANSFER_EVENT_SIGNATURE, 0, toMasked, tokenId)
}
}
if (toMasked == 0) revert MintToZeroAddress();
_currentIndex = end;
}
_afterTokenTransfers(address(0), to, startTokenId, quantity);
}
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);
unchecked {
_packedAddressData[to] += quantity * ((1 << _BITPOS_NUMBER_MINTED) | 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);
}
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);
if (_currentIndex != end) revert();
}
}
}
function _safeMint(address to, uint256 quantity) internal virtual {
_safeMint(to, quantity, '');
}
function _burn(uint256 tokenId) internal virtual {
_burn(tokenId, false);
}
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) {
if (!_isSenderApprovedOrOwner(approvedAddress, from, _msgSenderERC721A()))
if (!isApprovedForAll(from, _msgSenderERC721A())) revert TransferCallerNotOwnerNorApproved();
}
_beforeTokenTransfers(from, address(0), tokenId, 1);
assembly {
if approvedAddress {
sstore(approvedAddressSlot, 0)
}
}
unchecked {
_packedAddressData[from] += (1 << _BITPOS_NUMBER_BURNED) - 1;
_packedOwnerships[tokenId] = _packOwnershipData(
from,
(_BITMASK_BURNED | _BITMASK_NEXT_INITIALIZED) | _nextExtraData(from, address(0), prevOwnershipPacked)
);
if (prevOwnershipPacked & _BITMASK_NEXT_INITIALIZED == 0) {
uint256 nextTokenId = tokenId + 1;
if (_packedOwnerships[nextTokenId] == 0) {
if (nextTokenId != _currentIndex) {
_packedOwnerships[nextTokenId] = prevOwnershipPacked;
}
}
}
}
emit Transfer(from, address(0), tokenId);
_afterTokenTransfers(from, address(0), tokenId, 1);
unchecked {
_burnCounter++;
}
}
function _setExtraDataAt(uint256 index, uint24 extraData) internal virtual {
uint256 packed = _packedOwnerships[index];
if (packed == 0) revert OwnershipNotInitializedForExtraData();
uint256 extraDataCasted;
assembly {
extraDataCasted := extraData
}
packed = (packed & _BITMASK_EXTRA_DATA_COMPLEMENT) | (extraDataCasted << _BITPOS_EXTRA_DATA);
_packedOwnerships[index] = packed;
}
function _extraData(
address from,
address to,
uint24 previousExtraData
) internal view virtual returns (uint24) {}
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;
}
function _msgSenderERC721A() internal view virtual returns (address) {
return msg.sender;
}
function _toString(uint256 value) internal pure virtual returns (string memory str) {
assembly {
let m := add(mload(0x40), 0xa0)
mstore(0x40, m)
str := sub(m, 0x20)
mstore(str, 0)
let end := str
for { let temp := value } 1 {} {
str := sub(str, 1)
mstore8(str, add(48, mod(temp, 10)))
temp := div(temp, 10)
if iszero(temp) { break }
}
let length := sub(end, str)
str := sub(str, 0x20)
mstore(str, length)
}
}
}
pragma solidity ^0.8.4;
abstract contract ERC721AC is ERC721A, CreatorTokenBase, AutomaticValidatorTransferApproval {
constructor(string memory name_, string memory symbol_) CreatorTokenBase() ERC721A(name_, symbol_) {}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool isApproved) {
isApproved = super.isApprovedForAll(owner, operator);
if (!isApproved) {
if (autoApproveTransfersFromValidator) {
isApproved = operator == address(getTransferValidator());
}
}
}
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return
interfaceId == type(ICreatorToken).interfaceId ||
interfaceId == type(ICreatorTokenLegacy).interfaceId ||
super.supportsInterface(interfaceId);
}
function getTransferValidationFunction() external pure returns (bytes4 functionSignature, bool isViewFunction) {
functionSignature = bytes4(keccak256("validateTransfer(address,address,address,uint256)"));
isViewFunction = true;
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual override {
for (uint256 i = 0; i < quantity;) {
_validateBeforeTransfer(from, to, startTokenId + i);
unchecked {
++i;
}
}
}
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual override {
for (uint256 i = 0; i < quantity;) {
_validateAfterTransfer(from, to, startTokenId + i);
unchecked {
++i;
}
}
}
function _msgSenderERC721A() internal view virtual override returns (address) {
return _msgSender();
}
function _tokenType() internal pure override returns(uint16) {
return uint16(TOKEN_TYPE_ERC721);
}
}
pragma solidity ^0.8.0;
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);
}
}
pragma solidity ^0.8.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
pragma solidity ^0.8.0;
interface IERC2981 is IERC165 {
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
returns (address receiver, uint256 royaltyAmount);
}
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;
abstract contract ERC2981 is IERC2981, ERC165 {
struct RoyaltyInfo {
address receiver;
uint96 royaltyFraction;
}
RoyaltyInfo private _defaultRoyaltyInfo;
mapping(uint256 => RoyaltyInfo) private _tokenRoyaltyInfo;
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC165) returns (bool) {
return interfaceId == type(IERC2981).interfaceId || super.supportsInterface(interfaceId);
}
function royaltyInfo(uint256 _tokenId, uint256 _salePrice) public view virtual override returns (address, uint256) {
RoyaltyInfo memory royalty = _tokenRoyaltyInfo[_tokenId];
if (royalty.receiver == address(0)) {
royalty = _defaultRoyaltyInfo;
}
uint256 royaltyAmount = (_salePrice * royalty.royaltyFraction) / _feeDenominator();
return (royalty.receiver, royaltyAmount);
}
function _feeDenominator() internal pure virtual returns (uint96) {
return 10000;
}
function _setDefaultRoyalty(address receiver, uint96 feeNumerator) internal virtual {
require(feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice");
require(receiver != address(0), "ERC2981: invalid receiver");
_defaultRoyaltyInfo = RoyaltyInfo(receiver, feeNumerator);
}
function _deleteDefaultRoyalty() internal virtual {
delete _defaultRoyaltyInfo;
}
function _setTokenRoyalty(
uint256 tokenId,
address receiver,
uint96 feeNumerator
) internal virtual {
require(feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice");
require(receiver != address(0), "ERC2981: Invalid parameters");
_tokenRoyaltyInfo[tokenId] = RoyaltyInfo(receiver, feeNumerator);
}
function _resetTokenRoyalty(uint256 tokenId) internal virtual {
delete _tokenRoyaltyInfo[tokenId];
}
}
pragma solidity ^0.8.0;
interface IPythEvents {
event PriceFeedUpdate(
bytes32 indexed id,
uint64 publishTime,
int64 price,
uint64 conf
);
event TwapPriceFeedUpdate(
bytes32 indexed id,
uint64 startTime,
uint64 endTime,
int64 twapPrice,
uint64 twapConf,
uint32 downSlotsRatio
);
}
pragma solidity ^0.8.0;
contract PythStructs {
struct Price {
int64 price;
uint64 conf;
int32 expo;
uint publishTime;
}
struct PriceFeed {
bytes32 id;
Price price;
Price emaPrice;
}
struct TwapPriceFeed {
bytes32 id;
uint64 startTime;
uint64 endTime;
Price twap;
uint32 downSlotsRatio;
}
struct TwapPriceInfo {
int128 cumulativePrice;
uint128 cumulativeConf;
uint64 numDownSlots;
uint64 publishSlot;
uint64 publishTime;
uint64 prevPublishTime;
int32 expo;
}
}
pragma solidity ^0.8.0;
interface IPyth is IPythEvents {
function getPriceUnsafe(
bytes32 id
) external view returns (PythStructs.Price memory price);
function getPriceNoOlderThan(
bytes32 id,
uint age
) external view returns (PythStructs.Price memory price);
function getEmaPriceUnsafe(
bytes32 id
) external view returns (PythStructs.Price memory price);
function getEmaPriceNoOlderThan(
bytes32 id,
uint age
) external view returns (PythStructs.Price memory price);
function updatePriceFeeds(bytes[] calldata updateData) external payable;
function updatePriceFeedsIfNecessary(
bytes[] calldata updateData,
bytes32[] calldata priceIds,
uint64[] calldata publishTimes
) external payable;
function getUpdateFee(
bytes[] calldata updateData
) external view returns (uint feeAmount);
function parsePriceFeedUpdates(
bytes[] calldata updateData,
bytes32[] calldata priceIds,
uint64 minPublishTime,
uint64 maxPublishTime
) external payable returns (PythStructs.PriceFeed[] memory priceFeeds);
function parseTwapPriceFeedUpdates(
bytes[] calldata updateData,
bytes32[] calldata priceIds
)
external
payable
returns (PythStructs.TwapPriceFeed[] memory twapPriceFeeds);
function parsePriceFeedUpdatesUnique(
bytes[] calldata updateData,
bytes32[] calldata priceIds,
uint64 minPublishTime,
uint64 maxPublishTime
) external payable returns (PythStructs.PriceFeed[] memory priceFeeds);
function parsePriceFeedUpdatesWithSlots(
bytes[] calldata updateData,
bytes32[] calldata priceIds,
uint64 minPublishTime,
uint64 maxPublishTime
)
external
payable
returns (
PythStructs.PriceFeed[] memory priceFeeds,
uint64[] memory slots
);
}
pragma solidity ^0.8.24;
error InsufficientUpdateFee(uint256 requiredFee);
error ContractNotVerified(address contractAddress);
contract KingdomlyFeeContract is Ownable {
uint256 private cachedOneDollarInWei;
uint256 private maxPriceAgeInSeconds;
IPyth pyth;
bytes32 ethUsdPriceId;
constructor(address _pyth, bytes32 _ethUsdPriceId) Ownable() {
pyth = IPyth(_pyth);
ethUsdPriceId = _ethUsdPriceId;
maxPriceAgeInSeconds = 60 * 60 * 24;
}
function getOneDollarInWei() public view returns (uint256) {
try
pyth.getPriceNoOlderThan(ethUsdPriceId, maxPriceAgeInSeconds)
returns (PythStructs.Price memory price) {
uint256 ethPrice18Decimals = (uint256(uint64(price.price)) *
(10 ** 18)) / (10 ** uint8(uint32(-1 * price.expo)));
uint256 oneDollarInWei = ((10 ** 18) * (10 ** 18)) /
ethPrice18Decimals;
return oneDollarInWei;
} catch {
return cachedOneDollarInWei;
}
}
function updateOracleAndGetOneDollarInWei(
bytes[] calldata pythPriceUpdate
) public payable returns (uint256) {
uint256 updateFee = pyth.getUpdateFee(pythPriceUpdate);
if (msg.value != updateFee) {
revert InsufficientUpdateFee(updateFee);
}
pyth.updatePriceFeeds{value: msg.value}(pythPriceUpdate);
cachedOneDollarInWei = getOneDollarInWei();
return cachedOneDollarInWei;
}
function updateMaxPriceAgeInSeconds(
uint256 _maxPriceAgeInSeconds
) public onlyOwner {
maxPriceAgeInSeconds = _maxPriceAgeInSeconds;
}
}
pragma solidity >=0.8.13;
interface IDelegateRegistry {
enum DelegationType {
NONE,
ALL,
CONTRACT,
ERC721,
ERC20,
ERC1155
}
struct Delegation {
DelegationType type_;
address to;
address from;
bytes32 rights;
address contract_;
uint256 tokenId;
uint256 amount;
}
event DelegateAll(address indexed from, address indexed to, bytes32 rights, bool enable);
event DelegateContract(
address indexed from, address indexed to, address indexed contract_, bytes32 rights, bool enable
);
event DelegateERC721(
address indexed from,
address indexed to,
address indexed contract_,
uint256 tokenId,
bytes32 rights,
bool enable
);
event DelegateERC20(
address indexed from, address indexed to, address indexed contract_, bytes32 rights, uint256 amount
);
event DelegateERC1155(
address indexed from,
address indexed to,
address indexed contract_,
uint256 tokenId,
bytes32 rights,
uint256 amount
);
error MulticallFailed();
function multicall(bytes[] calldata data) external payable returns (bytes[] memory results);
function delegateAll(address to, bytes32 rights, bool enable) external payable returns (bytes32 delegationHash);
function delegateContract(address to, address contract_, bytes32 rights, bool enable)
external
payable
returns (bytes32 delegationHash);
function delegateERC721(address to, address contract_, uint256 tokenId, bytes32 rights, bool enable)
external
payable
returns (bytes32 delegationHash);
function delegateERC20(address to, address contract_, bytes32 rights, uint256 amount)
external
payable
returns (bytes32 delegationHash);
function delegateERC1155(address to, address contract_, uint256 tokenId, bytes32 rights, uint256 amount)
external
payable
returns (bytes32 delegationHash);
function checkDelegateForAll(address to, address from, bytes32 rights) external view returns (bool);
function checkDelegateForContract(address to, address from, address contract_, bytes32 rights)
external
view
returns (bool);
function checkDelegateForERC721(address to, address from, address contract_, uint256 tokenId, bytes32 rights)
external
view
returns (bool);
function checkDelegateForERC20(address to, address from, address contract_, bytes32 rights)
external
view
returns (uint256);
function checkDelegateForERC1155(address to, address from, address contract_, uint256 tokenId, bytes32 rights)
external
view
returns (uint256);
function getIncomingDelegations(address to) external view returns (Delegation[] memory delegations);
function getOutgoingDelegations(address from) external view returns (Delegation[] memory delegations);
function getIncomingDelegationHashes(address to) external view returns (bytes32[] memory delegationHashes);
function getOutgoingDelegationHashes(address from) external view returns (bytes32[] memory delegationHashes);
function getDelegationsFromHashes(bytes32[] calldata delegationHashes)
external
view
returns (Delegation[] memory delegations);
function readSlot(bytes32 location) external view returns (bytes32);
function readSlots(bytes32[] calldata locations) external view returns (bytes32[] memory);
}
pragma solidity ^0.8.24;
error MintInactive();
error Unauthorized(address caller);
error InvalidOperation(string reason);
error ExceedsMaxSupply(uint256 requested, uint256 available);
error InsufficientEther(uint256 required, uint256 provided);
error ExceedsMaxPerWallet(uint256 requested, uint256 allowed);
error ExceedsMintQuota(uint256 requested, uint256 allowed);
error ExceedsMaxMintGroupSupply(uint256 requested, uint256 available);
error MintGroupInactive(uint256 mintId);
error NotInPresale(address caller, uint256 mintId);
error MintGroupDoesNotExist(uint256 mintId);
error ArrayLengthMismatch();
error InvalidKingdomlyFeeContract();
contract megafknwizards is ERC721AC, ERC2981, Ownable {
event BatchMetadataUpdate(
uint256 indexed fromTokenId,
uint256 indexed toTokenId
);
event TokensMinted(
address indexed recipient,
uint256 amount,
uint256 mintId
);
event TokensDelegateMinted(
address indexed vault,
address indexed hotWallet,
uint256 amount,
uint256 mintId
);
event SalePriceChanged(uint256 indexed mintId, uint256 newPrice);
event MaxMintPerWalletChanged(
uint256 newMaxMintPerWallet,
uint256 mintGroupId
);
event PreSaleMintStatusChanged(bool status, uint256 mintGroupId);
event PreSaleMintScheduledStartTimestampChanged(
uint256 timestamp,
uint256 mintGroupId
);
event KingdomlyFeeContractChanged(address feeContractAddress);
struct BaseVariables {
string name;
string symbol;
address ownerPayoutAddress;
string initialBaseURI;
uint256 maxSupply;
}
mapping(address => uint256) private pendingBalances;
uint256 public maxSupply;
uint256 public immutable threeDollarsInCents;
bool public contractMintLive = false;
uint256 public scheduledMintLiveTimestamp = 0;
string public baseURI;
address public feeAddress;
address public ownerPayoutAddress;
address public kingdomlyAdmin;
KingdomlyFeeContract public kingdomlyFeeContract;
mapping(uint256 => uint256) public maxMintPerWallet;
mapping(uint256 => uint256) public mintPrice;
mapping(uint256 => uint256) public maxSupplyPerMintGroup;
mapping(uint256 => uint256) public mintGroupMints;
mapping(address => mapping(uint256 => uint256)) private addressMints;
mapping(uint256 => mapping(address => uint256)) public mintQuotas;
mapping(uint256 => bool) public contractPresaleActive;
mapping(uint256 => uint256) public presaleScheduledStartTimestamp;
uint256[] public activeMintGroups;
constructor(
BaseVariables memory _baseVariables,
uint256[] memory _maxMintPerWallet,
uint256[] memory _maxSupplyPerMintGroup,
uint256[] memory _mintPrice,
uint96 _royaltyPercentage,
address _kingdomlyAdmin,
KingdomlyFeeContract _kingdomlyFeeContract
) ERC721AC(_baseVariables.name, _baseVariables.symbol) Ownable() {
if (
_maxMintPerWallet.length != _maxSupplyPerMintGroup.length &&
_maxMintPerWallet.length != _mintPrice.length
) {
revert ArrayLengthMismatch();
}
uint256 totalMaxSupplyPerMintGroup = 0;
for (uint256 i = 0; i < _maxSupplyPerMintGroup.length; i++) {
totalMaxSupplyPerMintGroup += _maxSupplyPerMintGroup[i];
maxSupplyPerMintGroup[i] = _maxSupplyPerMintGroup[i];
maxMintPerWallet[i] = _maxMintPerWallet[i];
mintPrice[i] = _mintPrice[i];
mintGroupMints[i] = 0;
activeMintGroups.push(i);
}
if (totalMaxSupplyPerMintGroup > _baseVariables.maxSupply) {
revert InvalidOperation({
reason: "Max supply per mint group exceeds total max supply"
});
}
maxSupply = _baseVariables.maxSupply;
baseURI = _baseVariables.initialBaseURI;
ownerPayoutAddress = _baseVariables.ownerPayoutAddress;
feeAddress = 0x10317Fa93da2a2e6d7B8e29D2BC2e6B95f2ECc84;
_setDefaultRoyalty(
_baseVariables.ownerPayoutAddress,
_royaltyPercentage
);
kingdomlyAdmin = _kingdomlyAdmin;
kingdomlyFeeContract = _kingdomlyFeeContract;
threeDollarsInCents = 300;
}
modifier isKingdomlyAdmin() {
if (msg.sender != kingdomlyAdmin) {
revert Unauthorized(msg.sender);
}
_;
}
function initializeNewMintGroup(uint256 mintId) internal {
mintPrice[mintId] = 0;
maxMintPerWallet[mintId] = 0;
maxSupplyPerMintGroup[mintId] = 0;
mintGroupMints[mintId] = 0;
activeMintGroups.push(mintId);
}
function isMintGroupActive(uint256 mintId) private view returns (bool) {
for (uint256 i = 0; i < activeMintGroups.length; i++) {
if (activeMintGroups[i] == mintId) {
return true;
}
}
return false;
}
function mintLive() public view returns (bool) {
if (!contractMintLive) {
if (
scheduledMintLiveTimestamp == 0 ||
block.timestamp <= scheduledMintLiveTimestamp
) {
return false;
}
}
return true;
}
function setNewMaxPerMintGroup(
uint256 mintId,
uint256 newMax
) public onlyOwner {
if (!isMintGroupActive(mintId)) {
initializeNewMintGroup(mintId);
}
uint256 totalMaxMintPerMG = 0;
for (uint256 i = 0; i < activeMintGroups.length; i++) {
if (activeMintGroups[i] == mintId) {
totalMaxMintPerMG += newMax;
} else {
totalMaxMintPerMG += maxSupplyPerMintGroup[activeMintGroups[i]];
}
}
if (totalMaxMintPerMG > maxSupply) {
revert InvalidOperation({
reason: "New supply per mint group exceeds total supply."
});
}
maxSupplyPerMintGroup[mintId] = newMax;
}
function setMintQuota(
address[] memory addressToAdd,
uint256 mintId,
uint256[] memory _mintQuotas
) external onlyOwner {
if (!isMintGroupActive(mintId)) {
initializeNewMintGroup(mintId);
}
for (uint256 i = 0; i < addressToAdd.length; i++) {
mintQuotas[mintId][addressToAdd[i]] = _mintQuotas[i];
}
}
function stopOrStartpresaleMint(
bool presaleStatus,
uint256 mintId
) public onlyOwner {
if (!isMintGroupActive(mintId)) {
revert MintGroupDoesNotExist({mintId: mintId});
}
contractPresaleActive[mintId] = presaleStatus;
if (presaleStatus == false) {
presaleScheduledStartTimestamp[mintId] = 0;
}
emit PreSaleMintStatusChanged(presaleStatus, mintId);
}
function schedulePresaleMintStart(
uint256 startTimestamp,
uint256 mintId
) public onlyOwner {
if (!isMintGroupActive(mintId)) {
revert MintGroupDoesNotExist({mintId: mintId});
}
presaleScheduledStartTimestamp[mintId] = startTimestamp;
emit PreSaleMintScheduledStartTimestampChanged(startTimestamp, mintId);
}
function presaleActive(uint256 mintId) public view returns (bool) {
if (!contractPresaleActive[mintId]) {
if (
presaleScheduledStartTimestamp[mintId] == 0 ||
block.timestamp <= presaleScheduledStartTimestamp[mintId]
) {
return false;
}
}
return true;
}
function setMaxMintPerWallet(
uint256 newMaxMintPerWallet,
uint256 mintGroupId
) public onlyOwner {
maxMintPerWallet[mintGroupId] = newMaxMintPerWallet;
emit MaxMintPerWalletChanged(newMaxMintPerWallet, mintGroupId);
}
function changeSalePrice(
uint256 newmintPrice,
uint256 mintId
) public onlyOwner {
if (!isMintGroupActive(mintId)) {
initializeNewMintGroup(mintId);
}
mintPrice[mintId] = newmintPrice;
emit SalePriceChanged(mintId, newmintPrice);
}
function airdropNFTs(
address[] memory recipients,
uint256[] memory amounts
) external payable onlyOwner returns (uint256 totalCharge) {
if (recipients.length != amounts.length) {
revert InvalidOperation({
reason: "Mismatch between recipients and amounts"
});
}
uint256 totalNFTToMint = 0;
for (uint256 i = 0; i < amounts.length; i++) {
totalNFTToMint += amounts[i];
}
totalCharge = quoteAirdropFees(totalNFTToMint);
if (msg.value < totalCharge) {
revert InvalidOperation({
reason: "Not enough Ether sent for the airdrop charge"
});
}
pendingBalances[feeAddress] += totalCharge;
for (uint256 j = 0; j < recipients.length; j++) {
uint256 amount = amounts[j];
if (totalSupply() + amount > maxSupply) {
revert InvalidOperation({reason: "Airdrop exceeds max supply"});
}
_safeMint(recipients[j], amount);
}
_refundExcessEther(totalCharge);
}
function canMintCheck(
uint256 amount,
uint256 mintId,
address minterAddress
) public view returns (bool, string memory) {
if (
amount + addressMints[minterAddress][mintId] >
maxMintPerWallet[mintId]
) {
return (false, "ExceedsMaxPerWallet");
}
if (amount == 0) {
return (false, "InvalidOperation");
}
if (!mintLive()) {
return (false, "MintInactive");
}
if (!contractPresaleActive[mintId]) {
if (
presaleScheduledStartTimestamp[mintId] == 0 ||
block.timestamp <= presaleScheduledStartTimestamp[mintId]
) {
return (false, "MintGroupInactive");
}
}
if (mintId != 0) {
if (mintQuotas[mintId][minterAddress] == 0) {
return (false, "NotInPresale");
}
if (amount > mintQuotas[mintId][minterAddress]) {
return (false, "ExceedsMintQuota");
}
}
if (mintGroupMints[mintId] + amount > maxSupplyPerMintGroup[mintId]) {
return (false, "ExceedsMaxMintGroupSupply");
}
if (totalSupply() + amount > maxSupply) {
return (false, "ExceedsMaxSupply");
}
return (true, "");
}
function batchMint(
uint256 amount,
uint256 mintId
) external payable returns (uint256 totalCostWithFee) {
if (
amount + addressMints[msg.sender][mintId] > maxMintPerWallet[mintId]
) {
revert ExceedsMaxPerWallet({
requested: amount,
allowed: maxMintPerWallet[mintId] -
addressMints[msg.sender][mintId]
});
}
addressMints[msg.sender][mintId] += amount;
totalCostWithFee = _batchMint(msg.sender, amount, mintId);
emit TokensMinted(msg.sender, amount, mintId);
_refundExcessEther(totalCostWithFee);
}
address constant DELEGATE_REGISTRY =
0x00000000000000447e69651d841bD8D104Bed493;
function canDelegateMintCheck(
uint256 amount,
uint256 mintId,
address vault,
address minterAddress
) public view returns (bool, string memory) {
if (
!IDelegateRegistry(DELEGATE_REGISTRY).checkDelegateForContract(
minterAddress,
vault,
address(this),
""
)
) {
return (false, "Unauthorized");
}
if (amount + addressMints[vault][mintId] > maxMintPerWallet[mintId]) {
return (false, "ExceedsMaxPerWallet");
}
if (amount == 0) {
return (false, "InvalidOperation");
}
if (!mintLive()) {
return (false, "MintInactive");
}
if (!contractPresaleActive[mintId]) {
if (
presaleScheduledStartTimestamp[mintId] == 0 ||
block.timestamp <= presaleScheduledStartTimestamp[mintId]
) {
return (false, "MintGroupInactive");
}
}
if (mintId != 0) {
if (mintQuotas[mintId][vault] == 0) {
return (false, "NotInPresale");
}
if (amount > mintQuotas[mintId][vault]) {
return (false, "ExceedsMintQuota");
}
}
if (mintGroupMints[mintId] + amount > maxSupplyPerMintGroup[mintId]) {
return (false, "ExceedsMaxMintGroupSupply");
}
if (totalSupply() + amount > maxSupply) {
return (false, "ExceedsMaxSupply");
}
return (true, "");
}
function delegatedMint(
uint256 amount,
uint256 mintId,
address vault
) external payable returns (uint256 totalCostWithFee) {
if (
!IDelegateRegistry(DELEGATE_REGISTRY).checkDelegateForContract(
msg.sender,
vault,
address(this),
""
)
) {
revert Unauthorized(vault);
}
if (amount + addressMints[vault][mintId] > maxMintPerWallet[mintId]) {
revert ExceedsMaxPerWallet({
requested: amount,
allowed: maxMintPerWallet[mintId] - addressMints[vault][mintId]
});
}
addressMints[vault][mintId] += amount;
totalCostWithFee = _batchMint(vault, amount, mintId);
emit TokensDelegateMinted(vault, msg.sender, amount, mintId);
_refundExcessEther(totalCostWithFee);
}
function _batchMint(
address delegatedCaller,
uint256 amount,
uint256 mintId
) internal returns (uint256) {
if (amount == 0) {
revert InvalidOperation({reason: "Amount must be greater than 0"});
}
if (!mintLive()) {
revert MintInactive();
}
if (!contractPresaleActive[mintId]) {
if (
presaleScheduledStartTimestamp[mintId] == 0 ||
block.timestamp <= presaleScheduledStartTimestamp[mintId]
) {
revert MintGroupInactive({mintId: mintId});
}
}
if (mintId != 0) {
if (mintQuotas[mintId][delegatedCaller] == 0) {
revert NotInPresale({caller: delegatedCaller, mintId: mintId});
}
if (amount > mintQuotas[mintId][delegatedCaller]) {
revert ExceedsMintQuota({
requested: amount,
allowed: mintQuotas[mintId][delegatedCaller]
});
}
mintQuotas[mintId][delegatedCaller] -= amount;
}
if (mintGroupMints[mintId] + amount > maxSupplyPerMintGroup[mintId]) {
revert ExceedsMaxMintGroupSupply({
requested: amount,
available: maxSupplyPerMintGroup[mintId] -
mintGroupMints[mintId]
});
}
if (totalSupply() + amount > maxSupply) {
revert ExceedsMaxSupply({
requested: amount,
available: maxSupply - totalSupply()
});
}
(
uint256 totalCostWithFee,
uint256 mintingCost,
uint256 minterFee,
uint256 creatorFee
) = quoteBatchMint(mintId, amount);
if (msg.value < totalCostWithFee) {
revert InsufficientEther({
required: totalCostWithFee,
provided: msg.value
});
}
uint256 totalFee = minterFee + creatorFee;
pendingBalances[feeAddress] += totalFee;
pendingBalances[ownerPayoutAddress] += mintingCost - creatorFee;
mintGroupMints[mintId] += amount;
_safeMint(msg.sender, amount);
return totalCostWithFee;
}
function quoteBatchMint(
uint256 mintId,
uint256 amount
)
public
view
returns (
uint256 totalCostWithFee,
uint256 mintingCost,
uint256 minterFee,
uint256 creatorFee
)
{
mintingCost = mintPrice[mintId] * amount;
minterFee = threeDollarsEth() * amount;
creatorFee = (mintingCost * 3) / 100;
totalCostWithFee = mintingCost + minterFee;
}
function quoteAirdropFees(
uint256 amount
) public view returns (uint256 totalAirdropCostWithFee) {
totalAirdropCostWithFee = (threeDollarsEth() * amount * 11) / 100;
}
function changeMintStatus(bool status) public onlyOwner {
if (contractMintLive == status) {
revert InvalidOperation({
reason: "Mint status is already the one you entered"
});
}
if (status == false) {
scheduledMintLiveTimestamp = 0;
}
contractMintLive = status;
}
function setMintLiveTimestamp(uint256 timestamp) public onlyOwner {
scheduledMintLiveTimestamp = timestamp;
}
function setBaseURI(string memory newBaseURI) public onlyOwner {
baseURI = newBaseURI;
emit BatchMetadataUpdate(1, type(uint256).max);
}
function _withdrawFor(address user) internal returns (uint256 payout) {
payout = pendingBalances[user];
pendingBalances[user] = 0;
(bool success, ) = payable(user).call{value: payout}("");
if (!success) {
revert InvalidOperation({reason: "Withdraw Transfer Failed"});
}
}
function withdrawMintFunds() public {
_withdrawFor(ownerPayoutAddress);
_withdrawFor(feeAddress);
}
function withdrawFeeFunds() public {
_withdrawFor(feeAddress);
}
function _refundExcessEther(uint256 totalCharge) internal {
uint256 excess = msg.value - totalCharge;
if (excess > 0) {
(bool success, ) = payable(msg.sender).call{value: excess}("");
if (!success) {
pendingBalances[msg.sender] += excess;
}
}
}
function _baseURI() internal view override returns (string memory) {
return baseURI;
}
function checkPendingBalance() public view returns (uint256) {
return pendingBalances[msg.sender];
}
function checkPendingBalanceFor(
address user
) public view returns (uint256) {
return pendingBalances[user];
}
function _startTokenId() internal view virtual override returns (uint256) {
return 1;
}
function supportsInterface(
bytes4 interfaceId
) public view override(ERC721AC, ERC2981) returns (bool) {
return
ERC721AC.supportsInterface(interfaceId) ||
ERC2981.supportsInterface(interfaceId);
}
function setNewKingdomlyFeeContract(
KingdomlyFeeContract _kingdomlyFeeContract
) external isKingdomlyAdmin {
if (address(_kingdomlyFeeContract) == address(0)) {
revert InvalidKingdomlyFeeContract();
}
kingdomlyFeeContract = _kingdomlyFeeContract;
emit KingdomlyFeeContractChanged(address(_kingdomlyFeeContract));
}
function getKingdomlyFeeContract()
external
view
returns (KingdomlyFeeContract)
{
return kingdomlyFeeContract;
}
function getOneDollarInWei() internal view returns (uint256) {
return kingdomlyFeeContract.getOneDollarInWei();
}
function threeDollarsEth() public view returns (uint256) {
return (getOneDollarInWei() * threeDollarsInCents) / 100;
}
function _requireCallerIsContractOwner() internal view virtual override {
_checkOwner();
}
function setDefaultRoyalty(
address receiver,
uint96 feeNumerator
) external onlyOwner {
_setDefaultRoyalty(receiver, feeNumerator);
}
function setTokenRoyalty(
uint256 tokenId,
address receiver,
uint96 feeNumerator
) external onlyOwner {
_setTokenRoyalty(tokenId, receiver, feeNumerator);
}
function setOwnerPayoutAddress(
address _ownerPayoutAddress
) external onlyOwner {
ownerPayoutAddress = _ownerPayoutAddress;
}
}
