File 1 of 1: CollectrV1.sol
pragma solidity 0.8.17;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
interface ICreatorCore is IERC165 {
event ExtensionRegistered(address indexed extension, address indexed sender);
event ExtensionUnregistered(address indexed extension, address indexed sender);
event ExtensionBlacklisted(address indexed extension, address indexed sender);
event MintPermissionsUpdated(address indexed extension, address indexed permissions, address indexed sender);
event RoyaltiesUpdated(uint256 indexed tokenId, address payable[] receivers, uint256[] basisPoints);
event DefaultRoyaltiesUpdated(address payable[] receivers, uint256[] basisPoints);
event ApproveTransferUpdated(address extension);
event ExtensionRoyaltiesUpdated(address indexed extension, address payable[] receivers, uint256[] basisPoints);
event ExtensionApproveTransferUpdated(address indexed extension, bool enabled);
function getExtensions() external view returns (address[] memory);
function registerExtension(address extension, string calldata baseURI) external;
function registerExtension(address extension, string calldata baseURI, bool baseURIIdentical) external;
function unregisterExtension(address extension) external;
function blacklistExtension(address extension) external;
function setBaseTokenURIExtension(string calldata uri) external;
function setBaseTokenURIExtension(string calldata uri, bool identical) external;
function setTokenURIPrefixExtension(string calldata prefix) external;
function setTokenURIExtension(uint256 tokenId, string calldata uri) external;
function setTokenURIExtension(uint256[] memory tokenId, string[] calldata uri) external;
function setBaseTokenURI(string calldata uri) external;
function setTokenURIPrefix(string calldata prefix) external;
function setTokenURI(uint256 tokenId, string calldata uri) external;
function setTokenURI(uint256[] memory tokenIds, string[] calldata uris) external;
function setMintPermissions(address extension, address permissions) external;
function setApproveTransferExtension(bool enabled) external;
function tokenExtension(uint256 tokenId) external view returns (address);
function setRoyalties(address payable[] calldata receivers, uint256[] calldata basisPoints) external;
function setRoyalties(uint256 tokenId, address payable[] calldata receivers, uint256[] calldata basisPoints) external;
function setRoyaltiesExtension(address extension, address payable[] calldata receivers, uint256[] calldata basisPoints) external;
function getRoyalties(uint256 tokenId) external view returns (address payable[] memory, uint256[] memory);
function getFeeRecipients(uint256 tokenId) external view returns (address payable[] memory);
function getFeeBps(uint256 tokenId) external view returns (uint[] memory);
function getFees(uint256 tokenId) external view returns (address payable[] memory, uint256[] memory);
function royaltyInfo(uint256 tokenId, uint256 value) external view returns (address, uint256);
function setApproveTransfer(address extension) external;
function getApproveTransfer() external view returns (address);
}
interface ICreatorExtensionRoyalties is IERC165 {
function getRoyalties(address creator, uint256 tokenId) external view returns (address payable[] memory, uint256[] memory);
}
interface ICreatorExtensionTokenURI is IERC165 {
function tokenURI(address creator, uint256 tokenId) external view returns (string memory);
}
library AddressUpgradeable {
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 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);
}
}
}
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;
}
}
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
library ERC165Checker {
bytes4 private constant _INTERFACE_ID_INVALID = 0xffffffff;
function supportsERC165(address account) internal view returns (bool) {
return
supportsERC165InterfaceUnchecked(account, type(IERC165).interfaceId) &&
!supportsERC165InterfaceUnchecked(account, _INTERFACE_ID_INVALID);
}
function supportsInterface(address account, bytes4 interfaceId) internal view returns (bool) {
return supportsERC165(account) && supportsERC165InterfaceUnchecked(account, interfaceId);
}
function getSupportedInterfaces(address account, bytes4[] memory interfaceIds)
internal
view
returns (bool[] memory)
{
bool[] memory interfaceIdsSupported = new bool[](interfaceIds.length);
if (supportsERC165(account)) {
for (uint256 i = 0; i < interfaceIds.length; i++) {
interfaceIdsSupported[i] = supportsERC165InterfaceUnchecked(account, interfaceIds[i]);
}
}
return interfaceIdsSupported;
}
function supportsAllInterfaces(address account, bytes4[] memory interfaceIds) internal view returns (bool) {
if (!supportsERC165(account)) {
return false;
}
for (uint256 i = 0; i < interfaceIds.length; i++) {
if (!supportsERC165InterfaceUnchecked(account, interfaceIds[i])) {
return false;
}
}
return true;
}
function supportsERC165InterfaceUnchecked(address account, bytes4 interfaceId) internal view returns (bool) {
bytes memory encodedParams = abi.encodeWithSelector(IERC165.supportsInterface.selector, interfaceId);
bool success;
uint256 returnSize;
uint256 returnValue;
assembly {
success := staticcall(30000, account, add(encodedParams, 0x20), mload(encodedParams), 0x00, 0x20)
returnSize := returndatasize()
returnValue := mload(0x00)
}
return success && returnSize >= 0x20 && returnValue > 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);
}
}
}
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);
}
}
library EnumerableSet {
struct Set {
bytes32[] _values;
mapping(bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) {
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
if (lastIndex != toDeleteIndex) {
bytes32 lastValue = set._values[lastIndex];
set._values[toDeleteIndex] = lastValue;
set._indexes[lastValue] = valueIndex;
}
set._values.pop();
delete set._indexes[value];
return true;
} else {
return false;
}
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
return set._values[index];
}
function _values(Set storage set) private view returns (bytes32[] memory) {
return set._values;
}
struct Bytes32Set {
Set _inner;
}
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
bytes32[] memory store = _values(set._inner);
bytes32[] memory result;
assembly {
result := store
}
return result;
}
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(uint160(value))));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(uint160(value))));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(uint160(value))));
}
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint160(uint256(_at(set._inner, index))));
}
function values(AddressSet storage set) internal view returns (address[] memory) {
bytes32[] memory store = _values(set._inner);
address[] memory result;
assembly {
result := store
}
return result;
}
struct UintSet {
Set _inner;
}
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
function values(UintSet storage set) internal view returns (uint256[] memory) {
bytes32[] memory store = _values(set._inner);
uint256[] memory result;
assembly {
result := store
}
return result;
}
}
abstract contract CreatorCore is ReentrancyGuard, ICreatorCore, ERC165 {
using Strings for uint256;
using EnumerableSet for EnumerableSet.AddressSet;
using AddressUpgradeable for address;
uint256 internal _tokenCount = 0;
address internal _approveTransferBase;
EnumerableSet.AddressSet internal _extensions;
EnumerableSet.AddressSet internal _blacklistedExtensions;
mapping (address => string) private _extensionBaseURI;
mapping (address => bool) private _extensionBaseURIIdentical;
mapping (address => string) private _extensionURIPrefix;
mapping (uint256 => string) internal _tokenURIs;
struct RoyaltyConfig {
address payable receiver;
uint16 bps;
}
mapping (address => RoyaltyConfig[]) internal _extensionRoyalty;
mapping (uint256 => RoyaltyConfig[]) internal _tokenRoyalty;
bytes4 private constant _CREATOR_CORE_V1 = 0x28f10a21;
bytes4 private constant _INTERFACE_ID_ROYALTIES_CREATORCORE = 0xbb3bafd6;
bytes4 private constant _INTERFACE_ID_ROYALTIES_RARIBLE = 0xb7799584;
bytes4 private constant _INTERFACE_ID_ROYALTIES_FOUNDATION = 0xd5a06d4c;
bytes4 private constant _INTERFACE_ID_ROYALTIES_EIP2981 = 0x2a55205a;
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return interfaceId == type(ICreatorCore).interfaceId || interfaceId == _CREATOR_CORE_V1 || super.supportsInterface(interfaceId)
|| interfaceId == _INTERFACE_ID_ROYALTIES_CREATORCORE || interfaceId == _INTERFACE_ID_ROYALTIES_RARIBLE
|| interfaceId == _INTERFACE_ID_ROYALTIES_FOUNDATION || interfaceId == _INTERFACE_ID_ROYALTIES_EIP2981;
}
function requireExtension() internal view {
require(_extensions.contains(msg.sender), "Must be registered extension");
}
function requireNonBlacklist(address extension) internal view {
require(!_blacklistedExtensions.contains(extension), "Extension blacklisted");
}
function getExtensions() external view override returns (address[] memory extensions) {
extensions = new address[](_extensions.length());
for (uint i; i < _extensions.length();) {
extensions[i] = _extensions.at(i);
unchecked { ++i; }
}
return extensions;
}
function _registerExtension(address extension, string calldata baseURI, bool baseURIIdentical) internal virtual {
require(extension != address(this) && extension.isContract(), "Invalid");
emit ExtensionRegistered(extension, msg.sender);
_extensionBaseURI[extension] = baseURI;
_extensionBaseURIIdentical[extension] = baseURIIdentical;
_extensions.add(extension);
_setApproveTransferExtension(extension, true);
}
function setApproveTransferExtension(bool enabled) external override {
requireExtension();
_setApproveTransferExtension(msg.sender, enabled);
}
function _setApproveTransferExtension(address extension, bool enabled) internal virtual;
function _unregisterExtension(address extension) internal {
emit ExtensionUnregistered(extension, msg.sender);
_extensions.remove(extension);
}
function _blacklistExtension(address extension) internal {
require(extension != address(0) && extension != address(this), "Cannot blacklist yourself");
if (_extensions.contains(extension)) {
emit ExtensionUnregistered(extension, msg.sender);
_extensions.remove(extension);
}
if (!_blacklistedExtensions.contains(extension)) {
emit ExtensionBlacklisted(extension, msg.sender);
_blacklistedExtensions.add(extension);
}
}
function _setBaseTokenURIExtension(string calldata uri, bool identical) internal {
_extensionBaseURI[msg.sender] = uri;
_extensionBaseURIIdentical[msg.sender] = identical;
}
function _setTokenURIPrefixExtension(string calldata prefix) internal {
_extensionURIPrefix[msg.sender] = prefix;
}
function _setTokenURIExtension(uint256 tokenId, string calldata uri) internal {
require(_tokenExtension(tokenId) == msg.sender, "Invalid token");
_tokenURIs[tokenId] = uri;
}
function _setBaseTokenURI(string calldata uri) internal {
_extensionBaseURI[address(0)] = uri;
}
function _setTokenURIPrefix(string calldata prefix) internal {
_extensionURIPrefix[address(0)] = prefix;
}
function _setTokenURI(uint256 tokenId, string calldata uri) internal {
require(tokenId > 0 && tokenId <= _tokenCount && _tokenExtension(tokenId) == address(0), "Invalid token");
_tokenURIs[tokenId] = uri;
}
function _tokenURI(uint256 tokenId) internal view returns (string memory) {
require(tokenId > 0 && tokenId <= _tokenCount, "Invalid token");
address extension = _tokenExtension(tokenId);
require(!_blacklistedExtensions.contains(extension), "Extension blacklisted");
if (bytes(_tokenURIs[tokenId]).length != 0) {
if (bytes(_extensionURIPrefix[extension]).length != 0) {
return string(abi.encodePacked(_extensionURIPrefix[extension], _tokenURIs[tokenId]));
}
return _tokenURIs[tokenId];
}
if (ERC165Checker.supportsInterface(extension, type(ICreatorExtensionTokenURI).interfaceId)) {
return ICreatorExtensionTokenURI(extension).tokenURI(address(this), tokenId);
}
if (!_extensionBaseURIIdentical[extension]) {
return string(abi.encodePacked(_extensionBaseURI[extension], tokenId.toString()));
} else {
return _extensionBaseURI[extension];
}
}
function _getRoyalties(uint256 tokenId) view internal returns (address payable[] memory receivers, uint256[] memory bps) {
RoyaltyConfig[] memory royalties = _tokenRoyalty[tokenId];
if (royalties.length == 0) {
address extension = _tokenExtension(tokenId);
if (extension != address(0)) {
if (ERC165Checker.supportsInterface(extension, type(ICreatorExtensionRoyalties).interfaceId)) {
(receivers, bps) = ICreatorExtensionRoyalties(extension).getRoyalties(address(this), tokenId);
if (receivers.length > 0) return (receivers, bps);
}
royalties = _extensionRoyalty[extension];
}
}
if (royalties.length == 0) {
royalties = _extensionRoyalty[address(0)];
}
if (royalties.length > 0) {
receivers = new address payable[](royalties.length);
bps = new uint256[](royalties.length);
for (uint i; i < royalties.length;) {
receivers[i] = royalties[i].receiver;
bps[i] = royalties[i].bps;
unchecked { ++i; }
}
}
}
function _getRoyaltyReceivers(uint256 tokenId) view internal returns (address payable[] memory recievers) {
(recievers, ) = _getRoyalties(tokenId);
}
function _getRoyaltyBPS(uint256 tokenId) view internal returns (uint256[] memory bps) {
(, bps) = _getRoyalties(tokenId);
}
function _getRoyaltyInfo(uint256 tokenId, uint256 value) view internal returns (address receiver, uint256 amount){
(address payable[] memory receivers, uint256[] memory bps) = _getRoyalties(tokenId);
require(receivers.length <= 1, "More than 1 royalty receiver");
if (receivers.length == 0) {
return (address(this), 0);
}
return (receivers[0], bps[0]*value/10000);
}
function _setRoyalties(uint256 tokenId, address payable[] calldata receivers, uint256[] calldata basisPoints) internal {
_checkRoyalties(receivers, basisPoints);
delete _tokenRoyalty[tokenId];
_setRoyalties(receivers, basisPoints, _tokenRoyalty[tokenId]);
emit RoyaltiesUpdated(tokenId, receivers, basisPoints);
}
function _setRoyaltiesExtension(address extension, address payable[] calldata receivers, uint256[] calldata basisPoints) internal {
_checkRoyalties(receivers, basisPoints);
delete _extensionRoyalty[extension];
_setRoyalties(receivers, basisPoints, _extensionRoyalty[extension]);
if (extension == address(0)) {
emit DefaultRoyaltiesUpdated(receivers, basisPoints);
} else {
emit ExtensionRoyaltiesUpdated(extension, receivers, basisPoints);
}
}
function _checkRoyalties(address payable[] calldata receivers, uint256[] calldata basisPoints) private pure {
require(receivers.length == basisPoints.length, "Invalid input");
uint256 totalBasisPoints;
for (uint i; i < basisPoints.length;) {
totalBasisPoints += basisPoints[i];
unchecked { ++i; }
}
require(totalBasisPoints < 10000, "Invalid total royalties");
}
function _setRoyalties(address payable[] calldata receivers, uint256[] calldata basisPoints, RoyaltyConfig[] storage royalties) private {
for (uint i; i < basisPoints.length;) {
royalties.push(
RoyaltyConfig(
{
receiver: receivers[i],
bps: uint16(basisPoints[i])
}
)
);
unchecked { ++i; }
}
}
function _setApproveTransferBase(address extension) internal {
_approveTransferBase = extension;
emit ApproveTransferUpdated(extension);
}
function getApproveTransfer() external view override returns (address) {
return _approveTransferBase;
}
function _tokenExtension(uint256 tokenId) internal virtual view returns(address);
}
interface IERC1155CreatorCore is ICreatorCore {
function mintBaseNew(address[] calldata to, uint256[] calldata amounts, string[] calldata uris) external returns (uint256[] memory);
function mintBaseExisting(address[] calldata to, uint256[] calldata tokenIds, uint256[] calldata amounts) external;
function mintExtensionNew(address[] calldata to, uint256[] calldata amounts, string[] calldata uris) external returns (uint256[] memory);
function mintExtensionExisting(address[] calldata to, uint256[] calldata tokenIds, uint256[] calldata amounts) external;
function burn(address account, uint256[] calldata tokenIds, uint256[] calldata amounts) external;
function totalSupply(uint256 tokenId) external view returns (uint256);
}
interface IAdminControl is IERC165 {
event AdminApproved(address indexed account, address indexed sender);
event AdminRevoked(address indexed account, address indexed sender);
function getAdmins() external view returns (address[] memory);
function approveAdmin(address admin) external;
function revokeAdmin(address admin) external;
function isAdmin(address admin) external view returns (bool);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
abstract contract AdminControl is Ownable, IAdminControl, ERC165 {
using EnumerableSet for EnumerableSet.AddressSet;
EnumerableSet.AddressSet private _admins;
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return interfaceId == type(IAdminControl).interfaceId
|| super.supportsInterface(interfaceId);
}
modifier adminRequired() {
require(owner() == msg.sender || _admins.contains(msg.sender), "AdminControl: Must be owner or admin");
_;
}
function getAdmins() external view override returns (address[] memory admins) {
admins = new address[](_admins.length());
for (uint i = 0; i < _admins.length(); i++) {
admins[i] = _admins.at(i);
}
return admins;
}
function approveAdmin(address admin) external override onlyOwner {
if (!_admins.contains(admin)) {
emit AdminApproved(admin, msg.sender);
_admins.add(admin);
}
}
function revokeAdmin(address admin) external override onlyOwner {
if (_admins.contains(admin)) {
emit AdminRevoked(admin, msg.sender);
_admins.remove(admin);
}
}
function isAdmin(address admin) public override view returns (bool) {
return (owner() == admin || _admins.contains(admin));
}
}
interface ILazyPayableClaim {
enum StorageProtocol { INVALID, NONE, ARWEAVE, IPFS }
event ClaimInitialized(address indexed creatorContract, uint256 indexed instanceId, address initializer);
event ClaimUpdated(address indexed creatorContract, uint256 indexed instanceId);
event ClaimMint(address indexed creatorContract, uint256 indexed instanceId);
function withdraw(address payable receiver, uint256 amount) external;
}
interface ICollectrV1 is ILazyPayableClaim {
struct ClaimParameters {
uint256 totalMax;
uint256 walletMax;
uint48 startDate;
uint48 endDate;
string location;
uint256 cost;
}
struct Claim {
uint256 total;
uint256 totalMax;
uint256 walletMax;
uint48 startDate;
uint48 endDate;
string location;
uint256 tokenId;
uint256 cost;
}
function updatePaymentReceivers(
uint256 instanceId,
address[] calldata _paymentAddresses,
uint256[] calldata _paymentSplits
) external;
function initializeClaim(
uint256 instanceId,
ClaimParameters calldata claimParameters,
address[] calldata _paymentAddresses,
uint256[] calldata _paymentSplits
) external;
function updateClaim(uint256 instanceId, ClaimParameters calldata claimParameters) external;
function updateTokenURIParams(uint256 instanceId, string calldata location) external;
function getClaim(uint256 instanceId) external view returns(Claim memory);
function getClaimForToken(uint256 tokenId) external view returns(uint256, Claim memory);
function airdrop(uint256 instanceId, address[] calldata recipients, uint256[] calldata amounts) external;
}
contract LazyPayableClaim is ILazyPayableClaim, AdminControl {
string internal constant ARWEAVE_PREFIX = "https://arweave.net/";
string internal constant IPFS_PREFIX = "ipfs://";
uint256 internal constant MINT_INDEX_BITMASK = 0xFF;
uint256 internal constant SPLIT_DENOMINATOR = 100000;
uint256 internal constant MAX_UINT_24 = 0xffffff;
uint256 internal constant MAX_UINT_32 = 0xffffffff;
uint256 internal constant MAX_UINT_56 = 0xffffffffffffff;
uint256 internal constant MAX_UINT_256 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
address private constant ADDRESS_ZERO = 0x0000000000000000000000000000000000000000;
mapping(uint256 => mapping(address => uint256)) internal _mintsPerWallet;
struct PaymentReceiver {
address paymentAddress;
uint256 paymentSplit;
}
constructor() {}
function withdraw(address payable receiver, uint256 amount) external override adminRequired {
(bool sent, ) = receiver.call{value: amount}("");
require(sent, "Failed to transfer to receiver");
}
function _transferFunds(uint256 cost, PaymentReceiver[] memory paymentReceivers) internal {
require(msg.value >= cost, "Invalid amount");
for(uint i=0; i < paymentReceivers.length; i++) {
(bool sent, ) = paymentReceivers[i].paymentAddress.call{value: (cost * paymentReceivers[i].paymentSplit) / SPLIT_DENOMINATOR}("");
require(sent, "Failed to transfer to receiver");
}
}
function _validateMint(address receiver, uint256 instanceId, uint256 walletMax, uint256 startDate, uint256 endDate) internal {
require(
(startDate <= block.timestamp) &&
(endDate == 0 || endDate >= block.timestamp),
"Claim inactive"
);
require(++_mintsPerWallet[instanceId][receiver] <= walletMax, "Maximum tokens already minted for this wallet");
}
function _getTotalMints(address minter, uint256 instanceId) internal view returns(uint256) {
return uint256(_mintsPerWallet[instanceId][minter]);
}
}
contract CollectrV1 is
IERC165,
ICollectrV1,
LazyPayableClaim
{
using Strings for uint256;
address immutable collectrNFT1155;
mapping(uint256 => Claim) private _claims;
mapping(uint256 => uint256) private _claimTokenIds;
mapping(uint256 => PaymentReceiver[]) public _paymentReceivers;
function supportsInterface(
bytes4 interfaceId
) public view virtual override(IERC165, AdminControl) returns (bool) {
return
interfaceId == type(ICollectrV1).interfaceId ||
interfaceId == type(ILazyPayableClaim).interfaceId ||
interfaceId == type(IAdminControl).interfaceId ||
interfaceId == type(IERC165).interfaceId;
}
constructor(
address _collectrNFT1155
) {
collectrNFT1155 = _collectrNFT1155;
}
function updatePaymentReceivers(
uint256 instanceId,
address[] calldata _paymentAddresses,
uint256[] calldata _paymentSplits
) external override adminRequired
{
Claim memory claim = _claims[instanceId];
require(
bytes(claim.location).length != 0,
"Claim not initialized"
);
require(_paymentAddresses.length == _paymentSplits.length, "Every address needs a matching split");
require(_paymentAddresses.length >= 1 && _paymentAddresses.length <= 12, "Wrong amount of addresses");
uint256 totalSplits = 0;
for (uint256 i = 0; i < _paymentSplits.length; i++) {
totalSplits += _paymentSplits[i];
}
require(totalSplits == SPLIT_DENOMINATOR, "The sum of all splits must equal 100000");
delete _paymentReceivers[instanceId];
for (uint i = 0; i < _paymentAddresses.length; i++) {
_paymentReceivers[instanceId].push(
PaymentReceiver(_paymentAddresses[i], _paymentSplits[i])
);
}
}
function initializeClaim(
uint256 instanceId,
ClaimParameters calldata claimParameters,
address[] calldata _paymentAddresses,
uint256[] calldata _paymentSplits
) external override adminRequired {
require(
bytes(_claims[instanceId].location).length == 0,
"Claim already initialized"
);
require(
bytes(claimParameters.location).length != 0,
"Cannot initialize with empty metadata"
);
require(
claimParameters.endDate == 0 ||
claimParameters.startDate < claimParameters.endDate,
"Cannot have startDate greater than or equal to endDate"
);
require(_paymentAddresses.length == _paymentSplits.length, "Every address needs a matching split");
require(_paymentAddresses.length >= 1 && _paymentAddresses.length <= 12, "Wrong amount of addresses");
uint256 totalSplits = 0;
for (uint256 i = 0; i < _paymentSplits.length; i++) {
totalSplits += _paymentSplits[i];
}
require(totalSplits == SPLIT_DENOMINATOR, "The sum of all splits must equal 100000");
address[] memory receivers = new address[](1);
receivers[0] = msg.sender;
string[] memory uris = new string[](1);
uris[0] = claimParameters.location;
uint256[] memory amounts = new uint256[](1);
uint256[] memory newTokenIds = IERC1155CreatorCore(
collectrNFT1155
).mintExtensionNew(receivers, amounts, uris);
_claims[instanceId] = Claim({
total: 0,
totalMax: claimParameters.totalMax,
walletMax: claimParameters.walletMax,
startDate: claimParameters.startDate,
endDate: claimParameters.endDate,
location: claimParameters.location,
tokenId: newTokenIds[0],
cost: claimParameters.cost
});
_claimTokenIds[newTokenIds[0]] = instanceId;
for (uint i = 0; i < _paymentAddresses.length; i++) {
_paymentReceivers[instanceId].push(
PaymentReceiver(_paymentAddresses[i], _paymentSplits[i])
);
}
emit ClaimInitialized(collectrNFT1155, instanceId, msg.sender);
}
function updateClaim(
uint256 instanceId,
ClaimParameters memory claimParameters
) external override adminRequired {
Claim memory claim = _claims[instanceId];
require(
bytes(claim.location).length != 0,
"Claim not initialized"
);
require(
bytes(claimParameters.location).length != 0,
"Cannot set empty metadata"
);
require(
claimParameters.endDate == 0 ||
claimParameters.startDate < claimParameters.endDate,
"Cannot have startDate greater than or equal to endDate"
);
if (
claimParameters.totalMax != 0 &&
claim.total > claimParameters.totalMax
) {
claimParameters.totalMax = claim.total;
}
_claims[instanceId] = Claim({
total: claim.total,
totalMax: claimParameters.totalMax,
walletMax: claimParameters.walletMax,
startDate: claimParameters.startDate,
endDate: claimParameters.endDate,
location: claimParameters.location,
tokenId: claim.tokenId,
cost: claimParameters.cost
});
IERC1155CreatorCore(collectrNFT1155).setTokenURIExtension(claim.tokenId, claimParameters.location);
emit ClaimUpdated(collectrNFT1155, instanceId);
}
function updateTokenURIParams(
uint256 instanceId,
string calldata location
) external override adminRequired {
Claim storage claim = _claims[instanceId];
require(
bytes(claim.location).length != 0,
"Claim not initialized"
);
require(
bytes(location).length != 0,
"Cannot set empty metadata"
);
claim.location = location;
emit ClaimUpdated(collectrNFT1155, instanceId);
}
function getClaim(
uint256 instanceId
) public view override returns (Claim memory claim) {
return _getClaim(instanceId);
}
function getClaimForToken(
uint256 tokenId
) external view override returns (uint256 instanceId, Claim memory claim) {
instanceId = _claimTokenIds[tokenId];
claim = _getClaim(instanceId);
}
function _getClaim(
uint256 instanceId
) private view returns (Claim storage claim) {
claim = _claims[instanceId];
require(
bytes(claim.location).length != 0,
"Claim not initialized"
);
}
function getTotalMints(
address minter,
uint256 instanceId
) external view returns (uint256) {
return _getTotalMints(minter, instanceId);
}
function mint(
address receiver,
uint256 instanceId
) external payable {
Claim storage claim = _getClaim(instanceId);
PaymentReceiver[] storage paymentReceivers = _paymentReceivers[instanceId];
if (receiver == address(0)) {
receiver = msg.sender;
}
require(
++claim.total <= claim.totalMax || claim.totalMax == 0,
"Maximum tokens already minted for this claim"
);
_validateMint(
receiver,
instanceId,
claim.walletMax,
claim.startDate,
claim.endDate
);
_transferFunds(
claim.cost,
paymentReceivers
);
address[] memory recipients = new address[](1);
recipients[0] = receiver;
uint256[] memory amounts = new uint256[](1);
amounts[0] = 1;
_mintClaim(claim, recipients, amounts);
emit ClaimMint(collectrNFT1155, instanceId);
}
function airdrop(
uint256 instanceId,
address[] calldata recipients,
uint256[] calldata amounts
) external adminRequired {
Claim storage claim = _claims[instanceId];
uint256 totalAmount;
for (uint256 i; i < amounts.length; ) {
totalAmount += amounts[i];
unchecked {
++i;
}
}
require(totalAmount <= MAX_UINT_32, "Too many requested");
require((claim.total + totalAmount) <= claim.totalMax, "Maximum tokens already minted for this claim");
_mintClaim(claim, recipients, amounts);
}
function _mintClaim(
Claim storage claim,
address[] memory recipients,
uint256[] memory amounts
) private {
uint256[] memory tokenIds = new uint256[](1);
tokenIds[0] = claim.tokenId;
IERC1155CreatorCore(collectrNFT1155).mintExtensionExisting(
recipients,
tokenIds,
amounts
);
}
}
