文件 1 的 1：DigiDaigakuGiantDragons.sol
pragma solidity 0.8.9;
struct Quest {
bool isActive;
uint32 questId;
uint64 startTimestamp;
uint32 arrayIndex;
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface IAdventurous is IERC165 {
event AdventureApprovalForAll(address indexed tokenOwner, address indexed operator, bool approved);
event QuestUpdated(uint256 indexed tokenId, address indexed tokenOwner, address indexed adventure, uint256 questId, bool active, bool booted);
function adventureTransferFrom(address from, address to, uint256 tokenId) external;
function adventureSafeTransferFrom(address from, address to, uint256 tokenId) external;
function adventureBurn(uint256 tokenId) external;
function enterQuest(uint256 tokenId, uint256 questId) external;
function exitQuest(uint256 tokenId, uint256 questId) external;
function getQuestCount(uint256 tokenId, address adventure) external view returns (uint256);
function getTimeOnQuest(uint256 tokenId, address adventure, uint256 questId) external view returns (uint256);
function isParticipatingInQuest(uint256 tokenId, address adventure, uint256 questId) external view returns (bool participatingInQuest, uint256 startTimestamp, uint256 index);
function getActiveQuests(uint256 tokenId, address adventure) external view returns (Quest[] memory activeQuests);
}
interface IAdventure is IERC165 {
function questsLockTokens() external view returns (bool);
function onQuestEntered(address adventurer, uint256 tokenId, uint256 questId) external;
function onQuestExited(address adventurer, uint256 tokenId, uint256 questId, uint256 questStartTimestamp) external;
}
interface IOwnableInitializer is IERC165 {
function initializeOwner(address owner_) external;
function transferOwnership(address newOwner) external;
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
error CallerIsNotTheContractOwner();
error NewOwnerIsTheZeroAddress();
error OwnerAlreadyInitialized();
abstract contract InitializableOwnable is Context, IOwnableInitializer {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function initializeOwner(address owner_) public override {
if(_owner != address(0)) {
revert OwnerAlreadyInitialized();
}
_transferOwnership(owner_);
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
if(owner() != _msgSender()) {
revert CallerIsNotTheContractOwner();
}
}
function transferOwnership(address newOwner) public virtual override onlyOwner {
if(newOwner == address(0)) {
revert NewOwnerIsTheZeroAddress();
}
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes calldata data
) external;
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external;
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
function approve(address to, uint256 tokenId) external;
function setApprovalForAll(address operator, bool _approved) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function isApprovedForAll(address owner, address operator) external view returns (bool);
}
error AdventureIsStillWhitelisted();
error AlreadyWhitelisted();
error ArrayIndexOverflowsUint128();
error CallerNotAWhitelistedAdventure();
error InvalidAdventureContract();
error NotWhitelisted();
abstract contract AdventureWhitelist is InitializableOwnable {
struct AdventureDetails {
bool isWhitelisted;
uint128 arrayIndex;
}
event AdventureWhitelistUpdated(address indexed adventure, bool whitelisted);
address[] public whitelistedAdventureList;
mapping (address => AdventureDetails) public whitelistedAdventures;
function isAdventureWhitelisted(address account) public view returns (bool) {
return whitelistedAdventures[account].isWhitelisted;
}
function whitelistAdventure(address adventure) external onlyOwner {
if(isAdventureWhitelisted(adventure)) {
revert AlreadyWhitelisted();
}
if(!IERC165(adventure).supportsInterface(type(IAdventure).interfaceId)) {
revert InvalidAdventureContract();
}
uint256 arrayIndex = whitelistedAdventureList.length;
if(arrayIndex > type(uint128).max) {
revert ArrayIndexOverflowsUint128();
}
whitelistedAdventures[adventure].isWhitelisted = true;
whitelistedAdventures[adventure].arrayIndex = uint128(arrayIndex);
whitelistedAdventureList.push(adventure);
emit AdventureWhitelistUpdated(adventure, true);
}
function unwhitelistAdventure(address adventure) external onlyOwner {
if(!isAdventureWhitelisted(adventure)) {
revert NotWhitelisted();
}
uint128 itemPositionToDelete = whitelistedAdventures[adventure].arrayIndex;
uint256 arrayEndIndex = whitelistedAdventureList.length - 1;
if(itemPositionToDelete != arrayEndIndex) {
whitelistedAdventureList[itemPositionToDelete] = whitelistedAdventureList[arrayEndIndex];
whitelistedAdventures[whitelistedAdventureList[itemPositionToDelete]].arrayIndex = itemPositionToDelete;
}
whitelistedAdventureList.pop();
delete whitelistedAdventures[adventure];
emit AdventureWhitelistUpdated(adventure, false);
}
function _requireCallerIsWhitelistedAdventure() internal view {
if(!isAdventureWhitelisted(_msgSender())) {
revert CallerNotAWhitelistedAdventure();
}
}
function _requireAdventureRemovedFromWhitelist(address adventure) internal view {
if(isAdventureWhitelisted(adventure)) {
revert AdventureIsStillWhitelisted();
}
}
}
interface IAdventureERC721Initializer is IERC165 {
function initializeAdventureERC721(uint256 maxSimultaneousQuests_) external;
}
interface IERC721Initializer is IERC721 {
function initializeERC721(string memory name_, string memory symbol_) external;
}
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
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 functionCall(target, data, "Address: low-level call failed");
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
function toString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
string private _name;
string private _symbol;
mapping(uint256 => address) private _owners;
mapping(address => uint256) private _balances;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: address zero is not a valid owner");
return _balances[owner];
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _owners[tokenId];
require(owner != address(0), "ERC721: invalid token ID");
return owner;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
_requireMinted(tokenId);
string memory baseURI = _baseURI();
return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
}
function _baseURI() internal view virtual returns (string memory) {
return "";
}
function approve(address to, uint256 tokenId) public virtual override {
address owner = ERC721.ownerOf(tokenId);
require(to != owner, "ERC721: approval to current owner");
require(
_msgSender() == owner || isApprovedForAll(owner, _msgSender()),
"ERC721: approve caller is not token owner nor approved for all"
);
_approve(to, tokenId);
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
_requireMinted(tokenId);
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address operator, bool approved) public virtual override {
_setApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return _operatorApprovals[owner][operator];
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner nor approved");
_transfer(from, to, tokenId);
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public virtual override {
safeTransferFrom(from, to, tokenId, "");
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) public virtual override {
require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner nor approved");
_safeTransfer(from, to, tokenId, data);
}
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory data
) internal virtual {
_transfer(from, to, tokenId);
require(_checkOnERC721Received(from, to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer");
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return _owners[tokenId] != address(0);
}
function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
address owner = ERC721.ownerOf(tokenId);
return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender);
}
function _safeMint(address to, uint256 tokenId) internal virtual {
_safeMint(to, tokenId, "");
}
function _safeMint(
address to,
uint256 tokenId,
bytes memory data
) internal virtual {
_mint(to, tokenId);
require(
_checkOnERC721Received(address(0), to, tokenId, data),
"ERC721: transfer to non ERC721Receiver implementer"
);
}
function _mint(address to, uint256 tokenId) internal virtual {
require(to != address(0), "ERC721: mint to the zero address");
require(!_exists(tokenId), "ERC721: token already minted");
_beforeTokenTransfer(address(0), to, tokenId);
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(address(0), to, tokenId);
_afterTokenTransfer(address(0), to, tokenId);
}
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId);
_approve(address(0), tokenId);
_balances[owner] -= 1;
delete _owners[tokenId];
emit Transfer(owner, address(0), tokenId);
_afterTokenTransfer(owner, address(0), tokenId);
}
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
require(to != address(0), "ERC721: transfer to the zero address");
_beforeTokenTransfer(from, to, tokenId);
_approve(address(0), tokenId);
_balances[from] -= 1;
_balances[to] += 1;
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
_afterTokenTransfer(from, to, tokenId);
}
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
}
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
require(owner != operator, "ERC721: approve to caller");
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
function _requireMinted(uint256 tokenId) internal view virtual {
require(_exists(tokenId), "ERC721: invalid token ID");
}
function _checkOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory data
) private returns (bool) {
if (to.isContract()) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {
return retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert("ERC721: transfer to non ERC721Receiver implementer");
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
} else {
return true;
}
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 tokenId
) internal virtual {}
}
error AlreadyInitializedERC721();
abstract contract InitializableERC721 is InitializableOwnable, ERC721, IERC721Initializer {
bool private initializedERC721;
string internal _contractName;
string internal _contractSymbol;
function initializeERC721(string memory name_, string memory symbol_) public override onlyOwner {
if(initializedERC721) {
revert AlreadyInitializedERC721();
}
_contractName = name_;
_contractSymbol = symbol_;
initializedERC721 = true;
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, IERC165) returns (bool) {
return
interfaceId == type(IERC721Initializer).interfaceId ||
super.supportsInterface(interfaceId);
}
function name() public view virtual override returns (string memory) {
return _contractName;
}
function symbol() public view virtual override returns (string memory) {
return _contractSymbol;
}
}
error AdventureApprovalToCaller();
error AlreadyInitializedAdventureERC721();
error AlreadyOnQuest();
error AnActiveQuestIsPreventingTransfers();
error CallerNotApprovedForAdventure();
error CallerNotTokenOwner();
error MaxSimultaneousQuestsCannotBeZero();
error MaxSimultaneousQuestsExceeded();
error NotOnQuest();
error QuestIdOutOfRange();
error TooManyActiveQuests();
abstract contract AdventureERC721 is InitializableERC721, AdventureWhitelist, IAdventurous, IAdventureERC721Initializer {
uint256 private constant MAX_CONCURRENT_QUESTS = 100;
uint256 internal constant TRANSFERRING_VIA_ERC721 = 1;
uint256 internal constant TRANSFERRING_VIA_ADVENTURE = 2;
bool private initializedAdventureERC721;
uint256 internal transferType;
uint256 private _maxSimultaneousQuests;
mapping (uint256 => uint256) internal blockingQuestCounts;
mapping (address => mapping (address => bool)) private operatorAdventureApprovals;
mapping (uint256 => mapping (address => uint32[])) public activeQuestList;
mapping (uint256 => mapping (address => mapping (uint32 => Quest))) public activeQuestLookup;
function initializeAdventureERC721(uint256 maxSimultaneousQuests_) public override onlyOwner {
if(initializedAdventureERC721) {
revert AlreadyInitializedAdventureERC721();
}
_validateMaxSimultaneousQuests(maxSimultaneousQuests_);
_maxSimultaneousQuests = maxSimultaneousQuests_;
initializedAdventureERC721 = true;
transferType = TRANSFERRING_VIA_ERC721;
}
function supportsInterface(bytes4 interfaceId) public view virtual override (InitializableERC721, IERC165) returns (bool) {
return
interfaceId == type(IAdventurous).interfaceId ||
interfaceId == type(IAdventureERC721Initializer).interfaceId ||
super.supportsInterface(interfaceId);
}
function adventureTransferFrom(address from, address to, uint256 tokenId) external override {
_requireCallerIsWhitelistedAdventure();
_requireCallerApprovedForAdventure(tokenId);
transferType = TRANSFERRING_VIA_ADVENTURE;
_transfer(from, to, tokenId);
transferType = TRANSFERRING_VIA_ERC721;
}
function adventureSafeTransferFrom(address from, address to, uint256 tokenId) external override {
_requireCallerIsWhitelistedAdventure();
_requireCallerApprovedForAdventure(tokenId);
transferType = TRANSFERRING_VIA_ADVENTURE;
_safeTransfer(from, to, tokenId, "");
transferType = TRANSFERRING_VIA_ERC721;
}
function adventureBurn(uint256 tokenId) external override {
_requireCallerIsWhitelistedAdventure();
_requireCallerApprovedForAdventure(tokenId);
transferType = TRANSFERRING_VIA_ADVENTURE;
_burn(tokenId);
transferType = TRANSFERRING_VIA_ERC721;
}
function enterQuest(uint256 tokenId, uint256 questId) external override {
_requireCallerIsWhitelistedAdventure();
_requireCallerApprovedForAdventure(tokenId);
_enterQuest(tokenId, _msgSender(), questId);
}
function exitQuest(uint256 tokenId, uint256 questId) external override {
_requireCallerIsWhitelistedAdventure();
_requireCallerApprovedForAdventure(tokenId);
_exitQuest(tokenId, _msgSender(), questId);
}
function bootFromAllQuests(uint256 tokenId, address adventure) external onlyOwner {
_requireAdventureRemovedFromWhitelist(adventure);
_exitAllQuests(tokenId, adventure, true);
}
function userExitQuest(uint256 tokenId, address adventure, uint256 questId) external {
_requireAdventureRemovedFromWhitelist(adventure);
_requireCallerOwnsToken(tokenId);
_exitQuest(tokenId, adventure, questId);
}
function userExitAllQuests(uint256 tokenId, address adventure) external {
_requireAdventureRemovedFromWhitelist(adventure);
_requireCallerOwnsToken(tokenId);
_exitAllQuests(tokenId, adventure, false);
}
function setAdventuresApprovedForAll(address operator, bool approved) external {
address tokenOwner = _msgSender();
if(tokenOwner == operator) {
revert AdventureApprovalToCaller();
}
operatorAdventureApprovals[tokenOwner][operator] = approved;
emit AdventureApprovalForAll(tokenOwner, operator, approved);
}
function areAdventuresApprovedForAll(address owner, address operator) public view returns (bool) {
return operatorAdventureApprovals[owner][operator];
}
function getQuestCount(uint256 tokenId, address adventure) public override view returns (uint256) {
return activeQuestList[tokenId][adventure].length;
}
function getTimeOnQuest(uint256 tokenId, address adventure, uint256 questId) public override view returns (uint256) {
(bool participatingInQuest, uint256 startTimestamp,) = isParticipatingInQuest(tokenId, adventure, questId);
return participatingInQuest ? (block.timestamp - startTimestamp) : 0;
}
function isParticipatingInQuest(uint256 tokenId, address adventure, uint256 questId) public override view returns (bool participatingInQuest, uint256 startTimestamp, uint256 index) {
if(questId > type(uint32).max) {
revert QuestIdOutOfRange();
}
Quest storage quest = activeQuestLookup[tokenId][adventure][uint32(questId)];
participatingInQuest = quest.isActive;
startTimestamp = quest.startTimestamp;
index = quest.arrayIndex;
return (participatingInQuest, startTimestamp, index);
}
function getActiveQuests(uint256 tokenId, address adventure) public override view returns (Quest[] memory activeQuests) {
uint256 questCount = getQuestCount(tokenId, adventure);
activeQuests = new Quest[](questCount);
uint32[] memory activeQuestIdList = activeQuestList[tokenId][adventure];
for(uint256 i = 0; i < questCount; ++i) {
activeQuests[i] = activeQuestLookup[tokenId][adventure][activeQuestIdList[i]];
}
return activeQuests;
}
function maxSimultaneousQuests() public view returns (uint256) {
return _maxSimultaneousQuests;
}
function _enterQuest(uint256 tokenId, address adventure, uint256 questId) internal {
(bool participatingInQuest,,) = isParticipatingInQuest(tokenId, adventure, questId);
if(participatingInQuest) {
revert AlreadyOnQuest();
}
uint256 currentQuestCount = getQuestCount(tokenId, adventure);
if(currentQuestCount >= _maxSimultaneousQuests) {
revert TooManyActiveQuests();
}
uint32 castedQuestId = uint32(questId);
activeQuestList[tokenId][adventure].push(castedQuestId);
activeQuestLookup[tokenId][adventure][castedQuestId].isActive = true;
activeQuestLookup[tokenId][adventure][castedQuestId].startTimestamp = uint64(block.timestamp);
activeQuestLookup[tokenId][adventure][castedQuestId].questId = castedQuestId;
activeQuestLookup[tokenId][adventure][castedQuestId].arrayIndex = uint32(currentQuestCount);
address ownerOfToken = ownerOf(tokenId);
emit QuestUpdated(tokenId, ownerOfToken, adventure, questId, true, false);
if(IAdventure(adventure).questsLockTokens()) {
unchecked {
++blockingQuestCounts[tokenId];
}
}
IAdventure(adventure).onQuestEntered(ownerOfToken, tokenId, questId);
}
function _exitQuest(uint256 tokenId, address adventure, uint256 questId) internal {
(bool participatingInQuest, uint256 startTimestamp, uint256 index) = isParticipatingInQuest(tokenId, adventure, questId);
if(!participatingInQuest) {
revert NotOnQuest();
}
uint32 castedQuestId = uint32(questId);
uint256 lastArrayIndex = getQuestCount(tokenId, adventure) - 1;
if(index != lastArrayIndex) {
activeQuestList[tokenId][adventure][index] = activeQuestList[tokenId][adventure][lastArrayIndex];
activeQuestLookup[tokenId][adventure][activeQuestList[tokenId][adventure][lastArrayIndex]].arrayIndex = uint32(index);
}
activeQuestList[tokenId][adventure].pop();
delete activeQuestLookup[tokenId][adventure][castedQuestId];
address ownerOfToken = ownerOf(tokenId);
emit QuestUpdated(tokenId, ownerOfToken, adventure, questId, false, false);
if(IAdventure(adventure).questsLockTokens()) {
--blockingQuestCounts[tokenId];
}
IAdventure(adventure).onQuestExited(ownerOfToken, tokenId, questId, startTimestamp);
}
function _exitAllQuests(uint256 tokenId, address adventure, bool booted) internal {
address tokenOwner = ownerOf(tokenId);
uint256 questCount = getQuestCount(tokenId, adventure);
if(IAdventure(adventure).questsLockTokens()) {
blockingQuestCounts[tokenId] -= questCount;
}
for(uint256 i = 0; i < questCount;) {
uint32 questId = activeQuestList[tokenId][adventure][i];
Quest memory quest = activeQuestLookup[tokenId][adventure][questId];
uint256 startTimestamp = quest.startTimestamp;
emit QuestUpdated(tokenId, tokenOwner, adventure, questId, false, booted);
delete activeQuestLookup[tokenId][adventure][questId];
IAdventure(adventure).onQuestExited(tokenOwner, tokenId, questId, startTimestamp);
unchecked {
++i;
}
}
delete activeQuestList[tokenId][adventure];
}
function _beforeTokenTransfer(address , address , uint256 tokenId) internal virtual override {
if(blockingQuestCounts[tokenId] > 0) {
revert AnActiveQuestIsPreventingTransfers();
}
}
function _requireCallerApprovedForAdventure(uint256 tokenId) internal view {
if(!areAdventuresApprovedForAll(ownerOf(tokenId), _msgSender())) {
revert CallerNotApprovedForAdventure();
}
}
function _requireCallerOwnsToken(uint256 tokenId) internal view {
if(ownerOf(tokenId) != _msgSender()) {
revert CallerNotTokenOwner();
}
}
function _validateMaxSimultaneousQuests(uint256 maxSimultaneousQuests_) internal pure {
if(maxSimultaneousQuests_ == 0) {
revert MaxSimultaneousQuestsCannotBeZero();
}
if(maxSimultaneousQuests_ > MAX_CONCURRENT_QUESTS) {
revert MaxSimultaneousQuestsExceeded();
}
}
}
interface IRoyaltiesInitializer is IERC165 {
function initializeRoyalties(address receiver, uint96 feeNumerator) external;
}
interface IURIInitializer is IERC165 {
function initializeURI(string memory baseURI_, string memory suffixURI_) external;
}
interface IERC2981 is IERC165 {
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
returns (address receiver, uint256 royaltyAmount);
}
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];
}
}
error AlreadyInitializedRoyalties();
error AlreadyInitializedURI();
error ExceedsMaxRoyaltyFee();
error NonexistentToken();
abstract contract AdventureNFT is AdventureERC721, ERC2981, IRoyaltiesInitializer, IURIInitializer {
using Strings for uint256;
uint96 private constant MAX_ROYALTY_FEE_NUMERATOR = 10000;
bool private initializedRoyalties;
bool private initializedURI;
string public baseTokenURI;
string public suffixURI = ".json";
event BaseURISet(string baseTokenURI);
event SuffixURISet(string suffixURI);
event RoyaltySet(address receiver, uint96 feeNumerator);
function initializeRoyalties(address receiver, uint96 feeNumerator) public override onlyOwner {
if(initializedRoyalties) {
revert AlreadyInitializedRoyalties();
}
setRoyaltyInfo(receiver, feeNumerator);
initializedRoyalties = true;
}
function initializeURI(string memory baseURI_, string memory suffixURI_) public override onlyOwner {
if(initializedURI) {
revert AlreadyInitializedURI();
}
setBaseURI(baseURI_);
setSuffixURI(suffixURI_);
initializedURI = true;
}
function _baseURI() internal view virtual override returns (string memory) {
return baseTokenURI;
}
function setBaseURI(string memory baseTokenURI_) public onlyOwner {
baseTokenURI = baseTokenURI_;
emit BaseURISet(baseTokenURI_);
}
function setSuffixURI(string memory suffixURI_) public onlyOwner {
suffixURI = suffixURI_;
emit SuffixURISet(suffixURI_);
}
function setRoyaltyInfo(address receiver, uint96 feeNumerator) public onlyOwner {
if(feeNumerator > MAX_ROYALTY_FEE_NUMERATOR) {
revert ExceedsMaxRoyaltyFee();
}
_setDefaultRoyalty(receiver, feeNumerator);
emit RoyaltySet(receiver, feeNumerator);
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
if(!_exists(tokenId)) {
revert NonexistentToken();
}
string memory baseURI = _baseURI();
return bytes(baseURI).length > 0
? string(abi.encodePacked(baseURI, tokenId.toString(), suffixURI))
: "";
}
function supportsInterface(bytes4 interfaceId) public view virtual override (AdventureERC721, ERC2981, IERC165) returns (bool) {
return
interfaceId == type(IRoyaltiesInitializer).interfaceId ||
interfaceId == type(IURIInitializer).interfaceId ||
super.supportsInterface(interfaceId);
}
}
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);
}
interface IOperatorFiltererInitializer {
function initializeOperatorFilterer(address subscriptionOrRegistrantToCopy, bool subscribe) external;
}
abstract contract InitializableOperatorFilterer is IOperatorFiltererInitializer {
error OperatorNotAllowed(address operator);
IOperatorFilterRegistry public constant OPERATOR_FILTER_REGISTRY = IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E);
modifier onlyAllowedOperator(address from) virtual {
if (from != msg.sender) {
_checkFilterOperator(msg.sender);
}
_;
}
modifier onlyAllowedOperatorApproval(address operator) virtual {
_checkFilterOperator(operator);
_;
}
function initializeOperatorFilterer(address subscriptionOrRegistrantToCopy, bool subscribe) public virtual override {
if (address(OPERATOR_FILTER_REGISTRY).code.length > 0) {
if (subscribe) {
OPERATOR_FILTER_REGISTRY.registerAndSubscribe(address(this), subscriptionOrRegistrantToCopy);
} else {
if (subscriptionOrRegistrantToCopy != address(0)) {
OPERATOR_FILTER_REGISTRY.registerAndCopyEntries(address(this), subscriptionOrRegistrantToCopy);
} else {
OPERATOR_FILTER_REGISTRY.register(address(this));
}
}
}
}
function _checkFilterOperator(address operator) internal view virtual {
if (address(OPERATOR_FILTER_REGISTRY).code.length > 0) {
if (!OPERATOR_FILTER_REGISTRY.isOperatorAllowed(address(this), operator)) {
revert OperatorNotAllowed(operator);
}
}
}
}
abstract contract InitializableDefaultOperatorFilterer is InitializableOperatorFilterer {
address internal constant DEFAULT_SUBSCRIPTION = address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6);
function initializeOperatorFilterer(address , bool ) public virtual override {
super.initializeOperatorFilterer(DEFAULT_SUBSCRIPTION, true);
}
}
abstract contract BlacklistedTransferAdventureNFT is AdventureNFT, InitializableDefaultOperatorFilterer {
function setApprovalForAll(address operator, bool approved) public virtual override onlyAllowedOperatorApproval(operator) {
super.setApprovalForAll(operator, approved);
}
function approve(address operator, uint256 tokenId) public virtual override onlyAllowedOperatorApproval(operator) {
super.approve(operator, tokenId);
}
function transferFrom(address from, address to, uint256 tokenId) public virtual override onlyAllowedOperator(from) {
super.transferFrom(from, to, tokenId);
}
function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override onlyAllowedOperator(from) {
super.safeTransferFrom(from, to, tokenId);
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public virtual override onlyAllowedOperator(from) {
super.safeTransferFrom(from, to, tokenId, data);
}
}
contract DigiDaigakuGiantDragons is BlacklistedTransferAdventureNFT {
error DigiDaigakuGiantDragons__MinterAlreadyWhitelisted();
error DigiDaigakuGiantDragons__MinterNotWhitelisted();
mapping (address => bool) public whitelistedMinters;
event GiantDragonMinted(address indexed to, uint256 indexed dragonTokenId, uint256 indexed dragonEssenceId);
event MinterWhitelistUpdated(address indexed minter, bool indexed whitelisted);
constructor(address royaltyReceiver_, uint96 royaltyFeeNumerator_) ERC721("", "") {
initializeERC721("DigiDaigakuGiantDragons", "DIDGD");
initializeURI("https://digidaigaku.com/giant-dragons/metadata/", ".json");
initializeAdventureERC721(100);
initializeRoyalties(royaltyReceiver_, royaltyFeeNumerator_);
initializeOperatorFilterer(address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6), true);
}
function whitelistMinter(address minter) external onlyOwner {
_requireMinterIsNotWhitelisted(minter);
whitelistedMinters[minter] = true;
emit MinterWhitelistUpdated(minter, true);
}
function unwhitelistMinter(address minter) external onlyOwner {
_requireMinterIsWhitelisted(minter);
delete whitelistedMinters[minter];
emit MinterWhitelistUpdated(minter, false);
}
function mintDragonsBatch(
address to,
uint256[] calldata babyDragonTokenIds,
uint256[] calldata dragonEssenceTokenIds
) external {
_requireMinterIsWhitelisted(_msgSender());
unchecked {
for (uint256 i = 0; i < dragonEssenceTokenIds.length; ++i) {
_mint(to, babyDragonTokenIds[i]);
emit GiantDragonMinted(to, babyDragonTokenIds[i], dragonEssenceTokenIds[i]);
}
}
}
function _requireMinterIsWhitelisted(address minter) private view {
if(!whitelistedMinters[minter]) {
revert DigiDaigakuGiantDragons__MinterNotWhitelisted();
}
}
function _requireMinterIsNotWhitelisted(address minter) private view {
if(whitelistedMinters[minter]) {
revert DigiDaigakuGiantDragons__MinterAlreadyWhitelisted();
}
}
}
