컴파일러
0.8.18+commit.87f61d96
파일 1 / 73 : 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);
}
}
}
파일 2 / 73 : AddressRelay.sol
pragma solidity 0.8.18;
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {IAddressRelay, Implementation} from "./interfaces/IAddressRelay.sol";
import {IERC165} from "./interfaces/IERC165.sol";
import {IERC173} from "./interfaces/IERC173.sol";
contract AddressRelay is IAddressRelay, Ownable {
mapping(bytes4 => address) public selectorToImplAddress;
mapping(bytes4 => bool) public supportedInterfaces;
bytes4[] selectors;
address[] implAddresses;
address public fallbackImplAddress;
bool public relayFrozen;
constructor() {
supportedInterfaces[0x01ffc9a7] = true;
supportedInterfaces[0x7f5828d0] = true;
supportedInterfaces[0x80ac58cd] = true;
supportedInterfaces[0x5b5e139f] = true;
supportedInterfaces[0x2a55205a] = true;
supportedInterfaces[0xad092b5c] = true;
}
function freezeRelay() external onlyOwner {
relayFrozen = true;
}
function addOrUpdateSelectors(
bytes4[] memory _selectors,
address _implAddress
) external onlyOwner {
require(!relayFrozen, "RELAY_FROZEN");
for (uint256 i = 0; i < _selectors.length; i++) {
bytes4 selector = _selectors[i];
selectorToImplAddress[selector] = _implAddress;
selectors.push(selector);
}
bool implAddressExists = false;
for (uint256 i = 0; i < implAddresses.length; i++) {
if (implAddresses[i] == _implAddress) {
implAddressExists = true;
break;
}
}
if (!implAddressExists) {
implAddresses.push(_implAddress);
}
}
function removeSelectors(bytes4[] memory _selectors) external onlyOwner {
require(!relayFrozen, "RELAY_FROZEN");
for (uint256 i = 0; i < _selectors.length; i++) {
bytes4 selector = _selectors[i];
delete selectorToImplAddress[selector];
for (uint256 j = 0; j < selectors.length; j++) {
if (selectors[j] == selector) {
delete selectors[j];
break;
}
}
}
}
function removeImplAddressAndAllSelectors(
address _implAddress
) external onlyOwner {
require(!relayFrozen, "RELAY_FROZEN");
for (uint256 i = 0; i < implAddresses.length; i++) {
if (implAddresses[i] == _implAddress) {
delete implAddresses[i];
break;
}
}
for (uint256 i = 0; i < selectors.length; i++) {
if (selectorToImplAddress[selectors[i]] == _implAddress) {
delete selectorToImplAddress[selectors[i]];
delete selectors[i];
}
}
}
function getImplAddress(
bytes4 _functionSelector
) external view returns (address) {
address implAddress = selectorToImplAddress[_functionSelector];
if (implAddress == address(0)) {
implAddress = fallbackImplAddress;
}
require(implAddress != address(0), "Function does not exist");
return implAddress;
}
function getImplAddressNoFallback(
bytes4 _functionSelector
) external view returns (address) {
address implAddress = selectorToImplAddress[_functionSelector];
require(implAddress != address(0), "Function does not exist");
return implAddress;
}
function getAllImplAddressesAndSelectors()
external
view
returns (Implementation[] memory)
{
uint256 trueImplAddressCount = 0;
uint256 implAddressesLength = implAddresses.length;
for (uint256 i = 0; i < implAddressesLength; i++) {
if (implAddresses[i] != address(0)) {
trueImplAddressCount++;
}
}
Implementation[] memory impls = new Implementation[](
trueImplAddressCount
);
uint256 implIndex = 0;
for (uint256 i = 0; i < implAddressesLength; i++) {
if (implAddresses[i] == address(0)) {
continue;
}
address implAddress = implAddresses[i];
bytes4[] memory selectors_;
uint256 selectorCount = 0;
uint256 selectorsLength = selectors.length;
for (uint256 j = 0; j < selectorsLength; j++) {
if (selectorToImplAddress[selectors[j]] == implAddress) {
selectorCount++;
}
}
selectors_ = new bytes4[](selectorCount);
uint256 selectorIndex = 0;
for (uint256 j = 0; j < selectorsLength; j++) {
if (selectorToImplAddress[selectors[j]] == implAddress) {
selectors_[selectorIndex] = selectors[j];
selectorIndex++;
}
}
impls[implIndex] = Implementation(implAddress, selectors_);
implIndex++;
}
return impls;
}
function getSelectorsForImplAddress(
address _implAddress
) external view returns (bytes4[] memory) {
uint256 selectorCount = 0;
uint256 selectorsLength = selectors.length;
for (uint256 i = 0; i < selectorsLength; i++) {
if (selectorToImplAddress[selectors[i]] == _implAddress) {
selectorCount++;
}
}
bytes4[] memory selectorArr = new bytes4[](selectorCount);
uint256 selectorIndex = 0;
for (uint256 i = 0; i < selectorsLength; i++) {
if (selectorToImplAddress[selectors[i]] == _implAddress) {
selectorArr[selectorIndex] = selectors[i];
selectorIndex++;
}
}
return selectorArr;
}
function setFallbackImplAddress(
address _fallbackAddress
) external onlyOwner {
require(!relayFrozen, "RELAY_FROZEN");
fallbackImplAddress = _fallbackAddress;
}
function updateSupportedInterfaces(
bytes4 _interfaceId,
bool _supported
) external onlyOwner {
supportedInterfaces[_interfaceId] = _supported;
}
function supportsInterface(
bytes4 _interfaceId
) external view returns (bool) {
return supportedInterfaces[_interfaceId];
}
}
파일 3 / 73 : AddressUpgradeable.sol
pragma solidity ^0.8.1;
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);
}
}
}
파일 4 / 73 : 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;
}
}
파일 5 / 73 : ContextUpgradeable.sol
pragma solidity ^0.8.0;
import "../proxy/utils/Initializable.sol";
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal onlyInitializing {
}
function __Context_init_unchained() internal onlyInitializing {
}
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
uint256[50] private __gap;
}
파일 6 / 73 : Counters.sol
pragma solidity ^0.8.0;
library Counters {
struct Counter {
uint256 _value;
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
unchecked {
counter._value += 1;
}
}
function decrement(Counter storage counter) internal {
uint256 value = counter._value;
require(value > 0, "Counter: decrement overflow");
unchecked {
counter._value = value - 1;
}
}
function reset(Counter storage counter) internal {
counter._value = 0;
}
}
파일 7 / 73 : DelegateRegistry.sol
pragma solidity 0.8.18;
import {IDelegateRegistry as IDelegateRegistry} from "../interfaces/IDelegateRegistry.sol";
import {RegistryHashes as Hashes} from "../libraries/RegistryHashes.sol";
import {RegistryStorage as Storage} from "../libraries/RegistryStorage.sol";
import {RegistryOps as Ops} from "../libraries/RegistryOps.sol";
contract DelegateRegistry is IDelegateRegistry {
mapping(bytes32 => bytes32[5]) internal delegations;
mapping(address => bytes32[]) internal outgoingDelegationHashes;
mapping(address => bytes32[]) internal incomingDelegationHashes;
function multicall(
bytes[] calldata data
) external payable override returns (bytes[] memory results) {
results = new bytes[](data.length);
bool success;
unchecked {
for (uint256 i = 0; i < data.length; ++i) {
(success, results[i]) = address(this).delegatecall(data[i]);
if (!success) revert MulticallFailed();
}
}
}
function delegateAll(
address to,
bytes32 rights,
bool enable
) external payable override returns (bytes32 hash) {
hash = Hashes.allHash(msg.sender, rights, to);
bytes32 location = Hashes.location(hash);
address loadedFrom = _loadFrom(location);
if (enable) {
if (loadedFrom == Storage.DELEGATION_EMPTY) {
_pushDelegationHashes(msg.sender, to, hash);
_writeDelegationAddresses(location, msg.sender, to, address(0));
if (rights != "")
_writeDelegation(
location,
Storage.POSITIONS_RIGHTS,
rights
);
} else if (loadedFrom == Storage.DELEGATION_REVOKED) {
_updateFrom(location, msg.sender);
}
} else if (loadedFrom == msg.sender) {
_updateFrom(location, Storage.DELEGATION_REVOKED);
}
emit DelegateAll(msg.sender, to, rights, enable);
}
function delegateContract(
address to,
address contract_,
bytes32 rights,
bool enable
) external payable override returns (bytes32 hash) {
hash = Hashes.contractHash(msg.sender, rights, to, contract_);
bytes32 location = Hashes.location(hash);
address loadedFrom = _loadFrom(location);
if (enable) {
if (loadedFrom == Storage.DELEGATION_EMPTY) {
_pushDelegationHashes(msg.sender, to, hash);
_writeDelegationAddresses(location, msg.sender, to, contract_);
if (rights != "")
_writeDelegation(
location,
Storage.POSITIONS_RIGHTS,
rights
);
} else if (loadedFrom == Storage.DELEGATION_REVOKED) {
_updateFrom(location, msg.sender);
}
} else if (loadedFrom == msg.sender) {
_updateFrom(location, Storage.DELEGATION_REVOKED);
}
emit DelegateContract(msg.sender, to, contract_, rights, enable);
}
function delegateERC721(
address to,
address contract_,
uint256 tokenId,
bytes32 rights,
bool enable
) external payable override returns (bytes32 hash) {
hash = Hashes.erc721Hash(msg.sender, rights, to, tokenId, contract_);
bytes32 location = Hashes.location(hash);
address loadedFrom = _loadFrom(location);
if (enable) {
if (loadedFrom == Storage.DELEGATION_EMPTY) {
_pushDelegationHashes(msg.sender, to, hash);
_writeDelegationAddresses(location, msg.sender, to, contract_);
_writeDelegation(location, Storage.POSITIONS_TOKEN_ID, tokenId);
if (rights != "")
_writeDelegation(
location,
Storage.POSITIONS_RIGHTS,
rights
);
} else if (loadedFrom == Storage.DELEGATION_REVOKED) {
_updateFrom(location, msg.sender);
}
} else if (loadedFrom == msg.sender) {
_updateFrom(location, Storage.DELEGATION_REVOKED);
}
emit DelegateERC721(msg.sender, to, contract_, tokenId, rights, enable);
}
function delegateERC20(
address to,
address contract_,
bytes32 rights,
uint256 amount
) external payable override returns (bytes32 hash) {
hash = Hashes.erc20Hash(msg.sender, rights, to, contract_);
bytes32 location = Hashes.location(hash);
address loadedFrom = _loadFrom(location);
if (amount != 0) {
if (loadedFrom == Storage.DELEGATION_EMPTY) {
_pushDelegationHashes(msg.sender, to, hash);
_writeDelegationAddresses(location, msg.sender, to, contract_);
_writeDelegation(location, Storage.POSITIONS_AMOUNT, amount);
if (rights != "")
_writeDelegation(
location,
Storage.POSITIONS_RIGHTS,
rights
);
} else if (loadedFrom == Storage.DELEGATION_REVOKED) {
_updateFrom(location, msg.sender);
_writeDelegation(location, Storage.POSITIONS_AMOUNT, amount);
} else if (loadedFrom == msg.sender) {
_writeDelegation(location, Storage.POSITIONS_AMOUNT, amount);
}
} else if (loadedFrom == msg.sender) {
_updateFrom(location, Storage.DELEGATION_REVOKED);
_writeDelegation(location, Storage.POSITIONS_AMOUNT, uint256(0));
}
emit DelegateERC20(msg.sender, to, contract_, rights, amount);
}
function delegateERC1155(
address to,
address contract_,
uint256 tokenId,
bytes32 rights,
uint256 amount
) external payable override returns (bytes32 hash) {
hash = Hashes.erc1155Hash(msg.sender, rights, to, tokenId, contract_);
bytes32 location = Hashes.location(hash);
address loadedFrom = _loadFrom(location);
if (amount != 0) {
if (loadedFrom == Storage.DELEGATION_EMPTY) {
_pushDelegationHashes(msg.sender, to, hash);
_writeDelegationAddresses(location, msg.sender, to, contract_);
_writeDelegation(location, Storage.POSITIONS_TOKEN_ID, tokenId);
_writeDelegation(location, Storage.POSITIONS_AMOUNT, amount);
if (rights != "")
_writeDelegation(
location,
Storage.POSITIONS_RIGHTS,
rights
);
} else if (loadedFrom == Storage.DELEGATION_REVOKED) {
_updateFrom(location, msg.sender);
_writeDelegation(location, Storage.POSITIONS_AMOUNT, amount);
} else if (loadedFrom == msg.sender) {
_writeDelegation(location, Storage.POSITIONS_AMOUNT, amount);
}
} else if (loadedFrom == msg.sender) {
_updateFrom(location, Storage.DELEGATION_REVOKED);
_writeDelegation(location, Storage.POSITIONS_AMOUNT, uint256(0));
}
emit DelegateERC1155(
msg.sender,
to,
contract_,
tokenId,
rights,
amount
);
}
function sweep() external {
assembly ("memory-safe") {
let result := call(
gas(),
0x000000dE1E80ea5a234FB5488fee2584251BC7e8,
selfbalance(),
0,
0,
0,
0
)
}
}
function checkDelegateForAll(
address to,
address from,
bytes32 rights
) external view override returns (bool valid) {
if (!_invalidFrom(from)) {
valid = _validateFrom(Hashes.allLocation(from, "", to), from);
if (!Ops.or(rights == "", valid))
valid = _validateFrom(
Hashes.allLocation(from, rights, to),
from
);
}
assembly ("memory-safe") {
mstore(0, iszero(iszero(valid)))
return(0, 32)
}
}
function checkDelegateForContract(
address to,
address from,
address contract_,
bytes32 rights
) external view override returns (bool valid) {
if (!_invalidFrom(from)) {
valid =
_validateFrom(Hashes.allLocation(from, "", to), from) ||
_validateFrom(
Hashes.contractLocation(from, "", to, contract_),
from
);
if (!Ops.or(rights == "", valid)) {
valid =
_validateFrom(Hashes.allLocation(from, rights, to), from) ||
_validateFrom(
Hashes.contractLocation(from, rights, to, contract_),
from
);
}
}
assembly ("memory-safe") {
mstore(0, iszero(iszero(valid)))
return(0, 32)
}
}
function checkDelegateForERC721(
address to,
address from,
address contract_,
uint256 tokenId,
bytes32 rights
) external view override returns (bool valid) {
if (!_invalidFrom(from)) {
valid =
_validateFrom(Hashes.allLocation(from, "", to), from) ||
_validateFrom(
Hashes.contractLocation(from, "", to, contract_),
from
) ||
_validateFrom(
Hashes.erc721Location(from, "", to, tokenId, contract_),
from
);
if (!Ops.or(rights == "", valid)) {
valid =
_validateFrom(Hashes.allLocation(from, rights, to), from) ||
_validateFrom(
Hashes.contractLocation(from, rights, to, contract_),
from
) ||
_validateFrom(
Hashes.erc721Location(
from,
rights,
to,
tokenId,
contract_
),
from
);
}
}
assembly ("memory-safe") {
mstore(0, iszero(iszero(valid)))
return(0, 32)
}
}
function checkDelegateForERC20(
address to,
address from,
address contract_,
bytes32 rights
) external view override returns (uint256 amount) {
if (!_invalidFrom(from)) {
amount = (_validateFrom(Hashes.allLocation(from, "", to), from) ||
_validateFrom(
Hashes.contractLocation(from, "", to, contract_),
from
))
? type(uint256).max
: _loadDelegationUint(
Hashes.erc20Location(from, "", to, contract_),
Storage.POSITIONS_AMOUNT
);
if (!Ops.or(rights == "", amount == type(uint256).max)) {
uint256 rightsBalance = (_validateFrom(
Hashes.allLocation(from, rights, to),
from
) ||
_validateFrom(
Hashes.contractLocation(from, rights, to, contract_),
from
))
? type(uint256).max
: _loadDelegationUint(
Hashes.erc20Location(from, rights, to, contract_),
Storage.POSITIONS_AMOUNT
);
amount = Ops.max(rightsBalance, amount);
}
}
assembly ("memory-safe") {
mstore(0, amount)
return(0, 32)
}
}
function checkDelegateForERC1155(
address to,
address from,
address contract_,
uint256 tokenId,
bytes32 rights
) external view override returns (uint256 amount) {
if (!_invalidFrom(from)) {
amount = (_validateFrom(Hashes.allLocation(from, "", to), from) ||
_validateFrom(
Hashes.contractLocation(from, "", to, contract_),
from
))
? type(uint256).max
: _loadDelegationUint(
Hashes.erc1155Location(from, "", to, tokenId, contract_),
Storage.POSITIONS_AMOUNT
);
if (!Ops.or(rights == "", amount == type(uint256).max)) {
uint256 rightsBalance = (_validateFrom(
Hashes.allLocation(from, rights, to),
from
) ||
_validateFrom(
Hashes.contractLocation(from, rights, to, contract_),
from
))
? type(uint256).max
: _loadDelegationUint(
Hashes.erc1155Location(
from,
rights,
to,
tokenId,
contract_
),
Storage.POSITIONS_AMOUNT
);
amount = Ops.max(rightsBalance, amount);
}
}
assembly ("memory-safe") {
mstore(0, amount)
return(0, 32)
}
}
function getIncomingDelegations(
address to
) external view override returns (Delegation[] memory delegations_) {
delegations_ = _getValidDelegationsFromHashes(
incomingDelegationHashes[to]
);
}
function getOutgoingDelegations(
address from
) external view returns (Delegation[] memory delegations_) {
delegations_ = _getValidDelegationsFromHashes(
outgoingDelegationHashes[from]
);
}
function getIncomingDelegationHashes(
address to
) external view returns (bytes32[] memory delegationHashes) {
delegationHashes = _getValidDelegationHashesFromHashes(
incomingDelegationHashes[to]
);
}
function getOutgoingDelegationHashes(
address from
) external view returns (bytes32[] memory delegationHashes) {
delegationHashes = _getValidDelegationHashesFromHashes(
outgoingDelegationHashes[from]
);
}
function getDelegationsFromHashes(
bytes32[] calldata hashes
) external view returns (Delegation[] memory delegations_) {
delegations_ = new Delegation[](hashes.length);
unchecked {
for (uint256 i = 0; i < hashes.length; ++i) {
bytes32 location = Hashes.location(hashes[i]);
address from = _loadFrom(location);
if (_invalidFrom(from)) {
delegations_[i] = Delegation({
type_: DelegationType.NONE,
to: address(0),
from: address(0),
rights: "",
amount: 0,
contract_: address(0),
tokenId: 0
});
} else {
(
,
address to,
address contract_
) = _loadDelegationAddresses(location);
delegations_[i] = Delegation({
type_: Hashes.decodeType(hashes[i]),
to: to,
from: from,
rights: _loadDelegationBytes32(
location,
Storage.POSITIONS_RIGHTS
),
amount: _loadDelegationUint(
location,
Storage.POSITIONS_AMOUNT
),
contract_: contract_,
tokenId: _loadDelegationUint(
location,
Storage.POSITIONS_TOKEN_ID
)
});
}
}
}
}
function readSlot(
bytes32 location
) external view returns (bytes32 contents) {
assembly {
contents := sload(location)
}
}
function readSlots(
bytes32[] calldata locations
) external view returns (bytes32[] memory contents) {
uint256 length = locations.length;
contents = new bytes32[](length);
bytes32 tempLocation;
bytes32 tempValue;
unchecked {
for (uint256 i = 0; i < length; ++i) {
tempLocation = locations[i];
assembly {
tempValue := sload(tempLocation)
}
contents[i] = tempValue;
}
}
}
function supportsInterface(
bytes4 interfaceId
) external pure returns (bool) {
return
Ops.or(
interfaceId == type(IDelegateRegistry).interfaceId,
interfaceId == 0x01ffc9a7
);
}
function _pushDelegationHashes(
address from,
address to,
bytes32 delegationHash
) internal {
outgoingDelegationHashes[from].push(delegationHash);
incomingDelegationHashes[to].push(delegationHash);
}
function _writeDelegation(
bytes32 location,
uint256 position,
bytes32 data
) internal {
assembly {
sstore(add(location, position), data)
}
}
function _writeDelegation(
bytes32 location,
uint256 position,
uint256 data
) internal {
assembly {
sstore(add(location, position), data)
}
}
function _writeDelegationAddresses(
bytes32 location,
address from,
address to,
address contract_
) internal {
(bytes32 firstSlot, bytes32 secondSlot) = Storage.packAddresses(
from,
to,
contract_
);
uint256 firstPacked = Storage.POSITIONS_FIRST_PACKED;
uint256 secondPacked = Storage.POSITIONS_SECOND_PACKED;
assembly {
sstore(add(location, firstPacked), firstSlot)
sstore(add(location, secondPacked), secondSlot)
}
}
function _updateFrom(bytes32 location, address from) internal {
uint256 firstPacked = Storage.POSITIONS_FIRST_PACKED;
uint256 cleanAddress = Storage.CLEAN_ADDRESS;
uint256 cleanUpper12Bytes = type(uint256).max << 160;
assembly {
let slot := and(
sload(add(location, firstPacked)),
cleanUpper12Bytes
)
sstore(
add(location, firstPacked),
or(slot, and(from, cleanAddress))
)
}
}
function _getValidDelegationsFromHashes(
bytes32[] storage hashes
) internal view returns (Delegation[] memory delegations_) {
uint256 count = 0;
uint256 hashesLength = hashes.length;
bytes32 hash;
bytes32[] memory filteredHashes = new bytes32[](hashesLength);
unchecked {
for (uint256 i = 0; i < hashesLength; ++i) {
hash = hashes[i];
if (_invalidFrom(_loadFrom(Hashes.location(hash)))) continue;
filteredHashes[count++] = hash;
}
delegations_ = new Delegation[](count);
bytes32 location;
for (uint256 i = 0; i < count; ++i) {
hash = filteredHashes[i];
location = Hashes.location(hash);
(
address from,
address to,
address contract_
) = _loadDelegationAddresses(location);
delegations_[i] = Delegation({
type_: Hashes.decodeType(hash),
to: to,
from: from,
rights: _loadDelegationBytes32(
location,
Storage.POSITIONS_RIGHTS
),
amount: _loadDelegationUint(
location,
Storage.POSITIONS_AMOUNT
),
contract_: contract_,
tokenId: _loadDelegationUint(
location,
Storage.POSITIONS_TOKEN_ID
)
});
}
}
}
function _getValidDelegationHashesFromHashes(
bytes32[] storage hashes
) internal view returns (bytes32[] memory validHashes) {
uint256 count = 0;
uint256 hashesLength = hashes.length;
bytes32 hash;
bytes32[] memory filteredHashes = new bytes32[](hashesLength);
unchecked {
for (uint256 i = 0; i < hashesLength; ++i) {
hash = hashes[i];
if (_invalidFrom(_loadFrom(Hashes.location(hash)))) continue;
filteredHashes[count++] = hash;
}
validHashes = new bytes32[](count);
for (uint256 i = 0; i < count; ++i) {
validHashes[i] = filteredHashes[i];
}
}
}
function _loadDelegationBytes32(
bytes32 location,
uint256 position
) internal view returns (bytes32 data) {
assembly {
data := sload(add(location, position))
}
}
function _loadDelegationUint(
bytes32 location,
uint256 position
) internal view returns (uint256 data) {
assembly {
data := sload(add(location, position))
}
}
function _loadFrom(bytes32 location) internal view returns (address) {
bytes32 data;
uint256 firstPacked = Storage.POSITIONS_FIRST_PACKED;
assembly {
data := sload(add(location, firstPacked))
}
return Storage.unpackAddress(data);
}
function _validateFrom(
bytes32 location,
address from
) internal view returns (bool) {
return (from == _loadFrom(location));
}
function _loadDelegationAddresses(
bytes32 location
) internal view returns (address from, address to, address contract_) {
bytes32 firstSlot;
bytes32 secondSlot;
uint256 firstPacked = Storage.POSITIONS_FIRST_PACKED;
uint256 secondPacked = Storage.POSITIONS_SECOND_PACKED;
assembly {
firstSlot := sload(add(location, firstPacked))
secondSlot := sload(add(location, secondPacked))
}
(from, to, contract_) = Storage.unpackAddresses(firstSlot, secondSlot);
}
function _invalidFrom(address from) internal pure returns (bool) {
return
Ops.or(
from == Storage.DELEGATION_EMPTY,
from == Storage.DELEGATION_REVOKED
);
}
}
파일 8 / 73 : 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));
}
}
파일 9 / 73 : ECDSAUpgradeable.sol
pragma solidity ^0.8.0;
import "../StringsUpgradeable.sol";
library ECDSAUpgradeable {
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", StringsUpgradeable.toString(s.length), s));
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
}
}
파일 10 / 73 : ERC1155.sol
pragma solidity ^0.8.0;
import "./IERC1155.sol";
import "./IERC1155Receiver.sol";
import "./extensions/IERC1155MetadataURI.sol";
import "../../utils/Address.sol";
import "../../utils/Context.sol";
import "../../utils/introspection/ERC165.sol";
contract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI {
using Address for address;
mapping(uint256 => mapping(address => uint256)) private _balances;
mapping(address => mapping(address => bool)) private _operatorApprovals;
string private _uri;
constructor(string memory uri_) {
_setURI(uri_);
}
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC1155).interfaceId ||
interfaceId == type(IERC1155MetadataURI).interfaceId ||
super.supportsInterface(interfaceId);
}
function uri(uint256) public view virtual override returns (string memory) {
return _uri;
}
function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {
require(account != address(0), "ERC1155: address zero is not a valid owner");
return _balances[id][account];
}
function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
public
view
virtual
override
returns (uint256[] memory)
{
require(accounts.length == ids.length, "ERC1155: accounts and ids length mismatch");
uint256[] memory batchBalances = new uint256[](accounts.length);
for (uint256 i = 0; i < accounts.length; ++i) {
batchBalances[i] = balanceOf(accounts[i], ids[i]);
}
return batchBalances;
}
function setApprovalForAll(address operator, bool approved) public virtual override {
_setApprovalForAll(_msgSender(), operator, approved);
}
function isApprovedForAll(address account, address operator) public view virtual override returns (bool) {
return _operatorApprovals[account][operator];
}
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual override {
require(
from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: caller is not token owner or approved"
);
_safeTransferFrom(from, to, id, amount, data);
}
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override {
require(
from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: caller is not token owner or approved"
);
_safeBatchTransferFrom(from, to, ids, amounts, data);
}
function _safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual {
require(to != address(0), "ERC1155: transfer to the zero address");
address operator = _msgSender();
uint256[] memory ids = _asSingletonArray(id);
uint256[] memory amounts = _asSingletonArray(amount);
_beforeTokenTransfer(operator, from, to, ids, amounts, data);
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
unchecked {
_balances[id][from] = fromBalance - amount;
}
_balances[id][to] += amount;
emit TransferSingle(operator, from, to, id, amount);
_afterTokenTransfer(operator, from, to, ids, amounts, data);
_doSafeTransferAcceptanceCheck(operator, from, to, id, amount, data);
}
function _safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
require(to != address(0), "ERC1155: transfer to the zero address");
address operator = _msgSender();
_beforeTokenTransfer(operator, from, to, ids, amounts, data);
for (uint256 i = 0; i < ids.length; ++i) {
uint256 id = ids[i];
uint256 amount = amounts[i];
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
unchecked {
_balances[id][from] = fromBalance - amount;
}
_balances[id][to] += amount;
}
emit TransferBatch(operator, from, to, ids, amounts);
_afterTokenTransfer(operator, from, to, ids, amounts, data);
_doSafeBatchTransferAcceptanceCheck(operator, from, to, ids, amounts, data);
}
function _setURI(string memory newuri) internal virtual {
_uri = newuri;
}
function _mint(
address to,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual {
require(to != address(0), "ERC1155: mint to the zero address");
address operator = _msgSender();
uint256[] memory ids = _asSingletonArray(id);
uint256[] memory amounts = _asSingletonArray(amount);
_beforeTokenTransfer(operator, address(0), to, ids, amounts, data);
_balances[id][to] += amount;
emit TransferSingle(operator, address(0), to, id, amount);
_afterTokenTransfer(operator, address(0), to, ids, amounts, data);
_doSafeTransferAcceptanceCheck(operator, address(0), to, id, amount, data);
}
function _mintBatch(
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
require(to != address(0), "ERC1155: mint to the zero address");
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
address operator = _msgSender();
_beforeTokenTransfer(operator, address(0), to, ids, amounts, data);
for (uint256 i = 0; i < ids.length; i++) {
_balances[ids[i]][to] += amounts[i];
}
emit TransferBatch(operator, address(0), to, ids, amounts);
_afterTokenTransfer(operator, address(0), to, ids, amounts, data);
_doSafeBatchTransferAcceptanceCheck(operator, address(0), to, ids, amounts, data);
}
function _burn(
address from,
uint256 id,
uint256 amount
) internal virtual {
require(from != address(0), "ERC1155: burn from the zero address");
address operator = _msgSender();
uint256[] memory ids = _asSingletonArray(id);
uint256[] memory amounts = _asSingletonArray(amount);
_beforeTokenTransfer(operator, from, address(0), ids, amounts, "");
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: burn amount exceeds balance");
unchecked {
_balances[id][from] = fromBalance - amount;
}
emit TransferSingle(operator, from, address(0), id, amount);
_afterTokenTransfer(operator, from, address(0), ids, amounts, "");
}
function _burnBatch(
address from,
uint256[] memory ids,
uint256[] memory amounts
) internal virtual {
require(from != address(0), "ERC1155: burn from the zero address");
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
address operator = _msgSender();
_beforeTokenTransfer(operator, from, address(0), ids, amounts, "");
for (uint256 i = 0; i < ids.length; i++) {
uint256 id = ids[i];
uint256 amount = amounts[i];
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: burn amount exceeds balance");
unchecked {
_balances[id][from] = fromBalance - amount;
}
}
emit TransferBatch(operator, from, address(0), ids, amounts);
_afterTokenTransfer(operator, from, address(0), ids, amounts, "");
}
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
require(owner != operator, "ERC1155: setting approval status for self");
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {}
function _afterTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {}
function _doSafeTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) private {
if (to.isContract()) {
try IERC1155Receiver(to).onERC1155Received(operator, from, id, amount, data) returns (bytes4 response) {
if (response != IERC1155Receiver.onERC1155Received.selector) {
revert("ERC1155: ERC1155Receiver rejected tokens");
}
} catch Error(string memory reason) {
revert(reason);
} catch {
revert("ERC1155: transfer to non-ERC1155Receiver implementer");
}
}
}
function _doSafeBatchTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) private {
if (to.isContract()) {
try IERC1155Receiver(to).onERC1155BatchReceived(operator, from, ids, amounts, data) returns (
bytes4 response
) {
if (response != IERC1155Receiver.onERC1155BatchReceived.selector) {
revert("ERC1155: ERC1155Receiver rejected tokens");
}
} catch Error(string memory reason) {
revert(reason);
} catch {
revert("ERC1155: transfer to non-ERC1155Receiver implementer");
}
}
}
function _asSingletonArray(uint256 element) private pure returns (uint256[] memory) {
uint256[] memory array = new uint256[](1);
array[0] = element;
return array;
}
}
파일 11 / 73 : ERC1155Supply.sol
pragma solidity ^0.8.0;
import "../ERC1155.sol";
abstract contract ERC1155Supply is ERC1155 {
mapping(uint256 => uint256) private _totalSupply;
function totalSupply(uint256 id) public view virtual returns (uint256) {
return _totalSupply[id];
}
function exists(uint256 id) public view virtual returns (bool) {
return ERC1155Supply.totalSupply(id) > 0;
}
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual override {
super._beforeTokenTransfer(operator, from, to, ids, amounts, data);
if (from == address(0)) {
for (uint256 i = 0; i < ids.length; ++i) {
_totalSupply[ids[i]] += amounts[i];
}
}
if (to == address(0)) {
for (uint256 i = 0; i < ids.length; ++i) {
uint256 id = ids[i];
uint256 amount = amounts[i];
uint256 supply = _totalSupply[id];
require(supply >= amount, "ERC1155: burn amount exceeds totalSupply");
unchecked {
_totalSupply[id] = supply - amount;
}
}
}
}
}
파일 12 / 73 : 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;
}
}
파일 13 / 73 : ERC2981.sol
pragma solidity ^0.8.0;
import "../../interfaces/IERC2981.sol";
import "../../utils/introspection/ERC165.sol";
abstract contract ERC2981 is IERC2981, ERC165 {
struct RoyaltyInfo {
address receiver;
uint96 royaltyFraction;
}
RoyaltyInfo private _defaultRoyaltyInfo;
mapping(uint256 => RoyaltyInfo) private _tokenRoyaltyInfo;
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC165) returns (bool) {
return interfaceId == type(IERC2981).interfaceId || super.supportsInterface(interfaceId);
}
function royaltyInfo(uint256 _tokenId, uint256 _salePrice) public view virtual override returns (address, uint256) {
RoyaltyInfo memory royalty = _tokenRoyaltyInfo[_tokenId];
if (royalty.receiver == address(0)) {
royalty = _defaultRoyaltyInfo;
}
uint256 royaltyAmount = (_salePrice * royalty.royaltyFraction) / _feeDenominator();
return (royalty.receiver, royaltyAmount);
}
function _feeDenominator() internal pure virtual returns (uint96) {
return 10000;
}
function _setDefaultRoyalty(address receiver, uint96 feeNumerator) internal virtual {
require(feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice");
require(receiver != address(0), "ERC2981: invalid receiver");
_defaultRoyaltyInfo = RoyaltyInfo(receiver, feeNumerator);
}
function _deleteDefaultRoyalty() internal virtual {
delete _defaultRoyaltyInfo;
}
function _setTokenRoyalty(
uint256 tokenId,
address receiver,
uint96 feeNumerator
) internal virtual {
require(feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice");
require(receiver != address(0), "ERC2981: Invalid parameters");
_tokenRoyaltyInfo[tokenId] = RoyaltyInfo(receiver, feeNumerator);
}
function _resetTokenRoyalty(uint256 tokenId) internal virtual {
delete _tokenRoyaltyInfo[tokenId];
}
}
파일 14 / 73 : ERC4907AStorage.sol
pragma solidity ^0.8.0;
import {ERC4907AUpgradeable} from './ERC4907AUpgradeable.sol';
library ERC4907AStorage {
struct Layout {
mapping(uint256 => uint256) _packedUserInfo;
}
bytes32 internal constant STORAGE_SLOT = keccak256('ERC721A.contracts.storage.ERC4907A');
function layout() internal pure returns (Layout storage l) {
bytes32 slot = STORAGE_SLOT;
assembly {
l.slot := slot
}
}
}
파일 15 / 73 : ERC4907AUpgradeable.sol
pragma solidity ^0.8.4;
import './IERC4907AUpgradeable.sol';
import '../ERC721AUpgradeable.sol';
import {ERC4907AStorage} from './ERC4907AStorage.sol';
import '../ERC721A__Initializable.sol';
abstract contract ERC4907AUpgradeable is ERC721A__Initializable, ERC721AUpgradeable, IERC4907AUpgradeable {
using ERC4907AStorage for ERC4907AStorage.Layout;
function __ERC4907A_init() internal onlyInitializingERC721A {
__ERC4907A_init_unchained();
}
function __ERC4907A_init_unchained() internal onlyInitializingERC721A {}
uint256 private constant _BITPOS_EXPIRES = 160;
function setUser(
uint256 tokenId,
address user,
uint64 expires
) public virtual override {
address owner = ownerOf(tokenId);
if (_msgSenderERC721A() != owner)
if (!isApprovedForAll(owner, _msgSenderERC721A()))
if (getApproved(tokenId) != _msgSenderERC721A()) revert SetUserCallerNotOwnerNorApproved();
ERC4907AStorage.layout()._packedUserInfo[tokenId] =
(uint256(expires) << _BITPOS_EXPIRES) |
uint256(uint160(user));
emit UpdateUser(tokenId, user, expires);
}
function userOf(uint256 tokenId) public view virtual override returns (address) {
uint256 packed = ERC4907AStorage.layout()._packedUserInfo[tokenId];
assembly {
packed := mul(
packed,
lt(shl(_BITPOS_EXPIRES, timestamp()), packed)
)
}
return address(uint160(packed));
}
function userExpires(uint256 tokenId) public view virtual override returns (uint256) {
return ERC4907AStorage.layout()._packedUserInfo[tokenId] >> _BITPOS_EXPIRES;
}
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC721AUpgradeable, IERC721AUpgradeable)
returns (bool)
{
return super.supportsInterface(interfaceId) || interfaceId == 0xad092b5c;
}
function _explicitUserOf(uint256 tokenId) internal view virtual returns (address) {
return address(uint160(ERC4907AStorage.layout()._packedUserInfo[tokenId]));
}
}
파일 16 / 73 : 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 firstTokenId,
uint256 batchSize
) internal virtual {}
function _afterTokenTransfer(
address from,
address to,
uint256 firstTokenId,
uint256 batchSize
) internal virtual {}
function __unsafe_increaseBalance(address account, uint256 amount) internal {
_balances[account] += amount;
}
}
파일 17 / 73 : ERC721AQueryableUpgradeable.sol
pragma solidity ^0.8.4;
import './IERC721AQueryableUpgradeable.sol';
import '../ERC721AUpgradeable.sol';
import '../ERC721A__Initializable.sol';
abstract contract ERC721AQueryableUpgradeable is
ERC721A__Initializable,
ERC721AUpgradeable,
IERC721AQueryableUpgradeable
{
function __ERC721AQueryable_init() internal onlyInitializingERC721A {
__ERC721AQueryable_init_unchained();
}
function __ERC721AQueryable_init_unchained() internal onlyInitializingERC721A {}
function explicitOwnershipOf(uint256 tokenId) public view virtual override returns (TokenOwnership memory) {
TokenOwnership memory ownership;
if (tokenId < _startTokenId() || tokenId >= _nextTokenId()) {
return ownership;
}
ownership = _ownershipAt(tokenId);
if (ownership.burned) {
return ownership;
}
return _ownershipOf(tokenId);
}
function explicitOwnershipsOf(uint256[] calldata tokenIds)
external
view
virtual
override
returns (TokenOwnership[] memory)
{
unchecked {
uint256 tokenIdsLength = tokenIds.length;
TokenOwnership[] memory ownerships = new TokenOwnership[](tokenIdsLength);
for (uint256 i; i != tokenIdsLength; ++i) {
ownerships[i] = explicitOwnershipOf(tokenIds[i]);
}
return ownerships;
}
}
function tokensOfOwnerIn(
address owner,
uint256 start,
uint256 stop
) external view virtual override returns (uint256[] memory) {
unchecked {
if (start >= stop) revert InvalidQueryRange();
uint256 tokenIdsIdx;
uint256 stopLimit = _nextTokenId();
if (start < _startTokenId()) {
start = _startTokenId();
}
if (stop > stopLimit) {
stop = stopLimit;
}
uint256 tokenIdsMaxLength = balanceOf(owner);
if (start < stop) {
uint256 rangeLength = stop - start;
if (rangeLength < tokenIdsMaxLength) {
tokenIdsMaxLength = rangeLength;
}
} else {
tokenIdsMaxLength = 0;
}
uint256[] memory tokenIds = new uint256[](tokenIdsMaxLength);
if (tokenIdsMaxLength == 0) {
return tokenIds;
}
TokenOwnership memory ownership = explicitOwnershipOf(start);
address currOwnershipAddr;
if (!ownership.burned) {
currOwnershipAddr = ownership.addr;
}
for (uint256 i = start; i != stop && tokenIdsIdx != tokenIdsMaxLength; ++i) {
ownership = _ownershipAt(i);
if (ownership.burned) {
continue;
}
if (ownership.addr != address(0)) {
currOwnershipAddr = ownership.addr;
}
if (currOwnershipAddr == owner) {
tokenIds[tokenIdsIdx++] = i;
}
}
assembly {
mstore(tokenIds, tokenIdsIdx)
}
return tokenIds;
}
}
function tokensOfOwner(address owner) external view virtual override returns (uint256[] memory) {
unchecked {
uint256 tokenIdsIdx;
address currOwnershipAddr;
uint256 tokenIdsLength = balanceOf(owner);
uint256[] memory tokenIds = new uint256[](tokenIdsLength);
TokenOwnership memory ownership;
for (uint256 i = _startTokenId(); tokenIdsIdx != tokenIdsLength; ++i) {
ownership = _ownershipAt(i);
if (ownership.burned) {
continue;
}
if (ownership.addr != address(0)) {
currOwnershipAddr = ownership.addr;
}
if (currOwnershipAddr == owner) {
tokenIds[tokenIdsIdx++] = i;
}
}
return tokenIds;
}
}
}
파일 18 / 73 : ERC721AStorage.sol
pragma solidity ^0.8.0;
library ERC721AStorage {
struct TokenApprovalRef {
address value;
}
struct Layout {
uint256 _currentIndex;
uint256 _burnCounter;
string _name;
string _symbol;
mapping(uint256 => uint256) _packedOwnerships;
mapping(address => uint256) _packedAddressData;
mapping(uint256 => ERC721AStorage.TokenApprovalRef) _tokenApprovals;
mapping(address => mapping(address => bool)) _operatorApprovals;
}
bytes32 internal constant STORAGE_SLOT = keccak256('ERC721A.contracts.storage.ERC721A');
function layout() internal pure returns (Layout storage l) {
bytes32 slot = STORAGE_SLOT;
assembly {
l.slot := slot
}
}
}
파일 19 / 73 : ERC721AUpgradeable.sol
pragma solidity ^0.8.4;
import './IERC721AUpgradeable.sol';
import {ERC721AStorage} from './ERC721AStorage.sol';
import './ERC721A__Initializable.sol';
interface ERC721A__IERC721ReceiverUpgradeable {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
contract ERC721AUpgradeable is ERC721A__Initializable, IERC721AUpgradeable {
using ERC721AStorage for ERC721AStorage.Layout;
uint256 private constant _BITMASK_ADDRESS_DATA_ENTRY = (1 << 64) - 1;
uint256 private constant _BITPOS_NUMBER_MINTED = 64;
uint256 private constant _BITPOS_NUMBER_BURNED = 128;
uint256 private constant _BITPOS_AUX = 192;
uint256 private constant _BITMASK_AUX_COMPLEMENT = (1 << 192) - 1;
uint256 private constant _BITPOS_START_TIMESTAMP = 160;
uint256 private constant _BITMASK_BURNED = 1 << 224;
uint256 private constant _BITPOS_NEXT_INITIALIZED = 225;
uint256 private constant _BITMASK_NEXT_INITIALIZED = 1 << 225;
uint256 private constant _BITPOS_EXTRA_DATA = 232;
uint256 private constant _BITMASK_EXTRA_DATA_COMPLEMENT = (1 << 232) - 1;
uint256 private constant _BITMASK_ADDRESS = (1 << 160) - 1;
uint256 private constant _MAX_MINT_ERC2309_QUANTITY_LIMIT = 5000;
bytes32 private constant _TRANSFER_EVENT_SIGNATURE =
0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef;
function __ERC721A_init(string memory name_, string memory symbol_) internal onlyInitializingERC721A {
__ERC721A_init_unchained(name_, symbol_);
}
function __ERC721A_init_unchained(string memory name_, string memory symbol_) internal onlyInitializingERC721A {
ERC721AStorage.layout()._name = name_;
ERC721AStorage.layout()._symbol = symbol_;
ERC721AStorage.layout()._currentIndex = _startTokenId();
}
function _startTokenId() internal view virtual returns (uint256) {
return 0;
}
function _nextTokenId() internal view virtual returns (uint256) {
return ERC721AStorage.layout()._currentIndex;
}
function totalSupply() public view virtual override returns (uint256) {
unchecked {
return ERC721AStorage.layout()._currentIndex - ERC721AStorage.layout()._burnCounter - _startTokenId();
}
}
function _totalMinted() internal view virtual returns (uint256) {
unchecked {
return ERC721AStorage.layout()._currentIndex - _startTokenId();
}
}
function _totalBurned() internal view virtual returns (uint256) {
return ERC721AStorage.layout()._burnCounter;
}
function balanceOf(address owner) public view virtual override returns (uint256) {
if (owner == address(0)) revert BalanceQueryForZeroAddress();
return ERC721AStorage.layout()._packedAddressData[owner] & _BITMASK_ADDRESS_DATA_ENTRY;
}
function _numberMinted(address owner) internal view returns (uint256) {
return
(ERC721AStorage.layout()._packedAddressData[owner] >> _BITPOS_NUMBER_MINTED) & _BITMASK_ADDRESS_DATA_ENTRY;
}
function _numberBurned(address owner) internal view returns (uint256) {
return
(ERC721AStorage.layout()._packedAddressData[owner] >> _BITPOS_NUMBER_BURNED) & _BITMASK_ADDRESS_DATA_ENTRY;
}
function _getAux(address owner) internal view returns (uint64) {
return uint64(ERC721AStorage.layout()._packedAddressData[owner] >> _BITPOS_AUX);
}
function _setAux(address owner, uint64 aux) internal virtual {
uint256 packed = ERC721AStorage.layout()._packedAddressData[owner];
uint256 auxCasted;
assembly {
auxCasted := aux
}
packed = (packed & _BITMASK_AUX_COMPLEMENT) | (auxCasted << _BITPOS_AUX);
ERC721AStorage.layout()._packedAddressData[owner] = packed;
}
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return
interfaceId == 0x01ffc9a7 ||
interfaceId == 0x80ac58cd ||
interfaceId == 0x5b5e139f;
}
function name() public view virtual override returns (string memory) {
return ERC721AStorage.layout()._name;
}
function symbol() public view virtual override returns (string memory) {
return ERC721AStorage.layout()._symbol;
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
if (!_exists(tokenId)) revert URIQueryForNonexistentToken();
string memory baseURI = _baseURI();
return bytes(baseURI).length != 0 ? string(abi.encodePacked(baseURI, _toString(tokenId))) : '';
}
function _baseURI() internal view virtual returns (string memory) {
return '';
}
function ownerOf(uint256 tokenId) public view virtual override returns (address) {
return address(uint160(_packedOwnershipOf(tokenId)));
}
function _ownershipOf(uint256 tokenId) internal view virtual returns (TokenOwnership memory) {
return _unpackedOwnership(_packedOwnershipOf(tokenId));
}
function _ownershipAt(uint256 index) internal view virtual returns (TokenOwnership memory) {
return _unpackedOwnership(ERC721AStorage.layout()._packedOwnerships[index]);
}
function _initializeOwnershipAt(uint256 index) internal virtual {
if (ERC721AStorage.layout()._packedOwnerships[index] == 0) {
ERC721AStorage.layout()._packedOwnerships[index] = _packedOwnershipOf(index);
}
}
function _packedOwnershipOf(uint256 tokenId) private view returns (uint256 packed) {
if (_startTokenId() <= tokenId) {
packed = ERC721AStorage.layout()._packedOwnerships[tokenId];
if (packed & _BITMASK_BURNED == 0) {
if (packed == 0) {
if (tokenId >= ERC721AStorage.layout()._currentIndex) revert OwnerQueryForNonexistentToken();
for (;;) {
unchecked {
packed = ERC721AStorage.layout()._packedOwnerships[--tokenId];
}
if (packed == 0) continue;
return packed;
}
}
return packed;
}
}
revert OwnerQueryForNonexistentToken();
}
function _unpackedOwnership(uint256 packed) private pure returns (TokenOwnership memory ownership) {
ownership.addr = address(uint160(packed));
ownership.startTimestamp = uint64(packed >> _BITPOS_START_TIMESTAMP);
ownership.burned = packed & _BITMASK_BURNED != 0;
ownership.extraData = uint24(packed >> _BITPOS_EXTRA_DATA);
}
function _packOwnershipData(address owner, uint256 flags) private view returns (uint256 result) {
assembly {
owner := and(owner, _BITMASK_ADDRESS)
result := or(owner, or(shl(_BITPOS_START_TIMESTAMP, timestamp()), flags))
}
}
function _nextInitializedFlag(uint256 quantity) private pure returns (uint256 result) {
assembly {
result := shl(_BITPOS_NEXT_INITIALIZED, eq(quantity, 1))
}
}
function approve(address to, uint256 tokenId) public payable virtual override {
_approve(to, tokenId, true);
}
function getApproved(uint256 tokenId) public view virtual override returns (address) {
if (!_exists(tokenId)) revert ApprovalQueryForNonexistentToken();
return ERC721AStorage.layout()._tokenApprovals[tokenId].value;
}
function setApprovalForAll(address operator, bool approved) public virtual override {
ERC721AStorage.layout()._operatorApprovals[_msgSenderERC721A()][operator] = approved;
emit ApprovalForAll(_msgSenderERC721A(), operator, approved);
}
function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
return ERC721AStorage.layout()._operatorApprovals[owner][operator];
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return
_startTokenId() <= tokenId &&
tokenId < ERC721AStorage.layout()._currentIndex &&
ERC721AStorage.layout()._packedOwnerships[tokenId] & _BITMASK_BURNED == 0;
}
function _isSenderApprovedOrOwner(
address approvedAddress,
address owner,
address msgSender
) private pure returns (bool result) {
assembly {
owner := and(owner, _BITMASK_ADDRESS)
msgSender := and(msgSender, _BITMASK_ADDRESS)
result := or(eq(msgSender, owner), eq(msgSender, approvedAddress))
}
}
function _getApprovedSlotAndAddress(uint256 tokenId)
private
view
returns (uint256 approvedAddressSlot, address approvedAddress)
{
ERC721AStorage.TokenApprovalRef storage tokenApproval = ERC721AStorage.layout()._tokenApprovals[tokenId];
assembly {
approvedAddressSlot := tokenApproval.slot
approvedAddress := sload(approvedAddressSlot)
}
}
function transferFrom(
address from,
address to,
uint256 tokenId
) public payable virtual override {
uint256 prevOwnershipPacked = _packedOwnershipOf(tokenId);
if (address(uint160(prevOwnershipPacked)) != from) revert TransferFromIncorrectOwner();
(uint256 approvedAddressSlot, address approvedAddress) = _getApprovedSlotAndAddress(tokenId);
if (!_isSenderApprovedOrOwner(approvedAddress, from, _msgSenderERC721A()))
if (!isApprovedForAll(from, _msgSenderERC721A())) revert TransferCallerNotOwnerNorApproved();
if (to == address(0)) revert TransferToZeroAddress();
_beforeTokenTransfers(from, to, tokenId, 1);
assembly {
if approvedAddress {
sstore(approvedAddressSlot, 0)
}
}
unchecked {
--ERC721AStorage.layout()._packedAddressData[from];
++ERC721AStorage.layout()._packedAddressData[to];
ERC721AStorage.layout()._packedOwnerships[tokenId] = _packOwnershipData(
to,
_BITMASK_NEXT_INITIALIZED | _nextExtraData(from, to, prevOwnershipPacked)
);
if (prevOwnershipPacked & _BITMASK_NEXT_INITIALIZED == 0) {
uint256 nextTokenId = tokenId + 1;
if (ERC721AStorage.layout()._packedOwnerships[nextTokenId] == 0) {
if (nextTokenId != ERC721AStorage.layout()._currentIndex) {
ERC721AStorage.layout()._packedOwnerships[nextTokenId] = prevOwnershipPacked;
}
}
}
}
emit Transfer(from, to, tokenId);
_afterTokenTransfers(from, to, tokenId, 1);
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) public payable virtual override {
safeTransferFrom(from, to, tokenId, '');
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory _data
) public payable virtual override {
transferFrom(from, to, tokenId);
if (to.code.length != 0)
if (!_checkContractOnERC721Received(from, to, tokenId, _data)) {
revert TransferToNonERC721ReceiverImplementer();
}
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
function _checkContractOnERC721Received(
address from,
address to,
uint256 tokenId,
bytes memory _data
) private returns (bool) {
try
ERC721A__IERC721ReceiverUpgradeable(to).onERC721Received(_msgSenderERC721A(), from, tokenId, _data)
returns (bytes4 retval) {
return retval == ERC721A__IERC721ReceiverUpgradeable(to).onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert TransferToNonERC721ReceiverImplementer();
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
}
function _mint(address to, uint256 quantity) internal virtual {
uint256 startTokenId = ERC721AStorage.layout()._currentIndex;
if (quantity == 0) revert MintZeroQuantity();
_beforeTokenTransfers(address(0), to, startTokenId, quantity);
unchecked {
ERC721AStorage.layout()._packedAddressData[to] += quantity * ((1 << _BITPOS_NUMBER_MINTED) | 1);
ERC721AStorage.layout()._packedOwnerships[startTokenId] = _packOwnershipData(
to,
_nextInitializedFlag(quantity) | _nextExtraData(address(0), to, 0)
);
uint256 toMasked;
uint256 end = startTokenId + quantity;
assembly {
toMasked := and(to, _BITMASK_ADDRESS)
log4(
0,
0,
_TRANSFER_EVENT_SIGNATURE,
0,
toMasked,
startTokenId
)
for {
let tokenId := add(startTokenId, 1)
} iszero(eq(tokenId, end)) {
tokenId := add(tokenId, 1)
} {
log4(0, 0, _TRANSFER_EVENT_SIGNATURE, 0, toMasked, tokenId)
}
}
if (toMasked == 0) revert MintToZeroAddress();
ERC721AStorage.layout()._currentIndex = end;
}
_afterTokenTransfers(address(0), to, startTokenId, quantity);
}
function _mintERC2309(address to, uint256 quantity) internal virtual {
uint256 startTokenId = ERC721AStorage.layout()._currentIndex;
if (to == address(0)) revert MintToZeroAddress();
if (quantity == 0) revert MintZeroQuantity();
if (quantity > _MAX_MINT_ERC2309_QUANTITY_LIMIT) revert MintERC2309QuantityExceedsLimit();
_beforeTokenTransfers(address(0), to, startTokenId, quantity);
unchecked {
ERC721AStorage.layout()._packedAddressData[to] += quantity * ((1 << _BITPOS_NUMBER_MINTED) | 1);
ERC721AStorage.layout()._packedOwnerships[startTokenId] = _packOwnershipData(
to,
_nextInitializedFlag(quantity) | _nextExtraData(address(0), to, 0)
);
emit ConsecutiveTransfer(startTokenId, startTokenId + quantity - 1, address(0), to);
ERC721AStorage.layout()._currentIndex = startTokenId + quantity;
}
_afterTokenTransfers(address(0), to, startTokenId, quantity);
}
function _safeMint(
address to,
uint256 quantity,
bytes memory _data
) internal virtual {
_mint(to, quantity);
unchecked {
if (to.code.length != 0) {
uint256 end = ERC721AStorage.layout()._currentIndex;
uint256 index = end - quantity;
do {
if (!_checkContractOnERC721Received(address(0), to, index++, _data)) {
revert TransferToNonERC721ReceiverImplementer();
}
} while (index < end);
if (ERC721AStorage.layout()._currentIndex != end) revert();
}
}
}
function _safeMint(address to, uint256 quantity) internal virtual {
_safeMint(to, quantity, '');
}
function _approve(address to, uint256 tokenId) internal virtual {
_approve(to, tokenId, false);
}
function _approve(
address to,
uint256 tokenId,
bool approvalCheck
) internal virtual {
address owner = ownerOf(tokenId);
if (approvalCheck)
if (_msgSenderERC721A() != owner)
if (!isApprovedForAll(owner, _msgSenderERC721A())) {
revert ApprovalCallerNotOwnerNorApproved();
}
ERC721AStorage.layout()._tokenApprovals[tokenId].value = to;
emit Approval(owner, to, tokenId);
}
function _burn(uint256 tokenId) internal virtual {
_burn(tokenId, false);
}
function _burn(uint256 tokenId, bool approvalCheck) internal virtual {
uint256 prevOwnershipPacked = _packedOwnershipOf(tokenId);
address from = address(uint160(prevOwnershipPacked));
(uint256 approvedAddressSlot, address approvedAddress) = _getApprovedSlotAndAddress(tokenId);
if (approvalCheck) {
if (!_isSenderApprovedOrOwner(approvedAddress, from, _msgSenderERC721A()))
if (!isApprovedForAll(from, _msgSenderERC721A())) revert TransferCallerNotOwnerNorApproved();
}
_beforeTokenTransfers(from, address(0), tokenId, 1);
assembly {
if approvedAddress {
sstore(approvedAddressSlot, 0)
}
}
unchecked {
ERC721AStorage.layout()._packedAddressData[from] += (1 << _BITPOS_NUMBER_BURNED) - 1;
ERC721AStorage.layout()._packedOwnerships[tokenId] = _packOwnershipData(
from,
(_BITMASK_BURNED | _BITMASK_NEXT_INITIALIZED) | _nextExtraData(from, address(0), prevOwnershipPacked)
);
if (prevOwnershipPacked & _BITMASK_NEXT_INITIALIZED == 0) {
uint256 nextTokenId = tokenId + 1;
if (ERC721AStorage.layout()._packedOwnerships[nextTokenId] == 0) {
if (nextTokenId != ERC721AStorage.layout()._currentIndex) {
ERC721AStorage.layout()._packedOwnerships[nextTokenId] = prevOwnershipPacked;
}
}
}
}
emit Transfer(from, address(0), tokenId);
_afterTokenTransfers(from, address(0), tokenId, 1);
unchecked {
ERC721AStorage.layout()._burnCounter++;
}
}
function _setExtraDataAt(uint256 index, uint24 extraData) internal virtual {
uint256 packed = ERC721AStorage.layout()._packedOwnerships[index];
if (packed == 0) revert OwnershipNotInitializedForExtraData();
uint256 extraDataCasted;
assembly {
extraDataCasted := extraData
}
packed = (packed & _BITMASK_EXTRA_DATA_COMPLEMENT) | (extraDataCasted << _BITPOS_EXTRA_DATA);
ERC721AStorage.layout()._packedOwnerships[index] = packed;
}
function _extraData(
address from,
address to,
uint24 previousExtraData
) internal view virtual returns (uint24) {}
function _nextExtraData(
address from,
address to,
uint256 prevOwnershipPacked
) private view returns (uint256) {
uint24 extraData = uint24(prevOwnershipPacked >> _BITPOS_EXTRA_DATA);
return uint256(_extraData(from, to, extraData)) << _BITPOS_EXTRA_DATA;
}
function _msgSenderERC721A() internal view virtual returns (address) {
return msg.sender;
}
function _toString(uint256 value) internal pure virtual returns (string memory str) {
assembly {
let m := add(mload(0x40), 0xa0)
mstore(0x40, m)
str := sub(m, 0x20)
mstore(str, 0)
let end := str
for { let temp := value } 1 {} {
str := sub(str, 1)
mstore8(str, add(48, mod(temp, 10)))
temp := div(temp, 10)
if iszero(temp) { break }
}
let length := sub(end, str)
str := sub(str, 0x20)
mstore(str, length)
}
}
}
파일 20 / 73 : ERC721A__Initializable.sol
pragma solidity ^0.8.0;
import {ERC721A__InitializableStorage} from './ERC721A__InitializableStorage.sol';
abstract contract ERC721A__Initializable {
using ERC721A__InitializableStorage for ERC721A__InitializableStorage.Layout;
modifier initializerERC721A() {
require(
ERC721A__InitializableStorage.layout()._initializing
? _isConstructor()
: !ERC721A__InitializableStorage.layout()._initialized,
'ERC721A__Initializable: contract is already initialized'
);
bool isTopLevelCall = !ERC721A__InitializableStorage.layout()._initializing;
if (isTopLevelCall) {
ERC721A__InitializableStorage.layout()._initializing = true;
ERC721A__InitializableStorage.layout()._initialized = true;
}
_;
if (isTopLevelCall) {
ERC721A__InitializableStorage.layout()._initializing = false;
}
}
modifier onlyInitializingERC721A() {
require(
ERC721A__InitializableStorage.layout()._initializing,
'ERC721A__Initializable: contract is not initializing'
);
_;
}
function _isConstructor() private view returns (bool) {
address self = address(this);
uint256 cs;
assembly {
cs := extcodesize(self)
}
return cs == 0;
}
}
파일 21 / 73 : ERC721A__InitializableStorage.sol
pragma solidity ^0.8.0;
library ERC721A__InitializableStorage {
struct Layout {
bool _initialized;
bool _initializing;
}
bytes32 internal constant STORAGE_SLOT = keccak256('ERC721A.contracts.storage.initializable.facet');
function layout() internal pure returns (Layout storage l) {
bytes32 slot = STORAGE_SLOT;
assembly {
l.slot := slot
}
}
}
파일 22 / 73 : ERC721Enumerable.sol
pragma solidity ^0.8.0;
import "../ERC721.sol";
import "./IERC721Enumerable.sol";
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
mapping(address => mapping(uint256 => uint256)) private _ownedTokens;
mapping(uint256 => uint256) private _ownedTokensIndex;
uint256[] private _allTokens;
mapping(uint256 => uint256) private _allTokensIndex;
function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
return interfaceId == type(IERC721Enumerable).interfaceId || super.supportsInterface(interfaceId);
}
function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
require(index < ERC721.balanceOf(owner), "ERC721Enumerable: owner index out of bounds");
return _ownedTokens[owner][index];
}
function totalSupply() public view virtual override returns (uint256) {
return _allTokens.length;
}
function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
require(index < ERC721Enumerable.totalSupply(), "ERC721Enumerable: global index out of bounds");
return _allTokens[index];
}
function _beforeTokenTransfer(
address from,
address to,
uint256 firstTokenId,
uint256 batchSize
) internal virtual override {
super._beforeTokenTransfer(from, to, firstTokenId, batchSize);
if (batchSize > 1) {
revert("ERC721Enumerable: consecutive transfers not supported");
}
uint256 tokenId = firstTokenId;
if (from == address(0)) {
_addTokenToAllTokensEnumeration(tokenId);
} else if (from != to) {
_removeTokenFromOwnerEnumeration(from, tokenId);
}
if (to == address(0)) {
_removeTokenFromAllTokensEnumeration(tokenId);
} else if (to != from) {
_addTokenToOwnerEnumeration(to, tokenId);
}
}
function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
uint256 length = ERC721.balanceOf(to);
_ownedTokens[to][length] = tokenId;
_ownedTokensIndex[tokenId] = length;
}
function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
_allTokensIndex[tokenId] = _allTokens.length;
_allTokens.push(tokenId);
}
function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
uint256 lastTokenIndex = ERC721.balanceOf(from) - 1;
uint256 tokenIndex = _ownedTokensIndex[tokenId];
if (tokenIndex != lastTokenIndex) {
uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];
_ownedTokens[from][tokenIndex] = lastTokenId;
_ownedTokensIndex[lastTokenId] = tokenIndex;
}
delete _ownedTokensIndex[tokenId];
delete _ownedTokens[from][lastTokenIndex];
}
function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
uint256 lastTokenIndex = _allTokens.length - 1;
uint256 tokenIndex = _allTokensIndex[tokenId];
uint256 lastTokenId = _allTokens[lastTokenIndex];
_allTokens[tokenIndex] = lastTokenId;
_allTokensIndex[lastTokenId] = tokenIndex;
delete _allTokensIndex[tokenId];
_allTokens.pop();
}
}
파일 23 / 73 : EnumerableERC1155.sol
pragma solidity ^0.8.17;
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/common/ERC2981.sol";
contract EnumerableERC1155 is
ERC1155Supply,
Ownable,
Pausable,
ReentrancyGuard,
ERC2981
{
using ECDSA for bytes32;
address private presaleSignerAddress =
0x0fE6E0D15E6F775138Ab556dE54B96d5C1358F3D;
address public royaltyAddress = 0x7A4dF7B461f1bE3e88373a4d933aeefE2FAdcE71;
address[] public payoutAddresses = [
0xD3371FD388664Bd16A267788dbE977582B850f5b
];
bool public allMetadataFrozen = false;
bool public payoutAddressesFrozen;
mapping(address => mapping(uint256 => uint256))
public tokensMintedByAddress;
mapping(uint256 => bool) public tokenMetadataFrozen;
mapping(uint256 => bool) public tokenMintingPermanentlyDisabled;
mapping(uint256 => bool) public tokenPresaleSaleActive;
mapping(uint256 => bool) public tokenPublicSaleActive;
mapping(uint256 => bool) public tokenUsePresaleTimes;
mapping(uint256 => bool) public tokenUsePublicSaleTimes;
mapping(uint256 => string) public tokenURI;
mapping(uint256 => uint256) public tokenMaxSupply;
mapping(uint256 => uint256) public tokenPresaleMaxSupply;
mapping(uint256 => uint256) public tokenPresaleMintsPerAddress;
mapping(uint256 => uint256) public tokenPresalePrice;
mapping(uint256 => uint256) public tokenPresaleSaleEndTime;
mapping(uint256 => uint256) public tokenPresaleSaleStartTime;
mapping(uint256 => uint256) public tokenPublicMintsPerAddress;
mapping(uint256 => uint256) public tokenPublicPrice;
mapping(uint256 => uint256) public tokenPublicSaleEndTime;
mapping(uint256 => uint256) public tokenPublicSaleStartTime;
string public name = "Verification test";
string public symbol = "VRT";
uint256[] public payoutBasisPoints = [10000];
uint96 public royaltyFee = 0;
constructor()
ERC1155(
"ipfs://bafybeicin4rmb5y44r2a5jhwvobfgxutabetrttoi3u2po7pdymxt7dwdy/{id}"
)
{
_setDefaultRoyalty(royaltyAddress, royaltyFee);
tokenPublicPrice[1] = 0.1 ether;
tokenPublicMintsPerAddress[1] = 0;
require(
payoutAddresses.length == payoutBasisPoints.length,
"PAYOUT_ARRAYS_NOT_SAME_LENGTH"
);
uint256 totalPayoutBasisPoints = 0;
for (uint256 i = 0; i < payoutBasisPoints.length; i++) {
totalPayoutBasisPoints += payoutBasisPoints[i];
}
require(
totalPayoutBasisPoints == 10000,
"TOTAL_BASIS_POINTS_MUST_BE_10000"
);
}
modifier originalUser() {
require(tx.origin == msg.sender, "CANNOT_CALL_FROM_CONTRACT");
_;
}
function uri(
uint256 _tokenId
) public view override returns (string memory) {
if (bytes(tokenURI[_tokenId]).length == 0) {
return super.uri(_tokenId);
}
return tokenURI[_tokenId];
}
function setURI(
uint256 _tokenId,
string calldata _newTokenURI
) external onlyOwner {
require(
!allMetadataFrozen && !tokenMetadataFrozen[_tokenId],
"METADATA_HAS_BEEN_FROZEN"
);
tokenURI[_tokenId] = _newTokenURI;
}
function setGlobalURI(string calldata _newTokenURI) external onlyOwner {
require(!allMetadataFrozen, "METADATA_HAS_BEEN_FROZEN");
_setURI(_newTokenURI);
}
function freezeTokenMetadata(uint256 _tokenId) external onlyOwner {
require(
!tokenMetadataFrozen[_tokenId],
"METADATA_HAS_ALREADY_BEEN_FROZEN"
);
tokenMetadataFrozen[_tokenId] = true;
}
function freezeAllMetadata() external onlyOwner {
require(!allMetadataFrozen, "METADATA_HAS_ALREADY_BEEN_FROZEN");
allMetadataFrozen = true;
}
function reduceMaxSupply(
uint256 _tokenId,
uint256 _newMaxSupply
) external onlyOwner {
require(
tokenMaxSupply[_tokenId] == 0 ||
_newMaxSupply < tokenMaxSupply[_tokenId],
"NEW_MAX_SUPPLY_TOO_HIGH"
);
require(
_newMaxSupply >= totalSupply(_tokenId),
"SUPPLY_LOWER_THAN_MINTED_TOKENS"
);
tokenMaxSupply[_tokenId] = _newMaxSupply;
}
function permanentlyDisableTokenMinting(
uint256 _tokenId
) external onlyOwner {
tokenMintingPermanentlyDisabled[_tokenId] = true;
}
function setRoyaltyFee(uint96 _feeNumerator) external onlyOwner {
royaltyFee = _feeNumerator;
_setDefaultRoyalty(royaltyAddress, royaltyFee);
}
function setRoyaltyAddress(address _royaltyAddress) external onlyOwner {
royaltyAddress = _royaltyAddress;
_setDefaultRoyalty(royaltyAddress, royaltyFee);
}
function pause() external onlyOwner {
_pause();
}
function unpause() external onlyOwner {
_unpause();
}
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) public override {
require(amount > 0, "AMOUNT_CANNOT_BE_ZERO");
return super.safeTransferFrom(from, to, id, amount, data);
}
function supportsInterface(
bytes4 _interfaceId
) public view override(ERC1155, ERC2981) returns (bool) {
return super.supportsInterface(_interfaceId);
}
function giftTokens(
uint256 _tokenId,
address[] calldata _receivers,
uint256[] calldata _mintNumber
) external onlyOwner {
require(
!tokenMintingPermanentlyDisabled[_tokenId],
"MINTING_PERMANENTLY_DISABLED"
);
uint256 totalMint = 0;
for (uint256 i = 0; i < _mintNumber.length; i++) {
totalMint += _mintNumber[i];
}
require(
tokenMaxSupply[_tokenId] == 0 ||
totalSupply(_tokenId) + totalMint <= tokenMaxSupply[_tokenId],
"MINT_TOO_LARGE"
);
for (uint256 i = 0; i < _receivers.length; i++) {
_mint(_receivers[i], _tokenId, _mintNumber[i], "");
}
}
function setTokenPublicSaleState(
uint256 _tokenId,
bool _saleActiveState
) external onlyOwner {
require(
tokenPublicSaleActive[_tokenId] != _saleActiveState,
"NEW_STATE_IDENTICAL_TO_OLD_STATE"
);
tokenPublicSaleActive[_tokenId] = _saleActiveState;
}
function setTokenPublicPrice(
uint256 _tokenId,
uint256 _publicPrice
) external onlyOwner {
tokenPublicPrice[_tokenId] = _publicPrice;
}
function setTokenPublicMintsAllowedPerAddress(
uint256 _tokenId,
uint256 _mintsAllowed
) external onlyOwner {
tokenPublicMintsPerAddress[_tokenId] = _mintsAllowed;
}
function setTokenPublicSaleStartTime(
uint256 _tokenId,
uint256 _publicSaleStartTime
) external onlyOwner {
require(_publicSaleStartTime > block.timestamp, "TIME_IN_PAST");
tokenPublicSaleStartTime[_tokenId] = _publicSaleStartTime;
}
function setTokenPublicSaleEndTime(
uint256 _tokenId,
uint256 _publicSaleEndTime
) external onlyOwner {
require(_publicSaleEndTime > block.timestamp, "TIME_IN_PAST");
tokenPublicSaleEndTime[_tokenId] = _publicSaleEndTime;
}
function setTokenUsePublicSaleTimes(
uint256 _tokenId,
bool _usePublicSaleTimes
) external onlyOwner {
require(
tokenUsePublicSaleTimes[_tokenId] != _usePublicSaleTimes,
"NEW_STATE_IDENTICAL_TO_OLD_STATE"
);
tokenUsePublicSaleTimes[_tokenId] = _usePublicSaleTimes;
}
function tokenPublicSaleTimeIsActive(
uint256 _tokenId
) public view returns (bool) {
if (tokenUsePublicSaleTimes[_tokenId] == false) {
return true;
}
return
block.timestamp >= tokenPublicSaleStartTime[_tokenId] &&
block.timestamp <= tokenPublicSaleEndTime[_tokenId];
}
function mintToken(
uint256 _tokenId,
uint256 _numTokens
) external payable originalUser nonReentrant {
require(tokenPublicSaleActive[_tokenId], "PUBLIC_SALE_IS_NOT_ACTIVE");
require(
tokenPublicSaleTimeIsActive(_tokenId),
"PUBLIC_SALE_TIME_IS_NOT_ACTIVE"
);
require(
tokenPublicMintsPerAddress[_tokenId] == 0 ||
tokensMintedByAddress[msg.sender][_tokenId] + _numTokens <=
tokenPublicMintsPerAddress[_tokenId],
"MAX_MINTS_FOR_ADDRESS_EXCEEDED"
);
require(
tokenMaxSupply[_tokenId] == 0 ||
totalSupply(_tokenId) + _numTokens <= tokenMaxSupply[_tokenId],
"MAX_SUPPLY_EXCEEDED"
);
require(
msg.value == tokenPublicPrice[_tokenId] * _numTokens,
"PAYMENT_INCORRECT"
);
require(
!tokenMintingPermanentlyDisabled[_tokenId],
"MINTING_PERMANENTLY_DISABLED"
);
tokensMintedByAddress[msg.sender][_tokenId] += _numTokens;
_mint(msg.sender, _tokenId, _numTokens, "");
if (
tokenMaxSupply[_tokenId] != 0 &&
totalSupply(_tokenId) >= tokenMaxSupply[_tokenId]
) {
tokenPublicSaleActive[_tokenId] = false;
}
}
function setPresaleSignerAddress(
address _presaleSignerAddress
) external onlyOwner {
require(_presaleSignerAddress != address(0));
presaleSignerAddress = _presaleSignerAddress;
}
function setTokenPresaleState(
uint256 _tokenId,
bool _saleActiveState
) external onlyOwner {
require(
tokenPresaleSaleActive[_tokenId] != _saleActiveState,
"NEW_STATE_IDENTICAL_TO_OLD_STATE"
);
tokenPresaleSaleActive[_tokenId] = _saleActiveState;
}
function setTokenPresalePrice(
uint256 _tokenId,
uint256 _presalePrice
) external onlyOwner {
tokenPresalePrice[_tokenId] = _presalePrice;
}
function setTokenPresaleMintsAllowedPerAddress(
uint256 _tokenId,
uint256 _mintsAllowed
) external onlyOwner {
tokenPresaleMintsPerAddress[_tokenId] = _mintsAllowed;
}
function reducePresaleMaxSupply(
uint256 _tokenId,
uint256 _newPresaleMaxSupply
) external onlyOwner {
require(
tokenPresaleMaxSupply[_tokenId] == 0 ||
_newPresaleMaxSupply < tokenPresaleMaxSupply[_tokenId],
"NEW_MAX_SUPPLY_TOO_HIGH"
);
tokenPresaleMaxSupply[_tokenId] = _newPresaleMaxSupply;
}
function setTokenPresaleStartTime(
uint256 _tokenId,
uint256 _presaleStartTime
) external onlyOwner {
require(_presaleStartTime > block.timestamp, "TIME_IN_PAST");
tokenPresaleSaleStartTime[_tokenId] = _presaleStartTime;
}
function setTokenPresaleEndTime(
uint256 _tokenId,
uint256 _presaleEndTime
) external onlyOwner {
require(_presaleEndTime > block.timestamp, "TIME_IN_PAST");
tokenPresaleSaleEndTime[_tokenId] = _presaleEndTime;
}
function setTokenUsePresaleTimes(
uint256 _tokenId,
bool _usePresaleTimes
) external onlyOwner {
require(
tokenUsePresaleTimes[_tokenId] != _usePresaleTimes,
"NEW_STATE_IDENTICAL_TO_OLD_STATE"
);
tokenUsePresaleTimes[_tokenId] = _usePresaleTimes;
}
function tokenPresaleTimeIsActive(
uint256 _tokenId
) public view returns (bool) {
if (tokenUsePresaleTimes[_tokenId] == false) {
return true;
}
return
block.timestamp >= tokenPresaleSaleStartTime[_tokenId] &&
block.timestamp <= tokenPresaleSaleEndTime[_tokenId];
}
function verifySignerAddress(
bytes32 _messageHash,
bytes calldata _signature
) private view returns (bool) {
return
presaleSignerAddress ==
_messageHash.toEthSignedMessageHash().recover(_signature);
}
function presaleMint(
bytes32 _messageHash,
bytes calldata _signature,
uint256 _tokenId,
uint256 _numTokens,
uint256 _maximumAllowedMints
) external payable originalUser nonReentrant {
require(tokenPresaleSaleActive[_tokenId], "PRESALE_IS_NOT_ACTIVE");
require(
tokenPresaleTimeIsActive(_tokenId),
"PRESALE_TIME_IS_NOT_ACTIVE"
);
require(
!tokenMintingPermanentlyDisabled[_tokenId],
"MINTING_PERMANENTLY_DISABLED"
);
require(
tokenPresaleMintsPerAddress[_tokenId] == 0 ||
tokensMintedByAddress[msg.sender][_tokenId] + _numTokens <=
tokenPresaleMintsPerAddress[_tokenId],
"MAX_MINTS_PER_ADDRESS_EXCEEDED"
);
require(
_maximumAllowedMints == 0 ||
tokensMintedByAddress[msg.sender][_tokenId] + _numTokens <=
_maximumAllowedMints,
"MAX_MINTS_EXCEEDED"
);
require(
tokenPresaleMaxSupply[_tokenId] == 0 ||
totalSupply(_tokenId) + _numTokens <=
tokenPresaleMaxSupply[_tokenId],
"MAX_SUPPLY_EXCEEDED"
);
require(
msg.value == tokenPresalePrice[_tokenId] * _numTokens,
"PAYMENT_INCORRECT"
);
require(
keccak256(abi.encode(msg.sender, _maximumAllowedMints, _tokenId)) ==
_messageHash,
"MESSAGE_INVALID"
);
require(
verifySignerAddress(_messageHash, _signature),
"SIGNATURE_VALIDATION_FAILED"
);
tokensMintedByAddress[msg.sender][_tokenId] += _numTokens;
_mint(msg.sender, _tokenId, _numTokens, "");
if (
tokenPresaleMaxSupply[_tokenId] != 0 &&
totalSupply(_tokenId) >= tokenPresaleMaxSupply[_tokenId]
) {
tokenPresaleSaleActive[_tokenId] = false;
}
}
function freezePayoutAddresses() external onlyOwner {
require(!payoutAddressesFrozen, "PAYOUT_ADDRESSES_ALREADY_FROZEN");
payoutAddressesFrozen = true;
}
function updatePayoutAddressesAndBasisPoints(
address[] calldata _payoutAddresses,
uint256[] calldata _payoutBasisPoints
) external onlyOwner {
require(!payoutAddressesFrozen, "PAYOUT_ADDRESSES_FROZEN");
require(
_payoutAddresses.length == _payoutBasisPoints.length,
"ARRAY_LENGTHS_MUST_MATCH"
);
uint256 totalBasisPoints = 0;
for (uint256 i = 0; i < _payoutBasisPoints.length; i++) {
totalBasisPoints += _payoutBasisPoints[i];
}
require(totalBasisPoints == 10000, "TOTAL_BASIS_POINTS_MUST_BE_10000");
payoutAddresses = _payoutAddresses;
payoutBasisPoints = _payoutBasisPoints;
}
function withdraw() external onlyOwner nonReentrant {
require(address(this).balance > 0, "CONTRACT_HAS_NO_BALANCE");
uint256 balance = address(this).balance;
for (uint256 i = 0; i < payoutAddresses.length; i++) {
uint256 amount = (balance * payoutBasisPoints[i]) / 10000;
(bool success, ) = payoutAddresses[i].call{value: amount}("");
require(success, "Transfer failed.");
}
}
function setApprovalForAll(
address operator,
bool approved
) public override {
super.setApprovalForAll(operator, approved);
}
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal override whenNotPaused {
super._beforeTokenTransfer(operator, from, to, ids, amounts, data);
}
}
파일 24 / 73 : EnumerableERC721.sol
pragma solidity 0.8.18;
import {ERC721Enumerable, ERC721} from "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {Counters} from "@openzeppelin/contracts/utils/Counters.sol";
contract EnumerableERC721 is ERC721Enumerable, Ownable {
using Counters for Counters.Counter;
Counters.Counter private supplyCounter;
uint256 public constant PRICE = 0.01 ether;
uint256 public constant MAX_SUPPLY = 1000;
string public baseTokenURI =
"ipfs://bafybeih5lgrstt7kredzhpcvmft2qefue5pl3ykrdktadw5w62zd7cbkja/";
bool public publicSaleActive;
constructor() ERC721("Test Contract", "TEST") {
supplyCounter.increment();
}
function _baseURI() internal view virtual override returns (string memory) {
return baseTokenURI;
}
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
baseTokenURI = _newBaseURI;
}
function publicMint(uint256 _mintNumber) external payable virtual {
require(msg.value == PRICE * _mintNumber, "INVALID_PRICE");
require((totalSupply() + _mintNumber) <= MAX_SUPPLY, "MINT_TOO_LARGE");
for (uint256 i = 0; i < _mintNumber; i++) {
_safeMint(msg.sender, supplyCounter.current());
supplyCounter.increment();
}
}
function gift(
address[] calldata _receivers,
uint256 _mintNumber
) external onlyOwner {
require(
(totalSupply() + (_receivers.length * _mintNumber)) <= MAX_SUPPLY,
"MINT_TOO_LARGE"
);
for (uint256 i = 0; i < _receivers.length; i++) {
for (uint256 j = 0; j < _mintNumber; j++) {
_safeMint(_receivers[i], supplyCounter.current());
supplyCounter.increment();
}
}
}
function withdraw() external onlyOwner {
payable(owner()).transfer(address(this).balance);
}
}
파일 25 / 73 : HeyMintDefaults.sol
pragma solidity 0.8.18;
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
interface IHeyMintDefaults {
function getCreditCardDefaultAddresses()
external
view
returns (address[] memory);
}
contract HeyMintDefaults is IHeyMintDefaults, Ownable {
address[] private creditCardDefaultAddresses;
function getCreditCardDefaultAddresses()
external
view
returns (address[] memory)
{
return creditCardDefaultAddresses;
}
function setCreditCardDefaultAddresses(
address[] calldata _newAddresses
) external onlyOwner {
creditCardDefaultAddresses = _newAddresses;
}
}
파일 26 / 73 : HeyMintERC721ABase.sol
pragma solidity 0.8.18;
import {HeyMintERC721AUpgradeable} from "./HeyMintERC721AUpgradeable.sol";
import {BaseConfig, HeyMintStorage} from "../libraries/HeyMintStorage.sol";
import {ERC721AUpgradeable, IERC721AUpgradeable} from "erc721a-upgradeable/contracts/ERC721AUpgradeable.sol";
import {ECDSAUpgradeable} from "@openzeppelin/contracts-upgradeable/utils/cryptography/ECDSAUpgradeable.sol";
import {IERC2981Upgradeable, IERC165Upgradeable} from "@openzeppelin/contracts-upgradeable/interfaces/IERC2981Upgradeable.sol";
contract HeyMintERC721ABase is HeyMintERC721AUpgradeable, IERC2981Upgradeable {
using HeyMintStorage for HeyMintStorage.State;
using ECDSAUpgradeable for bytes32;
address public constant CORI_SUBSCRIPTION_ADDRESS =
0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6;
address public constant EMPTY_SUBSCRIPTION_ADDRESS =
0x511af84166215d528ABf8bA6437ec4BEcF31934B;
function initialize(
string memory _name,
string memory _symbol,
BaseConfig memory _config
) public initializerERC721A initializer {
__ERC721A_init(_name, _symbol);
__Ownable_init();
__ReentrancyGuard_init();
__OperatorFilterer_init(
_config.enforceRoyalties == true
? CORI_SUBSCRIPTION_ADDRESS
: EMPTY_SUBSCRIPTION_ADDRESS,
true
);
HeyMintStorage.state().cfg = _config;
if (_config.publicSaleStartTime > 0 && _config.publicSaleEndTime == 0) {
HeyMintStorage.state().cfg.publicSaleEndTime =
_config.publicSaleStartTime +
520 weeks;
}
if (_config.publicSaleEndTime > 0 && _config.publicSaleStartTime == 0) {
HeyMintStorage.state().cfg.publicSaleStartTime = uint32(
block.timestamp
);
}
if (_config.presaleStartTime > 0 && _config.presaleEndTime == 0) {
HeyMintStorage.state().cfg.presaleEndTime =
_config.presaleStartTime +
520 weeks;
}
if (_config.presaleEndTime > 0 && _config.presaleStartTime == 0) {
HeyMintStorage.state().cfg.presaleStartTime = uint32(
block.timestamp
);
}
}
function pause() external onlyOwner {
_pause();
}
function unpause() external onlyOwner {
_unpause();
}
function supportsInterface(
bytes4 interfaceId
)
public
view
virtual
override(HeyMintERC721AUpgradeable, IERC165Upgradeable)
returns (bool)
{
return HeyMintERC721AUpgradeable.supportsInterface(interfaceId);
}
function reduceMaxSupply(uint24 _newMaxSupply) external onlyOwner {
BaseConfig storage cfg = HeyMintStorage.state().cfg;
require(_newMaxSupply < cfg.maxSupply, "NEW_MAX_SUPPLY_TOO_HIGH");
require(
_newMaxSupply >= totalSupply(),
"SUPPLY_LOWER_THAN_MINTED_TOKENS"
);
cfg.maxSupply = _newMaxSupply;
}
function _baseURI() internal view virtual override returns (string memory) {
return HeyMintStorage.state().cfg.uriBase;
}
function tokenURI(
uint256 tokenId
)
public
view
virtual
override(ERC721AUpgradeable, IERC721AUpgradeable)
returns (string memory)
{
if (!_exists(tokenId)) revert URIQueryForNonexistentToken();
HeyMintStorage.State storage state = HeyMintStorage.state();
string memory specificTokenURI = state.data.tokenURIs[tokenId];
if (bytes(specificTokenURI).length != 0) return specificTokenURI;
string memory baseURI = _baseURI();
if (bytes(baseURI).length == 0) return "";
uint256 burnTokenId = state.data.tokenIdToBurnTokenId[tokenId];
uint256 tokenURITokenId = state.advCfg.useBurnTokenIdForMetadata &&
burnTokenId != 0
? burnTokenId
: tokenId;
return string(abi.encodePacked(baseURI, _toString(tokenURITokenId)));
}
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
require(!HeyMintStorage.state().advCfg.metadataFrozen, "NOT_ACTIVE");
HeyMintStorage.state().cfg.uriBase = _newBaseURI;
}
function freezeMetadata() external onlyOwner {
HeyMintStorage.state().advCfg.metadataFrozen = true;
}
function royaltyInfo(
uint256,
uint256 _salePrice
) external view override returns (address, uint256) {
HeyMintStorage.State storage state = HeyMintStorage.state();
address payoutAddress = state.advCfg.royaltyPayoutAddress !=
address(0x0)
? state.advCfg.royaltyPayoutAddress
: owner();
if (payoutAddress == address(0x0)) {
return (payoutAddress, 0);
}
return (payoutAddress, (_salePrice * state.cfg.royaltyBps) / 10000);
}
function withdraw() external nonReentrant onlyOwner {
HeyMintStorage.State storage state = HeyMintStorage.state();
if (state.cfg.fundingEndsAt > 0) {
require(
state.data.fundingTargetReached,
"FUNDING_TARGET_NOT_REACHED"
);
}
if (state.advCfg.refundEndsAt > 0) {
require(!refundGuaranteeActive(), "REFUND_GUARANTEE_STILL_ACTIVE");
}
uint256 balance = address(this).balance;
if (state.advCfg.payoutAddresses.length == 0) {
(bool success, ) = payable(owner()).call{value: balance}("");
require(success, "TRANSFER_FAILED");
} else {
for (uint256 i = 0; i < state.advCfg.payoutAddresses.length; i++) {
uint256 amount = (balance * state.advCfg.payoutBasisPoints[i]) /
10000;
(bool success, ) = HeyMintStorage
.state()
.advCfg
.payoutAddresses[i]
.call{value: amount}("");
require(success, "TRANSFER_FAILED");
}
}
}
function setPublicSaleState(bool _saleActiveState) external onlyOwner {
HeyMintStorage.state().cfg.publicSaleActive = _saleActiveState;
}
function setPublicPrice(uint32 _publicPrice) external onlyOwner {
HeyMintStorage.state().cfg.publicPrice = _publicPrice;
}
function setPublicMintsAllowedPerAddress(
uint8 _mintsAllowed
) external onlyOwner {
HeyMintStorage.state().cfg.publicMintsAllowedPerAddress = _mintsAllowed;
}
function setPublicMintsAllowedPerTransaction(
uint8 _mintsAllowed
) external onlyOwner {
HeyMintStorage
.state()
.cfg
.publicMintsAllowedPerTransaction = _mintsAllowed;
}
function setPublicSaleStartTime(
uint32 _publicSaleStartTime
) external onlyOwner {
HeyMintStorage.state().cfg.publicSaleStartTime = _publicSaleStartTime;
}
function setPublicSaleEndTime(
uint32 _publicSaleEndTime
) external onlyOwner {
require(_publicSaleEndTime > block.timestamp, "TIME_IN_PAST");
HeyMintStorage.state().cfg.publicSaleEndTime = _publicSaleEndTime;
}
function setUsePublicSaleTimes(
bool _usePublicSaleTimes
) external onlyOwner {
HeyMintStorage.state().cfg.usePublicSaleTimes = _usePublicSaleTimes;
}
function refundGuaranteeActive() public view returns (bool) {
HeyMintStorage.State storage state = HeyMintStorage.state();
return block.timestamp < state.advCfg.refundEndsAt;
}
}
파일 27 / 73 : HeyMintERC721AExtensionA.sol
pragma solidity 0.8.18;
import {HeyMintERC721AUpgradeable} from "./HeyMintERC721AUpgradeable.sol";
import {BaseConfig, AdvancedConfig, BurnToken, HeyMintStorage} from "../libraries/HeyMintStorage.sol";
contract HeyMintERC721AExtensionA is HeyMintERC721AUpgradeable {
using HeyMintStorage for HeyMintStorage.State;
event Stake(uint256 indexed tokenId);
event Unstake(uint256 indexed tokenId);
event Loan(address from, address to, uint256 tokenId);
event LoanRetrieved(address from, address to, uint256 tokenId);
function getSettings()
external
view
returns (
BaseConfig memory,
AdvancedConfig memory,
BurnToken[] memory,
bool,
bool,
bool,
uint256
)
{
HeyMintStorage.State storage state = HeyMintStorage.state();
return (
state.cfg,
state.advCfg,
state.burnTokens,
state.data.advancedConfigInitialized,
state.data.fundingTargetReached,
state.data.fundingSuccessDetermined,
state.data.currentLoanTotal
);
}
function updateBaseConfig(
BaseConfig memory _baseConfig
) external onlyOwner {
HeyMintStorage.State storage state = HeyMintStorage.state();
require(
_baseConfig.projectId == state.cfg.projectId,
"CANNOT_UPDATE_CONSTANT_VARIABLE"
);
require(
_baseConfig.maxSupply <= state.cfg.maxSupply,
"CANNOT_UPDATE_CONSTANT_VARIABLE"
);
require(
_baseConfig.presaleMaxSupply <= state.cfg.presaleMaxSupply,
"CANNOT_UPDATE_CONSTANT_VARIABLE"
);
require(
_baseConfig.fundingEndsAt == state.cfg.fundingEndsAt,
"CANNOT_UPDATE_CONSTANT_VARIABLE"
);
require(
_baseConfig.fundingTarget == state.cfg.fundingTarget,
"CANNOT_UPDATE_CONSTANT_VARIABLE"
);
require(
_baseConfig.heyMintFeeActive == state.cfg.heyMintFeeActive,
"CANNOT_UPDATE_CONSTANT_VARIABLE"
);
require(
_baseConfig.affiliateBasisPoints == state.cfg.affiliateBasisPoints,
"CANNOT_UPDATE_CONSTANT_VARIABLE"
);
require(
_baseConfig.presaleAffiliateMintEnabled ==
state.cfg.presaleAffiliateMintEnabled,
"CANNOT_UPDATE_CONSTANT_VARIABLE"
);
require(
_baseConfig.publicSaleAffiliateMintEnabled ==
state.cfg.publicSaleAffiliateMintEnabled,
"CANNOT_UPDATE_CONSTANT_VARIABLE"
);
if (state.advCfg.metadataFrozen) {
require(
keccak256(abi.encode(_baseConfig.uriBase)) ==
keccak256(abi.encode(state.cfg.uriBase)),
"CANNOT_UPDATE_CONSTANT_VARIABLE"
);
}
state.cfg = _baseConfig;
}
function updateAdvancedConfig(
AdvancedConfig memory _advancedConfig
) external onlyOwner {
HeyMintStorage.State storage state = HeyMintStorage.state();
if (state.advCfg.metadataFrozen) {
require(
_advancedConfig.metadataFrozen,
"CANNOT_UPDATE_CONSTANT_VARIABLE"
);
}
if (state.advCfg.soulbindAdminTransfersPermanentlyDisabled) {
require(
_advancedConfig.soulbindAdminTransfersPermanentlyDisabled,
"CANNOT_UPDATE_CONSTANT_VARIABLE"
);
}
if (state.advCfg.refundEndsAt > 0) {
require(
_advancedConfig.refundPrice == state.advCfg.refundPrice,
"CANNOT_UPDATE_CONSTANT_VARIABLE"
);
require(
_advancedConfig.refundEndsAt >= state.advCfg.refundEndsAt,
"CANNOT_UPDATE_CONSTANT_VARIABLE"
);
} else if (
_advancedConfig.refundEndsAt > 0 || _advancedConfig.refundPrice > 0
) {
require(
_advancedConfig.refundPrice > 0,
"REFUND_PRICE_MUST_BE_SET"
);
require(
_advancedConfig.refundEndsAt > 0,
"REFUND_DURATION_MUST_BE_SET"
);
}
if (!state.data.advancedConfigInitialized) {
state.data.advancedConfigInitialized = true;
}
uint256 payoutAddressesLength = _advancedConfig.payoutAddresses.length;
uint256 payoutBasisPointsLength = _advancedConfig
.payoutBasisPoints
.length;
if (state.advCfg.payoutAddressesFrozen) {
require(
_advancedConfig.payoutAddressesFrozen,
"CANNOT_UPDATE_CONSTANT_VARIABLE"
);
require(
payoutAddressesLength == state.advCfg.payoutAddresses.length,
"CANNOT_UPDATE_CONSTANT_VARIABLE"
);
require(
payoutBasisPointsLength ==
state.advCfg.payoutBasisPoints.length,
"CANNOT_UPDATE_CONSTANT_VARIABLE"
);
for (uint256 i = 0; i < payoutAddressesLength; i++) {
require(
_advancedConfig.payoutAddresses[i] ==
state.advCfg.payoutAddresses[i],
"CANNOT_UPDATE_CONSTANT_VARIABLE"
);
require(
_advancedConfig.payoutBasisPoints[i] ==
state.advCfg.payoutBasisPoints[i],
"CANNOT_UPDATE_CONSTANT_VARIABLE"
);
}
} else if (payoutAddressesLength > 0) {
require(
payoutAddressesLength == payoutBasisPointsLength,
"ARRAY_LENGTHS_MUST_MATCH"
);
uint256 totalBasisPoints = 0;
for (uint256 i = 0; i < payoutBasisPointsLength; i++) {
totalBasisPoints += _advancedConfig.payoutBasisPoints[i];
}
require(totalBasisPoints == 10000, "BASIS_POINTS_MUST_EQUAL_10000");
}
require(
(state.advCfg.subscriptionPeriod == 0 ||
_advancedConfig.subscriptionPeriod ==
state.advCfg.subscriptionPeriod),
"CANNOT_UPDATE_CONSTANT_VARIABLE"
);
require(
(state.advCfg.subscriptionPrice == 0 ||
_advancedConfig.subscriptionPrice ==
state.advCfg.subscriptionPrice),
"CANNOT_UPDATE_CONSTANT_VARIABLE"
);
require(
state.advCfg.subscriptionErc20Address == address(0) ||
_advancedConfig.subscriptionErc20Address ==
state.advCfg.subscriptionErc20Address,
"CANNOT_UPDATE_CONSTANT_VARIABLE"
);
state.advCfg = _advancedConfig;
}
}
파일 28 / 73 : HeyMintERC721AExtensionB.sol
pragma solidity 0.8.18;
import {HeyMintERC721AUpgradeable} from "./HeyMintERC721AUpgradeable.sol";
import {HeyMintStorage, BaseConfig} from "../libraries/HeyMintStorage.sol";
import {ECDSAUpgradeable} from "@openzeppelin/contracts-upgradeable/utils/cryptography/ECDSAUpgradeable.sol";
contract HeyMintERC721AExtensionB is HeyMintERC721AUpgradeable {
using HeyMintStorage for HeyMintStorage.State;
using ECDSAUpgradeable for bytes32;
event HeyMintAffiliatePaid(address to, uint256 numTokens, uint256 value);
function presalePriceInWei() public view returns (uint256) {
return uint256(HeyMintStorage.state().cfg.presalePrice) * 10 ** 13;
}
function setPresaleState(bool _saleActiveState) external onlyOwner {
HeyMintStorage.state().cfg.presaleActive = _saleActiveState;
}
function setPresalePrice(uint32 _presalePrice) external onlyOwner {
HeyMintStorage.state().cfg.presalePrice = _presalePrice;
}
function reducePresaleMaxSupply(
uint24 _newPresaleMaxSupply
) external onlyOwner {
BaseConfig storage cfg = HeyMintStorage.state().cfg;
require(
_newPresaleMaxSupply < cfg.presaleMaxSupply,
"NEW_MAX_SUPPLY_TOO_HIGH"
);
cfg.presaleMaxSupply = _newPresaleMaxSupply;
}
function setPresaleMintsAllowedPerAddress(
uint8 _mintsAllowed
) external onlyOwner {
HeyMintStorage
.state()
.cfg
.presaleMintsAllowedPerAddress = _mintsAllowed;
}
function setPresaleMintsAllowedPerTransaction(
uint8 _mintsAllowed
) external onlyOwner {
HeyMintStorage
.state()
.cfg
.presaleMintsAllowedPerTransaction = _mintsAllowed;
}
function setPresaleSignerAddress(
address _presaleSignerAddress
) external onlyOwner {
HeyMintStorage.state().cfg.presaleSignerAddress = _presaleSignerAddress;
}
function setPresaleStartTime(uint32 _presaleStartTime) external onlyOwner {
HeyMintStorage.state().cfg.presaleStartTime = _presaleStartTime;
}
function setPresaleEndTime(uint32 _presaleEndTime) external onlyOwner {
require(_presaleEndTime > block.timestamp, "TIME_IN_PAST");
HeyMintStorage.state().cfg.presaleEndTime = _presaleEndTime;
}
function setUsePresaleTimes(bool _usePresaleTimes) external onlyOwner {
HeyMintStorage.state().cfg.usePresaleTimes = _usePresaleTimes;
}
function presaleTimeIsActive() public view returns (bool) {
BaseConfig storage cfg = HeyMintStorage.state().cfg;
if (
cfg.usePresaleTimes == false ||
cfg.presaleStartTime == 0 ||
cfg.presaleEndTime == 0
) {
return true;
}
return
block.timestamp >= cfg.presaleStartTime &&
block.timestamp <= cfg.presaleEndTime;
}
function _presaleMint(
bytes32 _messageHash,
bytes calldata _signature,
uint256 _numTokens,
uint256 _maximumAllowedMints
) internal {
HeyMintStorage.State storage state = HeyMintStorage.state();
BaseConfig storage cfg = state.cfg;
require(cfg.presaleActive, "NOT_ACTIVE");
require(presaleTimeIsActive(), "NOT_ACTIVE");
uint256 qtyAlreadyMinted = _numberMinted(msg.sender);
require(
cfg.presaleMintsAllowedPerAddress == 0 ||
qtyAlreadyMinted + _numTokens <=
cfg.presaleMintsAllowedPerAddress,
"MAX_MINTS_EXCEEDED"
);
require(
cfg.presaleMintsAllowedPerTransaction == 0 ||
_numTokens <= cfg.presaleMintsAllowedPerTransaction,
"MAX_MINTS_EXCEEDED"
);
require(
qtyAlreadyMinted + _numTokens <= _maximumAllowedMints,
"MAX_MINTS_EXCEEDED"
);
require(
cfg.presaleMaxSupply == 0 ||
totalSupply() + _numTokens <= cfg.presaleMaxSupply,
"MAX_SUPPLY_EXCEEDED"
);
require(
totalSupply() + _numTokens <= cfg.maxSupply,
"MAX_SUPPLY_EXCEEDED"
);
uint256 presalePrice = presalePriceInWei();
if (cfg.heyMintFeeActive) {
uint256 heymintFee = _numTokens * heymintFeePerToken();
require(
msg.value == presalePrice * _numTokens + heymintFee,
"INVALID_PRICE_PAID"
);
(bool success, ) = heymintPayoutAddress.call{value: heymintFee}("");
require(success, "TRANSFER_FAILED");
} else {
require(
msg.value == presalePrice * _numTokens,
"INVALID_PRICE_PAID"
);
}
require(
keccak256(abi.encode(msg.sender, _maximumAllowedMints)) ==
_messageHash,
"MESSAGE_INVALID"
);
require(
verifySignerAddress(_messageHash, _signature),
"INVALID_SIGNATURE"
);
if (cfg.fundingEndsAt > 0) {
uint256 firstTokenIdToMint = _nextTokenId();
for (uint256 i = 0; i < _numTokens; i++) {
HeyMintStorage.state().data.pricePaid[
firstTokenIdToMint + i
] = presalePrice;
}
}
_safeMint(msg.sender, _numTokens);
if (
cfg.presaleMaxSupply != 0 && totalSupply() >= cfg.presaleMaxSupply
) {
cfg.presaleActive = false;
}
}
function presaleMint(
bytes32 _messageHash,
bytes calldata _signature,
uint256 _numTokens,
uint256 _maximumAllowedMints
) external payable nonReentrant {
_presaleMint(
_messageHash,
_signature,
_numTokens,
_maximumAllowedMints
);
}
function isPresaleAffiliateMintActive() public view returns (bool) {
HeyMintStorage.State storage state = HeyMintStorage.state();
return (state.cfg.presaleSignerAddress != address(0) &&
state.cfg.presaleAffiliateMintEnabled &&
state.cfg.presaleActive &&
state.cfg.presalePrice > 0 &&
state.cfg.affiliateBasisPoints > 0 &&
(!state.cfg.usePresaleTimes ||
block.timestamp >= state.cfg.presaleStartTime) &&
(!state.cfg.usePresaleTimes ||
block.timestamp < state.cfg.presaleEndTime));
}
function affiliatePresaleMint(
address _affPaymentAddress,
bytes32 _affMessageHash,
bytes calldata _affSignature,
bytes32 _messageHash,
bytes calldata _signature,
uint256 _numTokens,
uint256 _maximumAllowedMints
) external payable nonReentrant {
require(isPresaleAffiliateMintActive(), "NOT_ACTIVE");
HeyMintStorage.State storage state = HeyMintStorage.state();
require(
keccak256(abi.encode(state.cfg.projectId, _affPaymentAddress)) ==
_affMessageHash,
"MESSAGE_INVALID"
);
require(
verifySignerAddress(_affMessageHash, _affSignature),
"INVALID_SIGNATURE"
);
_presaleMint(
_messageHash,
_signature,
_numTokens,
_maximumAllowedMints
);
uint256 affFee = (_numTokens *
presalePriceInWei() *
state.cfg.affiliateBasisPoints) / 10000;
(bool ok, ) = _affPaymentAddress.call{value: affFee}("");
require(ok, "TRANSFER_FAILED");
emit HeyMintAffiliatePaid(_affPaymentAddress, _numTokens, affFee);
}
}
파일 29 / 73 : HeyMintERC721AExtensionC.sol
pragma solidity 0.8.18;
import {HeyMintERC721AUpgradeable} from "./HeyMintERC721AUpgradeable.sol";
import {AdvancedConfig, Data, BaseConfig, HeyMintStorage} from "../libraries/HeyMintStorage.sol";
import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
contract HeyMintERC721AExtensionC is HeyMintERC721AUpgradeable {
using HeyMintStorage for HeyMintStorage.State;
event Stake(uint256 indexed tokenId);
event Unstake(uint256 indexed tokenId);
event HeyMintAffiliatePaid(address to, uint256 numTokens, uint256 value);
function setTokenURIs(
uint256[] calldata _tokenIds,
string[] calldata _newURIs
) external onlyOwner {
require(!HeyMintStorage.state().advCfg.metadataFrozen, "NOT_ACTIVE");
uint256 tokenIdsLength = _tokenIds.length;
require(tokenIdsLength == _newURIs.length);
for (uint256 i = 0; i < tokenIdsLength; i++) {
HeyMintStorage.state().data.tokenURIs[_tokenIds[i]] = _newURIs[i];
}
}
function baseTokenURI() external view returns (string memory) {
return HeyMintStorage.state().cfg.uriBase;
}
function _publicSaleTimeIsActive() internal view returns (bool) {
HeyMintStorage.State storage state = HeyMintStorage.state();
if (
state.cfg.usePublicSaleTimes == false ||
state.cfg.publicSaleStartTime == 0 ||
state.cfg.publicSaleEndTime == 0
) {
return true;
}
return
block.timestamp >= state.cfg.publicSaleStartTime &&
block.timestamp <= state.cfg.publicSaleEndTime;
}
function isPublicAffiliateMintActive() public view returns (bool) {
HeyMintStorage.State storage state = HeyMintStorage.state();
return (state.cfg.presaleSignerAddress != address(0) &&
state.cfg.publicSaleAffiliateMintEnabled &&
state.cfg.publicSaleActive &&
state.cfg.publicPrice > 0 &&
state.cfg.affiliateBasisPoints > 0 &&
(!state.cfg.usePublicSaleTimes ||
block.timestamp >= state.cfg.publicSaleStartTime) &&
(!state.cfg.usePublicSaleTimes ||
block.timestamp < state.cfg.publicSaleEndTime));
}
function _creditCardMint(uint256 _numTokens, address _to) internal {
HeyMintStorage.State storage state = HeyMintStorage.state();
require(state.cfg.publicSaleActive, "NOT_ACTIVE");
require(_publicSaleTimeIsActive(), "NOT_ACTIVE");
require(
state.cfg.publicMintsAllowedPerAddress == 0 ||
_numberMinted(_to) + _numTokens <=
state.cfg.publicMintsAllowedPerAddress,
"MAX_MINTS_EXCEEDED"
);
require(
state.cfg.publicMintsAllowedPerTransaction == 0 ||
_numTokens <= state.cfg.publicMintsAllowedPerTransaction,
"MAX_MINTS_EXCEEDED"
);
require(
totalSupply() + _numTokens <= state.cfg.maxSupply,
"MAX_SUPPLY_EXCEEDED"
);
uint256 publicPrice = publicPriceInWei();
if (state.cfg.heyMintFeeActive) {
uint256 heymintFee = _numTokens * heymintFeePerToken();
require(
msg.value == publicPrice * _numTokens + heymintFee,
"INVALID_PRICE_PAID"
);
(bool success, ) = heymintPayoutAddress.call{value: heymintFee}("");
require(success, "TRANSFER_FAILED");
} else {
require(
msg.value == publicPrice * _numTokens,
"INVALID_PRICE_PAID"
);
}
if (state.cfg.fundingEndsAt > 0) {
uint256 firstTokenIdToMint = _nextTokenId();
for (uint256 i = 0; i < _numTokens; i++) {
HeyMintStorage.state().data.pricePaid[
firstTokenIdToMint + i
] = publicPrice;
}
}
_safeMint(_to, _numTokens);
if (totalSupply() >= state.cfg.maxSupply) {
state.cfg.publicSaleActive = false;
}
}
function creditCardMint(
uint256 _numTokens,
address _to
) external payable nonReentrant {
_creditCardMint(_numTokens, _to);
}
function affiliateCreditCardMint(
address _affPaymentAddress,
bytes32 _affMessageHash,
bytes calldata _affSignature,
uint256 _numTokens,
address _to
) external payable nonReentrant {
require(isPublicAffiliateMintActive(), "NOT_ACTIVE");
HeyMintStorage.State storage state = HeyMintStorage.state();
require(
keccak256(abi.encode(state.cfg.projectId, _affPaymentAddress)) ==
_affMessageHash,
"MESSAGE_INVALID"
);
require(
verifySignerAddress(_affMessageHash, _affSignature),
"INVALID_SIGNATURE"
);
_creditCardMint(_numTokens, _to);
uint256 affFee = (_numTokens *
publicPriceInWei() *
state.cfg.affiliateBasisPoints) / 10000;
(bool ok, ) = _affPaymentAddress.call{value: affFee}("");
require(ok, "TRANSFER_FAILED");
emit HeyMintAffiliatePaid(_affPaymentAddress, _numTokens, affFee);
}
function setSoulboundAdminAddress(
address _adminAddress
) external onlyOwner {
AdvancedConfig storage advCfg = HeyMintStorage.state().advCfg;
require(!advCfg.soulbindAdminTransfersPermanentlyDisabled);
advCfg.soulboundAdminAddress = _adminAddress;
}
function disableSoulbindAdminTransfersPermanently() external onlyOwner {
AdvancedConfig storage advCfg = HeyMintStorage.state().advCfg;
advCfg.soulboundAdminAddress = address(0);
advCfg.soulbindAdminTransfersPermanentlyDisabled = true;
}
function setSoulbindingState(bool _soulbindingActive) external onlyOwner {
HeyMintStorage.state().cfg.soulbindingActive = _soulbindingActive;
}
function soulboundAdminTransfer(
address _from,
address _to,
uint256 _tokenId
) external {
HeyMintStorage.State storage state = HeyMintStorage.state();
address adminAddress = state.advCfg.soulboundAdminAddress == address(0)
? owner()
: state.advCfg.soulboundAdminAddress;
require(msg.sender == adminAddress, "NOT_ADMIN");
require(state.cfg.soulbindingActive, "NOT_ACTIVE");
require(
!state.advCfg.soulbindAdminTransfersPermanentlyDisabled,
"NOT_ACTIVE"
);
state.data.soulboundAdminTransferInProgress = true;
_directApproveMsgSenderFor(_tokenId);
safeTransferFrom(_from, _to, _tokenId);
state.data.soulboundAdminTransferInProgress = false;
}
function setStakingState(bool _stakingState) external onlyOwner {
HeyMintStorage.state().advCfg.stakingActive = _stakingState;
}
function stakeTokens(uint256[] calldata _tokenIds) external {
HeyMintStorage.State storage state = HeyMintStorage.state();
require(state.advCfg.stakingActive, "NOT_ACTIVE");
for (uint256 i = 0; i < _tokenIds.length; i++) {
uint256 tokenId = _tokenIds[i];
require(ownerOf(tokenId) == msg.sender, "MUST_OWN_TOKEN");
if (state.data.currentTimeStaked[tokenId] == 0) {
state.data.currentTimeStaked[tokenId] = block.timestamp;
emit Stake(tokenId);
}
}
}
function unstakeTokens(uint256[] calldata _tokenIds) external {
Data storage data = HeyMintStorage.state().data;
for (uint256 i = 0; i < _tokenIds.length; i++) {
uint256 tokenId = _tokenIds[i];
require(ownerOf(tokenId) == msg.sender, "MUST_OWN_TOKEN");
if (data.currentTimeStaked[tokenId] != 0) {
data.totalTimeStaked[tokenId] +=
block.timestamp -
data.currentTimeStaked[tokenId];
data.currentTimeStaked[tokenId] = 0;
emit Unstake(tokenId);
}
}
}
function stakingTransfer(
address _from,
address _to,
uint256 _tokenId
) external {
Data storage data = HeyMintStorage.state().data;
require(ownerOf(_tokenId) == msg.sender, "MUST_OWN_TOKEN");
data.stakingTransferActive = true;
safeTransferFrom(_from, _to, _tokenId);
data.stakingTransferActive = false;
}
function adminUnstake(uint256 _tokenId) external onlyOwner {
Data storage data = HeyMintStorage.state().data;
require(HeyMintStorage.state().data.currentTimeStaked[_tokenId] != 0);
data.totalTimeStaked[_tokenId] +=
block.timestamp -
data.currentTimeStaked[_tokenId];
data.currentTimeStaked[_tokenId] = 0;
emit Unstake(_tokenId);
}
function totalTokenStakeTime(
uint256 _tokenId
) external view returns (uint256) {
Data storage data = HeyMintStorage.state().data;
uint256 currentStakeStartTime = data.currentTimeStaked[_tokenId];
if (currentStakeStartTime != 0) {
return
(block.timestamp - currentStakeStartTime) +
data.totalTimeStaked[_tokenId];
}
return data.totalTimeStaked[_tokenId];
}
function currentTokenStakeTime(
uint256 _tokenId
) external view returns (uint256) {
uint256 currentStakeStartTime = HeyMintStorage
.state()
.data
.currentTimeStaked[_tokenId];
if (currentStakeStartTime != 0) {
return block.timestamp - currentStakeStartTime;
}
return 0;
}
function setFreeClaimState(bool _freeClaimActive) external onlyOwner {
AdvancedConfig storage advCfg = HeyMintStorage.state().advCfg;
if (_freeClaimActive) {
require(
advCfg.freeClaimContractAddress != address(0),
"NOT_CONFIGURED"
);
require(advCfg.mintsPerFreeClaim != 0, "NOT_CONFIGURED");
}
advCfg.freeClaimActive = _freeClaimActive;
}
function setFreeClaimContractAddress(
address _freeClaimContractAddress
) external onlyOwner {
HeyMintStorage
.state()
.advCfg
.freeClaimContractAddress = _freeClaimContractAddress;
}
function updateMintsPerFreeClaim(
uint8 _mintsPerFreeClaim
) external onlyOwner {
HeyMintStorage.state().advCfg.mintsPerFreeClaim = _mintsPerFreeClaim;
}
function checkFreeClaimEligibility(
uint256[] calldata _tokenIDs
) external view returns (bool[] memory) {
Data storage data = HeyMintStorage.state().data;
bool[] memory eligible = new bool[](_tokenIDs.length);
for (uint256 i = 0; i < _tokenIDs.length; i++) {
eligible[i] = !data.freeClaimUsed[_tokenIDs[i]];
}
return eligible;
}
function freeClaim(
uint256[] calldata _tokenIDs
) external payable nonReentrant {
HeyMintStorage.State storage state = HeyMintStorage.state();
uint256 tokenIdsLength = _tokenIDs.length;
uint256 totalMints = tokenIdsLength * state.advCfg.mintsPerFreeClaim;
require(
state.advCfg.freeClaimContractAddress != address(0),
"NOT_CONFIGURED"
);
require(state.advCfg.mintsPerFreeClaim != 0, "NOT_CONFIGURED");
require(state.advCfg.freeClaimActive, "NOT_ACTIVE");
require(
totalSupply() + totalMints <= state.cfg.maxSupply,
"MAX_SUPPLY_EXCEEDED"
);
if (state.cfg.heyMintFeeActive) {
uint256 heymintFee = totalMints * heymintFeePerToken();
require(msg.value == heymintFee, "PAYMENT_INCORRECT");
(bool success, ) = heymintPayoutAddress.call{value: heymintFee}("");
require(success, "TRANSFER_FAILED");
}
IERC721 ExternalERC721FreeClaimContract = IERC721(
state.advCfg.freeClaimContractAddress
);
for (uint256 i = 0; i < tokenIdsLength; i++) {
require(
ExternalERC721FreeClaimContract.ownerOf(_tokenIDs[i]) ==
msg.sender,
"MUST_OWN_TOKEN"
);
require(
!state.data.freeClaimUsed[_tokenIDs[i]],
"TOKEN_ALREADY_CLAIMED"
);
state.data.freeClaimUsed[_tokenIDs[i]] = true;
}
_safeMint(msg.sender, totalMints);
}
function setGenerateRandomHashState(
bool _randomHashActive
) external onlyOwner {
BaseConfig storage cfg = HeyMintStorage.state().cfg;
cfg.randomHashActive = _randomHashActive;
}
function getRandomHashes(
uint256[] calldata _tokenIDs
) external view returns (bytes32[] memory) {
Data storage data = HeyMintStorage.state().data;
bytes32[] memory randomHashes = new bytes32[](_tokenIDs.length);
for (uint256 i = 0; i < _tokenIDs.length; i++) {
randomHashes[i] = data.randomHashStore[_tokenIDs[i]];
}
return randomHashes;
}
}
파일 30 / 73 : HeyMintERC721AExtensionD.sol
pragma solidity 0.8.18;
import {HeyMintERC721AUpgradeable} from "./HeyMintERC721AUpgradeable.sol";
import {AdvancedConfig, HeyMintStorage} from "../libraries/HeyMintStorage.sol";
import {MerkleProofUpgradeable} from "@openzeppelin/contracts-upgradeable/utils/cryptography/MerkleProofUpgradeable.sol";
import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
contract HeyMintERC721AExtensionD is HeyMintERC721AUpgradeable {
using HeyMintStorage for HeyMintStorage.State;
event Loan(address from, address to, uint256 tokenId);
event LoanRetrieved(address from, address to, uint256 tokenId);
address public constant heymintAdminAddress =
0x52EA5F96f004d174470901Ba3F1984D349f0D3eF;
address public constant burnAddress =
0x000000000000000000000000000000000000dEaD;
function setHeymintFeePerToken(uint256 _heymintFeePerToken) external {
require(msg.sender == heymintAdminAddress, "MUST_BE_HEYMINT_ADMIN");
HeyMintStorage.state().data.heymintFeePerToken = _heymintFeePerToken;
}
function setHeymintFeeState(bool _feeActive) external {
require(msg.sender == heymintAdminAddress, "MUST_BE_HEYMINT_ADMIN");
HeyMintStorage.state().cfg.heyMintFeeActive = _feeActive;
}
function remainingDepositPaymentInWei() public view returns (uint256) {
return
uint256(HeyMintStorage.state().advCfg.remainingDepositPayment) *
10 ** 13;
}
function setDepositClaimState(bool _depositClaimActive) external onlyOwner {
AdvancedConfig storage advCfg = HeyMintStorage.state().advCfg;
if (_depositClaimActive) {
require(advCfg.depositMerkleRoot != bytes32(0), "NOT_CONFIGURED");
require(
advCfg.depositContractAddress != address(0),
"NOT_CONFIGURED"
);
}
advCfg.depositClaimActive = _depositClaimActive;
}
function setDepositMerkleRoot(
bytes32 _depositMerkleRoot
) external onlyOwner {
HeyMintStorage.state().advCfg.depositMerkleRoot = _depositMerkleRoot;
}
function setDepositContractAddress(
address _depositContractAddress
) external onlyOwner {
HeyMintStorage
.state()
.advCfg
.depositContractAddress = _depositContractAddress;
}
function setRemainingDepositPayment(
uint32 _remainingDepositPayment
) external onlyOwner {
HeyMintStorage
.state()
.advCfg
.remainingDepositPayment = _remainingDepositPayment;
}
function burnDepositTokensToMint(
uint256[] calldata _tokenIds,
bytes32[][] calldata _merkleProofs
) external payable nonReentrant {
HeyMintStorage.State storage state = HeyMintStorage.state();
require(state.advCfg.depositMerkleRoot != bytes32(0), "NOT_CONFIGURED");
require(
state.advCfg.depositContractAddress != address(0),
"NOT_CONFIGURED"
);
require(state.advCfg.depositClaimActive, "NOT_ACTIVE");
uint256 numberOfTokens = _tokenIds.length;
require(numberOfTokens > 0, "NO_TOKEN_IDS_PROVIDED");
require(
numberOfTokens == _merkleProofs.length,
"ARRAY_LENGTHS_MUST_MATCH"
);
require(
totalSupply() + numberOfTokens <= state.cfg.maxSupply,
"MAX_SUPPLY_EXCEEDED"
);
require(
msg.value == remainingDepositPaymentInWei() * numberOfTokens,
"INCORRECT_REMAINING_PAYMENT"
);
IERC721 DepositContract = IERC721(state.advCfg.depositContractAddress);
for (uint256 i = 0; i < numberOfTokens; i++) {
require(
MerkleProofUpgradeable.verify(
_merkleProofs[i],
state.advCfg.depositMerkleRoot,
keccak256(abi.encodePacked(_tokenIds[i]))
),
"INVALID_MERKLE_PROOF"
);
require(
DepositContract.ownerOf(_tokenIds[i]) == msg.sender,
"MUST_OWN_TOKEN"
);
DepositContract.transferFrom(msg.sender, burnAddress, _tokenIds[i]);
}
_safeMint(msg.sender, numberOfTokens);
}
function fundingTargetInWei() public view returns (uint256) {
return uint256(HeyMintStorage.state().cfg.fundingTarget) * 10 ** 16;
}
function determineFundingSuccess() external {
HeyMintStorage.State storage state = HeyMintStorage.state();
require(state.cfg.fundingEndsAt > 0, "NOT_CONFIGURED");
require(
address(this).balance >= fundingTargetInWei(),
"FUNDING_TARGET_NOT_MET"
);
require(
!state.data.fundingSuccessDetermined,
"SUCCESS_ALREADY_DETERMINED"
);
state.data.fundingTargetReached = true;
state.data.fundingSuccessDetermined = true;
}
function burnToRefund(uint256[] calldata _tokenIds) external nonReentrant {
HeyMintStorage.State storage state = HeyMintStorage.state();
require(state.cfg.fundingEndsAt > 0, "NOT_CONFIGURED");
require(
block.timestamp > uint256(state.cfg.fundingEndsAt) + 1 days,
"FUNDING_PERIOD_STILL_ACTIVE"
);
require(!state.data.fundingTargetReached, "FUNDING_TARGET_WAS_MET");
require(
address(this).balance < fundingTargetInWei(),
"FUNDING_TARGET_WAS_MET"
);
uint256 totalRefund = 0;
for (uint256 i = 0; i < _tokenIds.length; i++) {
require(ownerOf(_tokenIds[i]) == msg.sender, "MUST_OWN_TOKEN");
require(
state.data.pricePaid[_tokenIds[i]] > 0,
"TOKEN_WAS_NOT_PURCHASED"
);
safeTransferFrom(
msg.sender,
0x000000000000000000000000000000000000dEaD,
_tokenIds[i]
);
totalRefund += state.data.pricePaid[_tokenIds[i]];
}
(bool success, ) = payable(msg.sender).call{value: totalRefund}("");
require(success, "TRANSFER_FAILED");
}
function setLoaningActive(bool _loaningActive) external onlyOwner {
HeyMintStorage.state().advCfg.loaningActive = _loaningActive;
}
function loan(uint256 _tokenId, address _receiver) external nonReentrant {
HeyMintStorage.State storage state = HeyMintStorage.state();
require(
state.data.tokenOwnersOnLoan[_tokenId] == address(0),
"CANNOT_LOAN_BORROWED_TOKEN"
);
require(state.advCfg.loaningActive, "NOT_ACTIVE");
require(ownerOf(_tokenId) == msg.sender, "MUST_OWN_TOKEN");
require(_receiver != msg.sender, "CANNOT_LOAN_TO_SELF");
safeTransferFrom(msg.sender, _receiver, _tokenId);
state.data.tokenOwnersOnLoan[_tokenId] = msg.sender;
state.data.totalLoanedPerAddress[msg.sender] += 1;
state.data.currentLoanTotal += 1;
emit Loan(msg.sender, _receiver, _tokenId);
}
function retrieveLoan(uint256 _tokenId) external nonReentrant {
HeyMintStorage.State storage state = HeyMintStorage.state();
address borrowerAddress = ownerOf(_tokenId);
require(borrowerAddress != msg.sender, "MUST_OWN_TOKEN");
require(
state.data.tokenOwnersOnLoan[_tokenId] == msg.sender,
"MUST_OWN_TOKEN"
);
delete state.data.tokenOwnersOnLoan[_tokenId];
state.data.totalLoanedPerAddress[msg.sender] -= 1;
state.data.currentLoanTotal -= 1;
_directApproveMsgSenderFor(_tokenId);
safeTransferFrom(borrowerAddress, msg.sender, _tokenId);
emit LoanRetrieved(borrowerAddress, msg.sender, _tokenId);
}
function adminRetrieveLoan(uint256 _tokenId) external onlyOwner {
HeyMintStorage.State storage state = HeyMintStorage.state();
address borrowerAddress = ownerOf(_tokenId);
address loanerAddress = state.data.tokenOwnersOnLoan[_tokenId];
require(loanerAddress != address(0), "TOKEN_NOT_LOANED");
delete state.data.tokenOwnersOnLoan[_tokenId];
state.data.totalLoanedPerAddress[loanerAddress] -= 1;
state.data.currentLoanTotal -= 1;
_directApproveMsgSenderFor(_tokenId);
safeTransferFrom(borrowerAddress, loanerAddress, _tokenId);
emit LoanRetrieved(borrowerAddress, loanerAddress, _tokenId);
}
function totalLoaned() public view returns (uint256) {
return HeyMintStorage.state().data.currentLoanTotal;
}
function loanedBalanceOf(address _owner) public view returns (uint256) {
return HeyMintStorage.state().data.totalLoanedPerAddress[_owner];
}
function loanedTokensByAddress(
address _owner
) external view returns (uint256[] memory) {
uint256 totalTokensLoaned = loanedBalanceOf(_owner);
uint256 mintedSoFar = totalSupply();
uint256 tokenIdsIdx = 0;
uint256[] memory allTokenIds = new uint256[](totalTokensLoaned);
for (
uint256 i = 1;
i <= mintedSoFar && tokenIdsIdx != totalTokensLoaned;
i++
) {
if (HeyMintStorage.state().data.tokenOwnersOnLoan[i] == _owner) {
allTokenIds[tokenIdsIdx] = i;
tokenIdsIdx++;
}
}
return allTokenIds;
}
function refundPriceInWei() public view returns (uint256) {
return uint256(HeyMintStorage.state().advCfg.refundPrice) * 10 ** 13;
}
function refundGuaranteeActive() public view returns (bool) {
HeyMintStorage.State storage state = HeyMintStorage.state();
return block.timestamp < state.advCfg.refundEndsAt;
}
function setRefundAddress(address _refundAddress) external onlyOwner {
require(_refundAddress != address(0), "CANNOT_SEND_TO_ZERO_ADDRESS");
HeyMintStorage.state().advCfg.refundAddress = _refundAddress;
}
function increaseRefundEndsAt(uint32 _newRefundEndsAt) external onlyOwner {
AdvancedConfig storage advCfg = HeyMintStorage.state().advCfg;
require(
_newRefundEndsAt > advCfg.refundEndsAt,
"MUST_INCREASE_DURATION"
);
HeyMintStorage.state().advCfg.refundEndsAt = _newRefundEndsAt;
}
function refund(uint256 _tokenId) external nonReentrant {
require(refundGuaranteeActive(), "REFUND_GUARANTEE_EXPIRED");
require(ownerOf(_tokenId) == msg.sender, "MUST_OWN_TOKEN");
HeyMintStorage.State storage state = HeyMintStorage.state();
if (state.cfg.fundingEndsAt > 0) {
delete state.data.pricePaid[_tokenId];
}
address addressToSendToken = state.advCfg.refundAddress != address(0)
? state.advCfg.refundAddress
: owner();
safeTransferFrom(msg.sender, addressToSendToken, _tokenId);
(bool success, ) = payable(msg.sender).call{value: refundPriceInWei()}(
""
);
require(success, "TRANSFER_FAILED");
}
}
파일 31 / 73 : HeyMintERC721AExtensionE.sol
pragma solidity 0.8.18;
import {HeyMintERC721AUpgradeable} from "./HeyMintERC721AUpgradeable.sol";
import {HeyMintStorage, BaseConfig, AdvancedConfig, BurnToken} from "../libraries/HeyMintStorage.sol";
import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import {IERC1155} from "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import {IDelegateRegistry} from "../interfaces/IDelegateRegistry.sol";
contract HeyMintERC721AExtensionE is HeyMintERC721AUpgradeable {
using HeyMintStorage for HeyMintStorage.State;
event HeyMintAffiliatePaid(address to, uint256 numTokens, uint256 value);
address public constant burnAddress =
0x000000000000000000000000000000000000dEaD;
address public constant heymintAdminAddress =
0x52EA5F96f004d174470901Ba3F1984D349f0D3eF;
address public constant delegationRegistryAddress =
0x00000000000000447e69651d841bD8D104Bed493;
function isPublicAffiliateMintActive() public view returns (bool) {
HeyMintStorage.State storage state = HeyMintStorage.state();
return (state.cfg.presaleSignerAddress != address(0) &&
state.cfg.publicSaleAffiliateMintEnabled &&
state.cfg.publicSaleActive &&
state.cfg.publicPrice > 0 &&
state.cfg.affiliateBasisPoints > 0 &&
(!state.cfg.usePublicSaleTimes ||
block.timestamp >= state.cfg.publicSaleStartTime) &&
(!state.cfg.usePublicSaleTimes ||
block.timestamp < state.cfg.publicSaleEndTime));
}
function publicSaleTimeIsActive() public view returns (bool) {
HeyMintStorage.State storage state = HeyMintStorage.state();
if (
state.cfg.usePublicSaleTimes == false ||
state.cfg.publicSaleStartTime == 0 ||
state.cfg.publicSaleEndTime == 0
) {
return true;
}
return
block.timestamp >= state.cfg.publicSaleStartTime &&
block.timestamp <= state.cfg.publicSaleEndTime;
}
function _publicMint(uint256 _numTokens) internal {
BaseConfig storage cfg = HeyMintStorage.state().cfg;
require(cfg.publicSaleActive, "NOT_ACTIVE");
require(publicSaleTimeIsActive(), "NOT_ACTIVE");
require(
cfg.publicMintsAllowedPerAddress == 0 ||
_numberMinted(msg.sender) + _numTokens <=
cfg.publicMintsAllowedPerAddress,
"MAX_MINTS_EXCEEDED"
);
require(
cfg.publicMintsAllowedPerTransaction == 0 ||
_numTokens <= cfg.publicMintsAllowedPerTransaction,
"MAX_MINTS_EXCEEDED"
);
require(
totalSupply() + _numTokens <= cfg.maxSupply,
"MAX_SUPPLY_EXCEEDED"
);
uint256 publicPrice = publicPriceInWei();
if (cfg.heyMintFeeActive) {
uint256 heymintFee = _numTokens * heymintFeePerToken();
require(
msg.value == publicPrice * _numTokens + heymintFee,
"INVALID_PRICE_PAID"
);
(bool success, ) = heymintPayoutAddress.call{value: heymintFee}("");
require(success, "TRANSFER_FAILED");
} else {
require(
msg.value == publicPrice * _numTokens,
"INVALID_PRICE_PAID"
);
}
if (cfg.fundingEndsAt > 0) {
uint256 firstTokenIdToMint = _nextTokenId();
for (uint256 i = 0; i < _numTokens; i++) {
HeyMintStorage.state().data.pricePaid[
firstTokenIdToMint + i
] = publicPrice;
}
}
_safeMint(msg.sender, _numTokens);
if (totalSupply() >= cfg.maxSupply) {
cfg.publicSaleActive = false;
}
}
function publicMint(uint256 _numTokens) external payable nonReentrant {
_publicMint(_numTokens);
}
function affiliatePublicMint(
address _affPaymentAddress,
bytes32 _affMessageHash,
bytes calldata _affSignature,
uint256 _numTokens
) external payable nonReentrant {
require(isPublicAffiliateMintActive(), "NOT_ACTIVE");
HeyMintStorage.State storage state = HeyMintStorage.state();
require(
keccak256(abi.encode(state.cfg.projectId, _affPaymentAddress)) ==
_affMessageHash,
"MESSAGE_INVALID"
);
require(
verifySignerAddress(_affMessageHash, _affSignature),
"INVALID_SIGNATURE"
);
_publicMint(_numTokens);
uint256 affFee = (_numTokens *
publicPriceInWei() *
state.cfg.affiliateBasisPoints) / 10000;
(bool ok, ) = _affPaymentAddress.call{value: affFee}("");
require(ok, "TRANSFER_FAILED");
emit HeyMintAffiliatePaid(_affPaymentAddress, _numTokens, affFee);
}
function gift(
address[] calldata _receivers,
uint256[] calldata _mintNumber
) external payable onlyOwner {
HeyMintStorage.State storage state = HeyMintStorage.state();
require(
_receivers.length == _mintNumber.length,
"ARRAY_LENGTHS_MUST_MATCH"
);
uint256 totalMints = 0;
for (uint256 i = 0; i < _mintNumber.length; i++) {
totalMints += _mintNumber[i];
}
require(
totalSupply() + totalMints <= state.cfg.maxSupply,
"MAX_SUPPLY_EXCEEDED"
);
if (state.cfg.heyMintFeeActive) {
uint256 heymintFee = (totalMints * heymintFeePerToken()) / 10;
require(msg.value == heymintFee, "PAYMENT_INCORRECT");
(bool success, ) = heymintPayoutAddress.call{value: heymintFee}("");
require(success, "TRANSFER_FAILED");
}
for (uint256 i = 0; i < _receivers.length; i++) {
_safeMint(_receivers[i], _mintNumber[i]);
}
}
function burnPaymentInWei() public view returns (uint256) {
return uint256(HeyMintStorage.state().advCfg.burnPayment) * 10 ** 13;
}
function setBurnClaimState(bool _burnClaimActive) external onlyOwner {
HeyMintStorage.State storage state = HeyMintStorage.state();
if (_burnClaimActive) {
require(state.burnTokens.length != 0, "NOT_CONFIGURED");
require(state.advCfg.mintsPerBurn != 0, "NOT_CONFIGURED");
}
state.advCfg.burnClaimActive = _burnClaimActive;
}
function updateBurnTokens(
BurnToken[] calldata _burnTokens
) external onlyOwner {
BurnToken[] storage burnTokens = HeyMintStorage.state().burnTokens;
uint256 oldBurnTokensLength = burnTokens.length;
uint256 newBurnTokensLength = _burnTokens.length;
for (uint256 i = 0; i < newBurnTokensLength; i++) {
if (i < oldBurnTokensLength) {
burnTokens[i] = _burnTokens[i];
} else {
burnTokens.push(_burnTokens[i]);
}
}
for (uint256 i = oldBurnTokensLength; i > newBurnTokensLength; i--) {
burnTokens.pop();
}
}
function updateMintsPerBurn(uint8 _mintsPerBurn) external onlyOwner {
HeyMintStorage.state().advCfg.mintsPerBurn = _mintsPerBurn;
}
function updatePaymentPerBurn(uint32 _burnPayment) external onlyOwner {
HeyMintStorage.state().advCfg.burnPayment = _burnPayment;
}
function setUseBurnTokenIdForMetadata(
bool _useBurnTokenIdForMetadata
) external onlyOwner {
HeyMintStorage
.state()
.advCfg
.useBurnTokenIdForMetadata = _useBurnTokenIdForMetadata;
}
function _burnToMint(
address[] calldata _contracts,
uint256[][] calldata _tokenIds,
uint256 _tokensToMint,
address _vault
) internal {
HeyMintStorage.State storage state = HeyMintStorage.state();
IDelegateRegistry delegateContract = IDelegateRegistry(
delegationRegistryAddress
);
require(state.burnTokens.length > 0, "NOT_CONFIGURED");
require(state.advCfg.mintsPerBurn != 0, "NOT_CONFIGURED");
require(state.advCfg.burnClaimActive, "NOT_ACTIVE");
require(
_contracts.length == _tokenIds.length,
"ARRAY_LENGTHS_MUST_MATCH"
);
require(
_contracts.length == state.burnTokens.length,
"ARRAY_LENGTHS_MUST_MATCH"
);
require(
totalSupply() + _tokensToMint <= state.cfg.maxSupply,
"MAX_SUPPLY_EXCEEDED"
);
address mintWallet = _vault == address(0) ? msg.sender : _vault;
uint256 burnPaymentTotal = burnPaymentInWei() *
(_tokensToMint / state.advCfg.mintsPerBurn);
if (state.cfg.heyMintFeeActive) {
uint256 heymintFee = _tokensToMint * heymintFeePerToken();
require(
msg.value == burnPaymentTotal + heymintFee,
"INVALID_PRICE_PAID"
);
(bool success, ) = heymintPayoutAddress.call{value: heymintFee}("");
require(success, "TRANSFER_FAILED");
} else {
require(msg.value == burnPaymentTotal, "INVALID_PRICE_PAID");
}
for (uint256 i = 0; i < state.burnTokens.length; i++) {
BurnToken memory burnToken = state.burnTokens[i];
require(
burnToken.contractAddress == _contracts[i],
"INCORRECT_CONTRACT"
);
require(
_vault == address(0) ||
delegateContract.checkDelegateForContract(
msg.sender,
_vault,
_contracts[i],
""
)
);
if (burnToken.tokenType == 1) {
uint256 _tokenIdsLength = _tokenIds[i].length;
require(
(_tokenIdsLength / burnToken.tokensPerBurn) *
state.advCfg.mintsPerBurn ==
_tokensToMint,
"INCORRECT_NO_OF_TOKENS_TO_BURN"
);
for (uint256 j = 0; j < _tokenIdsLength; j++) {
IERC721 burnContract = IERC721(_contracts[i]);
uint256 tokenId = _tokenIds[i][j];
require(
burnContract.ownerOf(tokenId) == mintWallet,
"MUST_OWN_TOKEN"
);
burnContract.transferFrom(mintWallet, burnAddress, tokenId);
}
} else if (burnToken.tokenType == 2) {
uint256 amountToBurn = _tokenIds[i][0];
require(
(amountToBurn / burnToken.tokensPerBurn) *
state.advCfg.mintsPerBurn ==
_tokensToMint,
"INCORRECT_NO_OF_TOKENS_TO_BURN"
);
IERC1155 burnContract = IERC1155(_contracts[i]);
require(
burnContract.balanceOf(mintWallet, burnToken.tokenId) >=
amountToBurn,
"MUST_OWN_TOKEN"
);
burnContract.safeTransferFrom(
mintWallet,
burnAddress,
burnToken.tokenId,
amountToBurn,
""
);
}
}
if (state.advCfg.useBurnTokenIdForMetadata) {
require(
_tokenIds[0].length == _tokensToMint,
"BURN_TOKENS_MUST_MATCH_MINT_NO"
);
uint256 firstNewTokenId = _nextTokenId();
for (uint256 i = 0; i < _tokensToMint; i++) {
state.data.tokenIdToBurnTokenId[
firstNewTokenId + i
] = _tokenIds[0][i];
}
}
_safeMint(mintWallet, _tokensToMint);
}
function burnToMint(
address[] calldata _contracts,
uint256[][] calldata _tokenIds,
uint256 _tokensToMint
) external payable nonReentrant {
_burnToMint(_contracts, _tokenIds, _tokensToMint, address(0));
}
function burnToMintDelegated(
address[] calldata _contracts,
uint256[][] calldata _tokenIds,
uint256 _tokensToMint,
address _vault
) external payable nonReentrant {
_burnToMint(_contracts, _tokenIds, _tokensToMint, _vault);
}
function setRoyaltyBasisPoints(uint16 _royaltyBps) external onlyOwner {
HeyMintStorage.state().cfg.royaltyBps = _royaltyBps;
}
function setRoyaltyPayoutAddress(
address _royaltyPayoutAddress
) external onlyOwner {
HeyMintStorage
.state()
.advCfg
.royaltyPayoutAddress = _royaltyPayoutAddress;
}
function freezePayoutAddresses() external onlyOwner {
HeyMintStorage.state().advCfg.payoutAddressesFrozen = true;
}
function updatePayoutAddressesAndBasisPoints(
address[] calldata _payoutAddresses,
uint16[] calldata _payoutBasisPoints
) external onlyOwner {
AdvancedConfig storage advCfg = HeyMintStorage.state().advCfg;
uint256 payoutBasisPointsLength = _payoutBasisPoints.length;
require(
!advCfg.payoutAddressesFrozen,
"CANNOT_UPDATE_CONSTANT_VARIABLE"
);
require(
_payoutAddresses.length == payoutBasisPointsLength,
"ARRAY_LENGTHS_MUST_MATCH"
);
uint256 totalBasisPoints = 0;
for (uint256 i = 0; i < payoutBasisPointsLength; i++) {
totalBasisPoints += _payoutBasisPoints[i];
}
require(totalBasisPoints == 10000, "BASIS_POINTS_MUST_EQUAL_10000");
advCfg.payoutAddresses = _payoutAddresses;
advCfg.payoutBasisPoints = _payoutBasisPoints;
}
}
파일 32 / 73 : HeyMintERC721AReference.sol
pragma solidity 0.8.18;
contract HeyMintERC721AReference {
struct BaseConfig {
bool publicSaleActive;
bool usePublicSaleTimes;
bool presaleActive;
bool usePresaleTimes;
bool soulbindingActive;
bool randomHashActive;
bool enforceRoyalties;
bool heyMintFeeActive;
bool presaleAffiliateMintEnabled;
bool publicSaleAffiliateMintEnabled;
uint8 publicMintsAllowedPerAddress;
uint8 presaleMintsAllowedPerAddress;
uint8 publicMintsAllowedPerTransaction;
uint8 presaleMintsAllowedPerTransaction;
uint24 maxSupply;
uint24 presaleMaxSupply;
uint16 royaltyBps;
uint16 affiliateBasisPoints;
uint32 publicPrice;
uint32 presalePrice;
uint24 projectId;
address presaleSignerAddress;
uint32 publicSaleStartTime;
uint32 publicSaleEndTime;
uint32 presaleStartTime;
uint32 presaleEndTime;
uint32 fundingEndsAt;
uint32 fundingTarget;
string uriBase;
}
struct AdvancedConfig {
bool stakingActive;
bool loaningActive;
bool freeClaimActive;
uint8 mintsPerFreeClaim;
address freeClaimContractAddress;
bool burnClaimActive;
bool useBurnTokenIdForMetadata;
uint8 mintsPerBurn;
uint32 burnPayment;
bool payoutAddressesFrozen;
uint32 refundEndsAt;
uint32 refundPrice;
bool metadataFrozen;
bool soulbindAdminTransfersPermanentlyDisabled;
bool depositClaimActive;
uint32 remainingDepositPayment;
bool subscriptionsEnabled;
uint32 subscriptionPrice;
uint32 subscriptionPeriod;
uint32 subscriptionGracePeriod;
bool subscriptionAdminTransfersPermanentlyDisabled;
address subscriptionErc20Address;
address depositContractAddress;
bytes32 depositMerkleRoot;
uint16[] payoutBasisPoints;
address[] payoutAddresses;
address royaltyPayoutAddress;
address soulboundAdminAddress;
address refundAddress;
address[] creditCardMintAddresses;
address subscriptionAdminAddress;
}
struct BurnToken {
address contractAddress;
uint8 tokenType;
uint8 tokensPerBurn;
uint16 tokenId;
}
struct TokenOwnership {
address addr;
uint64 startTimestamp;
bool burned;
uint24 extraData;
}
function CORI_SUBSCRIPTION_ADDRESS() external view returns (address) {}
function EMPTY_SUBSCRIPTION_ADDRESS() external view returns (address) {}
function approve(address to, uint256 tokenId) external payable {}
function balanceOf(address _owner) external view returns (uint256) {}
function defaultHeymintFeePerToken() external view returns (uint256) {}
function explicitOwnershipOf(
uint256 tokenId
) external view returns (TokenOwnership memory) {}
function explicitOwnershipsOf(
uint256[] memory tokenIds
) external view returns (TokenOwnership[] memory) {}
function freezeMetadata() external {}
function getApproved(uint256 tokenId) external view returns (address) {}
function heymintFeePerToken() external view returns (uint256) {}
function heymintPayoutAddress() external view returns (address) {}
function initialize(
string memory _name,
string memory _symbol,
BaseConfig memory _config
) external {}
function isApprovedForAll(
address _owner,
address operator
) external view returns (bool) {}
function isOperatorFilterRegistryRevoked() external view returns (bool) {}
function name() external view returns (string memory) {}
function numberMinted(address _owner) external view returns (uint256) {}
function owner() external view returns (address) {}
function ownerOf(uint256 tokenId) external view returns (address) {}
function pause() external {}
function paused() external view returns (bool) {}
function publicMint(uint256 _numTokens) external payable {}
function publicPriceInWei() external view returns (uint256) {}
function publicSaleTimeIsActive() external view returns (bool) {}
function reduceMaxSupply(uint24 _newMaxSupply) external {}
function refundGuaranteeActive() external view returns (bool) {}
function renounceOwnership() external {}
function revokeOperatorFilterRegistry() external {}
function royaltyInfo(
uint256,
uint256 _salePrice
) external view returns (address, uint256) {}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external payable {}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
) external payable {}
function setApprovalForAll(address operator, bool approved) external {}
function setBaseURI(string memory _newBaseURI) external {}
function setPublicMintsAllowedPerAddress(uint8 _mintsAllowed) external {}
function setPublicMintsAllowedPerTransaction(
uint8 _mintsAllowed
) external {}
function setPublicPrice(uint32 _publicPrice) external {}
function setPublicSaleEndTime(uint32 _publicSaleEndTime) external {}
function setPublicSaleStartTime(uint32 _publicSaleStartTime) external {}
function setPublicSaleState(bool _saleActiveState) external {}
function setUsePublicSaleTimes(bool _usePublicSaleTimes) external {}
function setUser(uint256 tokenId, address user, uint64 expires) external {}
function supportsInterface(
bytes4 interfaceId
) external view returns (bool) {}
function symbol() external view returns (string memory) {}
function tokenURI(uint256 tokenId) external view returns (string memory) {}
function tokensOfOwner(
address _owner
) external view returns (uint256[] memory) {}
function tokensOfOwnerIn(
address _owner,
uint256 start,
uint256 stop
) external view returns (uint256[] memory) {}
function totalSupply() external view returns (uint256) {}
function transferFrom(
address from,
address to,
uint256 tokenId
) external payable {}
function transferOwnership(address newOwner) external {}
function unpause() external {}
function userExpires(uint256 tokenId) external view returns (uint256) {}
function userOf(uint256 tokenId) external view returns (address) {}
function withdraw() external {}
function freezePayoutAddresses() external {}
function getSettings()
external
view
returns (
BaseConfig memory,
AdvancedConfig memory,
BurnToken[] memory,
bool,
bool,
bool,
uint256
)
{}
function gift(
address[] memory _receivers,
uint256[] memory _mintNumber
) external payable {}
function setRoyaltyBasisPoints(uint16 _royaltyBps) external {}
function setRoyaltyPayoutAddress(address _royaltyPayoutAddress) external {}
function updateAdvancedConfig(
AdvancedConfig memory _advancedConfig
) external {}
function updateBaseConfig(BaseConfig memory _baseConfig) external {}
function updatePayoutAddressesAndBasisPoints(
address[] memory _payoutAddresses,
uint16[] memory _payoutBasisPoints
) external {}
function burnAddress() external view returns (address) {}
function burnPaymentInWei() external view returns (uint256) {}
function burnToMint(
address[] memory _contracts,
uint256[][] memory _tokenIds,
uint256 _tokensToMint
) external payable {}
function burnToMintDelegated(
address[] memory _contracts,
uint256[][] memory _tokenIds,
uint256 _tokensToMint,
address _vault
) external payable {}
function presaleMint(
bytes32 _messageHash,
bytes memory _signature,
uint256 _numTokens,
uint256 _maximumAllowedMints
) external payable {}
function presalePriceInWei() external view returns (uint256) {}
function presaleTimeIsActive() external view returns (bool) {}
function reducePresaleMaxSupply(uint24 _newPresaleMaxSupply) external {}
function setBurnClaimState(bool _burnClaimActive) external {}
function setPresaleEndTime(uint32 _presaleEndTime) external {}
function setPresaleMintsAllowedPerAddress(uint8 _mintsAllowed) external {}
function setPresaleMintsAllowedPerTransaction(
uint8 _mintsAllowed
) external {}
function setPresalePrice(uint32 _presalePrice) external {}
function setPresaleSignerAddress(address _presaleSignerAddress) external {}
function setPresaleStartTime(uint32 _presaleStartTime) external {}
function setPresaleState(bool _saleActiveState) external {}
function setUseBurnTokenIdForMetadata(
bool _useBurnTokenIdForMetadata
) external {}
function setUsePresaleTimes(bool _usePresaleTimes) external {}
function updateBurnTokens(BurnToken[] memory _burnTokens) external {}
function updateMintsPerBurn(uint8 _mintsPerBurn) external {}
function updatePaymentPerBurn(uint32 _burnPayment) external {}
function adminUnstake(uint256 _tokenId) external {}
function baseTokenURI() external view returns (string memory) {}
function checkFreeClaimEligibility(
uint256[] memory _tokenIDs
) external view returns (bool[] memory) {}
function creditCardMint(uint256 _numTokens, address _to) external payable {}
function currentTokenStakeTime(
uint256 _tokenId
) external view returns (uint256) {}
function disableSoulbindAdminTransfersPermanently() external {}
function freeClaim(uint256[] memory _tokenIDs) external payable {}
function getRandomHashes(
uint256[] memory _tokenIDs
) external view returns (bytes32[] memory) {}
function setFreeClaimContractAddress(
address _freeClaimContractAddress
) external {}
function setFreeClaimState(bool _freeClaimActive) external {}
function setGenerateRandomHashState(bool _randomHashActive) external {}
function setSoulbindingState(bool _soulbindingActive) external {}
function setSoulboundAdminAddress(address _adminAddress) external {}
function setStakingState(bool _stakingState) external {}
function setTokenURIs(
uint256[] memory _tokenIds,
string[] memory _newURIs
) external {}
function soulboundAdminTransfer(
address _from,
address _to,
uint256 _tokenId
) external {}
function stakeTokens(uint256[] memory _tokenIds) external {}
function stakingTransfer(
address _from,
address _to,
uint256 _tokenId
) external {}
function totalTokenStakeTime(
uint256 _tokenId
) external view returns (uint256) {}
function unstakeTokens(uint256[] memory _tokenIds) external {}
function updateMintsPerFreeClaim(uint8 _mintsPerFreeClaim) external {}
function adminRetrieveLoan(uint256 _tokenId) external {}
function burnDepositTokensToMint(
uint256[] memory _tokenIds,
bytes32[][] memory _merkleProofs
) external payable {}
function burnToRefund(uint256[] memory _tokenIds) external {}
function determineFundingSuccess() external {}
function fundingTargetInWei() external view returns (uint256) {}
function heymintAdminAddress() external view returns (address) {}
function increaseRefundEndsAt(uint32 _newRefundEndsAt) external {}
function loan(uint256 _tokenId, address _receiver) external {}
function loanedBalanceOf(address _owner) external view returns (uint256) {}
function loanedTokensByAddress(
address _owner
) external view returns (uint256[] memory) {}
function refund(uint256 _tokenId) external {}
function refundPriceInWei() external view returns (uint256) {}
function remainingDepositPaymentInWei() external view returns (uint256) {}
function retrieveLoan(uint256 _tokenId) external {}
function setDepositClaimState(bool _depositClaimActive) external {}
function setDepositContractAddress(
address _depositContractAddress
) external {}
function setDepositMerkleRoot(bytes32 _depositMerkleRoot) external {}
function setHeymintFeePerToken(uint256 _heymintFeePerToken) external {}
function setHeymintFeeState(bool _feeActive) external {}
function setLoaningActive(bool _loaningActive) external {}
function setRefundAddress(address _refundAddress) external {}
function setRemainingDepositPayment(
uint32 _remainingDepositPayment
) external {}
function totalLoaned() external view returns (uint256) {}
function isPublicAffiliateMintActive() public view returns (bool) {}
function affiliatePublicMint(
address _affPaymentAddress,
bytes32 _affMessageHash,
bytes calldata _affSignature,
uint256 _numTokens
) external payable {}
function isPresaleAffiliateMintActive() public view returns (bool) {}
function affiliatePresaleMint(
address _affPaymentAddress,
bytes32 _affMessageHash,
bytes calldata _affSignature,
bytes32 _messageHash,
bytes calldata _signature,
uint256 _numTokens,
uint256 _maximumAllowedMints
) external payable {}
function affiliateCreditCardMint(
address _affPaymentAddress,
bytes32 _affMessageHash,
bytes calldata _affSignature,
uint256 _numTokens,
address _to
) external payable {}
}
파일 33 / 73 : HeyMintERC721AUpgradeable.sol
pragma solidity 0.8.18;
import {Data, HeyMintStorage} from "../libraries/HeyMintStorage.sol";
import {ERC721AUpgradeable, IERC721AUpgradeable, ERC721AStorage} from "erc721a-upgradeable/contracts/ERC721AUpgradeable.sol";
import {ERC4907AUpgradeable} from "erc721a-upgradeable/contracts/extensions/ERC4907AUpgradeable.sol";
import {ERC721AQueryableUpgradeable} from "erc721a-upgradeable/contracts/extensions/ERC721AQueryableUpgradeable.sol";
import {IERC2981Upgradeable, IERC165Upgradeable} from "@openzeppelin/contracts-upgradeable/interfaces/IERC2981Upgradeable.sol";
import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import {PausableUpgradeable} from "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol";
import {ReentrancyGuardUpgradeable} from "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
import {RevokableOperatorFiltererUpgradeable} from "operator-filter-registry/src/upgradeable/RevokableOperatorFiltererUpgradeable.sol";
import {ECDSAUpgradeable} from "@openzeppelin/contracts-upgradeable/utils/cryptography/ECDSAUpgradeable.sol";
contract HeyMintERC721AUpgradeable is
ERC4907AUpgradeable,
ERC721AQueryableUpgradeable,
OwnableUpgradeable,
PausableUpgradeable,
ReentrancyGuardUpgradeable,
RevokableOperatorFiltererUpgradeable
{
using HeyMintStorage for HeyMintStorage.State;
using ECDSAUpgradeable for bytes32;
uint256 public constant defaultHeymintFeePerToken = 0.0008 ether;
address public constant heymintPayoutAddress =
0xE1FaC470dE8dE91c66778eaa155C64c7ceEFc851;
function _startTokenId() internal view virtual override returns (uint256) {
return 1;
}
function numberMinted(address _owner) public view returns (uint256) {
return _numberMinted(_owner);
}
function _directApproveMsgSenderFor(uint256 _tokenId) internal {
ERC721AStorage.layout()._tokenApprovals[_tokenId].value = msg.sender;
}
function owner()
public
view
virtual
override(OwnableUpgradeable, RevokableOperatorFiltererUpgradeable)
returns (address)
{
return OwnableUpgradeable.owner();
}
function supportsInterface(
bytes4 interfaceId
)
public
view
virtual
override(ERC721AUpgradeable, IERC721AUpgradeable, ERC4907AUpgradeable)
returns (bool)
{
return
ERC721AUpgradeable.supportsInterface(interfaceId) ||
type(IERC2981Upgradeable).interfaceId == interfaceId ||
ERC4907AUpgradeable.supportsInterface(interfaceId);
}
function heymintFeePerToken() public view returns (uint256) {
uint256 fee = HeyMintStorage.state().data.heymintFeePerToken;
return fee == 0 ? defaultHeymintFeePerToken : fee;
}
function setApprovalForAll(
address operator,
bool approved
)
public
override(ERC721AUpgradeable, IERC721AUpgradeable)
onlyAllowedOperatorApproval(operator)
{
require(
!HeyMintStorage.state().cfg.soulbindingActive,
"TOKEN_IS_SOULBOUND"
);
super.setApprovalForAll(operator, approved);
}
function approve(
address to,
uint256 tokenId
)
public
payable
override(ERC721AUpgradeable, IERC721AUpgradeable)
onlyAllowedOperatorApproval(to)
{
require(
!HeyMintStorage.state().cfg.soulbindingActive,
"TOKEN_IS_SOULBOUND"
);
super.approve(to, tokenId);
}
function transferFrom(
address from,
address to,
uint256 tokenId
)
public
payable
override(ERC721AUpgradeable, IERC721AUpgradeable)
onlyAllowedOperator(from)
{
super.transferFrom(from, to, tokenId);
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId
)
public
payable
override(ERC721AUpgradeable, IERC721AUpgradeable)
onlyAllowedOperator(from)
{
super.safeTransferFrom(from, to, tokenId);
}
function safeTransferFrom(
address from,
address to,
uint256 tokenId,
bytes memory data
)
public
payable
override(ERC721AUpgradeable, IERC721AUpgradeable)
onlyAllowedOperator(from)
{
super.safeTransferFrom(from, to, tokenId, data);
}
function _generateRandomHash(uint256 _tokenId) internal {
Data storage data = HeyMintStorage.state().data;
if (data.randomHashStore[_tokenId] == bytes32(0)) {
data.randomHashStore[_tokenId] = keccak256(
abi.encode(block.prevrandao, _tokenId)
);
}
}
function _beforeTokenTransfers(
address from,
address to,
uint256 tokenId,
uint256 quantity
) internal override whenNotPaused onlyAllowedOperator(from) {
HeyMintStorage.State storage state = HeyMintStorage.state();
require(
!state.advCfg.stakingActive ||
state.data.stakingTransferActive ||
state.data.currentTimeStaked[tokenId] == 0,
"TOKEN_IS_STAKED"
);
require(
state.data.tokenOwnersOnLoan[tokenId] == address(0),
"CANNOT_TRANSFER_LOANED_TOKEN"
);
if (
state.cfg.soulbindingActive &&
!state.data.soulboundAdminTransferInProgress
) {
require(from == address(0), "TOKEN_IS_SOULBOUND");
}
if (state.cfg.randomHashActive && from == address(0)) {
_generateRandomHash(tokenId);
}
super._beforeTokenTransfers(from, to, tokenId, quantity);
}
function publicPriceInWei() public view returns (uint256) {
return uint256(HeyMintStorage.state().cfg.publicPrice) * 10 ** 13;
}
function verifySignerAddress(
bytes32 _messageHash,
bytes calldata _signature
) internal view returns (bool) {
return
HeyMintStorage.state().cfg.presaleSignerAddress ==
_messageHash.toEthSignedMessageHash().recover(_signature);
}
}
파일 34 / 73 : HeyMintStorage.sol
pragma solidity 0.8.18;
struct BaseConfig {
bool publicSaleActive;
bool usePublicSaleTimes;
bool presaleActive;
bool usePresaleTimes;
bool soulbindingActive;
bool randomHashActive;
bool enforceRoyalties;
bool heyMintFeeActive;
bool presaleAffiliateMintEnabled;
bool publicSaleAffiliateMintEnabled;
uint8 publicMintsAllowedPerAddress;
uint8 presaleMintsAllowedPerAddress;
uint8 publicMintsAllowedPerTransaction;
uint8 presaleMintsAllowedPerTransaction;
uint24 maxSupply;
uint24 presaleMaxSupply;
uint16 royaltyBps;
uint16 affiliateBasisPoints;
uint32 publicPrice;
uint32 presalePrice;
uint24 projectId;
address presaleSignerAddress;
uint32 publicSaleStartTime;
uint32 publicSaleEndTime;
uint32 presaleStartTime;
uint32 presaleEndTime;
uint32 fundingEndsAt;
uint32 fundingTarget;
string uriBase;
}
struct AdvancedConfig {
bool stakingActive;
bool loaningActive;
bool freeClaimActive;
uint8 mintsPerFreeClaim;
address freeClaimContractAddress;
bool burnClaimActive;
bool useBurnTokenIdForMetadata;
uint8 mintsPerBurn;
uint32 burnPayment;
bool payoutAddressesFrozen;
uint32 refundEndsAt;
uint32 refundPrice;
bool metadataFrozen;
bool soulbindAdminTransfersPermanentlyDisabled;
bool depositClaimActive;
uint32 remainingDepositPayment;
bool subscriptionsEnabled;
uint32 subscriptionPrice;
uint32 subscriptionPeriod;
uint32 subscriptionGracePeriod;
bool subscriptionAdminTransfersPermanentlyDisabled;
address subscriptionErc20Address;
address depositContractAddress;
bytes32 depositMerkleRoot;
uint16[] payoutBasisPoints;
address[] payoutAddresses;
address royaltyPayoutAddress;
address soulboundAdminAddress;
address refundAddress;
address[] creditCardMintAddresses;
address subscriptionAdminAddress;
}
struct BurnToken {
address contractAddress;
uint8 tokenType;
uint8 tokensPerBurn;
uint16 tokenId;
}
struct Data {
uint256 heymintFeePerToken;
bool advancedConfigInitialized;
mapping(uint256 => string) tokenURIs;
bool fundingTargetReached;
bool fundingSuccessDetermined;
mapping(uint256 => uint256) pricePaid;
bool soulboundAdminTransferInProgress;
mapping(uint256 => uint256) tokenIdToBurnTokenId;
bool stakingTransferActive;
mapping(uint256 => uint256) currentTimeStaked;
mapping(uint256 => uint256) totalTimeStaked;
uint256 currentLoanTotal;
mapping(address => uint256) totalLoanedPerAddress;
mapping(uint256 => address) tokenOwnersOnLoan;
mapping(uint256 => bool) freeClaimUsed;
mapping(uint256 => bytes32) randomHashStore;
mapping(bytes32 => uint256) tokensMintedByEmailAddress;
mapping(uint256 => uint256) subscriptionExpiration;
bool subscriptionAdminTransferInProgress;
}
library HeyMintStorage {
struct State {
BaseConfig cfg;
AdvancedConfig advCfg;
BurnToken[] burnTokens;
Data data;
}
bytes32 internal constant STORAGE_SLOT =
keccak256("heymint.launchpad.storage.erc721a");
function state() internal pure returns (State storage s) {
bytes32 slot = STORAGE_SLOT;
assembly {
s.slot := slot
}
}
}
파일 35 / 73 : IAddressRelay.sol
pragma solidity ^0.8.18;
struct Implementation {
address implAddress;
bytes4[] selectors;
}
interface IAddressRelay {
function fallbackImplAddress() external returns (address);
function addOrUpdateSelectors(
bytes4[] memory _selectors,
address _implAddress
) external;
function removeSelectors(bytes4[] memory _selectors) external;
function removeImplAddressAndAllSelectors(address _implAddress) external;
function getImplAddress(
bytes4 _functionSelector
) external view returns (address implAddress_);
function getAllImplAddressesAndSelectors()
external
view
returns (Implementation[] memory impls_);
function getSelectorsForImplAddress(
address _implAddress
) external view returns (bytes4[] memory selectors_);
function setFallbackImplAddress(address _fallbackAddress) external;
function updateSupportedInterfaces(
bytes4 _interfaceId,
bool _supported
) external;
function supportsInterface(
bytes4 _interfaceId
) external view returns (bool);
}
파일 36 / 73 : IDelegateRegistry.sol
pragma solidity >=0.8.13;
interface IDelegateRegistry {
enum DelegationType {
NONE,
ALL,
CONTRACT,
ERC721,
ERC20,
ERC1155
}
struct Delegation {
DelegationType type_;
address to;
address from;
bytes32 rights;
address contract_;
uint256 tokenId;
uint256 amount;
}
event DelegateAll(
address indexed from,
address indexed to,
bytes32 rights,
bool enable
);
event DelegateContract(
address indexed from,
address indexed to,
address indexed contract_,
bytes32 rights,
bool enable
);
event DelegateERC721(
address indexed from,
address indexed to,
address indexed contract_,
uint256 tokenId,
bytes32 rights,
bool enable
);
event DelegateERC20(
address indexed from,
address indexed to,
address indexed contract_,
bytes32 rights,
uint256 amount
);
event DelegateERC1155(
address indexed from,
address indexed to,
address indexed contract_,
uint256 tokenId,
bytes32 rights,
uint256 amount
);
error MulticallFailed();
function multicall(
bytes[] calldata data
) external payable returns (bytes[] memory results);
function delegateAll(
address to,
bytes32 rights,
bool enable
) external payable returns (bytes32 delegationHash);
function delegateContract(
address to,
address contract_,
bytes32 rights,
bool enable
) external payable returns (bytes32 delegationHash);
function delegateERC721(
address to,
address contract_,
uint256 tokenId,
bytes32 rights,
bool enable
) external payable returns (bytes32 delegationHash);
function delegateERC20(
address to,
address contract_,
bytes32 rights,
uint256 amount
) external payable returns (bytes32 delegationHash);
function delegateERC1155(
address to,
address contract_,
uint256 tokenId,
bytes32 rights,
uint256 amount
) external payable returns (bytes32 delegationHash);
function checkDelegateForAll(
address to,
address from,
bytes32 rights
) external view returns (bool);
function checkDelegateForContract(
address to,
address from,
address contract_,
bytes32 rights
) external view returns (bool);
function checkDelegateForERC721(
address to,
address from,
address contract_,
uint256 tokenId,
bytes32 rights
) external view returns (bool);
function checkDelegateForERC20(
address to,
address from,
address contract_,
bytes32 rights
) external view returns (uint256);
function checkDelegateForERC1155(
address to,
address from,
address contract_,
uint256 tokenId,
bytes32 rights
) external view returns (uint256);
function getIncomingDelegations(
address to
) external view returns (Delegation[] memory delegations);
function getOutgoingDelegations(
address from
) external view returns (Delegation[] memory delegations);
function getIncomingDelegationHashes(
address to
) external view returns (bytes32[] memory delegationHashes);
function getOutgoingDelegationHashes(
address from
) external view returns (bytes32[] memory delegationHashes);
function getDelegationsFromHashes(
bytes32[] calldata delegationHashes
) external view returns (Delegation[] memory delegations);
function readSlot(bytes32 location) external view returns (bytes32);
function readSlots(
bytes32[] calldata locations
) external view returns (bytes32[] memory);
}
파일 37 / 73 : IERC1155.sol
pragma solidity ^0.8.0;
import "../../utils/introspection/IERC165.sol";
interface IERC1155 is IERC165 {
event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);
event TransferBatch(
address indexed operator,
address indexed from,
address indexed to,
uint256[] ids,
uint256[] values
);
event ApprovalForAll(address indexed account, address indexed operator, bool approved);
event URI(string value, uint256 indexed id);
function balanceOf(address account, uint256 id) external view returns (uint256);
function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids)
external
view
returns (uint256[] memory);
function setApprovalForAll(address operator, bool approved) external;
function isApprovedForAll(address account, address operator) external view returns (bool);
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes calldata data
) external;
function safeBatchTransferFrom(
address from,
address to,
uint256[] calldata ids,
uint256[] calldata amounts,
bytes calldata data
) external;
}
파일 38 / 73 : IERC1155MetadataURI.sol
pragma solidity ^0.8.0;
import "../IERC1155.sol";
interface IERC1155MetadataURI is IERC1155 {
function uri(uint256 id) external view returns (string memory);
}
파일 39 / 73 : IERC1155Receiver.sol
pragma solidity ^0.8.0;
import "../../utils/introspection/IERC165.sol";
interface IERC1155Receiver is IERC165 {
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external returns (bytes4);
function onERC1155BatchReceived(
address operator,
address from,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
) external returns (bytes4);
}
파일 40 / 73 : IERC165.sol
pragma solidity ^0.8.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
파일 41 / 73 : IERC165Upgradeable.sol
pragma solidity ^0.8.0;
interface IERC165Upgradeable {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
파일 42 / 73 : IERC173.sol
pragma solidity ^0.8.18;
interface IERC173 {
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
function owner() external view returns (address owner_);
function transferOwnership(address _newOwner) external;
}
파일 43 / 73 : IERC2981.sol
pragma solidity ^0.8.0;
import "../utils/introspection/IERC165.sol";
interface IERC2981 is IERC165 {
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
returns (address receiver, uint256 royaltyAmount);
}
파일 44 / 73 : IERC2981Upgradeable.sol
pragma solidity ^0.8.0;
import "../utils/introspection/IERC165Upgradeable.sol";
interface IERC2981Upgradeable is IERC165Upgradeable {
function royaltyInfo(uint256 tokenId, uint256 salePrice)
external
view
returns (address receiver, uint256 royaltyAmount);
}
파일 45 / 73 : IERC4907AUpgradeable.sol
pragma solidity ^0.8.4;
import '../IERC721AUpgradeable.sol';
interface IERC4907AUpgradeable is IERC721AUpgradeable {
error SetUserCallerNotOwnerNorApproved();
event UpdateUser(uint256 indexed tokenId, address indexed user, uint64 expires);
function setUser(
uint256 tokenId,
address user,
uint64 expires
) external;
function userOf(uint256 tokenId) external view returns (address);
function userExpires(uint256 tokenId) external view returns (uint256);
}
파일 46 / 73 : 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);
}
파일 47 / 73 : IERC721AQueryableUpgradeable.sol
pragma solidity ^0.8.4;
import '../IERC721AUpgradeable.sol';
interface IERC721AQueryableUpgradeable is IERC721AUpgradeable {
error InvalidQueryRange();
function explicitOwnershipOf(uint256 tokenId) external view returns (TokenOwnership memory);
function explicitOwnershipsOf(uint256[] memory tokenIds) external view returns (TokenOwnership[] memory);
function tokensOfOwnerIn(
address owner,
uint256 start,
uint256 stop
) external view returns (uint256[] memory);
function tokensOfOwner(address owner) external view returns (uint256[] memory);
}
파일 48 / 73 : IERC721AUpgradeable.sol
pragma solidity ^0.8.4;
interface IERC721AUpgradeable {
error ApprovalCallerNotOwnerNorApproved();
error ApprovalQueryForNonexistentToken();
error BalanceQueryForZeroAddress();
error MintToZeroAddress();
error MintZeroQuantity();
error OwnerQueryForNonexistentToken();
error TransferCallerNotOwnerNorApproved();
error TransferFromIncorrectOwner();
error TransferToNonERC721ReceiverImplementer();
error TransferToZeroAddress();
error URIQueryForNonexistentToken();
error MintERC2309QuantityExceedsLimit();
error OwnershipNotInitializedForExtraData();
struct TokenOwnership {
address addr;
uint64 startTimestamp;
bool burned;
uint24 extraData;
}
function totalSupply() external view returns (uint256);
function supportsInterface(bytes4 interfaceId) external view returns (bool);
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 payable;
function safeTransferFrom(
address from,
address to,
uint256 tokenId
) external payable;
function transferFrom(
address from,
address to,
uint256 tokenId
) external payable;
function approve(address to, uint256 tokenId) external payable;
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);
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
event ConsecutiveTransfer(uint256 indexed fromTokenId, uint256 toTokenId, address indexed from, address indexed to);
}
파일 49 / 73 : IERC721Enumerable.sol
pragma solidity ^0.8.0;
import "../IERC721.sol";
interface IERC721Enumerable is IERC721 {
function totalSupply() external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);
function tokenByIndex(uint256 index) external view returns (uint256);
}
파일 50 / 73 : 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);
}
파일 51 / 73 : IERC721Receiver.sol
pragma solidity ^0.8.0;
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
파일 52 / 73 : IExchangeOperatorAddressList.sol
pragma solidity ^0.8.18;
interface IExchangeOperatorAddressList {
function operatorAddressToExchange(
address _operatorAddress
) external view returns (uint256);
}
파일 53 / 73 : IHeyMintDefaults.sol
pragma solidity ^0.8.18;
interface IHeyMintDefaults {
function getCreditCardDefaultAddresses()
external
view
returns (address[] memory);
}
파일 54 / 73 : 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);
}
파일 55 / 73 : Initializable.sol
pragma solidity ^0.8.2;
import "../../utils/AddressUpgradeable.sol";
abstract contract Initializable {
uint8 private _initialized;
bool private _initializing;
event Initialized(uint8 version);
modifier initializer() {
bool isTopLevelCall = !_initializing;
require(
(isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
"Initializable: contract is already initialized"
);
_initialized = 1;
if (isTopLevelCall) {
_initializing = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
emit Initialized(1);
}
}
modifier reinitializer(uint8 version) {
require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
_initialized = version;
_initializing = true;
_;
_initializing = false;
emit Initialized(version);
}
modifier onlyInitializing() {
require(_initializing, "Initializable: contract is not initializing");
_;
}
function _disableInitializers() internal virtual {
require(!_initializing, "Initializable: contract is initializing");
if (_initialized < type(uint8).max) {
_initialized = type(uint8).max;
emit Initialized(type(uint8).max);
}
}
function _getInitializedVersion() internal view returns (uint8) {
return _initialized;
}
function _isInitializing() internal view returns (bool) {
return _initializing;
}
}
파일 56 / 73 : 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);
}
}
}
파일 57 / 73 : MathUpgradeable.sol
pragma solidity ^0.8.0;
library MathUpgradeable {
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);
}
}
}
파일 58 / 73 : MerkleProofUpgradeable.sol
pragma solidity ^0.8.0;
library MerkleProofUpgradeable {
function verify(
bytes32[] memory proof,
bytes32 root,
bytes32 leaf
) internal pure returns (bool) {
return processProof(proof, leaf) == root;
}
function verifyCalldata(
bytes32[] calldata proof,
bytes32 root,
bytes32 leaf
) internal pure returns (bool) {
return processProofCalldata(proof, leaf) == root;
}
function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
bytes32 computedHash = leaf;
for (uint256 i = 0; i < proof.length; i++) {
computedHash = _hashPair(computedHash, proof[i]);
}
return computedHash;
}
function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {
bytes32 computedHash = leaf;
for (uint256 i = 0; i < proof.length; i++) {
computedHash = _hashPair(computedHash, proof[i]);
}
return computedHash;
}
function multiProofVerify(
bytes32[] memory proof,
bool[] memory proofFlags,
bytes32 root,
bytes32[] memory leaves
) internal pure returns (bool) {
return processMultiProof(proof, proofFlags, leaves) == root;
}
function multiProofVerifyCalldata(
bytes32[] calldata proof,
bool[] calldata proofFlags,
bytes32 root,
bytes32[] memory leaves
) internal pure returns (bool) {
return processMultiProofCalldata(proof, proofFlags, leaves) == root;
}
function processMultiProof(
bytes32[] memory proof,
bool[] memory proofFlags,
bytes32[] memory leaves
) internal pure returns (bytes32 merkleRoot) {
uint256 leavesLen = leaves.length;
uint256 totalHashes = proofFlags.length;
require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof");
bytes32[] memory hashes = new bytes32[](totalHashes);
uint256 leafPos = 0;
uint256 hashPos = 0;
uint256 proofPos = 0;
for (uint256 i = 0; i < totalHashes; i++) {
bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++];
hashes[i] = _hashPair(a, b);
}
if (totalHashes > 0) {
return hashes[totalHashes - 1];
} else if (leavesLen > 0) {
return leaves[0];
} else {
return proof[0];
}
}
function processMultiProofCalldata(
bytes32[] calldata proof,
bool[] calldata proofFlags,
bytes32[] memory leaves
) internal pure returns (bytes32 merkleRoot) {
uint256 leavesLen = leaves.length;
uint256 totalHashes = proofFlags.length;
require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof");
bytes32[] memory hashes = new bytes32[](totalHashes);
uint256 leafPos = 0;
uint256 hashPos = 0;
uint256 proofPos = 0;
for (uint256 i = 0; i < totalHashes; i++) {
bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++];
hashes[i] = _hashPair(a, b);
}
if (totalHashes > 0) {
return hashes[totalHashes - 1];
} else if (leavesLen > 0) {
return leaves[0];
} else {
return proof[0];
}
}
function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
return a < b ? _efficientHash(a, b) : _efficientHash(b, a);
}
function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
assembly {
mstore(0x00, a)
mstore(0x20, b)
value := keccak256(0x00, 0x40)
}
}
}
파일 59 / 73 : MutantPenguinsClub.sol
pragma solidity 0.8.18;
import {StorageSlot} from "@openzeppelin/contracts/utils/StorageSlot.sol";
import {IAddressRelay} from "./interfaces/IAddressRelay.sol";
import {BaseConfig} from "./libraries/HeyMintStorage.sol";
contract MutantPenguinsClub {
bytes32 internal constant _IMPLEMENTATION_SLOT =
0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
bytes32 internal constant _ADDRESS_RELAY_SLOT =
keccak256("heymint.launchpad.addressRelay");
constructor(
string memory _name,
string memory _symbol,
address _addressRelay,
address _implementation,
BaseConfig memory _baseConfig
) {
StorageSlot
.getAddressSlot(_IMPLEMENTATION_SLOT)
.value = _implementation;
StorageSlot.getAddressSlot(_ADDRESS_RELAY_SLOT).value = _addressRelay;
IAddressRelay addressRelay = IAddressRelay(
StorageSlot.getAddressSlot(_ADDRESS_RELAY_SLOT).value
);
address implContract = addressRelay.fallbackImplAddress();
(bool success, ) = implContract.delegatecall(
abi.encodeWithSelector(0x9cd1fe1a, _name, _symbol, _baseConfig)
);
require(success);
}
fallback() external payable {
IAddressRelay addressRelay = IAddressRelay(
StorageSlot.getAddressSlot(_ADDRESS_RELAY_SLOT).value
);
address implContract = addressRelay.getImplAddress(msg.sig);
assembly {
calldatacopy(0, 0, calldatasize())
let result := delegatecall(
gas(),
implContract,
0,
calldatasize(),
0,
0
)
returndatacopy(0, 0, returndatasize())
switch result
case 0 {
revert(0, returndatasize())
}
default {
return(0, returndatasize())
}
}
}
receive() external payable {}
}
파일 60 / 73 : OperatorFiltererUpgradeable.sol
pragma solidity ^0.8.13;
import {IOperatorFilterRegistry} from "../IOperatorFilterRegistry.sol";
import {Initializable} from "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
abstract contract OperatorFiltererUpgradeable is Initializable {
error OperatorNotAllowed(address operator);
IOperatorFilterRegistry constant OPERATOR_FILTER_REGISTRY =
IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E);
function __OperatorFilterer_init(address subscriptionOrRegistrantToCopy, bool subscribe)
internal
onlyInitializing
{
if (address(OPERATOR_FILTER_REGISTRY).code.length > 0) {
if (!OPERATOR_FILTER_REGISTRY.isRegistered(address(this))) {
if (subscribe) {
OPERATOR_FILTER_REGISTRY.registerAndSubscribe(address(this), subscriptionOrRegistrantToCopy);
} else {
if (subscriptionOrRegistrantToCopy != address(0)) {
OPERATOR_FILTER_REGISTRY.registerAndCopyEntries(address(this), subscriptionOrRegistrantToCopy);
} else {
OPERATOR_FILTER_REGISTRY.register(address(this));
}
}
}
}
}
modifier onlyAllowedOperator(address from) virtual {
if (from != msg.sender) {
_checkFilterOperator(msg.sender);
}
_;
}
modifier onlyAllowedOperatorApproval(address operator) virtual {
_checkFilterOperator(operator);
_;
}
function _checkFilterOperator(address operator) internal view virtual {
if (address(OPERATOR_FILTER_REGISTRY).code.length > 0) {
if (!OPERATOR_FILTER_REGISTRY.isOperatorAllowed(address(this), operator)) {
revert OperatorNotAllowed(operator);
}
}
}
}
파일 61 / 73 : Ownable.sol
pragma solidity ^0.8.0;
import "../utils/Context.sol";
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);
}
}
파일 62 / 73 : OwnableUpgradeable.sol
pragma solidity ^0.8.0;
import "../utils/ContextUpgradeable.sol";
import "../proxy/utils/Initializable.sol";
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function __Ownable_init() internal onlyInitializing {
__Ownable_init_unchained();
}
function __Ownable_init_unchained() internal onlyInitializing {
_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);
}
uint256[49] private __gap;
}
파일 63 / 73 : Pausable.sol
pragma solidity ^0.8.0;
import "../utils/Context.sol";
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() {
_paused = false;
}
modifier whenNotPaused() {
_requireNotPaused();
_;
}
modifier whenPaused() {
_requirePaused();
_;
}
function paused() public view virtual returns (bool) {
return _paused;
}
function _requireNotPaused() internal view virtual {
require(!paused(), "Pausable: paused");
}
function _requirePaused() internal view virtual {
require(paused(), "Pausable: not paused");
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
파일 64 / 73 : PausableUpgradeable.sol
pragma solidity ^0.8.0;
import "../utils/ContextUpgradeable.sol";
import "../proxy/utils/Initializable.sol";
abstract contract PausableUpgradeable is Initializable, ContextUpgradeable {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
function __Pausable_init() internal onlyInitializing {
__Pausable_init_unchained();
}
function __Pausable_init_unchained() internal onlyInitializing {
_paused = false;
}
modifier whenNotPaused() {
_requireNotPaused();
_;
}
modifier whenPaused() {
_requirePaused();
_;
}
function paused() public view virtual returns (bool) {
return _paused;
}
function _requireNotPaused() internal view virtual {
require(!paused(), "Pausable: paused");
}
function _requirePaused() internal view virtual {
require(paused(), "Pausable: not paused");
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
uint256[49] private __gap;
}
파일 65 / 73 : 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;
}
}
파일 66 / 73 : ReentrancyGuardUpgradeable.sol
pragma solidity ^0.8.0;
import "../proxy/utils/Initializable.sol";
abstract contract ReentrancyGuardUpgradeable is Initializable {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
function __ReentrancyGuard_init() internal onlyInitializing {
__ReentrancyGuard_init_unchained();
}
function __ReentrancyGuard_init_unchained() internal onlyInitializing {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
_nonReentrantBefore();
_;
_nonReentrantAfter();
}
function _nonReentrantBefore() private {
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
_status = _ENTERED;
}
function _nonReentrantAfter() private {
_status = _NOT_ENTERED;
}
uint256[49] private __gap;
}
파일 67 / 73 : RegistryHashes.sol
pragma solidity 0.8.18;
import {IDelegateRegistry} from "../interfaces/IDelegateRegistry.sol";
library RegistryHashes {
uint256 internal constant EXTRACT_LAST_BYTE = 0xff;
uint256 internal constant ALL_TYPE = 1;
uint256 internal constant CONTRACT_TYPE = 2;
uint256 internal constant ERC721_TYPE = 3;
uint256 internal constant ERC20_TYPE = 4;
uint256 internal constant ERC1155_TYPE = 5;
uint256 internal constant DELEGATION_SLOT = 0;
function decodeType(
bytes32 inputHash
) internal pure returns (IDelegateRegistry.DelegationType decodedType) {
assembly {
decodedType := and(inputHash, EXTRACT_LAST_BYTE)
}
}
function location(
bytes32 inputHash
) internal pure returns (bytes32 computedLocation) {
assembly ("memory-safe") {
mstore(0, inputHash)
mstore(32, DELEGATION_SLOT)
computedLocation := keccak256(0, 64)
}
}
function allHash(
address from,
bytes32 rights,
address to
) internal pure returns (bytes32 hash) {
assembly ("memory-safe") {
let ptr := mload(64)
mstore(add(ptr, 40), to)
mstore(add(ptr, 20), from)
mstore(ptr, rights)
hash := or(shl(8, keccak256(ptr, 72)), ALL_TYPE)
}
}
function allLocation(
address from,
bytes32 rights,
address to
) internal pure returns (bytes32 computedLocation) {
assembly ("memory-safe") {
let ptr := mload(64)
mstore(add(ptr, 40), to)
mstore(add(ptr, 20), from)
mstore(ptr, rights)
mstore(0, or(shl(8, keccak256(ptr, 72)), ALL_TYPE))
mstore(32, DELEGATION_SLOT)
computedLocation := keccak256(0, 64)
}
}
function contractHash(
address from,
bytes32 rights,
address to,
address contract_
) internal pure returns (bytes32 hash) {
assembly ("memory-safe") {
let ptr := mload(64)
mstore(add(ptr, 60), contract_)
mstore(add(ptr, 40), to)
mstore(add(ptr, 20), from)
mstore(ptr, rights)
hash := or(shl(8, keccak256(ptr, 92)), CONTRACT_TYPE)
}
}
function contractLocation(
address from,
bytes32 rights,
address to,
address contract_
) internal pure returns (bytes32 computedLocation) {
assembly ("memory-safe") {
let ptr := mload(64)
mstore(add(ptr, 60), contract_)
mstore(add(ptr, 40), to)
mstore(add(ptr, 20), from)
mstore(ptr, rights)
mstore(0, or(shl(8, keccak256(ptr, 92)), CONTRACT_TYPE))
mstore(32, DELEGATION_SLOT)
computedLocation := keccak256(0, 64)
}
}
function erc721Hash(
address from,
bytes32 rights,
address to,
uint256 tokenId,
address contract_
) internal pure returns (bytes32 hash) {
assembly ("memory-safe") {
let ptr := mload(64)
mstore(add(ptr, 92), tokenId)
mstore(add(ptr, 60), contract_)
mstore(add(ptr, 40), to)
mstore(add(ptr, 20), from)
mstore(ptr, rights)
hash := or(shl(8, keccak256(ptr, 124)), ERC721_TYPE)
}
}
function erc721Location(
address from,
bytes32 rights,
address to,
uint256 tokenId,
address contract_
) internal pure returns (bytes32 computedLocation) {
assembly ("memory-safe") {
let ptr := mload(64)
mstore(add(ptr, 92), tokenId)
mstore(add(ptr, 60), contract_)
mstore(add(ptr, 40), to)
mstore(add(ptr, 20), from)
mstore(ptr, rights)
mstore(0, or(shl(8, keccak256(ptr, 124)), ERC721_TYPE))
mstore(32, DELEGATION_SLOT)
computedLocation := keccak256(0, 64)
}
}
function erc20Hash(
address from,
bytes32 rights,
address to,
address contract_
) internal pure returns (bytes32 hash) {
assembly ("memory-safe") {
let ptr := mload(64)
mstore(add(ptr, 60), contract_)
mstore(add(ptr, 40), to)
mstore(add(ptr, 20), from)
mstore(ptr, rights)
hash := or(shl(8, keccak256(ptr, 92)), ERC20_TYPE)
}
}
function erc20Location(
address from,
bytes32 rights,
address to,
address contract_
) internal pure returns (bytes32 computedLocation) {
assembly ("memory-safe") {
let ptr := mload(64)
mstore(add(ptr, 60), contract_)
mstore(add(ptr, 40), to)
mstore(add(ptr, 20), from)
mstore(ptr, rights)
mstore(0, or(shl(8, keccak256(ptr, 92)), ERC20_TYPE))
mstore(32, DELEGATION_SLOT)
computedLocation := keccak256(0, 64)
}
}
function erc1155Hash(
address from,
bytes32 rights,
address to,
uint256 tokenId,
address contract_
) internal pure returns (bytes32 hash) {
assembly ("memory-safe") {
let ptr := mload(64)
mstore(add(ptr, 92), tokenId)
mstore(add(ptr, 60), contract_)
mstore(add(ptr, 40), to)
mstore(add(ptr, 20), from)
mstore(ptr, rights)
hash := or(shl(8, keccak256(ptr, 124)), ERC1155_TYPE)
}
}
function erc1155Location(
address from,
bytes32 rights,
address to,
uint256 tokenId,
address contract_
) internal pure returns (bytes32 computedLocation) {
assembly ("memory-safe") {
let ptr := mload(64)
mstore(add(ptr, 92), tokenId)
mstore(add(ptr, 60), contract_)
mstore(add(ptr, 40), to)
mstore(add(ptr, 20), from)
mstore(ptr, rights)
mstore(0, or(shl(8, keccak256(ptr, 124)), ERC1155_TYPE))
mstore(32, DELEGATION_SLOT)
computedLocation := keccak256(0, 64)
}
}
}
파일 68 / 73 : RegistryOps.sol
pragma solidity 0.8.18;
library RegistryOps {
function max(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := xor(x, mul(xor(x, y), gt(y, x)))
}
}
function and(bool x, bool y) internal pure returns (bool z) {
assembly {
z := and(iszero(iszero(x)), iszero(iszero(y)))
}
}
function or(bool x, bool y) internal pure returns (bool z) {
assembly {
z := or(iszero(iszero(x)), iszero(iszero(y)))
}
}
}
파일 69 / 73 : RegistryStorage.sol
pragma solidity 0.8.18;
library RegistryStorage {
address internal constant DELEGATION_EMPTY = address(0);
address internal constant DELEGATION_REVOKED = address(1);
uint256 internal constant POSITIONS_FIRST_PACKED = 0;
uint256 internal constant POSITIONS_SECOND_PACKED = 1;
uint256 internal constant POSITIONS_RIGHTS = 2;
uint256 internal constant POSITIONS_TOKEN_ID = 3;
uint256 internal constant POSITIONS_AMOUNT = 4;
uint256 internal constant CLEAN_ADDRESS =
0x00ffffffffffffffffffffffffffffffffffffffff;
uint256 internal constant CLEAN_FIRST8_BYTES_ADDRESS =
0xffffffffffffffff << 96;
uint256 internal constant CLEAN_PACKED8_BYTES_ADDRESS =
0xffffffffffffffff << 160;
function packAddresses(
address from,
address to,
address contract_
) internal pure returns (bytes32 firstPacked, bytes32 secondPacked) {
assembly {
firstPacked := or(
shl(64, and(contract_, CLEAN_FIRST8_BYTES_ADDRESS)),
and(from, CLEAN_ADDRESS)
)
secondPacked := or(shl(160, contract_), and(to, CLEAN_ADDRESS))
}
}
function unpackAddresses(
bytes32 firstPacked,
bytes32 secondPacked
) internal pure returns (address from, address to, address contract_) {
assembly {
from := and(firstPacked, CLEAN_ADDRESS)
to := and(secondPacked, CLEAN_ADDRESS)
contract_ := or(
shr(64, and(firstPacked, CLEAN_PACKED8_BYTES_ADDRESS)),
shr(160, secondPacked)
)
}
}
function unpackAddress(
bytes32 packedSlot
) internal pure returns (address unpacked) {
assembly {
unpacked := and(packedSlot, CLEAN_ADDRESS)
}
}
}
파일 70 / 73 : RevokableOperatorFiltererUpgradeable.sol
pragma solidity ^0.8.13;
import {OperatorFiltererUpgradeable} from "./OperatorFiltererUpgradeable.sol";
library RevokableOperatorFiltererUpgradeableStorage {
struct Layout {
bool _isOperatorFilterRegistryRevoked;
}
bytes32 internal constant STORAGE_SLOT = keccak256("RevokableOperatorFiltererUpgradeable.contracts.storage");
function layout() internal pure returns (Layout storage l) {
bytes32 slot = STORAGE_SLOT;
assembly {
l.slot := slot
}
}
}
abstract contract RevokableOperatorFiltererUpgradeable is OperatorFiltererUpgradeable {
using RevokableOperatorFiltererUpgradeableStorage for RevokableOperatorFiltererUpgradeableStorage.Layout;
error OnlyOwner();
error AlreadyRevoked();
event OperatorFilterRegistryRevoked();
function __RevokableOperatorFilterer_init(address subscriptionOrRegistrantToCopy, bool subscribe) internal {
OperatorFiltererUpgradeable.__OperatorFilterer_init(subscriptionOrRegistrantToCopy, subscribe);
}
function _checkFilterOperator(address operator) internal view virtual override {
if (
!RevokableOperatorFiltererUpgradeableStorage.layout()._isOperatorFilterRegistryRevoked
&& address(OPERATOR_FILTER_REGISTRY).code.length > 0
) {
if (!OPERATOR_FILTER_REGISTRY.isOperatorAllowed(address(this), operator)) {
revert OperatorNotAllowed(operator);
}
}
}
function revokeOperatorFilterRegistry() external {
if (msg.sender != owner()) {
revert OnlyOwner();
}
if (RevokableOperatorFiltererUpgradeableStorage.layout()._isOperatorFilterRegistryRevoked) {
revert AlreadyRevoked();
}
RevokableOperatorFiltererUpgradeableStorage.layout()._isOperatorFilterRegistryRevoked = true;
emit OperatorFilterRegistryRevoked();
}
function isOperatorFilterRegistryRevoked() public view returns (bool) {
return RevokableOperatorFiltererUpgradeableStorage.layout()._isOperatorFilterRegistryRevoked;
}
function owner() public view virtual returns (address);
}
파일 71 / 73 : StorageSlot.sol
pragma solidity ^0.8.0;
library StorageSlot {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
assembly {
r.slot := slot
}
}
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
assembly {
r.slot := slot
}
}
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
assembly {
r.slot := slot
}
}
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
assembly {
r.slot := slot
}
}
}
파일 72 / 73 : 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);
}
}
파일 73 / 73 : StringsUpgradeable.sol
pragma solidity ^0.8.0;
import "./math/MathUpgradeable.sol";
library StringsUpgradeable {
bytes16 private constant _SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
function toString(uint256 value) internal pure returns (string memory) {
unchecked {
uint256 length = MathUpgradeable.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, MathUpgradeable.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);
}
}
{
"compilationTarget": {
"contracts/MutantPenguinsClub.sol": "MutantPenguinsClub"
},
"evmVersion": "paris",
"libraries": {},
"metadata": {
"bytecodeHash": "ipfs"
},
"optimizer": {
"enabled": true,
"runs": 10000
},
"remappings": []
}[{"inputs":[{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"},{"internalType":"address","name":"_addressRelay","type":"address"},{"internalType":"address","name":"_implementation","type":"address"},{"components":[{"internalType":"bool","name":"publicSaleActive","type":"bool"},{"internalType":"bool","name":"usePublicSaleTimes","type":"bool"},{"internalType":"bool","name":"presaleActive","type":"bool"},{"internalType":"bool","name":"usePresaleTimes","type":"bool"},{"internalType":"bool","name":"soulbindingActive","type":"bool"},{"internalType":"bool","name":"randomHashActive","type":"bool"},{"internalType":"bool","name":"enforceRoyalties","type":"bool"},{"internalType":"bool","name":"heyMintFeeActive","type":"bool"},{"internalType":"bool","name":"presaleAffiliateMintEnabled","type":"bool"},{"internalType":"bool","name":"publicSaleAffiliateMintEnabled","type":"bool"},{"internalType":"uint8","name":"publicMintsAllowedPerAddress","type":"uint8"},{"internalType":"uint8","name":"presaleMintsAllowedPerAddress","type":"uint8"},{"internalType":"uint8","name":"publicMintsAllowedPerTransaction","type":"uint8"},{"internalType":"uint8","name":"presaleMintsAllowedPerTransaction","type":"uint8"},{"internalType":"uint24","name":"maxSupply","type":"uint24"},{"internalType":"uint24","name":"presaleMaxSupply","type":"uint24"},{"internalType":"uint16","name":"royaltyBps","type":"uint16"},{"internalType":"uint16","name":"affiliateBasisPoints","type":"uint16"},{"internalType":"uint32","name":"publicPrice","type":"uint32"},{"internalType":"uint32","name":"presalePrice","type":"uint32"},{"internalType":"uint24","name":"projectId","type":"uint24"},{"internalType":"address","name":"presaleSignerAddress","type":"address"},{"internalType":"uint32","name":"publicSaleStartTime","type":"uint32"},{"internalType":"uint32","name":"publicSaleEndTime","type":"uint32"},{"internalType":"uint32","name":"presaleStartTime","type":"uint32"},{"internalType":"uint32","name":"presaleEndTime","type":"uint32"},{"internalType":"uint32","name":"fundingEndsAt","type":"uint32"},{"internalType":"uint32","name":"fundingTarget","type":"uint32"},{"internalType":"string","name":"uriBase","type":"string"}],"internalType":"struct BaseConfig","name":"_baseConfig","type":"tuple"}],"stateMutability":"nonpayable","type":"constructor"},{"stateMutability":"payable","type":"fallback"},{"stateMutability":"payable","type":"receive"}]
