文件 1 的 1：IROIROShikigamiSale.sol
pragma solidity ^0.8.13;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IERC2981 is IERC165 {
function royaltyInfo(
uint256 tokenId,
uint256 salePrice
) external view returns (address receiver, uint256 royaltyAmount);
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
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];
}
}
interface IERC1155 is IERC165 {
event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);
event TransferBatch(
address indexed operator,
address indexed from,
address indexed to,
uint256[] ids,
uint256[] values
);
event ApprovalForAll(address indexed account, address indexed operator, bool approved);
event URI(string value, uint256 indexed id);
function balanceOf(address account, uint256 id) external view returns (uint256);
function balanceOfBatch(
address[] calldata accounts,
uint256[] calldata ids
) external view returns (uint256[] memory);
function setApprovalForAll(address operator, bool approved) external;
function isApprovedForAll(address account, address operator) external view returns (bool);
function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes calldata data) external;
function safeBatchTransferFrom(
address from,
address to,
uint256[] calldata ids,
uint256[] calldata amounts,
bytes calldata data
) external;
}
interface IERC1155MetadataURI is IERC1155 {
function uri(uint256 id) external view returns (string memory);
}
interface IERC1155Receiver is IERC165 {
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external returns (bytes4);
function onERC1155BatchReceived(
address operator,
address from,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
) external returns (bytes4);
}
library Address {
function isContract(address account) internal view returns (bool) {
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
contract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI {
using Address for address;
mapping(uint256 => mapping(address => uint256)) private _balances;
mapping(address => mapping(address => bool)) private _operatorApprovals;
string private _uri;
constructor(string memory uri_) {
_setURI(uri_);
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC1155).interfaceId ||
interfaceId == type(IERC1155MetadataURI).interfaceId ||
super.supportsInterface(interfaceId);
}
function uri(uint256) public view virtual override returns (string memory) {
return _uri;
}
function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {
require(account != address(0), "ERC1155: address zero is not a valid owner");
return _balances[id][account];
}
function balanceOfBatch(
address[] memory accounts,
uint256[] memory ids
) public view virtual override returns (uint256[] memory) {
require(accounts.length == ids.length, "ERC1155: accounts and ids length mismatch");
uint256[] memory batchBalances = new uint256[](accounts.length);
for (uint256 i = 0; i < accounts.length; ++i) {
batchBalances[i] = balanceOf(accounts[i], ids[i]);
}
return batchBalances;
}
function setApprovalForAll(address operator, bool approved) public virtual override {
_setApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address account, address operator) public view virtual override returns (bool) {
return _operatorApprovals[account][operator];
}
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual override {
require(
from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: caller is not token owner or approved"
);
_safeTransferFrom(from, to, id, amount, data);
}
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override {
require(
from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: caller is not token owner or approved"
);
_safeBatchTransferFrom(from, to, ids, amounts, data);
}
function _safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual {
require(to != address(0), "ERC1155: transfer to the zero address");
address operator = _msgSender();
uint256[] memory ids = _asSingletonArray(id);
uint256[] memory amounts = _asSingletonArray(amount);
_beforeTokenTransfer(operator, from, to, ids, amounts, data);
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
unchecked {
_balances[id][from] = fromBalance - amount;
}
_balances[id][to] += amount;
emit TransferSingle(operator, from, to, id, amount);
_afterTokenTransfer(operator, from, to, ids, amounts, data);
_doSafeTransferAcceptanceCheck(operator, from, to, id, amount, data);
}
function _safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
require(to != address(0), "ERC1155: transfer to the zero address");
address operator = _msgSender();
_beforeTokenTransfer(operator, from, to, ids, amounts, data);
for (uint256 i = 0; i < ids.length; ++i) {
uint256 id = ids[i];
uint256 amount = amounts[i];
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
unchecked {
_balances[id][from] = fromBalance - amount;
}
_balances[id][to] += amount;
}
emit TransferBatch(operator, from, to, ids, amounts);
_afterTokenTransfer(operator, from, to, ids, amounts, data);
_doSafeBatchTransferAcceptanceCheck(operator, from, to, ids, amounts, data);
}
function _setURI(string memory newuri) internal virtual {
_uri = newuri;
}
function _mint(address to, uint256 id, uint256 amount, bytes memory data) internal virtual {
require(to != address(0), "ERC1155: mint to the zero address");
address operator = _msgSender();
uint256[] memory ids = _asSingletonArray(id);
uint256[] memory amounts = _asSingletonArray(amount);
_beforeTokenTransfer(operator, address(0), to, ids, amounts, data);
_balances[id][to] += amount;
emit TransferSingle(operator, address(0), to, id, amount);
_afterTokenTransfer(operator, address(0), to, ids, amounts, data);
_doSafeTransferAcceptanceCheck(operator, address(0), to, id, amount, data);
}
function _mintBatch(
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
require(to != address(0), "ERC1155: mint to the zero address");
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
address operator = _msgSender();
_beforeTokenTransfer(operator, address(0), to, ids, amounts, data);
for (uint256 i = 0; i < ids.length; i++) {
_balances[ids[i]][to] += amounts[i];
}
emit TransferBatch(operator, address(0), to, ids, amounts);
_afterTokenTransfer(operator, address(0), to, ids, amounts, data);
_doSafeBatchTransferAcceptanceCheck(operator, address(0), to, ids, amounts, data);
}
function _burn(address from, uint256 id, uint256 amount) internal virtual {
require(from != address(0), "ERC1155: burn from the zero address");
address operator = _msgSender();
uint256[] memory ids = _asSingletonArray(id);
uint256[] memory amounts = _asSingletonArray(amount);
_beforeTokenTransfer(operator, from, address(0), ids, amounts, "");
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: burn amount exceeds balance");
unchecked {
_balances[id][from] = fromBalance - amount;
}
emit TransferSingle(operator, from, address(0), id, amount);
_afterTokenTransfer(operator, from, address(0), ids, amounts, "");
}
function _burnBatch(address from, uint256[] memory ids, uint256[] memory amounts) internal virtual {
require(from != address(0), "ERC1155: burn from the zero address");
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
address operator = _msgSender();
_beforeTokenTransfer(operator, from, address(0), ids, amounts, "");
for (uint256 i = 0; i < ids.length; i++) {
uint256 id = ids[i];
uint256 amount = amounts[i];
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: burn amount exceeds balance");
unchecked {
_balances[id][from] = fromBalance - amount;
}
}
emit TransferBatch(operator, from, address(0), ids, amounts);
_afterTokenTransfer(operator, from, address(0), ids, amounts, "");
}
function _setApprovalForAll(address owner, address operator, bool approved) internal virtual {
require(owner != operator, "ERC1155: setting approval status for self");
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {}
function _afterTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {}
function _doSafeTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) private {
if (to.isContract()) {
try IERC1155Receiver(to).onERC1155Received(operator, from, id, amount, data) returns (bytes4 response) {
if (response != IERC1155Receiver.onERC1155Received.selector) {
revert("ERC1155: ERC1155Receiver rejected tokens");
}
} catch Error(string memory reason) {
revert(reason);
} catch {
revert("ERC1155: transfer to non-ERC1155Receiver implementer");
}
}
}
function _doSafeBatchTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) private {
if (to.isContract()) {
try IERC1155Receiver(to).onERC1155BatchReceived(operator, from, ids, amounts, data) returns (
bytes4 response
) {
if (response != IERC1155Receiver.onERC1155BatchReceived.selector) {
revert("ERC1155: ERC1155Receiver rejected tokens");
}
} catch Error(string memory reason) {
revert(reason);
} catch {
revert("ERC1155: transfer to non-ERC1155Receiver implementer");
}
}
}
function _asSingletonArray(uint256 element) private pure returns (uint256[] memory) {
uint256[] memory array = new uint256[](1);
array[0] = element;
return array;
}
}
library Math {
enum Rounding {
Down,
Up,
Zero
}
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
return (a & b) + (a ^ b) / 2;
}
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
return a == 0 ? 0 : (a - 1) / b + 1;
}
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
uint256 prod0;
uint256 prod1;
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
if (prod1 == 0) {
return prod0 / denominator;
}
require(denominator > prod1, "Math: mulDiv overflow");
uint256 remainder;
assembly {
remainder := mulmod(x, y, denominator)
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
uint256 twos = denominator & (~denominator + 1);
assembly {
denominator := div(denominator, twos)
prod0 := div(prod0, twos)
twos := add(div(sub(0, twos), twos), 1)
}
prod0 |= prod1 * twos;
uint256 inverse = (3 * denominator) ^ 2;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
result = prod0 * inverse;
return result;
}
}
function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 result = 1 << (log2(a) >> 1);
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
}
}
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
}
}
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10 ** 64) {
value /= 10 ** 64;
result += 64;
}
if (value >= 10 ** 32) {
value /= 10 ** 32;
result += 32;
}
if (value >= 10 ** 16) {
value /= 10 ** 16;
result += 16;
}
if (value >= 10 ** 8) {
value /= 10 ** 8;
result += 8;
}
if (value >= 10 ** 4) {
value /= 10 ** 4;
result += 4;
}
if (value >= 10 ** 2) {
value /= 10 ** 2;
result += 2;
}
if (value >= 10 ** 1) {
result += 1;
}
}
return result;
}
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
}
}
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
}
}
}
library SignedMath {
function max(int256 a, int256 b) internal pure returns (int256) {
return a > b ? a : b;
}
function min(int256 a, int256 b) internal pure returns (int256) {
return a < b ? a : b;
}
function average(int256 a, int256 b) internal pure returns (int256) {
int256 x = (a & b) + ((a ^ b) >> 1);
return x + (int256(uint256(x) >> 255) & (a ^ b));
}
function abs(int256 n) internal pure returns (uint256) {
unchecked {
return uint256(n >= 0 ? n : -n);
}
}
}
library Strings {
bytes16 private constant _SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
function toString(uint256 value) internal pure returns (string memory) {
unchecked {
uint256 length = Math.log10(value) + 1;
string memory buffer = new string(length);
uint256 ptr;
assembly {
ptr := add(buffer, add(32, length))
}
while (true) {
ptr--;
assembly {
mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
}
value /= 10;
if (value == 0) break;
}
return buffer;
}
}
function toString(int256 value) internal pure returns (string memory) {
return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value))));
}
function toHexString(uint256 value) internal pure returns (string memory) {
unchecked {
return toHexString(value, Math.log256(value) + 1);
}
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
function equal(string memory a, string memory b) internal pure returns (bool) {
return keccak256(bytes(a)) == keccak256(bytes(b));
}
}
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);
}
abstract contract UpdatableOperatorFilterer {
address private _owner;
error OperatorNotAllowed(address operator);
error OnlyOwner();
event OperatorFilterRegistryAddressUpdated(address newRegistry);
IOperatorFilterRegistry public operatorFilterRegistry;
constructor(address _registry, address subscriptionOrRegistrantToCopy, bool subscribe) {
_owner = msg.sender;
IOperatorFilterRegistry registry = IOperatorFilterRegistry(_registry);
operatorFilterRegistry = registry;
if (address(registry).code.length > 0) {
if (subscribe) {
registry.registerAndSubscribe(address(this), subscriptionOrRegistrantToCopy);
} else {
if (subscriptionOrRegistrantToCopy != address(0)) {
registry.registerAndCopyEntries(address(this), subscriptionOrRegistrantToCopy);
} else {
registry.register(address(this));
}
}
}
}
modifier onlyAllowedOperator(address from) virtual {
if (from != msg.sender) {
_checkFilterOperator(msg.sender);
}
_;
}
modifier onlyAllowedOperatorApproval(address operator) virtual {
_checkFilterOperator(operator);
_;
}
function transferOwnershipRegister(address newOwner) public virtual {
require(msg.sender == _owner);
_owner = newOwner;
}
function updateOperatorFilterRegistryAddress(address newRegistry) public virtual {
if (msg.sender != returnOwnerRegister()) {
revert OnlyOwner();
}
operatorFilterRegistry = IOperatorFilterRegistry(newRegistry);
emit OperatorFilterRegistryAddressUpdated(newRegistry);
}
function returnOwnerRegister() public view virtual returns (address) {
return _owner;
}
function _checkFilterOperator(address operator) internal view virtual {
IOperatorFilterRegistry registry = operatorFilterRegistry;
if (address(registry) != address(0) && address(registry).code.length > 0) {
if (!registry.isOperatorAllowed(address(this), operator)) {
revert OperatorNotAllowed(operator);
}
}
}
}
abstract contract ERC1155Custom is ERC1155 {
using Strings for uint256;
string private _baseURI = "";
mapping(uint256 => string) private _tokenURIs;
function uri(uint256 tokenId) public view virtual override returns (string memory) {
string memory tokenURI = _tokenURIs[tokenId];
return bytes(tokenURI).length > 0 ? string(abi.encodePacked(_baseURI, tokenURI)) : super.uri(tokenId);
}
function _setURI(uint256 tokenId, string memory tokenURI) internal virtual {
_tokenURIs[tokenId] = tokenURI;
emit URI(uri(tokenId), tokenId);
}
function _setBaseURI(string memory baseURI) internal virtual {
_baseURI = baseURI;
}
mapping(uint256 => uint256) private _totalSupply;
function totalSupply(uint256 id) public view virtual returns (uint256) {
return _totalSupply[id];
}
function exists(uint256 id) public view virtual returns (bool) {
return ERC1155Custom.totalSupply(id) > 0;
}
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual override {
super._beforeTokenTransfer(operator, from, to, ids, amounts, data);
if (from == address(0)) {
for (uint256 i = 0; i < ids.length; ++i) {
_totalSupply[ids[i]] += amounts[i];
}
}
if (to == address(0)) {
for (uint256 i = 0; i < ids.length; ++i) {
uint256 id = ids[i];
uint256 amount = amounts[i];
uint256 supply = _totalSupply[id];
require(supply >= amount, "ERC1155: burn amount exceeds totalSupply");
unchecked {
_totalSupply[id] = supply - amount;
}
}
}
}
}
contract IROIROShikigami is Ownable, ERC1155Custom, ERC2981, UpdatableOperatorFilterer {
using Strings for uint256;
uint96 constant private ROYALTY_FEE_NUMERATOR = 500;
address public minterContract;
address public burnerContract;
address public managerAddress;
address private constant ADDRESS_ZERO = 0x0000000000000000000000000000000000000000;
mapping (uint256 => uint256) public shikigamiChoices;
mapping (uint256 => uint256) public burnedShikigamiCounter;
uint256 public shikigamiCount;
event NewShikigamiInitialized(uint256 indexed shikigamiId);
event ShikigamiBurned(address from, uint256 indexed shikigamiId, uint256 choice);
event ShikigamiMinted(address to, uint256 indexed shikigamiId, uint256 amount);
modifier onlyOwnerOrManager() {
require(msg.sender == owner() || msg.sender == managerAddress, "Caller is not the owner neither manager!" );
_;
}
constructor(address _manager, address ROYALTY_ADDRESS) ERC1155("") UpdatableOperatorFilterer(address(0x000000000000AAeB6D7670E522A718067333cd4E), address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6), true){
_setDefaultRoyalty( ROYALTY_ADDRESS, ROYALTY_FEE_NUMERATOR );
managerAddress = _manager;
}
function supportsInterface(bytes4 interfaceId) public view override( ERC1155, ERC2981 ) returns (bool) {
return super.supportsInterface(interfaceId);
}
function setDefaultRoyalty( address receiver, uint96 feeNumerator ) external onlyOwnerOrManager { _setDefaultRoyalty( receiver, feeNumerator ); }
function deleteDefaultRoyalty() external onlyOwnerOrManager { _deleteDefaultRoyalty(); }
function setTokenRoyalty( uint256 tokenId, address receiver, uint96 feeNumerator ) external onlyOwnerOrManager { _setTokenRoyalty( tokenId, receiver, feeNumerator ); }
function resetTokenRoyalty( uint256 tokenId ) external onlyOwnerOrManager { _resetTokenRoyalty( tokenId ); }
function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) { super.setApprovalForAll(operator, approved); }
function safeBatchTransferFrom(address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data) public override onlyAllowedOperator(from) { super.safeBatchTransferFrom(from, to, ids, amounts, data); }
function safeTransferFrom(address from, address to, uint256 tokenId, uint256 amount, bytes memory data) public override onlyAllowedOperator(from) { super.safeTransferFrom(from, to, tokenId, amount, data); }
function setMinterContract (address _minterContract) external onlyOwner {
require(_minterContract != ADDRESS_ZERO, "Address should be real!");
require(_minterContract != minterContract, "Address already set!");
minterContract = _minterContract;
}
function setBurnerContract (address _burnerContract) external onlyOwner {
require(_burnerContract != ADDRESS_ZERO, "Address should be real!");
require(_burnerContract != burnerContract, "Address already set!");
burnerContract = _burnerContract;
}
function setManager(address to) external onlyOwner {
managerAddress = to;
}
function setOperatorFilterRegistryAddress(address to) external onlyOwner {
updateOperatorFilterRegistryAddress(to);
}
function initializeShikigami(uint256 choiceCount, string calldata uri) external onlyOwnerOrManager {
require(choiceCount >= 1 && choiceCount <= 10, "Amount of choices must be between 1 and 10!");
require(keccak256(abi.encode(uri)) != keccak256(abi.encode("")), "uri can't be empty!");
require(shikigamiChoices[shikigamiCount] == 0, "Shikigami with this ID already exists!");
shikigamiChoices[shikigamiCount] = choiceCount;
_setURI(shikigamiCount, uri);
emit NewShikigamiInitialized(shikigamiCount);
shikigamiCount++;
}
function updateShikigamiURI(uint256 shikigamiId, string calldata uri) external onlyOwnerOrManager {
require(shikigamiChoices[shikigamiId] != 0, "Shikigami with this ID doesn't exist!");
require(keccak256(abi.encode(uri)) != keccak256(abi.encode("")), "uri can't be empty!");
_setURI(shikigamiId, uri);
}
function mintShikigami(address to, uint256 shikigamiId, uint256 amount) external {
require(msg.sender == minterContract, "Can only be called by the minter contract!");
require(shikigamiChoices[shikigamiId] != 0, "Shikigami with this ID doesn't exist!");
_mint(to, shikigamiId, amount, "");
emit ShikigamiMinted(to, shikigamiId, amount);
}
function burnShikigami(address from, uint256 shikigamiId, uint256 choice) external {
require(msg.sender == burnerContract, "Can only be called by the burner contract!");
require(choice <= shikigamiChoiceCount(shikigamiId), "No such choice available!");
_burn(from, shikigamiId, 1);
burnedShikigamiCounter[shikigamiId] += 1;
emit ShikigamiBurned(from, shikigamiId, choice);
}
function getAllShikigamiChoices() external view returns(uint256[] memory) {
uint256[] memory result = new uint256[](shikigamiCount);
for (uint256 i = 0; i < shikigamiCount; i++) {
result[i]= (shikigamiChoices[i]);
}
return result;
}
function shikigamiCountForOwner(address owner) external view returns(uint256[] memory) {
uint256[] memory result = new uint256[](shikigamiCount);
for (uint i = 0; i < shikigamiCount; i++) {
result[i]= (balanceOf(owner, i));
}
return result;
}
function shikigamiChoiceCount(uint256 shikigamiId) public view returns (uint) {
return shikigamiChoices[shikigamiId];
}
}
library MerkleProof {
function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
return processProof(proof, leaf) == root;
}
function verifyCalldata(bytes32[] calldata proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
return processProofCalldata(proof, leaf) == root;
}
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
bytes32 computedHash = leaf;
for (uint256 i = 0; i < proof.length; i++) {
computedHash = _hashPair(computedHash, proof[i]);
}
return computedHash;
}
function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {
bytes32 computedHash = leaf;
for (uint256 i = 0; i < proof.length; i++) {
computedHash = _hashPair(computedHash, proof[i]);
}
return computedHash;
}
function multiProofVerify(
bytes32[] memory proof,
bool[] memory proofFlags,
bytes32 root,
bytes32[] memory leaves
) internal pure returns (bool) {
return processMultiProof(proof, proofFlags, leaves) == root;
}
function multiProofVerifyCalldata(
bytes32[] calldata proof,
bool[] calldata proofFlags,
bytes32 root,
bytes32[] memory leaves
) internal pure returns (bool) {
return processMultiProofCalldata(proof, proofFlags, leaves) == root;
}
function processMultiProof(
bytes32[] memory proof,
bool[] memory proofFlags,
bytes32[] memory leaves
) internal pure returns (bytes32 merkleRoot) {
uint256 leavesLen = leaves.length;
uint256 proofLen = proof.length;
uint256 totalHashes = proofFlags.length;
require(leavesLen + proofLen - 1 == totalHashes, "MerkleProof: invalid multiproof");
bytes32[] memory hashes = new bytes32[](totalHashes);
uint256 leafPos = 0;
uint256 hashPos = 0;
uint256 proofPos = 0;
for (uint256 i = 0; i < totalHashes; i++) {
bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
bytes32 b = proofFlags[i]
? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
: proof[proofPos++];
hashes[i] = _hashPair(a, b);
}
if (totalHashes > 0) {
require(proofPos == proofLen, "MerkleProof: invalid multiproof");
unchecked {
return hashes[totalHashes - 1];
}
} else if (leavesLen > 0) {
return leaves[0];
} else {
return proof[0];
}
}
function processMultiProofCalldata(
bytes32[] calldata proof,
bool[] calldata proofFlags,
bytes32[] memory leaves
) internal pure returns (bytes32 merkleRoot) {
uint256 leavesLen = leaves.length;
uint256 proofLen = proof.length;
uint256 totalHashes = proofFlags.length;
require(leavesLen + proofLen - 1 == totalHashes, "MerkleProof: invalid multiproof");
bytes32[] memory hashes = new bytes32[](totalHashes);
uint256 leafPos = 0;
uint256 hashPos = 0;
uint256 proofPos = 0;
for (uint256 i = 0; i < totalHashes; i++) {
bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
bytes32 b = proofFlags[i]
? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
: proof[proofPos++];
hashes[i] = _hashPair(a, b);
}
if (totalHashes > 0) {
require(proofPos == proofLen, "MerkleProof: invalid multiproof");
unchecked {
return hashes[totalHashes - 1];
}
} else if (leavesLen > 0) {
return leaves[0];
} else {
return proof[0];
}
}
function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
return a < b ? _efficientHash(a, b) : _efficientHash(b, a);
}
function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
assembly {
mstore(0x00, a)
mstore(0x20, b)
value := keccak256(0x00, 0x40)
}
}
}
interface IDelegationRegistry {
enum DelegationType {
NONE,
ALL,
CONTRACT,
TOKEN
}
struct DelegationInfo {
DelegationType type_;
address vault;
address delegate;
address contract_;
uint256 tokenId;
}
struct ContractDelegation {
address contract_;
address delegate;
}
struct TokenDelegation {
address contract_;
uint256 tokenId;
address delegate;
}
event DelegateForAll(address vault, address delegate, bool value);
event DelegateForContract(address vault, address delegate, address contract_, bool value);
event DelegateForToken(address vault, address delegate, address contract_, uint256 tokenId, bool value);
event RevokeAllDelegates(address vault);
event RevokeDelegate(address vault, address delegate);
function delegateForAll(address delegate, bool value) external;
function delegateForContract(address delegate, address contract_, bool value) external;
function delegateForToken(address delegate, address contract_, uint256 tokenId, bool value) external;
function revokeAllDelegates() external;
function revokeDelegate(address delegate) external;
function revokeSelf(address vault) external;
function getDelegationsByDelegate(address delegate) external view returns (DelegationInfo[] memory);
function getDelegatesForAll(address vault) external view returns (address[] memory);
function getDelegatesForContract(address vault, address contract_) external view returns (address[] memory);
function getDelegatesForToken(address vault, address contract_, uint256 tokenId)
external
view
returns (address[] memory);
function getContractLevelDelegations(address vault)
external
view
returns (ContractDelegation[] memory delegations);
function getTokenLevelDelegations(address vault) external view returns (TokenDelegation[] memory delegations);
function checkDelegateForAll(address delegate, address vault) external view returns (bool);
function checkDelegateForContract(address delegate, address vault, address contract_)
external
view
returns (bool);
function checkDelegateForToken(address delegate, address vault, address contract_, uint256 tokenId)
external
view
returns (bool);
}
contract IROIROShikigamiSale is Ownable{
address public immutable shikigamiNftAddress;
address private uwuLabsAddress;
address private cyberZAddress;
address public managerAddress;
mapping(uint256 => ShikigamiSale) private shikigamiSales;
mapping(uint256 => uint256) private mintsByTeam;
mapping(uint256 => mapping(address => uint256)) mintedPerWalletWl;
mapping(uint256 => mapping(address => uint256)) mintedPerWalletPublic;
IROIROShikigami private immutable shikigami;
IDelegationRegistry public immutable registry;
event NewShikigamiSaleInitialized(uint256 indexed shikigamiId);
event ShikigamiSaleModified(uint256 indexed shikigamiId);
modifier onlyOwnerOrManager() {
require( msg.sender == owner() || msg.sender == managerAddress, "Caller is not the owner neither manager!" );
_;
}
constructor(address _registry, address payable _shikigamiNftAddress, address _manager, address _uwuLabsAddress, address _cyberZAddress ) {
shikigamiNftAddress = _shikigamiNftAddress;
managerAddress = _manager;
uwuLabsAddress = _uwuLabsAddress;
cyberZAddress = _cyberZAddress;
shikigami = IROIROShikigami(_shikigamiNftAddress);
registry = IDelegationRegistry(_registry);
}
struct ShikigamiSale {
uint256 wlSalePrice;
uint256 publicSalePrice;
uint64 maxSupply;
uint64 wlSupply;
uint64 teamSupply;
uint64 wlSaleStart;
uint64 publicSaleStart;
uint64 maxPerWalletPublic;
uint64 publicSaleClose;
bytes32 wlSaleRoot;
bytes32 publicSaleRoot;
}
struct ShikigamiSaleParameters {
uint256 wlSalePrice;
uint256 publicSalePrice;
uint64 maxSupply;
uint64 wlSupply;
uint64 teamSupply;
uint64 wlSaleStart;
uint64 publicSaleStart;
uint64 maxPerWalletPublic;
uint64 publicSaleClose;
bytes32 wlSaleRoot;
bytes32 publicSaleRoot;
}
function initializeShikigamiSale (uint256 shikigamiId, ShikigamiSaleParameters calldata shikigamiSaleParameters) external onlyOwnerOrManager {
require(shikigamiSales[shikigamiId].maxSupply == 0, "Sale for this ID already initialized!");
require(shikigamiSaleParameters.maxSupply > 0, "Supply can't be 0!");
require(shikigamiSaleParameters.wlSupply + shikigamiSaleParameters.teamSupply <= shikigamiSaleParameters.maxSupply, "Must be less or equal to the total supply!");
require(shikigamiSaleParameters.wlSaleStart < shikigamiSaleParameters.publicSaleStart, "Invalid time!");
require(shikigamiSaleParameters.publicSaleStart < shikigamiSaleParameters.publicSaleClose, "Invalid time!");
shikigamiSales[shikigamiId] = ShikigamiSale({
wlSalePrice: shikigamiSaleParameters.wlSalePrice,
publicSalePrice: shikigamiSaleParameters.publicSalePrice,
maxSupply: shikigamiSaleParameters.maxSupply,
wlSupply: shikigamiSaleParameters.wlSupply,
teamSupply: shikigamiSaleParameters.teamSupply,
wlSaleStart: shikigamiSaleParameters.wlSaleStart,
publicSaleStart: shikigamiSaleParameters.publicSaleStart,
maxPerWalletPublic: shikigamiSaleParameters.maxPerWalletPublic,
publicSaleClose: shikigamiSaleParameters.publicSaleClose,
wlSaleRoot: shikigamiSaleParameters.wlSaleRoot,
publicSaleRoot: shikigamiSaleParameters.publicSaleRoot
});
emit NewShikigamiSaleInitialized(shikigamiId);
}
function modifyShikigamiSale(uint256 shikigamiId, ShikigamiSaleParameters calldata shikigamiSaleParameters) external onlyOwnerOrManager {
ShikigamiSale storage shikigamiSale = shikigamiSales[shikigamiId];
require(shikigamiSale.maxSupply > 0, "Sale for this ID is not initialized!");
require(shikigamiSaleParameters.wlSupply + shikigamiSaleParameters.teamSupply <= shikigamiSale.maxSupply, "Must be less or equal to the total supply!");
require(shikigamiSaleParameters.wlSaleStart < shikigamiSaleParameters.publicSaleStart, "Invalid time!");
require(shikigamiSaleParameters.publicSaleStart < shikigamiSaleParameters.publicSaleClose, "Invalid time!");
shikigamiSales[shikigamiId] = ShikigamiSale({
wlSalePrice: shikigamiSaleParameters.wlSalePrice,
publicSalePrice: shikigamiSaleParameters.publicSalePrice,
maxSupply: shikigamiSale.maxSupply,
wlSupply: shikigamiSaleParameters.wlSupply,
teamSupply: shikigamiSaleParameters.teamSupply,
wlSaleStart: shikigamiSaleParameters.wlSaleStart,
publicSaleStart: shikigamiSaleParameters.publicSaleStart,
maxPerWalletPublic: shikigamiSaleParameters.maxPerWalletPublic,
publicSaleClose: shikigamiSaleParameters.publicSaleClose,
wlSaleRoot: shikigamiSaleParameters.wlSaleRoot,
publicSaleRoot: shikigamiSaleParameters.publicSaleRoot
});
emit ShikigamiSaleModified(shikigamiId);
}
function buyShikigami(uint256 shikigamiId, uint256 mintAmount, bytes32[] calldata merkleProof, uint256 merkleMaxAmount, address vault) external payable {
ShikigamiSale memory shikigamiSale = shikigamiSales[shikigamiId];
require(msg.sender == tx.origin, "Contracts can't mint!");
require(shikigamiSale.maxSupply > 0, "Sale for this ID is not initialized!");
require(block.timestamp > shikigamiSale.wlSaleStart && block.timestamp < shikigamiSale.publicSaleClose, "Sale is not live!");
if (vault == address(0)) {
vault = msg.sender;
} else {
require(registry.checkDelegateForContract(msg.sender, vault, address(this)), "Sender is not delegated!");
}
if (block.timestamp > shikigamiSale.wlSaleStart && block.timestamp < shikigamiSale.publicSaleStart) {
require(shikigami.totalSupply(shikigamiId) + shikigami.burnedShikigamiCounter(shikigamiId) + mintAmount <= shikigamiSale.wlSupply + shikigamiSale.teamSupply, "Mint cap for WL is reached!");
require(msg.value >= shikigamiSale.wlSalePrice * mintAmount, "Invalid value sent!");
require(mintedPerWalletWl[shikigamiId][vault] + mintAmount <= merkleMaxAmount, "Can't mint more than tree allows!");
require(MerkleProof.verify(merkleProof, shikigamiSale.wlSaleRoot, keccak256(abi.encodePacked(vault, merkleMaxAmount))), "Merkle verification failed!");
mintedPerWalletWl[shikigamiId][vault] += mintAmount;
shikigami.mintShikigami(vault, shikigamiId, mintAmount);
} else if (block.timestamp > shikigamiSale.publicSaleStart && block.timestamp < shikigamiSale.publicSaleClose) {
require(mintAmount <= shikigamiSale.maxPerWalletPublic, "Mint amount is too high!");
require(shikigami.totalSupply(shikigamiId) + shikigami.burnedShikigamiCounter(shikigamiId) + mintAmount <= shikigamiSale.maxSupply, "Mint cap for public is reached!");
require(msg.value >= shikigamiSale.publicSalePrice * mintAmount, "Invalid value sent!");
require(mintedPerWalletPublic[shikigamiId][vault] + mintAmount <= shikigamiSale.maxPerWalletPublic, "Mint amount exceeds mints per wallet!");
if(shikigamiSale.publicSaleRoot != "") {
require(mintedPerWalletPublic[shikigamiId][vault] + mintAmount <= merkleMaxAmount, "Can't mint more than tree allows");
require(MerkleProof.verify(merkleProof, shikigamiSale.publicSaleRoot, keccak256(abi.encodePacked(vault, merkleMaxAmount))), "Merkle verification failed!");
}
mintedPerWalletPublic[shikigamiId][vault] += mintAmount;
shikigami.mintShikigami(vault, shikigamiId, mintAmount);
}
}
function teamMint(address to, uint64 shikigamiId, uint64 amount) external onlyOwnerOrManager {
ShikigamiSale storage shikigamiSale = shikigamiSales[shikigamiId];
require(shikigamiSale.maxSupply > 0, "Sale for this ID is not initialized!");
require(shikigami.totalSupply(shikigamiId) + shikigami.burnedShikigamiCounter(shikigamiId) + amount <= shikigamiSale.maxSupply, "Mint cap for team is reached!");
if (block.timestamp < shikigamiSale.wlSaleStart) {
require(mintsByTeam[shikigamiId] + amount <= shikigamiSale.teamSupply, "Amount larger than team mint limit!");
mintsByTeam[shikigamiId] += amount;
shikigami.mintShikigami(to, shikigamiId, amount);
} else if (block.timestamp > shikigamiSale.publicSaleClose) {
shikigami.mintShikigami(to, shikigamiId, amount);
}
}
function withdraw() public payable onlyOwnerOrManager {
(bool successRoyalty, ) = payable(uwuLabsAddress).call{value: (address(this).balance) * 5 / 100}("");
require(successRoyalty, "Transaction failed!");
(bool successOwner, ) = payable(cyberZAddress).call{value: (address(this).balance)}("");
require(successOwner, "Transaction failed!");
}
function setManager(address to) external onlyOwner {
managerAddress = to;
}
function getSaleDetails(uint256 shikigamiId) external view returns(ShikigamiSale memory) {
require(shikigamiSales[shikigamiId].maxSupply > 0, "Sale for this ID is not initialized!");
return shikigamiSales[shikigamiId];
}
function getUnmintedSupply(uint256 shikigamiId) external view returns(uint256 unmintedSupply) {
ShikigamiSale storage shikigamiSale = shikigamiSales[shikigamiId];
require(shikigamiSales[shikigamiId].maxSupply > 0, "Sale for this ID is not initialized!");
unmintedSupply = shikigamiSale.maxSupply - (shikigami.burnedShikigamiCounter(shikigamiId) + shikigami.totalSupply(shikigamiId));
return unmintedSupply;
}
function getSalePhase(uint256 shikigamiId) external view returns(string memory) {
require(shikigamiSales[shikigamiId].maxSupply > 0, "Sale for this ID is not initialized!");
if (block.timestamp > shikigamiSales[shikigamiId].wlSaleStart && block.timestamp < shikigamiSales[shikigamiId].publicSaleStart) {
return "WL sale";
} else if (block.timestamp > shikigamiSales[shikigamiId].publicSaleStart && block.timestamp < shikigamiSales[shikigamiId].publicSaleClose) {
return "Public sale";
} else {
return "Sale closed";
}
}
}
