编译器
0.8.17+commit.8df45f5f
文件 1 的 31：AccessControl.sol
pragma solidity ^0.8.0;
import "./IAccessControl.sol";
import "../utils/Context.sol";
import "../utils/Strings.sol";
import "../utils/introspection/ERC165.sol";
abstract contract AccessControl is Context, IAccessControl, ERC165 {
struct RoleData {
mapping(address => bool) members;
bytes32 adminRole;
}
mapping(bytes32 => RoleData) private _roles;
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
modifier onlyRole(bytes32 role) {
_checkRole(role);
_;
}
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);
}
function hasRole(bytes32 role, address account) public view virtual override returns (bool) {
return _roles[role].members[account];
}
function _checkRole(bytes32 role) internal view virtual {
_checkRole(role, _msgSender());
}
function _checkRole(bytes32 role, address account) internal view virtual {
if (!hasRole(role, account)) {
revert(
string(
abi.encodePacked(
"AccessControl: account ",
Strings.toHexString(account),
" is missing role ",
Strings.toHexString(uint256(role), 32)
)
)
);
}
}
function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) {
return _roles[role].adminRole;
}
function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
_grantRole(role, account);
}
function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
_revokeRole(role, account);
}
function renounceRole(bytes32 role, address account) public virtual override {
require(account == _msgSender(), "AccessControl: can only renounce roles for self");
_revokeRole(role, account);
}
function _setupRole(bytes32 role, address account) internal virtual {
_grantRole(role, account);
}
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
bytes32 previousAdminRole = getRoleAdmin(role);
_roles[role].adminRole = adminRole;
emit RoleAdminChanged(role, previousAdminRole, adminRole);
}
function _grantRole(bytes32 role, address account) internal virtual {
if (!hasRole(role, account)) {
_roles[role].members[account] = true;
emit RoleGranted(role, account, _msgSender());
}
}
function _revokeRole(bytes32 role, address account) internal virtual {
if (hasRole(role, account)) {
_roles[role].members[account] = false;
emit RoleRevoked(role, account, _msgSender());
}
}
}
文件 2 的 31：Address.sol
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);
}
}
}
文件 3 的 31：Checkpoints.sol
pragma solidity ^0.8.0;
import "./math/Math.sol";
import "./math/SafeCast.sol";
library Checkpoints {
struct History {
Checkpoint[] _checkpoints;
}
struct Checkpoint {
uint32 _blockNumber;
uint224 _value;
}
function getAtBlock(History storage self, uint256 blockNumber) internal view returns (uint256) {
require(blockNumber < block.number, "Checkpoints: block not yet mined");
uint32 key = SafeCast.toUint32(blockNumber);
uint256 len = self._checkpoints.length;
uint256 pos = _upperBinaryLookup(self._checkpoints, key, 0, len);
return pos == 0 ? 0 : _unsafeAccess(self._checkpoints, pos - 1)._value;
}
function getAtProbablyRecentBlock(History storage self, uint256 blockNumber) internal view returns (uint256) {
require(blockNumber < block.number, "Checkpoints: block not yet mined");
uint32 key = SafeCast.toUint32(blockNumber);
uint256 len = self._checkpoints.length;
uint256 low = 0;
uint256 high = len;
if (len > 5) {
uint256 mid = len - Math.sqrt(len);
if (key < _unsafeAccess(self._checkpoints, mid)._blockNumber) {
high = mid;
} else {
low = mid + 1;
}
}
uint256 pos = _upperBinaryLookup(self._checkpoints, key, low, high);
return pos == 0 ? 0 : _unsafeAccess(self._checkpoints, pos - 1)._value;
}
function push(History storage self, uint256 value) internal returns (uint256, uint256) {
return _insert(self._checkpoints, SafeCast.toUint32(block.number), SafeCast.toUint224(value));
}
function push(
History storage self,
function(uint256, uint256) view returns (uint256) op,
uint256 delta
) internal returns (uint256, uint256) {
return push(self, op(latest(self), delta));
}
function latest(History storage self) internal view returns (uint224) {
uint256 pos = self._checkpoints.length;
return pos == 0 ? 0 : _unsafeAccess(self._checkpoints, pos - 1)._value;
}
function latestCheckpoint(History storage self)
internal
view
returns (
bool exists,
uint32 _blockNumber,
uint224 _value
)
{
uint256 pos = self._checkpoints.length;
if (pos == 0) {
return (false, 0, 0);
} else {
Checkpoint memory ckpt = _unsafeAccess(self._checkpoints, pos - 1);
return (true, ckpt._blockNumber, ckpt._value);
}
}
function length(History storage self) internal view returns (uint256) {
return self._checkpoints.length;
}
function _insert(
Checkpoint[] storage self,
uint32 key,
uint224 value
) private returns (uint224, uint224) {
uint256 pos = self.length;
if (pos > 0) {
Checkpoint memory last = _unsafeAccess(self, pos - 1);
require(last._blockNumber <= key, "Checkpoint: invalid key");
if (last._blockNumber == key) {
_unsafeAccess(self, pos - 1)._value = value;
} else {
self.push(Checkpoint({_blockNumber: key, _value: value}));
}
return (last._value, value);
} else {
self.push(Checkpoint({_blockNumber: key, _value: value}));
return (0, value);
}
}
function _upperBinaryLookup(
Checkpoint[] storage self,
uint32 key,
uint256 low,
uint256 high
) private view returns (uint256) {
while (low < high) {
uint256 mid = Math.average(low, high);
if (_unsafeAccess(self, mid)._blockNumber > key) {
high = mid;
} else {
low = mid + 1;
}
}
return high;
}
function _lowerBinaryLookup(
Checkpoint[] storage self,
uint32 key,
uint256 low,
uint256 high
) private view returns (uint256) {
while (low < high) {
uint256 mid = Math.average(low, high);
if (_unsafeAccess(self, mid)._blockNumber < key) {
low = mid + 1;
} else {
high = mid;
}
}
return high;
}
function _unsafeAccess(Checkpoint[] storage self, uint256 pos) private pure returns (Checkpoint storage result) {
assembly {
mstore(0, self.slot)
result.slot := add(keccak256(0, 0x20), pos)
}
}
struct Trace224 {
Checkpoint224[] _checkpoints;
}
struct Checkpoint224 {
uint32 _key;
uint224 _value;
}
function push(
Trace224 storage self,
uint32 key,
uint224 value
) internal returns (uint224, uint224) {
return _insert(self._checkpoints, key, value);
}
function lowerLookup(Trace224 storage self, uint32 key) internal view returns (uint224) {
uint256 len = self._checkpoints.length;
uint256 pos = _lowerBinaryLookup(self._checkpoints, key, 0, len);
return pos == len ? 0 : _unsafeAccess(self._checkpoints, pos)._value;
}
function upperLookup(Trace224 storage self, uint32 key) internal view returns (uint224) {
uint256 len = self._checkpoints.length;
uint256 pos = _upperBinaryLookup(self._checkpoints, key, 0, len);
return pos == 0 ? 0 : _unsafeAccess(self._checkpoints, pos - 1)._value;
}
function latest(Trace224 storage self) internal view returns (uint224) {
uint256 pos = self._checkpoints.length;
return pos == 0 ? 0 : _unsafeAccess(self._checkpoints, pos - 1)._value;
}
function latestCheckpoint(Trace224 storage self)
internal
view
returns (
bool exists,
uint32 _key,
uint224 _value
)
{
uint256 pos = self._checkpoints.length;
if (pos == 0) {
return (false, 0, 0);
} else {
Checkpoint224 memory ckpt = _unsafeAccess(self._checkpoints, pos - 1);
return (true, ckpt._key, ckpt._value);
}
}
function length(Trace224 storage self) internal view returns (uint256) {
return self._checkpoints.length;
}
function _insert(
Checkpoint224[] storage self,
uint32 key,
uint224 value
) private returns (uint224, uint224) {
uint256 pos = self.length;
if (pos > 0) {
Checkpoint224 memory last = _unsafeAccess(self, pos - 1);
require(last._key <= key, "Checkpoint: invalid key");
if (last._key == key) {
_unsafeAccess(self, pos - 1)._value = value;
} else {
self.push(Checkpoint224({_key: key, _value: value}));
}
return (last._value, value);
} else {
self.push(Checkpoint224({_key: key, _value: value}));
return (0, value);
}
}
function _upperBinaryLookup(
Checkpoint224[] storage self,
uint32 key,
uint256 low,
uint256 high
) private view returns (uint256) {
while (low < high) {
uint256 mid = Math.average(low, high);
if (_unsafeAccess(self, mid)._key > key) {
high = mid;
} else {
low = mid + 1;
}
}
return high;
}
function _lowerBinaryLookup(
Checkpoint224[] storage self,
uint32 key,
uint256 low,
uint256 high
) private view returns (uint256) {
while (low < high) {
uint256 mid = Math.average(low, high);
if (_unsafeAccess(self, mid)._key < key) {
low = mid + 1;
} else {
high = mid;
}
}
return high;
}
function _unsafeAccess(Checkpoint224[] storage self, uint256 pos)
private
pure
returns (Checkpoint224 storage result)
{
assembly {
mstore(0, self.slot)
result.slot := add(keccak256(0, 0x20), pos)
}
}
struct Trace160 {
Checkpoint160[] _checkpoints;
}
struct Checkpoint160 {
uint96 _key;
uint160 _value;
}
function push(
Trace160 storage self,
uint96 key,
uint160 value
) internal returns (uint160, uint160) {
return _insert(self._checkpoints, key, value);
}
function lowerLookup(Trace160 storage self, uint96 key) internal view returns (uint160) {
uint256 len = self._checkpoints.length;
uint256 pos = _lowerBinaryLookup(self._checkpoints, key, 0, len);
return pos == len ? 0 : _unsafeAccess(self._checkpoints, pos)._value;
}
function upperLookup(Trace160 storage self, uint96 key) internal view returns (uint160) {
uint256 len = self._checkpoints.length;
uint256 pos = _upperBinaryLookup(self._checkpoints, key, 0, len);
return pos == 0 ? 0 : _unsafeAccess(self._checkpoints, pos - 1)._value;
}
function latest(Trace160 storage self) internal view returns (uint160) {
uint256 pos = self._checkpoints.length;
return pos == 0 ? 0 : _unsafeAccess(self._checkpoints, pos - 1)._value;
}
function latestCheckpoint(Trace160 storage self)
internal
view
returns (
bool exists,
uint96 _key,
uint160 _value
)
{
uint256 pos = self._checkpoints.length;
if (pos == 0) {
return (false, 0, 0);
} else {
Checkpoint160 memory ckpt = _unsafeAccess(self._checkpoints, pos - 1);
return (true, ckpt._key, ckpt._value);
}
}
function length(Trace160 storage self) internal view returns (uint256) {
return self._checkpoints.length;
}
function _insert(
Checkpoint160[] storage self,
uint96 key,
uint160 value
) private returns (uint160, uint160) {
uint256 pos = self.length;
if (pos > 0) {
Checkpoint160 memory last = _unsafeAccess(self, pos - 1);
require(last._key <= key, "Checkpoint: invalid key");
if (last._key == key) {
_unsafeAccess(self, pos - 1)._value = value;
} else {
self.push(Checkpoint160({_key: key, _value: value}));
}
return (last._value, value);
} else {
self.push(Checkpoint160({_key: key, _value: value}));
return (0, value);
}
}
function _upperBinaryLookup(
Checkpoint160[] storage self,
uint96 key,
uint256 low,
uint256 high
) private view returns (uint256) {
while (low < high) {
uint256 mid = Math.average(low, high);
if (_unsafeAccess(self, mid)._key > key) {
high = mid;
} else {
low = mid + 1;
}
}
return high;
}
function _lowerBinaryLookup(
Checkpoint160[] storage self,
uint96 key,
uint256 low,
uint256 high
) private view returns (uint256) {
while (low < high) {
uint256 mid = Math.average(low, high);
if (_unsafeAccess(self, mid)._key < key) {
low = mid + 1;
} else {
high = mid;
}
}
return high;
}
function _unsafeAccess(Checkpoint160[] storage self, uint256 pos)
private
pure
returns (Checkpoint160 storage result)
{
assembly {
mstore(0, self.slot)
result.slot := add(keccak256(0, 0x20), pos)
}
}
}
文件 4 的 31：Constants.sol
pragma solidity ^0.8.13;
address constant CANONICAL_OPERATOR_FILTER_REGISTRY_ADDRESS = 0x000000000000AAeB6D7670E522A718067333cd4E;
address constant CANONICAL_CORI_SUBSCRIPTION = 0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6;
文件 5 的 31：Context.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;
}
}
文件 6 的 31：ECDSA.sol
pragma solidity ^0.8.0;
import "../Strings.sol";
library ECDSA {
enum RecoverError {
NoError,
InvalidSignature,
InvalidSignatureLength,
InvalidSignatureS,
InvalidSignatureV
}
function _throwError(RecoverError error) private pure {
if (error == RecoverError.NoError) {
return;
} else if (error == RecoverError.InvalidSignature) {
revert("ECDSA: invalid signature");
} else if (error == RecoverError.InvalidSignatureLength) {
revert("ECDSA: invalid signature length");
} else if (error == RecoverError.InvalidSignatureS) {
revert("ECDSA: invalid signature 's' value");
}
}
function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
if (signature.length == 65) {
bytes32 r;
bytes32 s;
uint8 v;
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return tryRecover(hash, v, r, s);
} else {
return (address(0), RecoverError.InvalidSignatureLength);
}
}
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, signature);
_throwError(error);
return recovered;
}
function tryRecover(
bytes32 hash,
bytes32 r,
bytes32 vs
) internal pure returns (address, RecoverError) {
bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
uint8 v = uint8((uint256(vs) >> 255) + 27);
return tryRecover(hash, v, r, s);
}
function recover(
bytes32 hash,
bytes32 r,
bytes32 vs
) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, r, vs);
_throwError(error);
return recovered;
}
function tryRecover(
bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s
) internal pure returns (address, RecoverError) {
if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
return (address(0), RecoverError.InvalidSignatureS);
}
address signer = ecrecover(hash, v, r, s);
if (signer == address(0)) {
return (address(0), RecoverError.InvalidSignature);
}
return (signer, RecoverError.NoError);
}
function recover(
bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s
) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, v, r, s);
_throwError(error);
return recovered;
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
}
}
文件 7 的 31：EIP712.sol
pragma solidity ^0.8.0;
import "./ECDSA.sol";
abstract contract EIP712 {
bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;
uint256 private immutable _CACHED_CHAIN_ID;
address private immutable _CACHED_THIS;
bytes32 private immutable _HASHED_NAME;
bytes32 private immutable _HASHED_VERSION;
bytes32 private immutable _TYPE_HASH;
constructor(string memory name, string memory version) {
bytes32 hashedName = keccak256(bytes(name));
bytes32 hashedVersion = keccak256(bytes(version));
bytes32 typeHash = keccak256(
"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
);
_HASHED_NAME = hashedName;
_HASHED_VERSION = hashedVersion;
_CACHED_CHAIN_ID = block.chainid;
_CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(typeHash, hashedName, hashedVersion);
_CACHED_THIS = address(this);
_TYPE_HASH = typeHash;
}
function _domainSeparatorV4() internal view returns (bytes32) {
if (address(this) == _CACHED_THIS && block.chainid == _CACHED_CHAIN_ID) {
return _CACHED_DOMAIN_SEPARATOR;
} else {
return _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION);
}
}
function _buildDomainSeparator(
bytes32 typeHash,
bytes32 nameHash,
bytes32 versionHash
) private view returns (bytes32) {
return keccak256(abi.encode(typeHash, nameHash, versionHash, block.chainid, address(this)));
}
function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);
}
}
文件 8 的 31：ERC165.sol
pragma solidity ^0.8.0;
import "./IERC165.sol";
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
文件 9 的 31：ERC721.sol
pragma solidity ^0.8.0;
import "./IERC721.sol";
import "./IERC721Receiver.sol";
import "./extensions/IERC721Metadata.sol";
import "../../utils/Address.sol";
import "../../utils/Context.sol";
import "../../utils/Strings.sol";
import "../../utils/introspection/ERC165.sol";
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,
uint256 batchSize
) internal virtual {
if (batchSize > 1) {
if (from != address(0)) {
_balances[from] -= batchSize;
}
if (to != address(0)) {
_balances[to] += batchSize;
}
}
}
function _afterTokenTransfer(
address from,
address to,
uint256 firstTokenId,
uint256 batchSize
) internal virtual {}
}
文件 10 的 31：ERC721MultiCollection.sol
pragma solidity 0.8.17;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "./interfaces/IERC721MultiCollection.sol";
abstract contract ERC721MultiCollection is ERC721, IERC721MultiCollection {
uint256 public immutable MAX_COLLECTION_SIZE;
mapping(address => mapping(uint256 => uint256)) private _collectionBalances;
mapping(address => mapping(uint256 => uint256)) private _collectionOwnedTokens;
mapping(address => mapping(uint256 => uint256)) private _collectionOwnedTokensIndex;
mapping(uint256 => uint256) private _tokensPerCollection;
bool private _newCollectionsForbidden;
uint256 private _nextCollectionId;
modifier onlyValidCollectionId(uint256 _collectionId) {
require(
_collectionId < _nextCollectionId,
"Collection ID does not exist"
);
_;
}
constructor(uint256 maxCollectionSize) {
MAX_COLLECTION_SIZE = maxCollectionSize;
}
function collectionExists(uint256 collectionId) external view override returns (bool) {
return collectionId < _nextCollectionId;
}
function _newCollectionsAllowed() internal view returns (bool) {
return !_newCollectionsForbidden;
}
function _validCollectionSize(uint256 collectionSize) internal view returns (bool) {
return collectionSize > 0 && collectionSize <= MAX_COLLECTION_SIZE;
}
function _addCollection(uint256 collectionSize) internal returns (uint256){
require(!_newCollectionsForbidden, "New collections forbidden");
require(_validCollectionSize(collectionSize), "Number of particles must be > 0 && <= MAX_COLLECTION_SIZE");
uint256 collectionId = _nextCollectionId;
_nextCollectionId++;
emit CollectionAdded(collectionId);
return collectionId;
}
function numberOfCollections() public view returns (uint256) {
return _nextCollectionId;
}
function balanceOf(address owner, uint256 collectionId) public view returns (uint256) {
require(owner != address(0), "ERC721MultiCollection: address zero is not a valid owner");
return _collectionBalances[owner][collectionId];
}
function tokenTotalSupply(uint256 collectionId) external view returns (uint256) {
return _tokensPerCollection[collectionId];
}
function tokenOfOwnerByIndex(address owner, uint256 index, uint256 collectionId) external view returns (uint256) {
require(index < balanceOf(owner, collectionId), "ERC721MultiCollection: owner index out of bounds");
return _collectionOwnedTokens[owner][index];
}
function _forbidNewCollections()
internal
{
require(!_newCollectionsForbidden, "Already forbidden");
_newCollectionsForbidden = true;
emit NewCollectionsForbidden();
}
function tokenIdToCollectionId(uint256 _tokenId) public view returns (uint256 collectionId) {
return _tokenId / MAX_COLLECTION_SIZE;
}
function _burn(address owner, uint256 collectionId, uint256 tokensToBurn) internal returns (uint256 tokensBurnt) {
uint256 balance = _collectionBalances[owner][collectionId];
require(balance >= tokensToBurn, "ERC721MultiCollection: burn amount exceeds balance");
for (uint256 i = 0; i < tokensToBurn;) {
uint256 tokenId = _collectionOwnedTokens[owner][balance - 1 - i];
_burn(tokenId);
unchecked { i++; }
}
return tokensToBurn;
}
function _addTokenToOwnerCollectionEnumeration(address to, uint256 tokenId, uint256 collectionId) private {
uint256 length = _collectionBalances[to][collectionId];
_collectionOwnedTokens[to][length] = tokenId;
_collectionOwnedTokensIndex[to][tokenId] = length;
_collectionBalances[to][collectionId] += 1;
}
function _removeTokenFromOwnerCollectionEnumeration(address from, uint256 tokenId, uint256 collectionId) private {
uint256 lastTokenIndex = _collectionBalances[from][collectionId] - 1;
uint256 tokenIndex = _collectionOwnedTokensIndex[from][tokenId];
if (tokenIndex != lastTokenIndex) {
uint256 lastTokenId = _collectionOwnedTokens[from][lastTokenIndex];
_collectionOwnedTokens[from][tokenIndex] = lastTokenId;
_collectionOwnedTokensIndex[from][lastTokenId] = tokenIndex;
}
delete _collectionOwnedTokensIndex[from][tokenId];
delete _collectionOwnedTokens[from][lastTokenIndex];
_collectionBalances[from][collectionId] -= 1;
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId,
uint256 batchSize
) internal virtual override(ERC721) {
super._beforeTokenTransfer(from, to, tokenId, batchSize);
uint256 collectionId = tokenIdToCollectionId(tokenId);
if (from != address(0)) {
_removeTokenFromOwnerCollectionEnumeration(from, tokenId, collectionId);
} else {
_tokensPerCollection[collectionId] += 1;
}
if (to != address(0)) {
_addTokenToOwnerCollectionEnumeration(to, tokenId, collectionId);
} else {
_tokensPerCollection[collectionId] -= 1;
}
}
}
文件 11 的 31：IAccessControl.sol
pragma solidity ^0.8.0;
interface IAccessControl {
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
function hasRole(bytes32 role, address account) external view returns (bool);
function getRoleAdmin(bytes32 role) external view returns (bytes32);
function grantRole(bytes32 role, address account) external;
function revokeRole(bytes32 role, address account) external;
function renounceRole(bytes32 role, address account) external;
}
文件 12 的 31：IERC165.sol
pragma solidity ^0.8.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
文件 13 的 31：IERC721.sol
pragma solidity ^0.8.0;
import "../../utils/introspection/IERC165.sol";
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);
}
文件 14 的 31：IERC721Metadata.sol
pragma solidity ^0.8.0;
import "../IERC721.sol";
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);
}
文件 15 的 31：IERC721MultiCollection.sol
pragma solidity 0.8.17;
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
interface IERC721MultiCollection is IERC721 {
event CollectionAdded(uint256 indexed collectionId);
event NewCollectionsForbidden();
function collectionExists(uint256 collectionId) external view returns (bool);
function balanceOf(address owner, uint256 collectionId) external view returns (uint256);
function tokenIdToCollectionId(uint256 tokenId) external view returns (uint256 collectionId);
function numberOfCollections() external view returns (uint256);
function tokenTotalSupply(uint256 collectionId) external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index, uint256 collectionId) external view returns (uint256);
function MAX_COLLECTION_SIZE() external view returns (uint256);
}
文件 16 的 31：IERC721Receiver.sol
pragma solidity ^0.8.0;
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
文件 17 的 31：IManifold.sol
pragma solidity 0.8.17;
interface IManifold {
function getRoyalties(uint256 tokenId) external view returns (address payable[] memory, uint256[] memory);
}文件 18 的 31：IOperatorFilterRegistry.sol
pragma solidity ^0.8.13;
interface IOperatorFilterRegistry {
function isOperatorAllowed(address registrant, address operator) external view returns (bool);
function register(address registrant) external;
function registerAndSubscribe(address registrant, address subscription) external;
function registerAndCopyEntries(address registrant, address registrantToCopy) external;
function unregister(address addr) external;
function updateOperator(address registrant, address operator, bool filtered) external;
function updateOperators(address registrant, address[] calldata operators, bool filtered) external;
function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external;
function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external;
function subscribe(address registrant, address registrantToSubscribe) external;
function unsubscribe(address registrant, bool copyExistingEntries) external;
function subscriptionOf(address addr) external returns (address registrant);
function subscribers(address registrant) external returns (address[] memory);
function subscriberAt(address registrant, uint256 index) external returns (address);
function copyEntriesOf(address registrant, address registrantToCopy) external;
function isOperatorFiltered(address registrant, address operator) external returns (bool);
function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool);
function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool);
function filteredOperators(address addr) external returns (address[] memory);
function filteredCodeHashes(address addr) external returns (bytes32[] memory);
function filteredOperatorAt(address registrant, uint256 index) external returns (address);
function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32);
function isRegistered(address addr) external returns (bool);
function codeHashOf(address addr) external returns (bytes32);
}
文件 19 的 31：IPRTCLCollections721V1.sol
pragma solidity 0.8.17;
import "./IManifold.sol";
import "./IERC721MultiCollection.sol";
interface IPRTCLCollections721V1 is IERC721, IERC721MultiCollection, IManifold {
event CollectionDataUpdated(uint256 indexed _collectionId);
event CollectionSizeUpdated(uint256 indexed _collectionId, uint256 _size);
event CollectionSold(uint256 indexed _collectionId, address _buyer);
event CollectionActive(uint256 indexed _collectionId);
event CollectionInactive(uint256 indexed _collectionId);
event CollectionRoyaltiesUpdated(uint256 indexed _collectionId);
event CollectionPrimarySplitUpdated(uint256 indexed _collectionId);
event CollectionFullyMinted(uint256 indexed _collectionId);
event BaseURIUpdated(string _baseURI);
event RoyaltiesAddressesUpdated(address _FJMAddress, address _DAOAddress);
event RandomizerUpdated(address _randomizer);
event CollectionSeedsSet(uint256 _collectionId, uint24 _seed1, uint24 _seed2);
function collectionIdToArtistAddress(uint256 _collectionId) external view returns (address payable);
function getPrimaryRevenueSplits(uint256 _collectionId, uint256 _price) external view
returns (
uint256 FJMRevenue_,
address payable FJMAddress_,
uint256 DAORevenue_,
address payable DAOAddress_,
uint256 artistRevenue_,
address payable artistAddress_
);
function collectionData(uint256 _collectionId) external view returns (
uint256 nParticles,
uint256 maxParticles,
bool active,
string memory collectionName,
bool sold,
uint24[] memory seeds,
uint256 setSeedsAfterBlock
);
function collectionCanBeSold(uint256 _collectionId) external view returns (bool);
function proceeds(uint256 _collectionId, uint256 _salePrice, uint256 _commission, uint256 _tokens) external view returns (uint256);
function getCoordinate(uint256 _tokenId) external view returns (uint256);
function markCollectionSold(uint256 _collectionId, address _buyer) external;
function mint(address _to, uint256 _collectionId, uint24 _amount) external returns (uint256 tokenId);
function burn(address owner, uint256 collectionId, uint256 tokensToRedeem) external returns (uint256 tokensBurnt);
function setCollectionSeeds(uint256 _collectionId, uint24[2] calldata _seeds) external;
}
文件 20 的 31：IPRTCLVotes.sol
pragma solidity 0.8.17;
interface IPRTCLVotes {
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate, uint256 collectionId);
event DelegateVotesChanged(address indexed delegate, uint256 previousBalance, uint256 newBalance, uint256 collectionId);
function getVotes(address account, uint256 collectionId) external view returns (uint256);
function getPastVotes(address account, uint256 blockNumber, uint256 collectionId) external view returns (uint256);
function getPastTotalSupply(uint256 blockNumber, uint256 collectionId) external view returns (uint256);
function getTotalSupply(uint256 collectionId) external view returns (uint256);
function delegate(address delegatee, uint256 collectionId) external;
function delegates(address account, uint256 collectionId) external view returns (address);
}
文件 21 的 31：IRandomizerV1.sol
pragma solidity 0.8.17;
interface IRandomizerV1 {
function setCollectionSeeds(uint256 _collectionId) external;
}
文件 22 的 31：Math.sol
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);
}
}
}
文件 23 的 31：PRTCLCollections721V1.sol
pragma solidity 0.8.17;
import "@openzeppelin/contracts/access/AccessControl.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
import "operator-filter-registry/src/RevokableDefaultOperatorFilterer.sol";
import "./interfaces/IPRTCLCollections721V1.sol";
import "./interfaces/IRandomizerV1.sol";
import "./governance/PRTCLCoreERC721Votes.sol";
contract PRTCLCollections721V1 is
AccessControl,
EIP712,
PRTCLCoreERC721Votes,
IPRTCLCollections721V1,
RevokableDefaultOperatorFilterer,
ReentrancyGuard
{
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant GOVERNOR_ROLE = keccak256("GOVERNOR_ROLE");
uint256 constant MAX_BPS = 10000;
uint256 constant DEFAULT_ARTIST_ROYALTY_BPS = 500;
uint256 constant DEFAULT_FJM_ROYALTY_BPS = 250;
uint256 constant DEFAULT_DAO_ROYALTY_BPS = 250;
uint256 constant DEFAULT_ARTIST_PRIMARY_BPS = 0;
uint256 constant DEFAULT_FJM_PRIMARY_BPS = 10000;
uint256 constant DEFAULT_DAO_PRIMARY_BPS = 0;
address payable public FJMAddress;
address payable public DAOAddress;
IRandomizerV1 public randomizerContract;
string public baseURI;
struct Collection {
uint24 nParticles;
uint24 maxParticles;
bool active;
bool sold;
string name;
uint24[] seeds;
uint256 setSeedsAfterBlock;
}
mapping(uint256 => Collection) collections;
struct CollectionFinance {
address payable artistAddress;
uint256 artistRoyaltyBPS;
uint256 FJMRoyaltyBPS;
uint256 DAORoyaltyBPS;
uint256 artistPrimaryBPS;
uint256 FJMPrimaryBPS;
uint256 DAOPrimaryBPS;
}
mapping(uint256 => CollectionFinance) collectionIdToFinancials;
address public operatorFilterRegistryAdmin;
modifier onlyNonZeroAddress(address _address) {
require(_address != address(0), "Must input non-zero address");
_;
}
modifier onlyNonEmptyString(string memory _string) {
require(bytes(_string).length != 0, "Must input non-empty string");
_;
}
constructor(
string memory _bURI,
address _delegationSigner,
address payable _FJMAddress,
address payable _DAOAddress
) onlyNonEmptyString(_bURI)
onlyNonZeroAddress(_delegationSigner)
ERC721MultiCollection(1_000_000)
ERC721("Particle", "PRTCL")
EIP712("Particle", "1")
PRTCLCoreERC721Votes(_delegationSigner)
ReentrancyGuard()
{
_grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
operatorFilterRegistryAdmin = msg.sender;
baseURI = _bURI;
updateRoyaltiesAddresses(_FJMAddress, _DAOAddress);
}
function updateBaseURI(string memory _newBaseURI)
external
onlyRole(DEFAULT_ADMIN_ROLE)
onlyNonEmptyString(_newBaseURI)
{
baseURI = _newBaseURI;
emit BaseURIUpdated(_newBaseURI);
}
function _baseURI() internal view override returns (string memory) {
return baseURI;
}
function updateDelegationSigner(address _newDelegationSigner)
external
onlyRole(DEFAULT_ADMIN_ROLE) {
_setDelegationSigner(_newDelegationSigner);
}
function updateOperatorFilterRegistryAdmin(address _newAdmin)
external
onlyRole(DEFAULT_ADMIN_ROLE)
onlyNonZeroAddress(_newAdmin)
{
operatorFilterRegistryAdmin = _newAdmin;
}
function owner() public view override returns (address) {
return operatorFilterRegistryAdmin;
}
function forbidNewCollections()
external
onlyRole(DEFAULT_ADMIN_ROLE)
{
_forbidNewCollections();
}
function newCollectionsAllowed() public view returns (bool) {
return _newCollectionsAllowed();
}
function collectionCanBeSold(uint256 _collectionId) onlyValidCollectionId(_collectionId) external view returns (bool) {
Collection memory collection = collections[_collectionId];
return !collection.sold && collection.nParticles == collection.maxParticles;
}
function proceeds(uint256 _collectionId, uint256 _salePrice, uint256 _commission, uint256 _tokens) onlyValidCollectionId(_collectionId) external view returns (uint256) {
return (_salePrice - _salePrice * _commission / 100) * _tokens / collections[_collectionId].maxParticles;
}
function markCollectionSold(uint256 _collectionId, address _buyer)
external
onlyRole(GOVERNOR_ROLE)
onlyValidCollectionId(_collectionId)
{
Collection storage collection = collections[_collectionId];
require(!collection.sold, "Already sold");
collection.sold = true;
emit CollectionSold(_collectionId, _buyer);
}
function getRoyalties(
uint256 tokenId
)
external
view
returns (address payable[] memory recipients, uint256[] memory bps)
{
require(_exists(tokenId), "Token ID does not exist");
recipients = new address payable[](3);
bps = new uint256[](3);
CollectionFinance memory financials = collectionIdToFinancials[
tokenIdToCollectionId(tokenId)
];
uint256 artistBPS = financials.artistRoyaltyBPS;
uint256 daoBPS = financials.DAORoyaltyBPS;
uint256 fjmBPS = financials.FJMRoyaltyBPS;
uint256 payeeCount;
if (artistBPS > 0) {
recipients[payeeCount] = financials.artistAddress;
bps[payeeCount++] = artistBPS;
}
if (daoBPS > 0) {
recipients[payeeCount] = DAOAddress;
bps[payeeCount++] = daoBPS;
}
if (fjmBPS > 0) {
recipients[payeeCount] = FJMAddress;
bps[payeeCount++] = fjmBPS;
}
if (3 > payeeCount) {
assembly {
let decrease := sub(3, payeeCount)
mstore(recipients, sub(mload(recipients), decrease))
mstore(bps, sub(mload(bps), decrease))
}
}
return (recipients, bps);
}
function collectionIdToArtistAddress(
uint256 _collectionId
) external view onlyValidCollectionId(_collectionId) returns (address payable) {
return collectionIdToFinancials[_collectionId].artistAddress;
}
function getPrimaryRevenueSplits(
uint256 _collectionId,
uint256 _price
)
external
view
onlyValidCollectionId(_collectionId)
returns (
uint256 FJMRevenue_,
address payable FJMAddress_,
uint256 DAORevenue_,
address payable DAOAddress_,
uint256 artistRevenue_,
address payable artistAddress_
)
{
CollectionFinance memory financials = collectionIdToFinancials[
_collectionId
];
FJMRevenue_ =
(_price * financials.FJMPrimaryBPS) /
MAX_BPS;
artistRevenue_ =
(_price * financials.artistPrimaryBPS) /
MAX_BPS;
DAORevenue_ =
(_price * financials.DAOPrimaryBPS) /
MAX_BPS;
FJMAddress_ = FJMAddress;
artistAddress_ = financials.artistAddress;
DAOAddress_ = DAOAddress;
}
function collectionData(uint256 _collectionId)
external
view
onlyValidCollectionId(_collectionId)
returns (
uint256 nParticles,
uint256 maxParticles,
bool active,
string memory collectionName,
bool sold,
uint24[] memory seeds,
uint256 setSeedsAfterBlock
)
{
Collection memory collection = collections[_collectionId];
nParticles = collection.nParticles;
maxParticles = collection.maxParticles;
active = collection.active;
collectionName = collection.name;
sold = collection.sold;
seeds = collection.seeds;
setSeedsAfterBlock = collection.setSeedsAfterBlock;
}
function getCoordinate(uint256 _tokenId) external view returns (uint256) {
Collection memory collection = collections[
tokenIdToCollectionId(_tokenId)
];
require(collection.seeds.length != 0, "Seeds not set yet");
uint32 p1 = collection.seeds[0];
uint32 p2 = collection.seeds[1];
uint256 maxParticles = collection.maxParticles;
return (_tokenId * p1 + p2) % maxParticles;
}
function addCollection(
string memory _collectionName,
uint24 _numberOfParticles,
address payable _artistAddress
)
external
onlyRole(DEFAULT_ADMIN_ROLE)
onlyNonZeroAddress(_artistAddress)
onlyNonEmptyString(_collectionName)
returns (uint256)
{
uint256 collectionId = _addCollection(_numberOfParticles);
require(collectionId <= type(uint232).max, "Collection id > 232 bits");
collectionIdToFinancials[collectionId].artistAddress = _artistAddress;
collectionIdToFinancials[collectionId].artistRoyaltyBPS = DEFAULT_ARTIST_ROYALTY_BPS;
collectionIdToFinancials[collectionId].FJMRoyaltyBPS = DEFAULT_FJM_ROYALTY_BPS;
collectionIdToFinancials[collectionId].DAORoyaltyBPS = DEFAULT_DAO_ROYALTY_BPS;
collectionIdToFinancials[collectionId].artistPrimaryBPS = DEFAULT_ARTIST_PRIMARY_BPS;
collectionIdToFinancials[collectionId].FJMPrimaryBPS = DEFAULT_FJM_PRIMARY_BPS;
collectionIdToFinancials[collectionId].DAOPrimaryBPS = DEFAULT_DAO_PRIMARY_BPS;
collections[collectionId].name = _collectionName;
collections[collectionId].maxParticles = _numberOfParticles;
return collectionId;
}
function toggleCollectionIsActive(uint256 _collectionId)
external
onlyRole(DEFAULT_ADMIN_ROLE)
onlyValidCollectionId(_collectionId)
{
collections[_collectionId].active = !collections[_collectionId].active;
if (collections[_collectionId].active) {
emit CollectionActive(_collectionId);
} else {
emit CollectionInactive(_collectionId);
}
}
function updateCollectionData(
uint256 _collectionId,
address payable _artistAddress,
string memory _collectionName
)
external
onlyValidCollectionId(_collectionId)
onlyRole(DEFAULT_ADMIN_ROLE)
onlyNonZeroAddress(_artistAddress)
onlyNonEmptyString(_collectionName)
{
collections[_collectionId].name = _collectionName;
collectionIdToFinancials[_collectionId].artistAddress = _artistAddress;
emit CollectionDataUpdated(_collectionId);
}
function updateCollectionMaxParticles(
uint256 _collectionId,
uint24 _maxParticles
)
external
onlyValidCollectionId(_collectionId)
onlyRole(DEFAULT_ADMIN_ROLE)
{
require(_validCollectionSize(_maxParticles), "maxParticles has to be > 0 and <= 1M");
require(collections[_collectionId].nParticles == 0, "maxParticles can only be updated if no particles have been minted");
collections[_collectionId].maxParticles = _maxParticles;
emit CollectionSizeUpdated(_collectionId, _maxParticles);
}
function updateCollectionRoyalties(
uint256 _collectionId,
uint256 _artistRoyaltyBPS,
uint256 _FJMRoyaltyBPS,
uint256 _DAORoyaltyBPS
)
external
onlyValidCollectionId(_collectionId)
onlyRole(DEFAULT_ADMIN_ROLE)
{
require(_artistRoyaltyBPS + _FJMRoyaltyBPS + _DAORoyaltyBPS <= MAX_BPS, "Royalties > 100%");
collectionIdToFinancials[_collectionId].artistRoyaltyBPS = _artistRoyaltyBPS;
collectionIdToFinancials[_collectionId].FJMRoyaltyBPS = _FJMRoyaltyBPS;
collectionIdToFinancials[_collectionId].DAORoyaltyBPS = _DAORoyaltyBPS;
emit CollectionRoyaltiesUpdated(_collectionId);
}
function updateCollectionPrimarySplit(
uint256 _collectionId,
uint256 _artistPrimaryBPS,
uint256 _FJMPrimaryBPS,
uint256 _DAOPrimaryBPS
)
external
onlyValidCollectionId(_collectionId)
onlyRole(DEFAULT_ADMIN_ROLE)
{
require(_artistPrimaryBPS + _FJMPrimaryBPS + _DAOPrimaryBPS == MAX_BPS, "Primary split != 100%");
collectionIdToFinancials[_collectionId].artistPrimaryBPS = _artistPrimaryBPS;
collectionIdToFinancials[_collectionId].FJMPrimaryBPS = _FJMPrimaryBPS;
collectionIdToFinancials[_collectionId].DAOPrimaryBPS = _DAOPrimaryBPS;
emit CollectionPrimarySplitUpdated(_collectionId);
}
function setCollectionSeeds(
uint256 _collectionId,
uint24[2] calldata _seeds
) external onlyValidCollectionId(_collectionId) {
require(
msg.sender == address(randomizerContract),
"Only randomizer may set"
);
Collection storage collection = collections[_collectionId];
require(collection.seeds.length == 0, "Seeds already set");
require(_seeds.length == 2, "Seeds must be length 2");
collection.seeds = _seeds;
emit CollectionSeedsSet(_collectionId, _seeds[0], _seeds[1]);
}
function requestCollectionSeeds(
uint256 _collectionId
) external onlyValidCollectionId(_collectionId) onlyRole(DEFAULT_ADMIN_ROLE) {
uint allowedBlock = collections[_collectionId].setSeedsAfterBlock;
require(allowedBlock > 0 && block.number > allowedBlock, "Too early to set seeds");
randomizerContract.setCollectionSeeds(_collectionId);
}
function updateRoyaltiesAddresses(
address payable _FJMAddress,
address payable _DAOAddress
)
public
onlyRole(DEFAULT_ADMIN_ROLE)
onlyNonZeroAddress(_FJMAddress)
onlyNonZeroAddress(_DAOAddress)
{
FJMAddress = _FJMAddress;
DAOAddress = _DAOAddress;
emit RoyaltiesAddressesUpdated(_FJMAddress, _DAOAddress);
}
function updateRandomizer(
address _randomizerAddress
)
external
onlyRole(DEFAULT_ADMIN_ROLE)
onlyNonZeroAddress(_randomizerAddress)
{
randomizerContract = IRandomizerV1(_randomizerAddress);
emit RandomizerUpdated(_randomizerAddress);
}
function mint(
address _to,
uint256 _collectionId,
uint24 _amount
) external onlyValidCollectionId(_collectionId) onlyRole(MINTER_ROLE) nonReentrant returns (uint256 tokenId) {
require(_amount > 0, "Must mint at least one token");
Collection storage collection = collections[_collectionId];
uint24 oldNParticles = collection.nParticles;
uint24 maxParticles = collection.maxParticles;
uint24 newNParticles = oldNParticles + _amount;
require(
newNParticles <= maxParticles,
"Cannot exceed max number of Particles"
);
require(
collection.active || hasRole(DEFAULT_ADMIN_ROLE, msg.sender),
"Collection must be active"
);
collection.nParticles = newNParticles;
uint256 newTokenId;
unchecked {
newTokenId = (_collectionId * MAX_COLLECTION_SIZE) + oldNParticles;
}
if (newNParticles == maxParticles) {
collection.setSeedsAfterBlock = block.number + 256;
collection.active = false;
emit CollectionFullyMinted(_collectionId);
}
for (uint256 i; i < _amount;) {
_safeMint(_to, newTokenId + i);
unchecked { i++; }
}
return newTokenId;
}
function burn(address tokensOwner, uint256 collectionId, uint256 tokensToRedeem)
external
onlyRole(GOVERNOR_ROLE)
onlyValidCollectionId(collectionId)
returns (uint256 tokensBurnt)
{
return _burn(tokensOwner, collectionId, tokensToRedeem);
}
function setApprovalForAll(address operator, bool approved) public override(IERC721, ERC721) onlyAllowedOperatorApproval(operator) {
super.setApprovalForAll(operator, approved);
}
function approve(address operator, uint256 tokenId) public override(IERC721, ERC721) onlyAllowedOperatorApproval(operator) {
super.approve(operator, tokenId);
}
function transferFrom(address from, address to, uint256 tokenId) public override(IERC721, ERC721) onlyAllowedOperator(from) {
super.transferFrom(from, to, tokenId);
}
function safeTransferFrom(address from, address to, uint256 tokenId) public override(IERC721, ERC721) onlyAllowedOperator(from) {
super.safeTransferFrom(from, to, tokenId);
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
override(IERC721, ERC721)
onlyAllowedOperator(from)
{
super.safeTransferFrom(from, to, tokenId, data);
}
function _beforeTokenTransfer(
address from,
address to,
uint256 tokenId,
uint256 batchSize
) internal override(ERC721MultiCollection) {
super._beforeTokenTransfer(from, to, tokenId, batchSize);
}
function _afterTokenTransfer(
address from,
address to,
uint256 tokenId,
uint256 batchSize
) internal override(PRTCLCoreERC721Votes) {
super._afterTokenTransfer(from, to, tokenId, batchSize);
}
function supportsInterface(
bytes4 interfaceId
)
public
view
override(ERC721, AccessControl, IERC165)
returns (bool)
{
return super.supportsInterface(interfaceId);
}
}
文件 24 的 31：PRTCLCoreERC721Votes.sol
pragma solidity 0.8.17;
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "../ERC721MultiCollection.sol";
import "./PRTCLVotes.sol";
abstract contract PRTCLCoreERC721Votes is ERC721MultiCollection, PRTCLVotes {
using ECDSA for bytes32;
address public delegateSigner;
event SignerUpdated(address signer);
constructor(address _delegateSigner) {
delegateSigner = _delegateSigner;
}
function _setDelegationSigner(address _signer) internal {
require(_signer != address(0), "Must input non-zero address");
delegateSigner = _signer;
emit SignerUpdated(_signer);
}
function _afterTokenTransfer(
address from,
address to,
uint256 firstTokenId,
uint256 batchSize
) internal virtual override {
_transferVotingUnits(from, to, batchSize, tokenIdToCollectionId(firstTokenId));
super._afterTokenTransfer(from, to, firstTokenId, batchSize);
}
function _getVotingUnits(address account, uint256 collectionId) internal view virtual override returns (uint256) {
return balanceOf(account, collectionId);
}
function delegate(address , uint256 ) public virtual override {
revert("PRTCLCoreERC721Votes: regular delegation disabled. Please use delegation with signature.");
}
function delegate(address delegatee, uint256 collectionId, bytes memory signature, uint256 expirationBlock) public {
require(verifyDelegation(signature, expirationBlock, msg.sender, delegatee, collectionId), "PRTCLCoreERC721Votes: invalid signature");
super.delegate(delegatee, collectionId);
}
function verifyDelegation(bytes memory _signature, uint256 _expirationBlock, address _delegate, address _delegatee, uint256 _collectionId) public
view returns (bool) {
bytes32 messageHash = keccak256(abi.encodePacked(_delegate, _delegatee, _collectionId, _expirationBlock));
return block.number < _expirationBlock && delegateSigner == messageHash.toEthSignedMessageHash().recover(_signature);
}
}文件 25 的 31：PRTCLVotes.sol
pragma solidity 0.8.17;
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/utils/Checkpoints.sol";
import "./IPRTCLVotes.sol";
abstract contract PRTCLVotes is IPRTCLVotes, Context {
using Checkpoints for Checkpoints.History;
mapping(uint256 => mapping(address => address)) private _collectionDelegation;
mapping(uint256 => mapping(address => Checkpoints.History)) private _collectionDelegateCheckpoints;
mapping(uint256 => Checkpoints.History) private _collectionTotalCheckpoints;
function getVotes(address account, uint256 collectionId) public view virtual override returns (uint256) {
return _collectionDelegateCheckpoints[collectionId][account].latest();
}
function getPastVotes(address account, uint256 blockNumber, uint256 collectionId) public view virtual override returns (uint256) {
require(blockNumber < block.number, "Votes: block not yet mined");
return _collectionDelegateCheckpoints[collectionId][account].getAtProbablyRecentBlock(blockNumber);
}
function getPastTotalSupply(uint256 blockNumber, uint256 collectionId) public view virtual override returns (uint256) {
require(blockNumber < block.number, "Votes: block not yet mined");
return _collectionTotalCheckpoints[collectionId].getAtProbablyRecentBlock(blockNumber);
}
function getTotalSupply(uint256 collectionId) public view virtual override returns (uint256) {
return _collectionTotalCheckpoints[collectionId].latest();
}
function delegates(address account, uint256 collectionId) public view virtual override returns (address) {
return _collectionDelegation[collectionId][account];
}
function delegate(address delegatee, uint256 collectionId) public virtual override {
address account = _msgSender();
address oldDelegate = delegates(account, collectionId);
_collectionDelegation[collectionId][account] = delegatee;
emit DelegateChanged(account, oldDelegate, delegatee, collectionId);
_moveDelegateVotes(oldDelegate, delegatee, _getVotingUnits(account, collectionId), collectionId);
}
function _transferVotingUnits(
address from,
address to,
uint256 amount,
uint256 collectionId
) internal virtual {
if (from == address(0)) {
_collectionTotalCheckpoints[collectionId].push(_add, amount);
}
if (to == address(0)) {
_collectionTotalCheckpoints[collectionId].push(_subtract, amount);
}
_moveDelegateVotes(delegates(from, collectionId), delegates(to, collectionId), amount, collectionId);
}
function _moveDelegateVotes(
address from,
address to,
uint256 amount,
uint256 collectionId
) private {
if (from != to && amount > 0) {
if (from != address(0)) {
(uint256 oldValue, uint256 newValue) = _collectionDelegateCheckpoints[collectionId][from].push(_subtract, amount);
emit DelegateVotesChanged(from, oldValue, newValue, collectionId);
}
if (to != address(0)) {
(uint256 oldValue, uint256 newValue) = _collectionDelegateCheckpoints[collectionId][to].push(_add, amount);
emit DelegateVotesChanged(to, oldValue, newValue, collectionId);
}
}
}
function _add(uint256 a, uint256 b) private pure returns (uint256) {
return a + b;
}
function _subtract(uint256 a, uint256 b) private pure returns (uint256) {
return a - b;
}
function _getVotingUnits(address owner, uint256 collectionId) internal view virtual returns (uint256);
}
文件 26 的 31：ReentrancyGuard.sol
pragma solidity ^0.8.0;
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
_nonReentrantBefore();
_;
_nonReentrantAfter();
}
function _nonReentrantBefore() private {
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
_status = _ENTERED;
}
function _nonReentrantAfter() private {
_status = _NOT_ENTERED;
}
}
文件 27 的 31：RevokableDefaultOperatorFilterer.sol
pragma solidity ^0.8.13;
import {RevokableOperatorFilterer} from "./RevokableOperatorFilterer.sol";
import {CANONICAL_CORI_SUBSCRIPTION, CANONICAL_OPERATOR_FILTER_REGISTRY_ADDRESS} from "./lib/Constants.sol";
abstract contract RevokableDefaultOperatorFilterer is RevokableOperatorFilterer {
constructor()
RevokableOperatorFilterer(CANONICAL_OPERATOR_FILTER_REGISTRY_ADDRESS, CANONICAL_CORI_SUBSCRIPTION, true)
{}
}
文件 28 的 31：RevokableOperatorFilterer.sol
pragma solidity ^0.8.13;
import {UpdatableOperatorFilterer} from "./UpdatableOperatorFilterer.sol";
import {IOperatorFilterRegistry} from "./IOperatorFilterRegistry.sol";
abstract contract RevokableOperatorFilterer is UpdatableOperatorFilterer {
error RegistryHasBeenRevoked();
error InitialRegistryAddressCannotBeZeroAddress();
event OperatorFilterRegistryRevoked();
bool public isOperatorFilterRegistryRevoked;
constructor(address _registry, address subscriptionOrRegistrantToCopy, bool subscribe)
UpdatableOperatorFilterer(_registry, subscriptionOrRegistrantToCopy, subscribe)
{
if (_registry == address(0)) {
revert InitialRegistryAddressCannotBeZeroAddress();
}
}
function updateOperatorFilterRegistryAddress(address newRegistry) public override {
if (msg.sender != owner()) {
revert OnlyOwner();
}
if (isOperatorFilterRegistryRevoked) {
revert RegistryHasBeenRevoked();
}
operatorFilterRegistry = IOperatorFilterRegistry(newRegistry);
emit OperatorFilterRegistryAddressUpdated(newRegistry);
}
function revokeOperatorFilterRegistry() public {
if (msg.sender != owner()) {
revert OnlyOwner();
}
if (isOperatorFilterRegistryRevoked) {
revert RegistryHasBeenRevoked();
}
operatorFilterRegistry = IOperatorFilterRegistry(address(0));
isOperatorFilterRegistryRevoked = true;
emit OperatorFilterRegistryRevoked();
}
}
文件 29 的 31：SafeCast.sol
pragma solidity ^0.8.0;
library SafeCast {
function toUint248(uint256 value) internal pure returns (uint248) {
require(value <= type(uint248).max, "SafeCast: value doesn't fit in 248 bits");
return uint248(value);
}
function toUint240(uint256 value) internal pure returns (uint240) {
require(value <= type(uint240).max, "SafeCast: value doesn't fit in 240 bits");
return uint240(value);
}
function toUint232(uint256 value) internal pure returns (uint232) {
require(value <= type(uint232).max, "SafeCast: value doesn't fit in 232 bits");
return uint232(value);
}
function toUint224(uint256 value) internal pure returns (uint224) {
require(value <= type(uint224).max, "SafeCast: value doesn't fit in 224 bits");
return uint224(value);
}
function toUint216(uint256 value) internal pure returns (uint216) {
require(value <= type(uint216).max, "SafeCast: value doesn't fit in 216 bits");
return uint216(value);
}
function toUint208(uint256 value) internal pure returns (uint208) {
require(value <= type(uint208).max, "SafeCast: value doesn't fit in 208 bits");
return uint208(value);
}
function toUint200(uint256 value) internal pure returns (uint200) {
require(value <= type(uint200).max, "SafeCast: value doesn't fit in 200 bits");
return uint200(value);
}
function toUint192(uint256 value) internal pure returns (uint192) {
require(value <= type(uint192).max, "SafeCast: value doesn't fit in 192 bits");
return uint192(value);
}
function toUint184(uint256 value) internal pure returns (uint184) {
require(value <= type(uint184).max, "SafeCast: value doesn't fit in 184 bits");
return uint184(value);
}
function toUint176(uint256 value) internal pure returns (uint176) {
require(value <= type(uint176).max, "SafeCast: value doesn't fit in 176 bits");
return uint176(value);
}
function toUint168(uint256 value) internal pure returns (uint168) {
require(value <= type(uint168).max, "SafeCast: value doesn't fit in 168 bits");
return uint168(value);
}
function toUint160(uint256 value) internal pure returns (uint160) {
require(value <= type(uint160).max, "SafeCast: value doesn't fit in 160 bits");
return uint160(value);
}
function toUint152(uint256 value) internal pure returns (uint152) {
require(value <= type(uint152).max, "SafeCast: value doesn't fit in 152 bits");
return uint152(value);
}
function toUint144(uint256 value) internal pure returns (uint144) {
require(value <= type(uint144).max, "SafeCast: value doesn't fit in 144 bits");
return uint144(value);
}
function toUint136(uint256 value) internal pure returns (uint136) {
require(value <= type(uint136).max, "SafeCast: value doesn't fit in 136 bits");
return uint136(value);
}
function toUint128(uint256 value) internal pure returns (uint128) {
require(value <= type(uint128).max, "SafeCast: value doesn't fit in 128 bits");
return uint128(value);
}
function toUint120(uint256 value) internal pure returns (uint120) {
require(value <= type(uint120).max, "SafeCast: value doesn't fit in 120 bits");
return uint120(value);
}
function toUint112(uint256 value) internal pure returns (uint112) {
require(value <= type(uint112).max, "SafeCast: value doesn't fit in 112 bits");
return uint112(value);
}
function toUint104(uint256 value) internal pure returns (uint104) {
require(value <= type(uint104).max, "SafeCast: value doesn't fit in 104 bits");
return uint104(value);
}
function toUint96(uint256 value) internal pure returns (uint96) {
require(value <= type(uint96).max, "SafeCast: value doesn't fit in 96 bits");
return uint96(value);
}
function toUint88(uint256 value) internal pure returns (uint88) {
require(value <= type(uint88).max, "SafeCast: value doesn't fit in 88 bits");
return uint88(value);
}
function toUint80(uint256 value) internal pure returns (uint80) {
require(value <= type(uint80).max, "SafeCast: value doesn't fit in 80 bits");
return uint80(value);
}
function toUint72(uint256 value) internal pure returns (uint72) {
require(value <= type(uint72).max, "SafeCast: value doesn't fit in 72 bits");
return uint72(value);
}
function toUint64(uint256 value) internal pure returns (uint64) {
require(value <= type(uint64).max, "SafeCast: value doesn't fit in 64 bits");
return uint64(value);
}
function toUint56(uint256 value) internal pure returns (uint56) {
require(value <= type(uint56).max, "SafeCast: value doesn't fit in 56 bits");
return uint56(value);
}
function toUint48(uint256 value) internal pure returns (uint48) {
require(value <= type(uint48).max, "SafeCast: value doesn't fit in 48 bits");
return uint48(value);
}
function toUint40(uint256 value) internal pure returns (uint40) {
require(value <= type(uint40).max, "SafeCast: value doesn't fit in 40 bits");
return uint40(value);
}
function toUint32(uint256 value) internal pure returns (uint32) {
require(value <= type(uint32).max, "SafeCast: value doesn't fit in 32 bits");
return uint32(value);
}
function toUint24(uint256 value) internal pure returns (uint24) {
require(value <= type(uint24).max, "SafeCast: value doesn't fit in 24 bits");
return uint24(value);
}
function toUint16(uint256 value) internal pure returns (uint16) {
require(value <= type(uint16).max, "SafeCast: value doesn't fit in 16 bits");
return uint16(value);
}
function toUint8(uint256 value) internal pure returns (uint8) {
require(value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits");
return uint8(value);
}
function toUint256(int256 value) internal pure returns (uint256) {
require(value >= 0, "SafeCast: value must be positive");
return uint256(value);
}
function toInt248(int256 value) internal pure returns (int248 downcasted) {
downcasted = int248(value);
require(downcasted == value, "SafeCast: value doesn't fit in 248 bits");
}
function toInt240(int256 value) internal pure returns (int240 downcasted) {
downcasted = int240(value);
require(downcasted == value, "SafeCast: value doesn't fit in 240 bits");
}
function toInt232(int256 value) internal pure returns (int232 downcasted) {
downcasted = int232(value);
require(downcasted == value, "SafeCast: value doesn't fit in 232 bits");
}
function toInt224(int256 value) internal pure returns (int224 downcasted) {
downcasted = int224(value);
require(downcasted == value, "SafeCast: value doesn't fit in 224 bits");
}
function toInt216(int256 value) internal pure returns (int216 downcasted) {
downcasted = int216(value);
require(downcasted == value, "SafeCast: value doesn't fit in 216 bits");
}
function toInt208(int256 value) internal pure returns (int208 downcasted) {
downcasted = int208(value);
require(downcasted == value, "SafeCast: value doesn't fit in 208 bits");
}
function toInt200(int256 value) internal pure returns (int200 downcasted) {
downcasted = int200(value);
require(downcasted == value, "SafeCast: value doesn't fit in 200 bits");
}
function toInt192(int256 value) internal pure returns (int192 downcasted) {
downcasted = int192(value);
require(downcasted == value, "SafeCast: value doesn't fit in 192 bits");
}
function toInt184(int256 value) internal pure returns (int184 downcasted) {
downcasted = int184(value);
require(downcasted == value, "SafeCast: value doesn't fit in 184 bits");
}
function toInt176(int256 value) internal pure returns (int176 downcasted) {
downcasted = int176(value);
require(downcasted == value, "SafeCast: value doesn't fit in 176 bits");
}
function toInt168(int256 value) internal pure returns (int168 downcasted) {
downcasted = int168(value);
require(downcasted == value, "SafeCast: value doesn't fit in 168 bits");
}
function toInt160(int256 value) internal pure returns (int160 downcasted) {
downcasted = int160(value);
require(downcasted == value, "SafeCast: value doesn't fit in 160 bits");
}
function toInt152(int256 value) internal pure returns (int152 downcasted) {
downcasted = int152(value);
require(downcasted == value, "SafeCast: value doesn't fit in 152 bits");
}
function toInt144(int256 value) internal pure returns (int144 downcasted) {
downcasted = int144(value);
require(downcasted == value, "SafeCast: value doesn't fit in 144 bits");
}
function toInt136(int256 value) internal pure returns (int136 downcasted) {
downcasted = int136(value);
require(downcasted == value, "SafeCast: value doesn't fit in 136 bits");
}
function toInt128(int256 value) internal pure returns (int128 downcasted) {
downcasted = int128(value);
require(downcasted == value, "SafeCast: value doesn't fit in 128 bits");
}
function toInt120(int256 value) internal pure returns (int120 downcasted) {
downcasted = int120(value);
require(downcasted == value, "SafeCast: value doesn't fit in 120 bits");
}
function toInt112(int256 value) internal pure returns (int112 downcasted) {
downcasted = int112(value);
require(downcasted == value, "SafeCast: value doesn't fit in 112 bits");
}
function toInt104(int256 value) internal pure returns (int104 downcasted) {
downcasted = int104(value);
require(downcasted == value, "SafeCast: value doesn't fit in 104 bits");
}
function toInt96(int256 value) internal pure returns (int96 downcasted) {
downcasted = int96(value);
require(downcasted == value, "SafeCast: value doesn't fit in 96 bits");
}
function toInt88(int256 value) internal pure returns (int88 downcasted) {
downcasted = int88(value);
require(downcasted == value, "SafeCast: value doesn't fit in 88 bits");
}
function toInt80(int256 value) internal pure returns (int80 downcasted) {
downcasted = int80(value);
require(downcasted == value, "SafeCast: value doesn't fit in 80 bits");
}
function toInt72(int256 value) internal pure returns (int72 downcasted) {
downcasted = int72(value);
require(downcasted == value, "SafeCast: value doesn't fit in 72 bits");
}
function toInt64(int256 value) internal pure returns (int64 downcasted) {
downcasted = int64(value);
require(downcasted == value, "SafeCast: value doesn't fit in 64 bits");
}
function toInt56(int256 value) internal pure returns (int56 downcasted) {
downcasted = int56(value);
require(downcasted == value, "SafeCast: value doesn't fit in 56 bits");
}
function toInt48(int256 value) internal pure returns (int48 downcasted) {
downcasted = int48(value);
require(downcasted == value, "SafeCast: value doesn't fit in 48 bits");
}
function toInt40(int256 value) internal pure returns (int40 downcasted) {
downcasted = int40(value);
require(downcasted == value, "SafeCast: value doesn't fit in 40 bits");
}
function toInt32(int256 value) internal pure returns (int32 downcasted) {
downcasted = int32(value);
require(downcasted == value, "SafeCast: value doesn't fit in 32 bits");
}
function toInt24(int256 value) internal pure returns (int24 downcasted) {
downcasted = int24(value);
require(downcasted == value, "SafeCast: value doesn't fit in 24 bits");
}
function toInt16(int256 value) internal pure returns (int16 downcasted) {
downcasted = int16(value);
require(downcasted == value, "SafeCast: value doesn't fit in 16 bits");
}
function toInt8(int256 value) internal pure returns (int8 downcasted) {
downcasted = int8(value);
require(downcasted == value, "SafeCast: value doesn't fit in 8 bits");
}
function toInt256(uint256 value) internal pure returns (int256) {
require(value <= uint256(type(int256).max), "SafeCast: value doesn't fit in an int256");
return int256(value);
}
}
文件 30 的 31：Strings.sol
pragma solidity ^0.8.0;
import "./math/Math.sol";
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);
}
}
文件 31 的 31：UpdatableOperatorFilterer.sol
pragma solidity ^0.8.13;
import {IOperatorFilterRegistry} from "./IOperatorFilterRegistry.sol";
abstract contract UpdatableOperatorFilterer {
error OperatorNotAllowed(address operator);
error OnlyOwner();
event OperatorFilterRegistryAddressUpdated(address newRegistry);
IOperatorFilterRegistry public operatorFilterRegistry;
constructor(address _registry, address subscriptionOrRegistrantToCopy, bool subscribe) {
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 updateOperatorFilterRegistryAddress(address newRegistry) public virtual {
if (msg.sender != owner()) {
revert OnlyOwner();
}
operatorFilterRegistry = IOperatorFilterRegistry(newRegistry);
emit OperatorFilterRegistryAddressUpdated(newRegistry);
}
function owner() public view virtual returns (address);
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);
}
}
}
}
{
"compilationTarget": {
"contracts/v1/PRTCLCollections721V1.sol": "PRTCLCollections721V1"
},
"evmVersion": "london",
"libraries": {},
"metadata": {
"bytecodeHash": "ipfs"
},
"optimizer": {
"enabled": true,
"runs": 400
},
"remappings": []
}[{"inputs":[{"internalType":"string","name":"_bURI","type":"string"},{"internalType":"address","name":"_delegationSigner","type":"address"},{"internalType":"address payable","name":"_FJMAddress","type":"address"},{"internalType":"address payable","name":"_DAOAddress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"InitialRegistryAddressCannotBeZeroAddress","type":"error"},{"inputs":[],"name":"OnlyOwner","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"OperatorNotAllowed","type":"error"},{"inputs":[],"name":"RegistryHasBeenRevoked","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"_baseURI","type":"string"}],"name":"BaseURIUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"_collectionId","type":"uint256"}],"name":"CollectionActive","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"collectionId","type":"uint256"}],"name":"CollectionAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"_collectionId","type":"uint256"}],"name":"CollectionDataUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"_collectionId","type":"uint256"}],"name":"CollectionFullyMinted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"_collectionId","type":"uint256"}],"name":"CollectionInactive","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"_collectionId","type":"uint256"}],"name":"CollectionPrimarySplitUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"_collectionId","type":"uint256"}],"name":"CollectionRoyaltiesUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"_collectionId","type":"uint256"},{"indexed":false,"internalType":"uint24","name":"_seed1","type":"uint24"},{"indexed":false,"internalType":"uint24","name":"_seed2","type":"uint24"}],"name":"CollectionSeedsSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"_collectionId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"_size","type":"uint256"}],"name":"CollectionSizeUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"_collectionId","type":"uint256"},{"indexed":false,"internalType":"address","name":"_buyer","type":"address"}],"name":"CollectionSold","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"delegator","type":"address"},{"indexed":true,"internalType":"address","name":"fromDelegate","type":"address"},{"indexed":true,"internalType":"address","name":"toDelegate","type":"address"},{"indexed":false,"internalType":"uint256","name":"collectionId","type":"uint256"}],"name":"DelegateChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"delegate","type":"address"},{"indexed":false,"internalType":"uint256","name":"previousBalance","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newBalance","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"collectionId","type":"uint256"}],"name":"DelegateVotesChanged","type":"event"},{"anonymous":false,"inputs":[],"name":"NewCollectionsForbidden","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"newRegistry","type":"address"}],"name":"OperatorFilterRegistryAddressUpdated","type":"event"},{"anonymous":false,"inputs":[],"name":"OperatorFilterRegistryRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"_randomizer","type":"address"}],"name":"RandomizerUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"_FJMAddress","type":"address"},{"indexed":false,"internalType":"address","name":"_DAOAddress","type":"address"}],"name":"RoyaltiesAddressesUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"signer","type":"address"}],"name":"SignerUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"DAOAddress","outputs":[{"internalType":"address payable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"FJMAddress","outputs":[{"internalType":"address payable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"GOVERNOR_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_COLLECTION_SIZE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MINTER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"_collectionName","type":"string"},{"internalType":"uint24","name":"_numberOfParticles","type":"uint24"},{"internalType":"address payable","name":"_artistAddress","type":"address"}],"name":"addCollection","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"collectionId","type":"uint256"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"tokensOwner","type":"address"},{"internalType":"uint256","name":"collectionId","type":"uint256"},{"internalType":"uint256","name":"tokensToRedeem","type":"uint256"}],"name":"burn","outputs":[{"internalType":"uint256","name":"tokensBurnt","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_collectionId","type":"uint256"}],"name":"collectionCanBeSold","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_collectionId","type":"uint256"}],"name":"collectionData","outputs":[{"internalType":"uint256","name":"nParticles","type":"uint256"},{"internalType":"uint256","name":"maxParticles","type":"uint256"},{"internalType":"bool","name":"active","type":"bool"},{"internalType":"string","name":"collectionName","type":"string"},{"internalType":"bool","name":"sold","type":"bool"},{"internalType":"uint24[]","name":"seeds","type":"uint24[]"},{"internalType":"uint256","name":"setSeedsAfterBlock","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"collectionId","type":"uint256"}],"name":"collectionExists","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_collectionId","type":"uint256"}],"name":"collectionIdToArtistAddress","outputs":[{"internalType":"address payable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"delegate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"delegatee","type":"address"},{"internalType":"uint256","name":"collectionId","type":"uint256"},{"internalType":"bytes","name":"signature","type":"bytes"},{"internalType":"uint256","name":"expirationBlock","type":"uint256"}],"name":"delegate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"delegateSigner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"collectionId","type":"uint256"}],"name":"delegates","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"forbidNewCollections","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"getCoordinate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"blockNumber","type":"uint256"},{"internalType":"uint256","name":"collectionId","type":"uint256"}],"name":"getPastTotalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"blockNumber","type":"uint256"},{"internalType":"uint256","name":"collectionId","type":"uint256"}],"name":"getPastVotes","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_collectionId","type":"uint256"},{"internalType":"uint256","name":"_price","type":"uint256"}],"name":"getPrimaryRevenueSplits","outputs":[{"internalType":"uint256","name":"FJMRevenue_","type":"uint256"},{"internalType":"address payable","name":"FJMAddress_","type":"address"},{"internalType":"uint256","name":"DAORevenue_","type":"uint256"},{"internalType":"address payable","name":"DAOAddress_","type":"address"},{"internalType":"uint256","name":"artistRevenue_","type":"uint256"},{"internalType":"address payable","name":"artistAddress_","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getRoyalties","outputs":[{"internalType":"address payable[]","name":"recipients","type":"address[]"},{"internalType":"uint256[]","name":"bps","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"collectionId","type":"uint256"}],"name":"getTotalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"collectionId","type":"uint256"}],"name":"getVotes","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isOperatorFilterRegistryRevoked","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_collectionId","type":"uint256"},{"internalType":"address","name":"_buyer","type":"address"}],"name":"markCollectionSold","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_collectionId","type":"uint256"},{"internalType":"uint24","name":"_amount","type":"uint24"}],"name":"mint","outputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"newCollectionsAllowed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"numberOfCollections","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"operatorFilterRegistry","outputs":[{"internalType":"contract IOperatorFilterRegistry","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"operatorFilterRegistryAdmin","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_collectionId","type":"uint256"},{"internalType":"uint256","name":"_salePrice","type":"uint256"},{"internalType":"uint256","name":"_commission","type":"uint256"},{"internalType":"uint256","name":"_tokens","type":"uint256"}],"name":"proceeds","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"randomizerContract","outputs":[{"internalType":"contract IRandomizerV1","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_collectionId","type":"uint256"}],"name":"requestCollectionSeeds","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"revokeOperatorFilterRegistry","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_collectionId","type":"uint256"},{"internalType":"uint24[2]","name":"_seeds","type":"uint24[2]"}],"name":"setCollectionSeeds","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_collectionId","type":"uint256"}],"name":"toggleCollectionIsActive","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"tokenIdToCollectionId","outputs":[{"internalType":"uint256","name":"collectionId","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"},{"internalType":"uint256","name":"collectionId","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"collectionId","type":"uint256"}],"name":"tokenTotalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_newBaseURI","type":"string"}],"name":"updateBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_collectionId","type":"uint256"},{"internalType":"address payable","name":"_artistAddress","type":"address"},{"internalType":"string","name":"_collectionName","type":"string"}],"name":"updateCollectionData","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_collectionId","type":"uint256"},{"internalType":"uint24","name":"_maxParticles","type":"uint24"}],"name":"updateCollectionMaxParticles","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_collectionId","type":"uint256"},{"internalType":"uint256","name":"_artistPrimaryBPS","type":"uint256"},{"internalType":"uint256","name":"_FJMPrimaryBPS","type":"uint256"},{"internalType":"uint256","name":"_DAOPrimaryBPS","type":"uint256"}],"name":"updateCollectionPrimarySplit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_collectionId","type":"uint256"},{"internalType":"uint256","name":"_artistRoyaltyBPS","type":"uint256"},{"internalType":"uint256","name":"_FJMRoyaltyBPS","type":"uint256"},{"internalType":"uint256","name":"_DAORoyaltyBPS","type":"uint256"}],"name":"updateCollectionRoyalties","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newDelegationSigner","type":"address"}],"name":"updateDelegationSigner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newRegistry","type":"address"}],"name":"updateOperatorFilterRegistryAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newAdmin","type":"address"}],"name":"updateOperatorFilterRegistryAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_randomizerAddress","type":"address"}],"name":"updateRandomizer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"_FJMAddress","type":"address"},{"internalType":"address payable","name":"_DAOAddress","type":"address"}],"name":"updateRoyaltiesAddresses","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"_signature","type":"bytes"},{"internalType":"uint256","name":"_expirationBlock","type":"uint256"},{"internalType":"address","name":"_delegate","type":"address"},{"internalType":"address","name":"_delegatee","type":"address"},{"internalType":"uint256","name":"_collectionId","type":"uint256"}],"name":"verifyDelegation","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"}]
