File 1 of 1: PioneerNFT.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.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;
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() {
_paused = false;
}
modifier whenNotPaused() {
_requireNotPaused();
_;
}
modifier whenPaused() {
_requirePaused();
_;
}
function paused() public view virtual returns (bool) {
return _paused;
}
function _requireNotPaused() internal view virtual {
require(!paused(), "Pausable: paused");
}
function _requirePaused() internal view virtual {
require(paused(), "Pausable: not paused");
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
pragma solidity ^0.8.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
pragma solidity ^0.8.0;
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
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);
}
pragma solidity ^0.8.0;
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
pragma solidity ^0.8.0;
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
pragma solidity ^0.8.1;
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);
}
}
}
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;
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);
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 * 8) < value ? 1 : 0);
}
}
}
pragma solidity ^0.8.0;
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 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);
}
}
pragma solidity ^0.8.0;
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
using Address for address;
using Strings for uint256;
string private _name;
string private _symbol;
mapping(uint256 => address) private _owners;
mapping(address => uint256) private _balances;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
function balanceOf(address owner) public view virtual override returns (uint256) {
require(owner != address(0), "ERC721: address zero is not a valid owner");
return _balances[owner];
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
address owner = _ownerOf(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 or 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 or 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 or 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 _ownerOf(uint256 tokenId) internal view virtual returns (address) {
return _owners[tokenId];
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return _ownerOf(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, 1);
require(!_exists(tokenId), "ERC721: token already minted");
unchecked {
_balances[to] += 1;
}
_owners[tokenId] = to;
emit Transfer(address(0), to, tokenId);
_afterTokenTransfer(address(0), to, tokenId, 1);
}
function _burn(uint256 tokenId) internal virtual {
address owner = ERC721.ownerOf(tokenId);
_beforeTokenTransfer(owner, address(0), tokenId, 1);
owner = ERC721.ownerOf(tokenId);
delete _tokenApprovals[tokenId];
unchecked {
_balances[owner] -= 1;
}
delete _owners[tokenId];
emit Transfer(owner, address(0), tokenId);
_afterTokenTransfer(owner, address(0), tokenId, 1);
}
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, 1);
require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
delete _tokenApprovals[tokenId];
unchecked {
_balances[from] -= 1;
_balances[to] += 1;
}
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
_afterTokenTransfer(from, to, tokenId, 1);
}
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 firstTokenId,
uint256 batchSize
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 firstTokenId,
uint256 batchSize
) internal virtual {}
function __unsafe_increaseBalance(address account, uint256 amount) internal {
_balances[account] += amount;
}
}
pragma solidity ^0.8.0;
interface IERC721Enumerable is IERC721 {
function totalSupply() external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);
function tokenByIndex(uint256 index) external view returns (uint256);
}
pragma solidity ^0.8.0;
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
mapping(address => mapping(uint256 => uint256)) private _ownedTokens;
mapping(uint256 => uint256) private _ownedTokensIndex;
uint256[] private _allTokens;
mapping(uint256 => uint256) private _allTokensIndex;
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
return interfaceId == type(IERC721Enumerable).interfaceId || super.supportsInterface(interfaceId);
}
function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
require(index < ERC721.balanceOf(owner), "ERC721Enumerable: owner index out of bounds");
return _ownedTokens[owner][index];
}
function totalSupply() public view virtual override returns (uint256) {
return _allTokens.length;
}
function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
require(index < ERC721Enumerable.totalSupply(), "ERC721Enumerable: global index out of bounds");
return _allTokens[index];
}
function _beforeTokenTransfer(
address from,
address to,
uint256 firstTokenId,
uint256 batchSize
) internal virtual override {
super._beforeTokenTransfer(from, to, firstTokenId, batchSize);
if (batchSize > 1) {
revert("ERC721Enumerable: consecutive transfers not supported");
}
uint256 tokenId = firstTokenId;
if (from == address(0)) {
_addTokenToAllTokensEnumeration(tokenId);
} else if (from != to) {
_removeTokenFromOwnerEnumeration(from, tokenId);
}
if (to == address(0)) {
_removeTokenFromAllTokensEnumeration(tokenId);
} else if (to != from) {
_addTokenToOwnerEnumeration(to, tokenId);
}
}
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
uint256 length = ERC721.balanceOf(to);
_ownedTokens[to][length] = tokenId;
_ownedTokensIndex[tokenId] = length;
}
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
_allTokensIndex[tokenId] = _allTokens.length;
_allTokens.push(tokenId);
}
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
uint256 lastTokenIndex = ERC721.balanceOf(from) - 1;
uint256 tokenIndex = _ownedTokensIndex[tokenId];
if (tokenIndex != lastTokenIndex) {
uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];
_ownedTokens[from][tokenIndex] = lastTokenId;
_ownedTokensIndex[lastTokenId] = tokenIndex;
}
delete _ownedTokensIndex[tokenId];
delete _ownedTokens[from][lastTokenIndex];
}
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
uint256 lastTokenIndex = _allTokens.length - 1;
uint256 tokenIndex = _allTokensIndex[tokenId];
uint256 lastTokenId = _allTokens[lastTokenIndex];
_allTokens[tokenIndex] = lastTokenId;
_allTokensIndex[lastTokenId] = tokenIndex;
delete _allTokensIndex[tokenId];
_allTokens.pop();
}
}
pragma solidity ^0.8.0;
interface IPioneerNFT {
enum SupplyType {
PRIVATE,
PUBLIC,
TEAM,
RESERVE
}
function mintPublic(address to) external returns (uint256);
}
pragma solidity ^0.8.0;
interface IPioneerNFTMintListener {
function onTokenMinted(IPioneerNFT.SupplyType supplyType, uint256 tokenId) external;
}
pragma solidity ^0.8.0;
interface IKIP13 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
pragma solidity ^0.8.0;
interface IKIP17 {
function balanceOf(address _owner) external view returns (uint256);
function ownerOf(uint256 _tokenId) external view returns (address);
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 _approved, uint256 _tokenId) external;
function setApprovalForAll(address _operator, bool _approved) external;
function getApproved(uint256 _tokenId) external view returns (address);
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
}
pragma solidity ^0.8.0;
interface IKIP17Enumerable {
function totalSupply() external view returns (uint256);
function tokenByIndex(uint256 _index) external view returns (uint256);
function tokenOfOwnerByIndex(address _owner, uint256 _index) external view returns (uint256);
}
pragma solidity ^0.8.0;
interface IKIP17Metadata {
function name() external view returns (string memory _name);
function symbol() external view returns (string memory _symbol);
function tokenURI(uint256 _tokenId) external view returns (string memory);
}
pragma solidity ^0.8.0;
interface IReserveMintRule {
function getMintRuleVersion() external pure returns (uint256);
function checkMintableTokens(uint256 startTokenId, uint256 amount) external view;
}
pragma solidity ^0.8.0;
contract PioneerNFT is
IPioneerNFT,
IKIP13,
IKIP17,
IKIP17Enumerable,
IKIP17Metadata,
IERC165,
ERC721,
ERC721Enumerable,
Pausable,
Ownable
{
struct Range {
uint256 start;
uint256 end;
}
string public baseURI = "";
uint256 public immutable mintIntervalForTeam;
uint256 public immutable mintAmountPerInterval;
mapping(SupplyType => uint256) public supplyForType;
mapping(SupplyType => address) public minters;
address public reserveTokenMintRule;
IPioneerNFTMintListener public mintListener;
mapping(address => bool) public pauseExcluded;
mapping(SupplyType => Range) private _tokenIdRanges;
event MinterChanged(SupplyType indexed supplyType, address previousMinter, address minter);
event ReserveTokenMintRuleChanged(address previousMintRule, address mintRule, uint256 version);
event BaseURIChanged(string previousBaseURI, string baseURI);
event MintingListenerRegistered(address listener);
event MintingListenerReverted(string reason);
modifier onlyMinter(SupplyType supplyType) {
require(msg.sender == minters[supplyType], "PioneerNFT: invalid authority; minter");
_;
}
constructor(uint256[] memory _supplyCaps, uint256 _mintIntervalForTeam) ERC721("Pioneer NFT", "PNFT") {
require(_supplyCaps.length == uint256(SupplyType.RESERVE) + 1, "PioneerNFT: invalid params; supplyCaps");
uint256 currentId = 1;
for (uint8 i = uint8(SupplyType.PRIVATE); i <= uint8(SupplyType.RESERVE); i++) {
_tokenIdRanges[SupplyType(i)].start = currentId;
_tokenIdRanges[SupplyType(i)].end = currentId = currentId + _supplyCaps[i];
}
mintIntervalForTeam = _mintIntervalForTeam;
mintAmountPerInterval =
(_supplyCaps[uint8(SupplyType.TEAM)] * _mintIntervalForTeam) /
(_supplyCaps[uint8(SupplyType.PRIVATE)] + _supplyCaps[uint8(SupplyType.PUBLIC)]);
minters[SupplyType.PRIVATE] = msg.sender;
minters[SupplyType.PUBLIC] = msg.sender;
minters[SupplyType.TEAM] = msg.sender;
minters[SupplyType.RESERVE] = msg.sender;
_pause();
}
function supportsInterface(bytes4 interfaceId)
public
view
override(IKIP13, IERC165, ERC721, ERC721Enumerable)
returns (bool)
{
return
interfaceId == type(IKIP13).interfaceId ||
interfaceId == type(IKIP17).interfaceId ||
interfaceId == type(IKIP17Metadata).interfaceId ||
interfaceId == type(IKIP17Enumerable).interfaceId ||
super.supportsInterface(interfaceId);
}
function name() public view override(IKIP17Metadata, ERC721) returns (string memory _name) {
return super.name();
}
function symbol() public view override(IKIP17Metadata, ERC721) returns (string memory _symbol) {
return super.symbol();
}
function tokenURI(uint256 _tokenId) public view override(IKIP17Metadata, ERC721) returns (string memory) {
return super.tokenURI(_tokenId);
}
function totalSupply() public view override(IKIP17Enumerable, ERC721Enumerable) returns (uint256) {
return super.totalSupply();
}
function tokenByIndex(uint256 _index) public view override(IKIP17Enumerable, ERC721Enumerable) returns (uint256) {
return super.tokenByIndex(_index);
}
function tokenOfOwnerByIndex(address _owner, uint256 _index)
public
view
override(IKIP17Enumerable, ERC721Enumerable)
returns (uint256)
{
return super.tokenOfOwnerByIndex(_owner, _index);
}
function balanceOf(address _owner) public view override(IKIP17, IERC721, ERC721) returns (uint256) {
return super.balanceOf(_owner);
}
function ownerOf(uint256 _tokenId) public view override(IKIP17, IERC721, ERC721) returns (address) {
return super.ownerOf(_tokenId);
}
function safeTransferFrom(
address _from,
address _to,
uint256 _tokenId,
bytes memory _data
) public override(IKIP17, IERC721, ERC721) {
return super.safeTransferFrom(_from, _to, _tokenId, _data);
}
function safeTransferFrom(
address _from,
address _to,
uint256 _tokenId
) public override(IKIP17, IERC721, ERC721) {
return super.safeTransferFrom(_from, _to, _tokenId);
}
function transferFrom(
address _from,
address _to,
uint256 _tokenId
) public override(IKIP17, IERC721, ERC721) {
return super.transferFrom(_from, _to, _tokenId);
}
function approve(address _approved, uint256 _tokenId) public override(IKIP17, IERC721, ERC721) {
return super.approve(_approved, _tokenId);
}
function setApprovalForAll(address _operator, bool _approved) public override(IKIP17, IERC721, ERC721) {
return super.setApprovalForAll(_operator, _approved);
}
function getApproved(uint256 _tokenId) public view override(IKIP17, IERC721, ERC721) returns (address) {
return super.getApproved(_tokenId);
}
function isApprovedForAll(address _owner, address _operator)
public
view
override(IKIP17, IERC721, ERC721)
returns (bool)
{
return super.isApprovedForAll(_owner, _operator);
}
function pause() public onlyOwner {
_pause();
}
function unpause() public onlyOwner {
_unpause();
}
function setMintListener(address listener) public onlyOwner {
require(listener != address(0), "PioneerNFT: invalid listener address");
require(
IERC165(listener).supportsInterface(type(IPioneerNFTMintListener).interfaceId),
"PioneerNFT: the given contract does not implemented IPioneerNFTMintingListener"
);
mintListener = IPioneerNFTMintListener(listener);
emit MintingListenerRegistered(listener);
}
function registerPauseExcluded(address excluded) public onlyOwner {
require(!pauseExcluded[excluded], "PioneerNFT: the address has already been registered");
require(Address.isContract(excluded), "PioneerNFT: the given address is not a contract");
pauseExcluded[excluded] = true;
}
function deregisterPauseExcluded(address excluded) public onlyOwner {
require(pauseExcluded[excluded], "PioneerNFT: the address was not registered");
pauseExcluded[excluded] = false;
}
function setMinter(SupplyType supplyType, address minter) public onlyOwner {
require(minter != address(0), "PioneerNFT: invalid params; minter");
address previousMinter = minters[supplyType];
minters[supplyType] = minter;
emit MinterChanged(supplyType, previousMinter, minter);
}
function setReserveTokenMintRule(address mintRule) public onlyOwner {
address previousMintRule = reserveTokenMintRule;
reserveTokenMintRule = mintRule;
emit ReserveTokenMintRuleChanged(
previousMintRule,
mintRule,
IReserveMintRule(reserveTokenMintRule).getMintRuleVersion()
);
}
function setBaseURI(string memory uri) public onlyOwner {
string memory previousBaseURI = baseURI;
baseURI = uri;
emit BaseURIChanged(previousBaseURI, baseURI);
}
function mintPrivate(address to) external onlyMinter(SupplyType.PRIVATE) returns (uint256) {
return _mint(SupplyType.PRIVATE, to);
}
function mintPublic(address to) external override(IPioneerNFT) onlyMinter(SupplyType.PUBLIC) returns (uint256) {
return _mint(SupplyType.PUBLIC, to);
}
function mintTeam(address to) external onlyMinter(SupplyType.TEAM) returns (uint256) {
_checkMintableTeamTokensAmount(1);
return _mint(SupplyType.TEAM, to);
}
function mintReserve(address to) external onlyMinter(SupplyType.RESERVE) returns (uint256) {
_checkMintableReserveTokensAmount(1);
return _mint(SupplyType.RESERVE, to);
}
function mintPrivateBatch(address to, uint256 amount)
external
onlyMinter(SupplyType.PRIVATE)
returns (uint256 startId, uint256 endId)
{
return _mintBatch(SupplyType.PRIVATE, to, amount);
}
function mintTeamBatch(address to, uint256 amount)
external
onlyMinter(SupplyType.TEAM)
returns (uint256 startId, uint256 endId)
{
_checkMintableTeamTokensAmount(amount);
return _mintBatch(SupplyType.TEAM, to, amount);
}
function mintReserveBatch(address to, uint256 amount)
external
onlyMinter(SupplyType.RESERVE)
returns (uint256 startId, uint256 endId)
{
_checkMintableReserveTokensAmount(amount);
return _mintBatch(SupplyType.RESERVE, to, amount);
}
function approveAndCall(
address to,
uint256 tokenId,
bytes calldata data
) external payable returns (bytes memory) {
approve(to, tokenId);
return Address.functionCallWithValue(to, data, msg.value);
}
function approveBatchAndCall(
address to,
uint256[] memory tokenIds,
bytes calldata data
) external payable returns (bytes memory) {
require(tokenIds.length > 0, "PioneerNFT: invalid params; token ids are empty");
for (uint256 i = 0; i < tokenIds.length; i++) {
approve(to, tokenIds[i]);
}
return Address.functionCallWithValue(to, data, msg.value);
}
function _checkMintableTeamTokensAmount(uint256 amount) internal view {
uint256 saleAmount = supplyForType[SupplyType.PRIVATE] + supplyForType[SupplyType.PUBLIC];
uint256 mintableAmount = (saleAmount / mintIntervalForTeam) * mintAmountPerInterval;
require(
mintableAmount >= supplyForType[SupplyType.TEAM] + amount,
"PioneerNFT: the mintable team tokens has been exceeded for the current sale amount"
);
}
function _checkMintableReserveTokensAmount(uint256 amount) internal view {
require(reserveTokenMintRule != address(0), "PioneerNFT: there is no rule for minting reserve tokens");
Range memory range = _tokenIdRanges[SupplyType.RESERVE];
uint256 tokenId = range.start + supplyForType[SupplyType.RESERVE];
IReserveMintRule(reserveTokenMintRule).checkMintableTokens(tokenId, amount);
}
function _mint(SupplyType supplyType, address to) internal returns (uint256) {
Range memory range = _tokenIdRanges[supplyType];
uint256 currentSupply = supplyForType[supplyType];
uint256 tokenId = range.start + currentSupply;
require(tokenId < range.end, "PioneerNFT: the supply has been exceeded");
supplyForType[supplyType] = currentSupply + 1;
_mint(to, tokenId);
if (address(mintListener) != address(0)) {
mintListener.onTokenMinted(supplyType, tokenId);
}
return tokenId;
}
function _mintBatch(
SupplyType supplyType,
address to,
uint256 amount
) internal returns (uint256 startId, uint256 endId) {
require(amount > 0, "PioneerNFT: invalid params; amount");
uint256 id;
for (uint256 i = 0; i < amount; i++) {
id = _mint(supplyType, to);
if (i == 0) {
startId = id;
}
}
return (startId, id);
}
function _baseURI() internal view override returns (string memory) {
return baseURI;
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId,
uint256 batchSize
) internal override(ERC721, ERC721Enumerable) {
require(
!paused() ||
from == address(0) ||
pauseExcluded[from] ||
pauseExcluded[to],
"PioneerNFT: paused"
);
super._beforeTokenTransfer(from, to, tokenId, batchSize);
}
}
