文件 1 的 1：LaunchCodes.sol
pragma solidity ^0.8.21;
contract ILaunchCodeErrors {
error LCDMismatchedArrayLengths();
error LCDQuantityMustBeGreaterThanZero();
error LCDQueryForZeroAddress();
error LCDCannotUpdateLocksOnUnlockedOrStakedTokens();
error LCDCanOnlyStakeUnlockedTokens();
error LCDCanOnlyUnstakeStakedTokens();
error LCDLockedToken();
error LCDNotTokenOwnerOrApproved();
error LCDNotTokenOwner();
error LCDTokenNotFound();
error LCDGlobalMintingLimitMet();
error LCDIndividualMintingLimitMet();
error LCDApproveCallerNotOwnerNorApproved();
error LCDApproveToCaller();
error LCDApproveToCurrentOwner();
error LCDFundsTransferFailed();
error LCDNoFundsToTransfer();
error LCDTransferToNonERC721Receiver();
error LCDClassAlreadyArchived();
error LCDClassAlreadyExists();
error LCDClassNotFound();
error LCDClassStillBackstopped();
error LCDBackstopEndInTheFuture();
error LCDCannotAssignStakingLocks();
error LCDInvalidPaidPrice();
}
pragma solidity ^0.8.0;
library Popcount {
uint256 private constant m1 = 0x5555555555555555555555555555555555555555555555555555555555555555;
uint256 private constant m2 = 0x3333333333333333333333333333333333333333333333333333333333333333;
uint256 private constant m4 = 0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f;
uint256 private constant h01 = 0x0101010101010101010101010101010101010101010101010101010101010101;
function popcount256A(uint256 x) internal pure returns (uint256 count) {
unchecked{
for (count=0; x!=0; count++)
x &= x - 1;
}
}
function popcount256B(uint256 x) internal pure returns (uint256) {
if (x == type(uint256).max) {
return 256;
}
unchecked {
x -= (x >> 1) & m1;
x = (x & m2) + ((x >> 2) & m2);
x = (x + (x >> 4)) & m4;
x = (x * h01) >> 248;
}
return x;
}
}
pragma solidity ^0.8.0;
library BitScan {
uint256 constant private DEBRUIJN_256 = 0x818283848586878898a8b8c8d8e8f929395969799a9b9d9e9faaeb6bedeeff;
bytes constant private LOOKUP_TABLE_256 = hex"0001020903110a19042112290b311a3905412245134d2a550c5d32651b6d3a7506264262237d468514804e8d2b95569d0d495ea533a966b11c886eb93bc176c9071727374353637324837e9b47af86c7155181ad4fd18ed32c9096db57d59ee30e2e4a6a5f92a6be3498aae067ddb2eb1d5989b56fd7baf33ca0c2ee77e5caf7ff0810182028303840444c545c646c7425617c847f8c949c48a4a8b087b8c0c816365272829aaec650acd0d28fdad4e22d6991bd97dfdcea58b4d6f29fede4f6fe0f1f2f3f4b5b6b607b8b93a3a7b7bf357199c5abcfd9e168bcdee9b3f1ecf5fd1e3e5a7a8aa2b670c4ced8bbe8f0f4fc3d79a1c3cde7effb78cce6facbf9f8";
function isolateLS1B256(uint256 bb) pure internal returns (uint256) {
require(bb > 0);
unchecked {
return bb & (0 - bb);
}
}
function isolateMS1B256(uint256 bb) pure internal returns (uint256) {
require(bb > 0);
unchecked {
bb |= bb >> 128;
bb |= bb >> 64;
bb |= bb >> 32;
bb |= bb >> 16;
bb |= bb >> 8;
bb |= bb >> 4;
bb |= bb >> 2;
bb |= bb >> 1;
return (bb >> 1) + 1;
}
}
function bitScanForward256(uint256 bb) pure internal returns (uint8) {
unchecked {
return uint8(LOOKUP_TABLE_256[(isolateLS1B256(bb) * DEBRUIJN_256) >> 248]);
}
}
function bitScanReverse256(uint256 bb) pure internal returns (uint8) {
unchecked {
return 255 - uint8(LOOKUP_TABLE_256[((isolateMS1B256(bb) * DEBRUIJN_256) >> 248)]);
}
}
function log2(uint256 bb) pure internal returns (uint8) {
unchecked {
return uint8(LOOKUP_TABLE_256[(isolateMS1B256(bb) * DEBRUIJN_256) >> 248]);
}
}
}
pragma solidity ^0.8.0;
library BitMaps {
using BitScan for uint256;
uint256 private constant MASK_INDEX_ZERO = (1 << 255);
uint256 private constant MASK_FULL = type(uint256).max;
struct BitMap {
mapping(uint256 => uint256) _data;
}
function get(BitMap storage bitmap, uint256 index) internal view returns (bool) {
uint256 bucket = index >> 8;
uint256 mask = MASK_INDEX_ZERO >> (index & 0xff);
return bitmap._data[bucket] & mask != 0;
}
function setTo(
BitMap storage bitmap,
uint256 index,
bool value
) internal {
if (value) {
set(bitmap, index);
} else {
unset(bitmap, index);
}
}
function set(BitMap storage bitmap, uint256 index) internal {
uint256 bucket = index >> 8;
uint256 mask = MASK_INDEX_ZERO >> (index & 0xff);
bitmap._data[bucket] |= mask;
}
function unset(BitMap storage bitmap, uint256 index) internal {
uint256 bucket = index >> 8;
uint256 mask = MASK_INDEX_ZERO >> (index & 0xff);
bitmap._data[bucket] &= ~mask;
}
function setBatch(BitMap storage bitmap, uint256 startIndex, uint256 amount) internal {
uint256 bucket = startIndex >> 8;
uint256 bucketStartIndex = (startIndex & 0xff);
unchecked {
if(bucketStartIndex + amount < 256) {
bitmap._data[bucket] |= MASK_FULL << (256 - amount) >> bucketStartIndex;
} else {
bitmap._data[bucket] |= MASK_FULL >> bucketStartIndex;
amount -= (256 - bucketStartIndex);
bucket++;
while(amount > 256) {
bitmap._data[bucket] = MASK_FULL;
amount -= 256;
bucket++;
}
bitmap._data[bucket] |= MASK_FULL << (256 - amount);
}
}
}
function unsetBatch(BitMap storage bitmap, uint256 startIndex, uint256 amount) internal {
uint256 bucket = startIndex >> 8;
uint256 bucketStartIndex = (startIndex & 0xff);
unchecked {
if(bucketStartIndex + amount < 256) {
bitmap._data[bucket] &= ~(MASK_FULL << (256 - amount) >> bucketStartIndex);
} else {
bitmap._data[bucket] &= ~(MASK_FULL >> bucketStartIndex);
amount -= (256 - bucketStartIndex);
bucket++;
while(amount > 256) {
bitmap._data[bucket] = 0;
amount -= 256;
bucket++;
}
bitmap._data[bucket] &= ~(MASK_FULL << (256 - amount));
}
}
}
function popcountA(BitMap storage bitmap, uint256 startIndex, uint256 amount) internal view returns(uint256 count) {
uint256 bucket = startIndex >> 8;
uint256 bucketStartIndex = (startIndex & 0xff);
unchecked {
if(bucketStartIndex + amount < 256) {
count += Popcount.popcount256A(
bitmap._data[bucket] & (MASK_FULL << (256 - amount) >> bucketStartIndex)
);
} else {
count += Popcount.popcount256A(
bitmap._data[bucket] & (MASK_FULL >> bucketStartIndex)
);
amount -= (256 - bucketStartIndex);
bucket++;
while(amount > 256) {
count += Popcount.popcount256A(bitmap._data[bucket]);
amount -= 256;
bucket++;
}
count += Popcount.popcount256A(
bitmap._data[bucket] & (MASK_FULL << (256 - amount))
);
}
}
}
function popcountB(BitMap storage bitmap, uint256 startIndex, uint256 amount) internal view returns(uint256 count) {
uint256 bucket = startIndex >> 8;
uint256 bucketStartIndex = (startIndex & 0xff);
unchecked {
if(bucketStartIndex + amount < 256) {
count += Popcount.popcount256B(
bitmap._data[bucket] & (MASK_FULL << (256 - amount) >> bucketStartIndex)
);
} else {
count += Popcount.popcount256B(
bitmap._data[bucket] & (MASK_FULL >> bucketStartIndex)
);
amount -= (256 - bucketStartIndex);
bucket++;
while(amount > 256) {
count += Popcount.popcount256B(bitmap._data[bucket]);
amount -= 256;
bucket++;
}
count += Popcount.popcount256B(
bitmap._data[bucket] & (MASK_FULL << (256 - amount))
);
}
}
}
function scanForward(BitMap storage bitmap, uint256 index) internal view returns (uint256 setBitIndex) {
uint256 bucket = index >> 8;
uint256 bucketIndex = (index & 0xff);
uint256 bb = bitmap._data[bucket];
bb = bb >> (0xff ^ bucketIndex);
if(bb > 0) {
unchecked {
setBitIndex = (bucket << 8) | (bucketIndex - bb.bitScanForward256());
}
} else {
while(true) {
require(bucket > 0, "BitMaps: The set bit before the index doesn't exist.");
unchecked {
bucket--;
}
bb = bitmap._data[bucket];
if(bb > 0) {
unchecked {
setBitIndex = (bucket << 8) | (255 - bb.bitScanForward256());
break;
}
}
}
}
}
function getBucket(BitMap storage bitmap, uint256 bucket) internal view returns (uint256) {
return bitmap._data[bucket];
}
}
pragma solidity ^0.8.1;
library Address {
function isContract(address account) internal view returns (bool) {
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
pragma solidity ^0.8.0;
library SignedMath {
function max(int256 a, int256 b) internal pure returns (int256) {
return a > b ? a : b;
}
function min(int256 a, int256 b) internal pure returns (int256) {
return a < b ? a : b;
}
function average(int256 a, int256 b) internal pure returns (int256) {
int256 x = (a & b) + ((a ^ b) >> 1);
return x + (int256(uint256(x) >> 255) & (a ^ b));
}
function abs(int256 n) internal pure returns (uint256) {
unchecked {
return uint256(n >= 0 ? n : -n);
}
}
}
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, "Math: mulDiv overflow");
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 << 3) < value ? 1 : 0);
}
}
}
pragma solidity ^0.8.0;
library Strings {
bytes16 private constant _SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
function toString(uint256 value) internal pure returns (string memory) {
unchecked {
uint256 length = Math.log10(value) + 1;
string memory buffer = new string(length);
uint256 ptr;
assembly {
ptr := add(buffer, add(32, length))
}
while (true) {
ptr--;
assembly {
mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
}
value /= 10;
if (value == 0) break;
}
return buffer;
}
}
function toString(int256 value) internal pure returns (string memory) {
return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value))));
}
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);
}
function equal(string memory a, string memory b) internal pure returns (bool) {
return keccak256(bytes(a)) == keccak256(bytes(b));
}
}
pragma solidity ^0.8.0;
interface IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
pragma solidity ^0.8.0;
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
pragma solidity ^0.8.0;
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() {
_paused = false;
}
modifier whenNotPaused() {
_requireNotPaused();
_;
}
modifier whenPaused() {
_requirePaused();
_;
}
function paused() public view virtual returns (bool) {
return _paused;
}
function _requireNotPaused() internal view virtual {
require(!paused(), "Pausable: paused");
}
function _requirePaused() internal view virtual {
require(paused(), "Pausable: not paused");
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
pragma solidity ^0.8.21;
contract Administrable is Pausable, Ownable {
error AdministrableCallerMustBeAdmin();
error AdministrableAlreadyAnAdmin();
error AdministrableNotAnAdmin();
mapping(address => bool) private _admins;
constructor(address[] memory _initialAdmins) {
for (uint256 i = 0; i < _initialAdmins.length; i++) {
_admins[_initialAdmins[i]] = true;
}
}
function addAdminRights(address _newAdmin) external onlyOwner {
if (_isAdmin(_newAdmin)) revert AdministrableAlreadyAnAdmin();
_admins[_newAdmin] = true;
}
function revokeAdminRights(address _admin) external onlyOwner {
if (!_isAdmin(_admin)) revert AdministrableNotAnAdmin();
delete _admins[_admin];
}
function pause() public onlyAdmin {
_pause();
}
function unpause() public onlyAdmin {
_unpause();
}
function _isAdmin(address _user) internal view returns (bool){
return _admins[_user];
}
modifier onlyAdmin(){
if (!_admins[_msgSender()]) revert AdministrableCallerMustBeAdmin();
_;
}
}
pragma solidity ^0.8.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
pragma solidity ^0.8.0;
abstract contract ERC165 is IERC165 {
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
pragma solidity ^0.8.0;
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
function safeTransferFrom(address from, address to, uint256 tokenId) external;
function transferFrom(address from, address to, uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function setApprovalForAll(address operator, bool approved) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function isApprovedForAll(address owner, address operator) external view returns (bool);
}
pragma solidity ^0.8.0;
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
pragma solidity ^0.8.21;
contract TokenDataBasedERC721Psi is Context, ERC165, IERC721, IERC721Metadata, ILaunchCodeErrors {
uint8 public constant NO_LOCK = 0;
uint8 public constant PENDING_LOCK = 1;
uint8 public constant STAKING_LOCK = 2;
uint8 public constant FIRST_ADMIN_LOCK = 3;
using Address for address;
using Strings for uint256;
using BitMaps for BitMaps.BitMap;
BitMaps.BitMap private _batchHead;
BitMaps.BitMap private _burnedToken;
string private _name;
string private _symbol;
string private _metadataBaseURI;
uint256 public totalMinted;
uint256 public totalBurned;
mapping(uint256 => address) private _tokenApprovals;
mapping(address => mapping(address => bool)) private _operatorApprovals;
mapping(uint256 => uint8) private _lockedTokens;
mapping(uint256 => TokenData) private _tokenData;
mapping(uint8 => Class) public classes;
mapping(address => BalanceCounts) public individualCounts;
struct Class {
bool active;
bool archived;
uint32 mintedCount;
uint32 mintingLimit;
uint256 price;
uint256 totalUnstakedHeldAssets;
uint256 totalUnstakedHeldFunding;
uint256 backstopEnd;
}
struct TokenData {
uint8 classId;
address owner;
uint256 heldAssets;
uint256 heldFunding;
}
struct BalanceCounts {
uint256 balance;
uint256 mintedCount;
}
constructor(string memory name_, string memory symbol_, string memory baseURI_) {
_name = name_;
_symbol = symbol_;
_metadataBaseURI = baseURI_;
}
function _baseURI() internal view virtual returns (string memory) {
return _metadataBaseURI;
}
function _setBaseURI(string memory baseURI) internal {
_metadataBaseURI = baseURI;
}
function _nextTokenId() internal view virtual returns (uint256) {
return totalMinted;
}
function _setTokenDataOf(uint256 tokenId, uint8 classId, uint256 heldAssets, uint256 heldFunding) internal virtual {
_tokenData[tokenId].classId = classId;
_tokenData[tokenId].heldAssets = heldAssets;
_tokenData[tokenId].heldFunding = heldFunding;
}
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 tokenDataOf(uint256 tokenId) public view returns (TokenData memory) {
TokenData memory data = _unfilteredTokenDataOf(tokenId);
if (_isClassBackstopExpired(data.classId)) {
return TokenData(data.classId, data.owner, 0, 0);
}
return data;
}
function _unfilteredTokenDataOf(uint256 tokenId) internal view virtual returns (TokenData memory) {
if (!_exists(tokenId)) revert LCDTokenNotFound();
(, uint256 tokenIdBatchHead) = _ownerAndBatchHeadOf(tokenId);
return _tokenData[tokenIdBatchHead];
}
function balanceOf(address owner)
public
view
virtual
override
returns (uint)
{
if (owner == address(0)) revert LCDQueryForZeroAddress();
return individualCounts[owner].balance;
}
function ownerOf(uint256 tokenId)
public
view
virtual
override
returns (address)
{
(address owner,) = _ownerAndBatchHeadOf(tokenId);
return owner;
}
function _ownerAndBatchHeadOf(uint256 tokenId) internal view returns (address owner, uint256 tokenIdBatchHead){
if (!_exists(tokenId)) revert LCDTokenNotFound();
tokenIdBatchHead = _getBatchHead(tokenId);
owner = _tokenData[tokenIdBatchHead].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) {
if (!_exists(tokenId)) revert LCDTokenNotFound();
return string(abi.encodePacked(_baseURI(), tokenId.toString()));
}
function approve(address to, uint256 tokenId) public virtual override {
address owner = ownerOf(tokenId);
if (to == owner) revert LCDApproveToCurrentOwner();
if (_msgSender() != owner && !isApprovedForAll(owner, _msgSender()))
revert LCDApproveCallerNotOwnerNorApproved();
_approve(to, tokenId);
}
function getApproved(uint256 tokenId)
public
view
virtual
override
returns (address)
{
if (!_exists(tokenId)) revert LCDTokenNotFound();
return _tokenApprovals[tokenId];
}
function setApprovalForAll(address operator, bool approved)
public
virtual
override
{
if (operator == _msgSender()) revert LCDApproveToCaller();
_operatorApprovals[_msgSender()][operator] = approved;
emit ApprovalForAll(_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 {
if (!_isApprovedOrOwner(_msgSender(), tokenId)) revert LCDNotTokenOwnerOrApproved();
_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 {
if (!_isApprovedOrOwner(_msgSender(), tokenId)) revert LCDNotTokenOwnerOrApproved();
_safeTransfer(from, to, tokenId, _data);
}
function _safeTransfer(
address from,
address to,
uint256 tokenId,
bytes memory _data
) internal virtual {
_transfer(from, to, tokenId);
if (!_checkOnERC721Received(from, to, tokenId, 1, _data)) revert LCDTransferToNonERC721Receiver();
}
function _exists(uint256 tokenId) internal view virtual returns (bool) {
return tokenId < _nextTokenId() && 0 <= tokenId && !_burnedToken.get(tokenId);
}
function _isApprovedOrOwner(address spender, uint256 tokenId)
internal
view
virtual
returns (bool)
{
if (!_exists(tokenId)) revert LCDTokenNotFound();
address owner = ownerOf(tokenId);
return (spender == owner ||
getApproved(tokenId) == spender ||
isApprovedForAll(owner, spender));
}
function _safeMint(address to, uint256 quantity) internal virtual {
_safeMint(to, quantity, "");
}
function _safeMint(
address to,
uint256 quantity,
bytes memory _data
) internal virtual {
uint256 nextTokenId = _nextTokenId();
_mint(to, quantity);
if (!_checkOnERC721Received(address(0), to, nextTokenId, quantity, _data)) revert LCDTransferToNonERC721Receiver();
}
function _mint(
address to,
uint256 quantity
) internal virtual {
uint256 nextTokenId = _nextTokenId();
if (quantity == 0) revert LCDQuantityMustBeGreaterThanZero();
if (to == address(0)) revert LCDQueryForZeroAddress();
_beforeTokenTransfers(address(0), to, nextTokenId, quantity);
totalMinted += quantity;
individualCounts[to].balance += quantity;
individualCounts[to].mintedCount += quantity;
_tokenData[nextTokenId] = TokenData(0, to, 0, 0);
_batchHead.set(nextTokenId);
for (uint256 tokenId = nextTokenId; tokenId < nextTokenId + quantity; tokenId++) {
emit Transfer(address(0), to, tokenId);
}
}
function _burn(uint256 tokenId) internal virtual {
address from = ownerOf(tokenId);
_beforeTokenTransfers(from, address(0), tokenId, 1);
_burnedToken.set(tokenId);
individualCounts[from].balance -= 1;
totalBurned += 1;
_afterTokenTransfers(from, address(0), tokenId, 1);
}
function _transfer(
address from,
address to,
uint256 tokenId
) internal virtual {
(address owner, uint256 tokenIdBatchHead) = _ownerAndBatchHeadOf(tokenId);
if (owner != from) revert LCDNotTokenOwner();
if (to == address(0)) revert LCDQueryForZeroAddress();
_beforeTokenTransfers(from, to, tokenId, 1);
_approve(address(0), tokenId);
uint256 subsequentTokenId = tokenId + 1;
if (!_batchHead.get(subsequentTokenId) &&
subsequentTokenId < _nextTokenId()
) {
_tokenData[subsequentTokenId].owner = from;
_batchHead.set(subsequentTokenId);
}
_lockedTokens[tokenId] = PENDING_LOCK;
_tokenData[tokenId].owner = to;
if (tokenId != tokenIdBatchHead) {
_batchHead.set(tokenId);
}
emit Transfer(from, to, tokenId);
_afterTokenTransfers(from, to, tokenId, 1);
}
function _approve(address to, uint256 tokenId) internal virtual {
_tokenApprovals[tokenId] = to;
emit Approval(ownerOf(tokenId), to, tokenId);
}
function _checkOnERC721Received(
address from,
address to,
uint256 startTokenId,
uint256 quantity,
bytes memory _data
) private returns (bool r) {
if (to.isContract()) {
r = true;
for (uint256 tokenId = startTokenId; tokenId < startTokenId + quantity; tokenId++) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
r = r && retval == IERC721Receiver.onERC721Received.selector;
} catch (bytes memory reason) {
if (reason.length == 0) {
revert LCDTransferToNonERC721Receiver();
} else {
assembly {
revert(add(32, reason), mload(reason))
}
}
}
}
return r;
} else {
return true;
}
}
function _getBatchHead(uint256 tokenId) internal view returns (uint256 tokenIdBatchHead) {
tokenIdBatchHead = _batchHead.scanForward(tokenId);
}
function getBatchHeadTest(uint256 tokenId) public virtual view returns (uint256) {
return _getBatchHead(tokenId);
}
function totalSupply() public virtual view returns (uint256) {
return totalMinted - totalBurned;
}
function tokensOfOwner(address owner) external view virtual returns (uint256[] memory) {
unchecked {
uint256 tokenIdsIdx;
uint256 tokenIdsLength = balanceOf(owner);
uint256[] memory tokenIds = new uint256[](tokenIdsLength);
for (uint256 i = 0; tokenIdsIdx != tokenIdsLength; ++i) {
if (_exists(i)) {
if (ownerOf(i) == owner) {
tokenIds[tokenIdsIdx++] = i;
}
}
}
return tokenIds;
}
}
function tokenLockOf(uint256 tokenId) public view returns (uint8){
if (!_exists(tokenId)) revert LCDTokenNotFound();
return _lockedTokens[tokenId];
}
function _setTokenLock(uint256 tokenId, uint8 lockType) internal virtual {
_lockedTokens[tokenId] = lockType;
}
function _isClassBackstopExpired(uint8 classId) internal view virtual returns (bool) {
return classes[classId].backstopEnd < block.timestamp;
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
function _afterTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal virtual {}
modifier unlocked(uint256 tokenId){
if (_lockedTokens[tokenId] > PENDING_LOCK) revert LCDLockedToken();
_;
}
}
pragma solidity ^0.8.0;
interface IERC2981 is IERC165 {
function royaltyInfo(
uint256 tokenId,
uint256 salePrice
) external view returns (address receiver, uint256 royaltyAmount);
}
pragma solidity ^0.8.21;
contract LaunchCodes is TokenDataBasedERC721Psi, IERC2981, Administrable {
uint8 public mintFundingPercentage = 10;
uint8 public burnFundingPercentage = 0;
uint8 public mintedClassId = 5;
uint32 public individualMintingLimit;
address public fundingDistributionAddress;
address public stakingDistributionAddress;
uint256 public frozenAssets;
uint256 public fundsPool;
event AdminParametersUpdated(uint8 mintFundingPercentage, uint8 burnFundingPercentage, uint8 mintedClassId, uint32 individualMintingLimit,
address fundingDistributionAddress, address stakingDistributionAddress);
event BatchMetadataUpdate(uint256 _fromTokenId, uint256 _toTokenId);
event ClassArchivedAndFundsReleased(uint256 classId, uint256 heldAssets, uint256 heldFunding);
event FundsTransfers(uint256 amount, address to);
event Locked(uint256 tokenId);
event LockUpdatedByAdmins(uint256 tokenId, uint8 lockId);
event TokenBurned(address owner, uint8 classId, uint256 tokenId);
event TokenMinted(address initiater, address receipent, uint8 classId, uint256 firstTokenId, uint256 lastTokenId);
event TokenStaked(uint256 tokenId, uint256 stakedFunds);
event TokenUnstaked(uint256 tokenId);
event Unlocked(uint256 tokenId);
constructor(
string memory _baseURI,
address _fundingDistributionAddress,
address _stakingDistributionAddress,
address[] memory _initialAdmins,
address[] memory _founderAddresses,
uint32[] memory _initialFounderTokenAmounts,
uint32 _individualLimit,
uint32 _communityClassGlobalLimit
) TokenDataBasedERC721Psi("Launch Codes", "LCD", _baseURI) Administrable(_initialAdmins) {
if (_founderAddresses.length != _initialFounderTokenAmounts.length) revert LCDMismatchedArrayLengths();
fundingDistributionAddress = _fundingDistributionAddress;
stakingDistributionAddress = _stakingDistributionAddress;
individualMintingLimit = _individualLimit;
uint8 founderClassId = 254;
classes[mintedClassId] = Class(true, false, 0, _communityClassGlobalLimit, 0.1 ether, 0, 0, block.timestamp + 730 days);
classes[founderClassId] = Class(true, false, 0, type(uint32).max, 0, 0, 0, type(uint32).max);
for (uint i = 0; i < _founderAddresses.length; i++) {
_processMint(_founderAddresses[i], founderClassId, _initialFounderTokenAmounts[i], 0);
}
}
function royaltyInfo(uint tokenId, uint salePrice) public view override returns (address, uint256) {
if (!_exists(tokenId)) revert LCDTokenNotFound();
return (fundingDistributionAddress, salePrice * (mintFundingPercentage + burnFundingPercentage) / 100);
}
function mint(uint32 _amount) external payable classNotArchived(mintedClassId) correctMintingPrice(msg.value, mintedClassId, _amount) globalLimitNotMet(mintedClassId, _amount) {
if (individualCounts[_msgSender()].mintedCount + _amount > individualMintingLimit) revert LCDIndividualMintingLimitMet();
_processMint(_msgSender(), mintedClassId, _amount, msg.value);
}
function adminMint(address _to, uint8 _classId, uint32 _amount) external payable onlyAdmin classNotArchived(_classId) globalLimitNotMet(_classId, _amount)
classExists(_classId) correctMintingPrice(msg.value, _classId, _amount) {
_processMint(_to, _classId, _amount, msg.value);
}
function burn(uint256[] calldata _tokenIds) external {
if (_tokenIds.length == 0) revert LCDQuantityMustBeGreaterThanZero();
uint256 refundAmount = 0;
for (uint i = 0; i < _tokenIds.length; i++) {
refundAmount += _processBurn(_tokenIds[i]);
}
_sendFundsTo(_msgSender(), refundAmount);
}
function transferFundsPool() public whenNotPaused {
if (fundsPool == 0) revert LCDNoFundsToTransfer();
emit FundsTransfers(fundsPool, fundingDistributionAddress);
uint256 transferredAmount = fundsPool;
fundsPool = 0;
_sendFundsTo(fundingDistributionAddress, transferredAmount);
}
function registerClass(uint8 _id, uint32 _globalLimit, uint256 _price, uint256 _backstopEnd) external onlyAdmin {
if (classes[_id].active) revert LCDClassAlreadyExists();
if (block.timestamp >= _backstopEnd) revert LCDBackstopEndInTheFuture();
classes[_id] = Class(true, false, 0, _globalLimit, _price, 0, 0, _backstopEnd);
}
function updateAdminParameters(uint8 _mintFundingPercentage, uint8 _burnFundingPercentage, uint8 _mintedClassId, uint32 _individualMintingLimit,
address _fundingDistributionAddress, address _stakingDistributionAddress) external onlyAdmin classExists(_mintedClassId) {
fundingDistributionAddress = _fundingDistributionAddress;
stakingDistributionAddress = _stakingDistributionAddress;
mintedClassId = _mintedClassId;
individualMintingLimit = _individualMintingLimit;
mintFundingPercentage = _mintFundingPercentage;
burnFundingPercentage = _burnFundingPercentage;
emit AdminParametersUpdated(_mintFundingPercentage, _burnFundingPercentage, _mintedClassId, _individualMintingLimit,
_fundingDistributionAddress, _stakingDistributionAddress);
}
function setBaseURI(string memory _metadataBaseURI) external onlyAdmin {
_setBaseURI(_metadataBaseURI);
emit BatchMetadataUpdate(0, _nextTokenId() - 1);
}
function updateLocks(uint256[] calldata _tokenIds, uint8 _newLockType) external onlyAdmin {
uint256 currentTokenId;
uint8 currentTokenLockType;
for (uint256 i = 0; i < _tokenIds.length; ++i) {
currentTokenId = _tokenIds[i];
currentTokenLockType = tokenLockOf(currentTokenId);
if (currentTokenLockType == NO_LOCK || currentTokenLockType == STAKING_LOCK) revert LCDCannotUpdateLocksOnUnlockedOrStakedTokens();
if (_newLockType == STAKING_LOCK) revert LCDCannotAssignStakingLocks();
_setTokenLock(currentTokenId, _newLockType);
emit LockUpdatedByAdmins(currentTokenId, _newLockType);
if (_newLockType <= PENDING_LOCK) {
emit Unlocked(currentTokenId);
} else {
emit Locked(currentTokenId);
}
}
}
function stakeTokens(uint256[] calldata _tokenIds) external {
uint256 transferFunds;
uint256 currentTokenId;
TokenData memory currentTokenData;
for (uint256 i = 0; i < _tokenIds.length; ++i) {
currentTokenId = _tokenIds[i];
if (!_isApprovedOrOwner(_msgSender(), currentTokenId)) revert LCDNotTokenOwnerOrApproved();
if (tokenLockOf(currentTokenId) > PENDING_LOCK) revert LCDCanOnlyStakeUnlockedTokens();
_setTokenLock(currentTokenId, STAKING_LOCK);
currentTokenData = _unfilteredTokenDataOf(currentTokenId);
if (!_isClassBackstopExpired(currentTokenData.classId)) {
transferFunds += currentTokenData.heldAssets;
classes[currentTokenData.classId].totalUnstakedHeldAssets -= currentTokenData.heldAssets;
emit TokenStaked(currentTokenId, currentTokenData.heldAssets);
} else {
emit TokenStaked(currentTokenId, 0);
}
emit Locked(currentTokenId);
}
if (transferFunds > 0) {
frozenAssets -= transferFunds;
_sendFundsTo(stakingDistributionAddress, transferFunds);
}
}
function unstakeTokens(uint256[] calldata _tokenIds) external payable {
uint256 neededFunds;
uint8 lockType;
uint256 currentTokenId;
TokenData memory currentTokenData;
for (uint256 i = 0; i < _tokenIds.length; ++i) {
currentTokenId = _tokenIds[i];
if (!_isApprovedOrOwner(_msgSender(), currentTokenId)) revert LCDNotTokenOwnerOrApproved();
lockType = tokenLockOf(currentTokenId);
if (tokenLockOf(currentTokenId) != STAKING_LOCK) revert LCDCanOnlyUnstakeStakedTokens();
currentTokenData = _unfilteredTokenDataOf(currentTokenId);
if (!_isClassBackstopExpired(currentTokenData.classId)) {
neededFunds += currentTokenData.heldAssets;
classes[currentTokenData.classId].totalUnstakedHeldAssets += currentTokenData.heldAssets;
}
_setTokenLock(currentTokenId, NO_LOCK);
emit TokenUnstaked(currentTokenId);
emit Unlocked(currentTokenId);
}
if (neededFunds != msg.value) revert LCDInvalidPaidPrice();
frozenAssets += msg.value;
}
function archiveClassAndReleaseFunds(uint8[] calldata _classIds) external onlyAdmin {
uint256 totalUnstakedHeldAssets = 0;
uint256 totalUnstakedHeldFunding = 0;
for (uint i = 0; i < _classIds.length; ++i) {
Class storage currentClass = classes[_classIds[i]];
if (!currentClass.active) revert LCDClassNotFound();
if (!_isClassBackstopExpired(_classIds[i])) revert LCDClassStillBackstopped();
if (currentClass.archived) revert LCDClassAlreadyArchived();
totalUnstakedHeldAssets += currentClass.totalUnstakedHeldAssets;
totalUnstakedHeldFunding += currentClass.totalUnstakedHeldFunding;
emit ClassArchivedAndFundsReleased(_classIds[i], currentClass.totalUnstakedHeldAssets, currentClass.totalUnstakedHeldFunding);
currentClass.totalUnstakedHeldAssets = 0;
currentClass.totalUnstakedHeldFunding = 0;
currentClass.archived = true;
}
frozenAssets -= totalUnstakedHeldAssets;
fundsPool += totalUnstakedHeldAssets + totalUnstakedHeldFunding;
}
function _processMint(address _to, uint8 _classId, uint32 _amount, uint256 _pricePaid) internal {
if (_amount == 0) revert LCDQuantityMustBeGreaterThanZero();
classes[_classId].mintedCount += _amount;
uint256 heldAssets;
(uint256 mintFunding, uint256 burnFunding) = _getFundingAmounts(_amount, _classId);
if (mintFunding + burnFunding > 0) {
uint256 asset = _pricePaid - mintFunding - burnFunding;
fundsPool += mintFunding;
frozenAssets += asset;
heldAssets = asset / _amount;
classes[_classId].totalUnstakedHeldAssets += asset;
classes[_classId].totalUnstakedHeldFunding += burnFunding;
}
uint256 fistMintedTokenId = _nextTokenId();
_safeMint(_to, _amount);
_setTokenDataOf(fistMintedTokenId, _classId, heldAssets, burnFunding / _amount);
emit TokenMinted(_msgSender(), _to, _classId, fistMintedTokenId, _nextTokenId() - 1);
}
function _processBurn(uint256 _tokenId) internal unlocked(_tokenId) returns (uint256){
if (!_isApprovedOrOwner(_msgSender(), _tokenId)) revert LCDNotTokenOwnerOrApproved();
TokenData memory currentTokenData = tokenDataOf(_tokenId);
_burn(_tokenId);
emit TokenBurned(_msgSender(), currentTokenData.classId, _tokenId);
if (!_isClassBackstopExpired(currentTokenData.classId)) {
frozenAssets -= currentTokenData.heldAssets;
fundsPool += currentTokenData.heldFunding;
classes[currentTokenData.classId].totalUnstakedHeldAssets -= currentTokenData.heldAssets;
classes[currentTokenData.classId].totalUnstakedHeldFunding -= currentTokenData.heldFunding;
return currentTokenData.heldAssets;
}
return 0;
}
function _getFundingAmounts(uint256 _amount, uint8 _classId) internal view returns (uint256, uint256){
uint256 price = _amount * classes[_classId].price;
return (price * mintFundingPercentage / 100, price * burnFundingPercentage / 100);
}
function _sendFundsTo(address _to, uint256 _amount) internal {
(bool sent,) = payable(_to).call{value: _amount}("");
if (!sent) revert LCDFundsTransferFailed();
}
function _beforeTokenTransfers(
address from,
address to,
uint256 startTokenId,
uint256 quantity
) internal override whenNotPaused unlocked(startTokenId) {}
modifier classExists(uint8 _classId){
if (!classes[_classId].active) revert LCDClassNotFound();
_;
}
modifier correctMintingPrice(uint256 _paidAmount, uint8 _classId, uint32 _amountOfTokens){
if (_paidAmount != classes[_classId].price * _amountOfTokens) revert LCDInvalidPaidPrice();
_;
}
modifier classNotArchived(uint8 _classId){
if (classes[_classId].archived) revert LCDClassAlreadyArchived();
_;
}
modifier globalLimitNotMet(uint8 _classId, uint32 _amount){
if (classes[_classId].mintedCount + _amount > classes[_classId].mintingLimit) revert LCDGlobalMintingLimitMet();
_;
}
}
