文件 1 的 7：DN404.sol
pragma solidity ^0.8.4;
abstract contract DN404 {
event Transfer(address indexed from, address indexed to, uint256 amount);
event Approval(address indexed owner, address indexed spender, uint256 amount);
event SkipNFTSet(address indexed target, bool status);
uint256 private constant _TRANSFER_EVENT_SIGNATURE =
0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef;
uint256 private constant _APPROVAL_EVENT_SIGNATURE =
0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925;
uint256 private constant _SKIP_NFT_SET_EVENT_SIGNATURE =
0xb5a1de456fff688115a4f75380060c23c8532d14ff85f687cc871456d6420393;
error DNAlreadyInitialized();
error InsufficientBalance();
error InsufficientAllowance();
error TotalSupplyOverflow();
error UnitIsZero();
error SenderNotMirror();
error TransferToZeroAddress();
error MirrorAddressIsZero();
error LinkMirrorContractFailed();
error ApprovalCallerNotOwnerNorApproved();
error TransferCallerNotOwnerNorApproved();
error TransferFromIncorrectOwner();
error TokenDoesNotExist();
error FnSelectorNotRecognized();
uint8 internal constant _ADDRESS_DATA_INITIALIZED_FLAG = 1 << 0;
uint8 internal constant _ADDRESS_DATA_SKIP_NFT_FLAG = 1 << 1;
uint8 internal constant _ADDRESS_DATA_OVERRIDE_PERMIT2_FLAG = 1 << 2;
address internal constant _PERMIT2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;
struct AddressData {
uint88 aux;
uint8 flags;
uint32 addressAlias;
uint32 ownedLength;
uint96 balance;
}
struct Uint32Map {
uint256 spacer;
}
struct Bitmap {
uint256 spacer;
}
struct Uint256Ref {
uint256 value;
}
struct AddressPairToUint256RefMap {
uint256 spacer;
}
struct DN404Storage {
uint32 numAliases;
uint32 nextTokenId;
uint32 burnedPoolHead;
uint32 burnedPoolTail;
uint32 totalNFTSupply;
uint96 totalSupply;
address mirrorERC721;
mapping(uint32 => address) aliasToAddress;
AddressPairToUint256RefMap operatorApprovals;
mapping(uint256 => address) nftApprovals;
Bitmap mayHaveNFTApproval;
Bitmap exists;
AddressPairToUint256RefMap allowance;
mapping(address => Uint32Map) owned;
Uint32Map burnedPool;
Uint32Map oo;
mapping(address => AddressData) addressData;
}
function _getDN404Storage() internal pure virtual returns (DN404Storage storage $) {
assembly {
$.slot := 0xa20d6e21d0e5255308
}
}
function _initializeDN404(
uint256 initialTokenSupply,
address initialSupplyOwner,
address mirror
) internal virtual {
DN404Storage storage $ = _getDN404Storage();
if ($.nextTokenId != 0) revert DNAlreadyInitialized();
if (mirror == address(0)) revert MirrorAddressIsZero();
assembly {
mstore(0x00, 0x0f4599e5)
mstore(0x20, caller())
if iszero(and(eq(mload(0x00), 1), call(gas(), mirror, 0, 0x1c, 0x24, 0x00, 0x20))) {
mstore(0x00, 0xd125259c)
revert(0x1c, 0x04)
}
}
$.nextTokenId = 1;
$.mirrorERC721 = mirror;
if (_unit() == 0) revert UnitIsZero();
if (initialTokenSupply != 0) {
if (initialSupplyOwner == address(0)) revert TransferToZeroAddress();
if (_totalSupplyOverflows(initialTokenSupply)) revert TotalSupplyOverflow();
$.totalSupply = uint96(initialTokenSupply);
AddressData storage initialOwnerAddressData = _addressData(initialSupplyOwner);
initialOwnerAddressData.balance = uint96(initialTokenSupply);
assembly {
mstore(0x00, initialTokenSupply)
log3(0x00, 0x20, _TRANSFER_EVENT_SIGNATURE, 0, shr(96, shl(96, initialSupplyOwner)))
}
_setSkipNFT(initialSupplyOwner, true);
}
}
function _unit() internal view virtual returns (uint256) {
return 10 ** 18;
}
function name() public view virtual returns (string memory);
function symbol() public view virtual returns (string memory);
function tokenURI(uint256 id) external view virtual returns (string memory);
function decimals() public pure returns (uint8) {
return 18;
}
function totalSupply() public view virtual returns (uint256) {
return uint256(_getDN404Storage().totalSupply);
}
function balanceOf(address owner) public view virtual returns (uint256) {
return _getDN404Storage().addressData[owner].balance;
}
function allowance(address owner, address spender) public view returns (uint256) {
if (_givePermit2DefaultInfiniteAllowance() && spender == _PERMIT2) {
uint8 flags = _getDN404Storage().addressData[owner].flags;
if (flags & _ADDRESS_DATA_OVERRIDE_PERMIT2_FLAG == 0) return type(uint256).max;
}
return _ref(_getDN404Storage().allowance, owner, spender).value;
}
function approve(address spender, uint256 amount) public virtual returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transfer(address to, uint256 amount) public virtual returns (bool) {
_transfer(msg.sender, to, amount);
return true;
}
function transferFrom(address from, address to, uint256 amount) public virtual returns (bool) {
Uint256Ref storage a = _ref(_getDN404Storage().allowance, from, msg.sender);
uint256 allowed = _givePermit2DefaultInfiniteAllowance() && msg.sender == _PERMIT2
&& (_getDN404Storage().addressData[from].flags & _ADDRESS_DATA_OVERRIDE_PERMIT2_FLAG) == 0
? type(uint256).max
: a.value;
if (allowed != type(uint256).max) {
if (amount > allowed) revert InsufficientAllowance();
unchecked {
a.value = allowed - amount;
}
}
_transfer(from, to, amount);
return true;
}
function _givePermit2DefaultInfiniteAllowance() internal view virtual returns (bool) {
return false;
}
function _mint(address to, uint256 amount) internal virtual {
if (to == address(0)) revert TransferToZeroAddress();
AddressData storage toAddressData = _addressData(to);
DN404Storage storage $ = _getDN404Storage();
_DNMintTemps memory t;
unchecked {
uint256 toBalance = uint256(toAddressData.balance) + amount;
toAddressData.balance = uint96(toBalance);
t.toEnd = toBalance / _unit();
}
uint256 maxId;
unchecked {
uint256 totalSupply_ = uint256($.totalSupply) + amount;
$.totalSupply = uint96(totalSupply_);
uint256 overflows = _toUint(_totalSupplyOverflows(totalSupply_));
if (overflows | _toUint(totalSupply_ < amount) != 0) revert TotalSupplyOverflow();
maxId = totalSupply_ / _unit();
}
unchecked {
if (toAddressData.flags & _ADDRESS_DATA_SKIP_NFT_FLAG == 0) {
Uint32Map storage toOwned = $.owned[to];
Uint32Map storage oo = $.oo;
uint256 toIndex = toAddressData.ownedLength;
_DNPackedLogs memory packedLogs = _packedLogsMalloc(_zeroFloorSub(t.toEnd, toIndex));
if (packedLogs.logs.length != 0) {
_packedLogsSet(packedLogs, to, 0);
$.totalNFTSupply += uint32(packedLogs.logs.length);
toAddressData.ownedLength = uint32(t.toEnd);
t.toAlias = _registerAndResolveAlias(toAddressData, to);
uint32 burnedPoolHead = $.burnedPoolHead;
uint32 burnedPoolTail = $.burnedPoolTail;
uint256 nextTokenId = $.nextTokenId;
do {
uint256 id;
if (burnedPoolHead != burnedPoolTail) {
id = _get($.burnedPool, burnedPoolHead++);
} else {
id = nextTokenId;
while (_get(oo, _ownershipIndex(id)) != 0) {
id = _useExistsLookup()
? _wrapNFTId(_findFirstUnset($.exists, id + 1, maxId + 1), maxId)
: _wrapNFTId(id + 1, maxId);
}
nextTokenId = _wrapNFTId(id + 1, maxId);
}
if (_useExistsLookup()) _set($.exists, id, true);
_set(toOwned, toIndex, uint32(id));
_setOwnerAliasAndOwnedIndex(oo, id, t.toAlias, uint32(toIndex++));
_packedLogsAppend(packedLogs, id);
} while (toIndex != t.toEnd);
$.nextTokenId = uint32(nextTokenId);
$.burnedPoolHead = burnedPoolHead;
_packedLogsSend(packedLogs, $.mirrorERC721);
}
}
}
assembly {
mstore(0x00, amount)
log3(0x00, 0x20, _TRANSFER_EVENT_SIGNATURE, 0, shr(96, shl(96, to)))
}
}
function _transfer(address from, address to, uint256 amount) internal virtual {
if (to == address(0)) revert TransferToZeroAddress();
AddressData storage fromAddressData = _addressData(from);
AddressData storage toAddressData = _addressData(to);
DN404Storage storage $ = _getDN404Storage();
_DNTransferTemps memory t;
t.fromOwnedLength = fromAddressData.ownedLength;
t.toOwnedLength = toAddressData.ownedLength;
t.totalSupply = $.totalSupply;
if (amount > (t.fromBalance = fromAddressData.balance)) revert InsufficientBalance();
_beforeToken20Transfers(from, to, amount);
unchecked {
fromAddressData.balance = uint96(t.fromBalance -= amount);
toAddressData.balance = uint96(t.toBalance = uint256(toAddressData.balance) + amount);
t.numNFTBurns = _zeroFloorSub(t.fromOwnedLength, t.fromBalance / _unit());
if (toAddressData.flags & _ADDRESS_DATA_SKIP_NFT_FLAG == 0) {
if (from == to) t.toOwnedLength = t.fromOwnedLength - t.numNFTBurns;
t.numNFTMints = _zeroFloorSub(t.toBalance / _unit(), t.toOwnedLength);
}
t.totalNFTSupply = uint256($.totalNFTSupply) + t.numNFTMints - t.numNFTBurns;
$.totalNFTSupply = uint32(t.totalNFTSupply);
Uint32Map storage oo = $.oo;
if (_toUint(_useDirectTransfersIfPossible()) & _toUint(from != to) != 0) {
uint256 n = _min(t.fromOwnedLength, _min(t.numNFTBurns, t.numNFTMints));
if (n != 0) {
_DNDirectLogs memory directLogs = _directLogsMalloc(n, from, to);
t.numNFTBurns -= n;
t.numNFTMints -= n;
Uint32Map storage fromOwned = $.owned[from];
Uint32Map storage toOwned = $.owned[to];
t.toAlias = _registerAndResolveAlias(toAddressData, to);
do {
uint256 id = _get(fromOwned, --t.fromOwnedLength);
_set(toOwned, t.toOwnedLength, uint32(id));
_setOwnerAliasAndOwnedIndex(oo, id, t.toAlias, uint32(t.toOwnedLength++));
_directLogsAppend(directLogs, id);
if (_get($.mayHaveNFTApproval, id)) {
_set($.mayHaveNFTApproval, id, false);
delete $.nftApprovals[id];
}
} while (--n != 0);
_directLogsSend(directLogs, $.mirrorERC721);
fromAddressData.ownedLength = uint32(t.fromOwnedLength);
toAddressData.ownedLength = uint32(t.toOwnedLength);
}
}
_DNPackedLogs memory packedLogs = _packedLogsMalloc(t.numNFTBurns + t.numNFTMints);
t.burnedPoolTail = $.burnedPoolTail;
if (t.numNFTBurns != 0) {
_packedLogsSet(packedLogs, from, 1);
bool addToBurnedPool = _addToBurnedPool(t.totalNFTSupply, t.totalSupply);
Uint32Map storage fromOwned = $.owned[from];
uint256 fromIndex = t.fromOwnedLength;
fromAddressData.ownedLength = uint32(t.fromEnd = fromIndex - t.numNFTBurns);
uint32 burnedPoolTail = t.burnedPoolTail;
do {
uint256 id = _get(fromOwned, --fromIndex);
_setOwnerAliasAndOwnedIndex(oo, id, 0, 0);
_packedLogsAppend(packedLogs, id);
if (_useExistsLookup()) _set($.exists, id, false);
if (addToBurnedPool) _set($.burnedPool, burnedPoolTail++, uint32(id));
if (_get($.mayHaveNFTApproval, id)) {
_set($.mayHaveNFTApproval, id, false);
delete $.nftApprovals[id];
}
} while (fromIndex != t.fromEnd);
if (addToBurnedPool) $.burnedPoolTail = (t.burnedPoolTail = burnedPoolTail);
}
if (t.numNFTMints != 0) {
_packedLogsSet(packedLogs, to, 0);
t.nextTokenId = $.nextTokenId;
Uint32Map storage toOwned = $.owned[to];
t.toAlias = _registerAndResolveAlias(toAddressData, to);
uint256 maxId = t.totalSupply / _unit();
uint256 toIndex = t.toOwnedLength;
toAddressData.ownedLength = uint32(t.toEnd = toIndex + t.numNFTMints);
uint32 burnedPoolHead = $.burnedPoolHead;
do {
uint256 id;
if (burnedPoolHead != t.burnedPoolTail) {
id = _get($.burnedPool, burnedPoolHead++);
} else {
id = t.nextTokenId;
while (_get(oo, _ownershipIndex(id)) != 0) {
id = _useExistsLookup()
? _wrapNFTId(_findFirstUnset($.exists, id + 1, maxId + 1), maxId)
: _wrapNFTId(id + 1, maxId);
}
t.nextTokenId = _wrapNFTId(id + 1, maxId);
}
if (_useExistsLookup()) _set($.exists, id, true);
_set(toOwned, toIndex, uint32(id));
_setOwnerAliasAndOwnedIndex(oo, id, t.toAlias, uint32(toIndex++));
_packedLogsAppend(packedLogs, id);
} while (toIndex != t.toEnd);
$.burnedPoolHead = burnedPoolHead;
$.nextTokenId = uint32(t.nextTokenId);
}
if (packedLogs.logs.length != 0) {
_packedLogsSend(packedLogs, $.mirrorERC721);
}
}
assembly {
mstore(0x00, amount)
log3(0x00, 0x20, _TRANSFER_EVENT_SIGNATURE, shr(96, shl(96, from)), shr(96, shl(96, to)))
}
_afterToken20Transfers(from, to, amount);
}
function _useDirectTransfersIfPossible() internal view virtual returns (bool) {
return true;
}
function _addToBurnedPool(uint256 totalNFTSupplyAfterBurn, uint256 totalSupplyAfterBurn)
internal
view
virtual
returns (bool)
{
totalNFTSupplyAfterBurn = totalNFTSupplyAfterBurn;
totalSupplyAfterBurn = totalSupplyAfterBurn;
return false;
}
function _useExistsLookup() internal pure virtual returns (bool) {
return true;
}
function _transferFromNFT(address from, address to, uint256 id, address msgSender)
internal
virtual
{
DN404Storage storage $ = _getDN404Storage();
if (to == address(0)) revert TransferToZeroAddress();
Uint32Map storage oo = $.oo;
if (from != $.aliasToAddress[_get(oo, _ownershipIndex(_restrictNFTId(id)))]) {
revert TransferFromIncorrectOwner();
}
if (msgSender != from) {
if (_ref($.operatorApprovals, from, msgSender).value == 0) {
if (msgSender != $.nftApprovals[id]) {
revert TransferCallerNotOwnerNorApproved();
}
}
}
AddressData storage fromAddressData = _addressData(from);
AddressData storage toAddressData = _addressData(to);
uint256 unit = _unit();
unchecked {
{
uint256 fromBalance = fromAddressData.balance;
if (unit > fromBalance) revert InsufficientBalance();
_beforeTokenTransfersNFT(from, to, id);
fromAddressData.balance = uint96(fromBalance - unit);
toAddressData.balance += uint96(unit);
}
mapping(address => Uint32Map) storage owned = $.owned;
Uint32Map storage fromOwned = owned[from];
if (_get($.mayHaveNFTApproval, id)) {
_set($.mayHaveNFTApproval, id, false);
delete $.nftApprovals[id];
}
{
uint32 updatedId = _get(fromOwned, --fromAddressData.ownedLength);
uint32 i = _get(oo, _ownedIndex(id));
_set(fromOwned, i, updatedId);
_set(oo, _ownedIndex(updatedId), i);
}
uint32 n = toAddressData.ownedLength++;
_set(owned[to], n, uint32(id));
_setOwnerAliasAndOwnedIndex(oo, id, _registerAndResolveAlias(toAddressData, to), n);
}
assembly {
mstore(0x00, unit)
log3(0x00, 0x20, _TRANSFER_EVENT_SIGNATURE, shr(96, shl(96, from)), shr(96, shl(96, to)))
}
_afterTokenTransfersNFT(from, to, id);
}
function _beforeTokenTransfersNFT(
address from,
address to,
uint256 tokenId
) internal virtual {}
function _afterTokenTransfersNFT(
address from,
address to,
uint256 tokenId
) internal virtual {}
function _beforeToken20Transfers(
address from,
address to,
uint256 amount
) internal virtual {}
function _afterToken20Transfers(
address from,
address to,
uint256 amount
) internal virtual {}
function _approve(address owner, address spender, uint256 amount) internal virtual {
if (_givePermit2DefaultInfiniteAllowance() && spender == _PERMIT2) {
_getDN404Storage().addressData[owner].flags |= _ADDRESS_DATA_OVERRIDE_PERMIT2_FLAG;
}
_ref(_getDN404Storage().allowance, owner, spender).value = amount;
assembly {
mstore(0x00, amount)
log3(0x00, 0x20, _APPROVAL_EVENT_SIGNATURE, shr(96, shl(96, owner)), shr(96, shl(96, spender)))
}
}
function _getAux(address owner) internal view virtual returns (uint88) {
return _getDN404Storage().addressData[owner].aux;
}
function _setAux(address owner, uint88 value) internal virtual {
_getDN404Storage().addressData[owner].aux = value;
}
function getSkipNFT(address owner) public view virtual returns (bool) {
AddressData storage d = _getDN404Storage().addressData[owner];
if (d.flags & _ADDRESS_DATA_INITIALIZED_FLAG == 0) return _hasCode(owner);
return d.flags & _ADDRESS_DATA_SKIP_NFT_FLAG != 0;
}
function setSkipNFT(bool skipNFT) public virtual returns (bool) {
_setSkipNFT(msg.sender, skipNFT);
return true;
}
function _setSkipNFT(address owner, bool state) internal virtual {
AddressData storage d = _addressData(owner);
if ((d.flags & _ADDRESS_DATA_SKIP_NFT_FLAG != 0) != state) {
d.flags ^= _ADDRESS_DATA_SKIP_NFT_FLAG;
}
assembly {
mstore(0x00, iszero(iszero(state)))
log2(0x00, 0x20, _SKIP_NFT_SET_EVENT_SIGNATURE, shr(96, shl(96, owner)))
}
}
function _addressData(address owner) internal virtual returns (AddressData storage d) {
d = _getDN404Storage().addressData[owner];
unchecked {
if (d.flags & _ADDRESS_DATA_INITIALIZED_FLAG == 0) {
uint256 skipNFT = (_toUint(_hasCode(owner)) * _ADDRESS_DATA_SKIP_NFT_FLAG);
d.flags = uint8(skipNFT | _ADDRESS_DATA_INITIALIZED_FLAG);
}
}
}
function _registerAndResolveAlias(AddressData storage toAddressData, address to)
internal
virtual
returns (uint32 addressAlias)
{
DN404Storage storage $ = _getDN404Storage();
addressAlias = toAddressData.addressAlias;
if (addressAlias == 0) {
unchecked {
addressAlias = ++$.numAliases;
}
toAddressData.addressAlias = addressAlias;
$.aliasToAddress[addressAlias] = to;
if (addressAlias == 0) revert();
}
}
function mirrorERC721() public view virtual returns (address) {
return _getDN404Storage().mirrorERC721;
}
function _totalNFTSupply() internal view virtual returns (uint256) {
return _getDN404Storage().totalNFTSupply;
}
function _balanceOfNFT(address owner) internal view virtual returns (uint256) {
return _getDN404Storage().addressData[owner].ownedLength;
}
function _ownerAt(uint256 id) internal view virtual returns (address) {
DN404Storage storage $ = _getDN404Storage();
return $.aliasToAddress[_get($.oo, _ownershipIndex(_restrictNFTId(id)))];
}
function _ownerOf(uint256 id) internal view virtual returns (address) {
if (!_exists(id)) revert TokenDoesNotExist();
return _ownerAt(id);
}
function _exists(uint256 id) internal view virtual returns (bool) {
return _ownerAt(id) != address(0);
}
function _getApproved(uint256 id) internal view virtual returns (address) {
if (!_exists(id)) revert TokenDoesNotExist();
return _getDN404Storage().nftApprovals[id];
}
function _approveNFT(address spender, uint256 id, address msgSender)
internal
virtual
returns (address owner)
{
DN404Storage storage $ = _getDN404Storage();
owner = $.aliasToAddress[_get($.oo, _ownershipIndex(_restrictNFTId(id)))];
if (msgSender != owner) {
if (_ref($.operatorApprovals, owner, msgSender).value == 0) {
revert ApprovalCallerNotOwnerNorApproved();
}
}
$.nftApprovals[id] = spender;
_set($.mayHaveNFTApproval, id, spender != address(0));
}
function _setApprovalForAll(address operator, bool approved, address msgSender)
internal
virtual
{
_ref(_getDN404Storage().operatorApprovals, msgSender, operator).value = _toUint(approved);
}
function _ownedIds(address owner, uint256 begin, uint256 end)
internal
view
virtual
returns (uint256[] memory ids)
{
DN404Storage storage $ = _getDN404Storage();
Uint32Map storage owned = $.owned[owner];
uint256 n = $.addressData[owner].ownedLength;
assembly {
n := xor(n, mul(lt(end, n), xor(end, n)))
ids := mload(0x40)
let i := begin
for {} lt(i, n) { i := add(i, 1) } {
let s := add(shl(96, owned.slot), shr(3, i))
let id := and(0xffffffff, shr(shl(5, and(i, 7)), sload(s)))
mstore(add(add(ids, 0x20), shl(5, sub(i, begin))), id)
}
mstore(ids, sub(i, begin))
mstore(0x40, add(add(ids, 0x20), shl(5, sub(i, begin))))
}
}
modifier dn404Fallback() virtual {
DN404Storage storage $ = _getDN404Storage();
uint256 fnSelector = _calldataload(0x00) >> 224;
if (fnSelector == 0xe5eb36c8) {
if (msg.sender != $.mirrorERC721) revert SenderNotMirror();
if (msg.data.length < 0x84) revert();
address from = address(uint160(_calldataload(0x04)));
address to = address(uint160(_calldataload(0x24)));
uint256 id = _calldataload(0x44);
address msgSender = address(uint160(_calldataload(0x64)));
_transferFromNFT(from, to, id, msgSender);
_return(1);
}
if (fnSelector == 0x813500fc) {
if (msg.sender != $.mirrorERC721) revert SenderNotMirror();
if (msg.data.length < 0x64) revert();
address spender = address(uint160(_calldataload(0x04)));
bool status = _calldataload(0x24) != 0;
address msgSender = address(uint160(_calldataload(0x44)));
_setApprovalForAll(spender, status, msgSender);
_return(1);
}
if (fnSelector == 0xe985e9c5) {
if (msg.sender != $.mirrorERC721) revert SenderNotMirror();
if (msg.data.length < 0x44) revert();
address owner = address(uint160(_calldataload(0x04)));
address operator = address(uint160(_calldataload(0x24)));
_return(_ref($.operatorApprovals, owner, operator).value);
}
if (fnSelector == 0x6352211e) {
if (msg.sender != $.mirrorERC721) revert SenderNotMirror();
if (msg.data.length < 0x24) revert();
uint256 id = _calldataload(0x04);
_return(uint160(_ownerOf(id)));
}
if (fnSelector == 0x24359879) {
if (msg.sender != $.mirrorERC721) revert SenderNotMirror();
if (msg.data.length < 0x24) revert();
uint256 id = _calldataload(0x04);
_return(uint160(_ownerAt(id)));
}
if (fnSelector == 0xd10b6e0c) {
if (msg.sender != $.mirrorERC721) revert SenderNotMirror();
if (msg.data.length < 0x64) revert();
address spender = address(uint160(_calldataload(0x04)));
uint256 id = _calldataload(0x24);
address msgSender = address(uint160(_calldataload(0x44)));
_return(uint160(_approveNFT(spender, id, msgSender)));
}
if (fnSelector == 0x081812fc) {
if (msg.sender != $.mirrorERC721) revert SenderNotMirror();
if (msg.data.length < 0x24) revert();
uint256 id = _calldataload(0x04);
_return(uint160(_getApproved(id)));
}
if (fnSelector == 0xf5b100ea) {
if (msg.sender != $.mirrorERC721) revert SenderNotMirror();
if (msg.data.length < 0x24) revert();
address owner = address(uint160(_calldataload(0x04)));
_return(_balanceOfNFT(owner));
}
if (fnSelector == 0xe2c79281) {
if (msg.sender != $.mirrorERC721) revert SenderNotMirror();
if (msg.data.length < 0x04) revert();
_return(_totalNFTSupply());
}
if (fnSelector == 0xb7a94eb8) {
_return(1);
}
_;
}
fallback() external payable virtual dn404Fallback {
revert FnSelectorNotRecognized();
}
receive() external payable virtual {
if (msg.value != 0) revert();
}
function _ownershipIndex(uint256 i) internal pure returns (uint256) {
unchecked {
return (i - 1) << 1;
}
}
function _ownedIndex(uint256 i) internal pure returns (uint256) {
unchecked {
return ((i - 1) << 1) + 1;
}
}
function _get(Uint32Map storage map, uint256 index) internal view returns (uint32 result) {
assembly {
let s := add(shl(96, map.slot), shr(3, index))
result := and(0xffffffff, shr(shl(5, and(index, 7)), sload(s)))
}
}
function _set(Uint32Map storage map, uint256 index, uint32 value) internal {
assembly {
let s := add(shl(96, map.slot), shr(3, index))
let o := shl(5, and(index, 7))
let v := sload(s)
let m := 0xffffffff
sstore(s, xor(v, shl(o, and(m, xor(shr(o, v), value)))))
}
}
function _setOwnerAliasAndOwnedIndex(
Uint32Map storage map,
uint256 id,
uint32 ownership,
uint32 ownedIndex
) internal {
assembly {
let i := sub(id, 1)
let s := add(shl(96, map.slot), shr(2, i))
let o := shl(6, and(i, 3))
let v := sload(s)
let m := 0xffffffffffffffff
let combined := or(shl(32, ownedIndex), and(0xffffffff, ownership))
sstore(s, xor(v, shl(o, and(m, xor(shr(o, v), combined)))))
}
}
function _get(Bitmap storage bitmap, uint256 index) internal view returns (bool result) {
assembly {
let s := add(shl(96, bitmap.slot), shr(8, index))
result := and(1, shr(and(0xff, index), sload(s)))
}
}
function _set(Bitmap storage bitmap, uint256 index, bool value) internal {
assembly {
let s := add(shl(96, bitmap.slot), shr(8, index))
let o := and(0xff, index)
sstore(s, or(and(sload(s), not(shl(o, 1))), shl(o, iszero(iszero(value)))))
}
}
function _findFirstUnset(Bitmap storage bitmap, uint256 begin, uint256 end)
internal
view
returns (uint256 unsetBitIndex)
{
assembly {
unsetBitIndex := not(0)
let s := shl(96, bitmap.slot)
let bucket := add(s, shr(8, begin))
let negBits := shl(and(0xff, begin), shr(and(0xff, begin), not(sload(bucket))))
if iszero(negBits) {
let lastBucket := add(s, shr(8, end))
for {} 1 {} {
bucket := add(bucket, 1)
negBits := not(sload(bucket))
if or(negBits, gt(bucket, lastBucket)) { break }
}
if gt(bucket, lastBucket) {
negBits := shr(and(0xff, not(end)), shl(and(0xff, not(end)), negBits))
}
}
if negBits {
let b := and(negBits, add(not(negBits), 1))
let r := shl(7, lt(0xffffffffffffffffffffffffffffffff, b))
r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, b))))
r := or(r, shl(5, lt(0xffffffff, shr(r, b))))
r := or(r, byte(and(div(0xd76453e0, shr(r, b)), 0x1f),
0x001f0d1e100c1d070f090b19131c1706010e11080a1a141802121b1503160405))
r := or(shl(8, sub(bucket, s)), r)
unsetBitIndex := or(r, sub(0, or(iszero(lt(r, end)), lt(r, begin))))
}
}
}
function _ref(AddressPairToUint256RefMap storage map, address a0, address a1)
internal
pure
returns (Uint256Ref storage ref)
{
assembly {
mstore(0x28, a1)
mstore(0x14, a0)
mstore(0x00, map.slot)
ref.slot := keccak256(0x00, 0x48)
mstore(0x28, 0x00)
}
}
function _wrapNFTId(uint256 id, uint256 maxId) internal pure returns (uint256 result) {
assembly {
result := or(mul(iszero(gt(id, maxId)), id), gt(id, maxId))
}
}
function _restrictNFTId(uint256 id) internal pure returns (uint256 result) {
assembly {
result := mul(id, lt(id, 0x100000000))
}
}
function _totalSupplyOverflows(uint256 amount) internal view returns (bool) {
unchecked {
return _toUint(amount > type(uint96).max)
| _toUint(amount / _unit() > type(uint32).max - 1) != 0;
}
}
function _zeroFloorSub(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := mul(gt(x, y), sub(x, y))
}
}
function _min(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := xor(x, mul(xor(x, y), lt(y, x)))
}
}
function _toUint(bool b) internal pure returns (uint256 result) {
assembly {
result := iszero(iszero(b))
}
}
struct _DNDirectLogs {
uint256 offset;
address from;
address to;
uint256[] logs;
}
function _directLogsMalloc(uint256 n, address from, address to)
private
pure
returns (_DNDirectLogs memory p)
{
assembly {
let logs := mload(0x40)
mstore(logs, n)
let offset := add(0x20, logs)
mstore(0x40, add(offset, shl(5, n)))
mstore(add(0x60, p), logs)
mstore(add(0x40, p), to)
mstore(add(0x20, p), from)
mstore(p, offset)
}
}
function _directLogsAppend(_DNDirectLogs memory p, uint256 id) private pure {
assembly {
let offset := mload(p)
mstore(offset, id)
mstore(p, add(offset, 0x20))
}
}
function _directLogsSend(_DNDirectLogs memory p, address mirror) private {
assembly {
let logs := mload(add(p, 0x60))
let n := add(0x84, shl(5, mload(logs)))
let o := sub(logs, 0x80)
mstore(o, 0x144027d3)
mstore(add(o, 0x20), mload(add(0x20, p)))
mstore(add(o, 0x40), mload(add(0x40, p)))
mstore(add(o, 0x60), 0x60)
if iszero(and(eq(mload(o), 1), call(gas(), mirror, 0, add(o, 0x1c), n, o, 0x20))) {
revert(o, 0x00)
}
}
}
struct _DNPackedLogs {
uint256 offset;
uint256 addressAndBit;
uint256[] logs;
}
function _packedLogsMalloc(uint256 n) private pure returns (_DNPackedLogs memory p) {
assembly {
let logs := mload(0x40)
mstore(logs, n)
let offset := add(0x20, logs)
mstore(0x40, add(offset, shl(5, n)))
mstore(add(0x40, p), logs)
mstore(p, offset)
}
}
function _packedLogsSet(_DNPackedLogs memory p, address a, uint256 burnBit) private pure {
assembly {
mstore(add(p, 0x20), or(shl(96, a), burnBit))
}
}
function _packedLogsAppend(_DNPackedLogs memory p, uint256 id) private pure {
assembly {
let offset := mload(p)
mstore(offset, or(mload(add(p, 0x20)), shl(8, id)))
mstore(p, add(offset, 0x20))
}
}
function _packedLogsSend(_DNPackedLogs memory p, address mirror) private {
assembly {
let logs := mload(add(p, 0x40))
let o := sub(logs, 0x40)
mstore(o, 0x263c69d6)
mstore(add(o, 0x20), 0x20)
let n := add(0x44, shl(5, mload(logs)))
if iszero(and(eq(mload(o), 1), call(gas(), mirror, 0, add(o, 0x1c), n, o, 0x20))) {
revert(o, 0x00)
}
}
}
struct _DNTransferTemps {
uint256 numNFTBurns;
uint256 numNFTMints;
uint256 fromBalance;
uint256 toBalance;
uint256 fromOwnedLength;
uint256 toOwnedLength;
uint256 totalSupply;
uint256 totalNFTSupply;
uint256 fromEnd;
uint256 toEnd;
uint32 toAlias;
uint256 nextTokenId;
uint32 burnedPoolTail;
}
struct _DNMintTemps {
uint256 toEnd;
uint32 toAlias;
}
function _hasCode(address a) private view returns (bool result) {
assembly {
result := extcodesize(a)
}
}
function _calldataload(uint256 offset) private pure returns (uint256 value) {
assembly {
value := calldataload(offset)
}
}
function _return(uint256 x) private pure {
assembly {
mstore(0x00, x)
return(0x00, 0x20)
}
}
}
文件 2 的 7：DN404Mirror.sol
pragma solidity ^0.8.4;
contract DN404Mirror {
event Transfer(address indexed from, address indexed to, uint256 indexed id);
event Approval(address indexed owner, address indexed account, uint256 indexed id);
event ApprovalForAll(address indexed owner, address indexed operator, bool isApproved);
event OwnershipTransferred(address indexed oldOwner, address indexed newOwner);
uint256 private constant _TRANSFER_EVENT_SIGNATURE =
0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef;
uint256 private constant _APPROVAL_EVENT_SIGNATURE =
0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925;
uint256 private constant _APPROVAL_FOR_ALL_EVENT_SIGNATURE =
0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31;
error SenderNotBase();
error SenderNotDeployer();
error TransferToNonERC721ReceiverImplementer();
error CannotLink();
error AlreadyLinked();
error NotLinked();
error FnSelectorNotRecognized();
struct DN404NFTStorage {
address baseERC20;
address deployer;
address owner;
}
function _getDN404NFTStorage() internal pure virtual returns (DN404NFTStorage storage $) {
assembly {
$.slot := 0x3602298b8c10b01230
}
}
constructor(address deployer) {
_getDN404NFTStorage().deployer = deployer;
}
function name() public view virtual returns (string memory result) {
return _readString(0x06fdde03, 0);
}
function symbol() public view virtual returns (string memory result) {
return _readString(0x95d89b41, 0);
}
function tokenURI(uint256 id) public view virtual returns (string memory result) {
return _readString(0xc87b56dd, id);
}
function totalSupply() public view virtual returns (uint256 result) {
return _readWord(0xe2c79281, 0, 0);
}
function balanceOf(address nftOwner) public view virtual returns (uint256 result) {
return _readWord(0xf5b100ea, uint160(nftOwner), 0);
}
function ownerOf(uint256 id) public view virtual returns (address result) {
return address(uint160(_readWord(0x6352211e, id, 0)));
}
function ownerAt(uint256 id) public view virtual returns (address result) {
return address(uint160(_readWord(0x24359879, id, 0)));
}
function approve(address spender, uint256 id) public virtual {
address base = baseERC20();
assembly {
spender := shr(96, shl(96, spender))
let m := mload(0x40)
mstore(0x00, 0xd10b6e0c)
mstore(0x20, spender)
mstore(0x40, id)
mstore(0x60, caller())
if iszero(
and(
gt(returndatasize(), 0x1f),
call(gas(), base, callvalue(), 0x1c, 0x64, 0x00, 0x20)
)
) {
returndatacopy(m, 0x00, returndatasize())
revert(m, returndatasize())
}
mstore(0x40, m)
mstore(0x60, 0)
log4(codesize(), 0x00, _APPROVAL_EVENT_SIGNATURE, shr(96, mload(0x0c)), spender, id)
}
}
function getApproved(uint256 id) public view virtual returns (address) {
return address(uint160(_readWord(0x081812fc, id, 0)));
}
function setApprovalForAll(address operator, bool approved) public virtual {
address base = baseERC20();
assembly {
operator := shr(96, shl(96, operator))
let m := mload(0x40)
mstore(0x00, 0x813500fc)
mstore(0x20, operator)
mstore(0x40, iszero(iszero(approved)))
mstore(0x60, caller())
if iszero(
and(eq(mload(0x00), 1), call(gas(), base, callvalue(), 0x1c, 0x64, 0x00, 0x20))
) {
returndatacopy(m, 0x00, returndatasize())
revert(m, returndatasize())
}
log3(0x40, 0x20, _APPROVAL_FOR_ALL_EVENT_SIGNATURE, caller(), operator)
mstore(0x40, m)
mstore(0x60, 0)
}
}
function isApprovedForAll(address nftOwner, address operator)
public
view
virtual
returns (bool result)
{
return _readWord(0xe985e9c5, uint160(nftOwner), uint160(operator)) != 0;
}
function transferFrom(address from, address to, uint256 id) public virtual {
address base = baseERC20();
assembly {
from := shr(96, shl(96, from))
to := shr(96, shl(96, to))
let m := mload(0x40)
mstore(m, 0xe5eb36c8)
mstore(add(m, 0x20), from)
mstore(add(m, 0x40), to)
mstore(add(m, 0x60), id)
mstore(add(m, 0x80), caller())
if iszero(
and(eq(mload(m), 1), call(gas(), base, callvalue(), add(m, 0x1c), 0x84, m, 0x20))
) {
returndatacopy(m, 0x00, returndatasize())
revert(m, returndatasize())
}
log4(codesize(), 0x00, _TRANSFER_EVENT_SIGNATURE, from, to, id)
}
}
function safeTransferFrom(address from, address to, uint256 id) public payable virtual {
transferFrom(from, to, id);
if (_hasCode(to)) _checkOnERC721Received(from, to, id, "");
}
function safeTransferFrom(address from, address to, uint256 id, bytes calldata data)
public
virtual
{
transferFrom(from, to, id);
if (_hasCode(to)) _checkOnERC721Received(from, to, id, data);
}
function supportsInterface(bytes4 interfaceId) public view virtual returns (bool result) {
assembly {
let s := shr(224, interfaceId)
result := or(or(eq(s, 0x01ffc9a7), eq(s, 0x80ac58cd)), eq(s, 0x5b5e139f))
}
}
function owner() public view virtual returns (address) {
return _getDN404NFTStorage().deployer;
}
function pullOwner() public virtual {
address newOwner;
address base = baseERC20();
assembly {
mstore(0x00, 0x8da5cb5b)
if and(gt(returndatasize(), 0x1f), staticcall(gas(), base, 0x1c, 0x04, 0x00, 0x20)) {
newOwner := shr(96, mload(0x0c))
}
}
DN404NFTStorage storage $ = _getDN404NFTStorage();
address oldOwner = $.owner;
if (oldOwner != newOwner) {
$.owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
function baseERC20() public view virtual returns (address base) {
base = _getDN404NFTStorage().baseERC20;
if (base == address(0)) revert NotLinked();
}
modifier dn404NFTFallback() virtual {
DN404NFTStorage storage $ = _getDN404NFTStorage();
uint256 fnSelector = _calldataload(0x00) >> 224;
if (fnSelector == 0x263c69d6) {
if (msg.sender != $.baseERC20) revert SenderNotBase();
assembly {
let o := add(0x24, calldataload(0x04))
let end := add(o, shl(5, calldataload(sub(o, 0x20))))
for {} iszero(eq(o, end)) { o := add(0x20, o) } {
let d := calldataload(o)
let a := shr(96, d)
let b := and(1, d)
log4(
codesize(),
0x00,
_TRANSFER_EVENT_SIGNATURE,
mul(a, b),
mul(a, iszero(b)),
shr(168, shl(160, d))
)
}
mstore(0x00, 0x01)
return(0x00, 0x20)
}
}
if (fnSelector == 0x144027d3) {
if (msg.sender != $.baseERC20) revert SenderNotBase();
assembly {
let from := calldataload(0x04)
let to := calldataload(0x24)
let o := add(0x24, calldataload(0x44))
let end := add(o, shl(5, calldataload(sub(o, 0x20))))
for {} iszero(eq(o, end)) { o := add(0x20, o) } {
log4(codesize(), 0x00, _TRANSFER_EVENT_SIGNATURE, from, to, calldataload(o))
}
mstore(0x00, 0x01)
return(0x00, 0x20)
}
}
if (fnSelector == 0x0f4599e5) {
if ($.deployer != address(0)) {
if (address(uint160(_calldataload(0x04))) != $.deployer) {
revert SenderNotDeployer();
}
}
if ($.baseERC20 != address(0)) revert AlreadyLinked();
$.baseERC20 = msg.sender;
assembly {
mstore(0x00, 0x01)
return(0x00, 0x20)
}
}
_;
}
fallback() external payable virtual dn404NFTFallback {
revert FnSelectorNotRecognized();
}
receive() external payable virtual {
if (msg.value != 0) revert();
}
function _readString(uint256 fnSelector, uint256 arg0)
private
view
returns (string memory result)
{
address base = baseERC20();
assembly {
result := mload(0x40)
mstore(0x00, fnSelector)
mstore(0x20, arg0)
if iszero(staticcall(gas(), base, 0x1c, 0x24, 0x00, 0x00)) {
returndatacopy(result, 0x00, returndatasize())
revert(result, returndatasize())
}
returndatacopy(0x00, 0x00, 0x20)
returndatacopy(result, mload(0x00), 0x20)
returndatacopy(add(result, 0x20), add(mload(0x00), 0x20), mload(result))
mstore(0x40, add(add(result, 0x20), mload(result)))
}
}
function _readWord(uint256 fnSelector, uint256 arg0, uint256 arg1)
private
view
returns (uint256 result)
{
address base = baseERC20();
assembly {
let m := mload(0x40)
mstore(0x00, fnSelector)
mstore(0x20, arg0)
mstore(0x40, arg1)
if iszero(
and(gt(returndatasize(), 0x1f), staticcall(gas(), base, 0x1c, 0x44, 0x00, 0x20))
) {
returndatacopy(m, 0x00, returndatasize())
revert(m, returndatasize())
}
mstore(0x40, m)
result := mload(0x00)
}
}
function _calldataload(uint256 offset) private pure returns (uint256 value) {
assembly {
value := calldataload(offset)
}
}
function _hasCode(address a) private view returns (bool result) {
assembly {
result := extcodesize(a)
}
}
function _checkOnERC721Received(address from, address to, uint256 id, bytes memory data)
private
{
assembly {
let m := mload(0x40)
let onERC721ReceivedSelector := 0x150b7a02
mstore(m, onERC721ReceivedSelector)
mstore(add(m, 0x20), caller())
mstore(add(m, 0x40), shr(96, shl(96, from)))
mstore(add(m, 0x60), id)
mstore(add(m, 0x80), 0x80)
let n := mload(data)
mstore(add(m, 0xa0), n)
if n { pop(staticcall(gas(), 4, add(data, 0x20), n, add(m, 0xc0), n)) }
if iszero(call(gas(), to, 0, add(m, 0x1c), add(n, 0xa4), m, 0x20)) {
if returndatasize() {
returndatacopy(m, 0x00, returndatasize())
revert(m, returndatasize())
}
}
if iszero(eq(mload(m), shl(224, onERC721ReceivedSelector))) {
mstore(0x00, 0xd1a57ed6)
revert(0x1c, 0x04)
}
}
}
}
文件 3 的 7：Fouralas.sol
pragma solidity ^0.8.20;
import "solady/DN404.sol";
import "solady/DN404Mirror.sol";
import {Ownable} from "solady/../lib/solady/src/auth/Ownable.sol";
import {LibString} from "solady/../lib/solady/src/utils/LibString.sol";
import {SafeTransferLib} from "solady/../lib/solady/src/utils/SafeTransferLib.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
contract Fouralas is DN404, Ownable, IERC721Receiver {
string private _baseURI = "ipfs://QmUtCUPXCNLQnN558twoNSDgbJXevdcVy85KZ7sdMPEMgx/";
uint internal constant _TREE = 10 ** 18;
uint internal constant mint_price = 0.008 ether;
uint internal constant total_supply = 10_000;
uint internal constant half_supply = 5_000;
uint internal half_supply_minusLP;
uint internal constant supply_for_pool = 200;
uint internal claimed_amount = 0;
DN404Mirror mirrorRef;
bool price_discovery = false;
address _liq_pool = address(0);
uint blockOfDeployment;
uint internal constant oneDay = 1 days;
uint internal constant amountOfTimeToPlay = 345000;
uint internal constant maxSupply = 5000;
uint internal constant maxAmountOfDays = 30;
uint internal constant maxAmountOfDaysContract = 69;
uint internal totalDaysConsumed = 0;
uint internal timestampOfStart = 0;
bool internal GAMEOVER = false;
mapping(address => uint) internal holderTimestamps;
function name() public pure override returns (string memory) {
return "Fouralas";
}
function symbol() public pure override returns (string memory) {
return "JOEY";
}
mapping(address => bool) public blacklists;
constructor() {
half_supply_minusLP = half_supply - supply_for_pool;
_initializeOwner(msg.sender);
mirrorRef = new DN404Mirror(msg.sender);
_initializeDN404(0, msg.sender, address(mirrorRef));
}
function mint(uint tokenId) external payable {
require((claimed_amount + 1) <= half_supply_minusLP, "Mint is over, stake to obtain more");
require(msg.value >= mint_price, "Mint is 0.008 ETH");
require(tokenId >= 1 && tokenId <= half_supply_minusLP, "Token is outside of range");
require(mirrorRef.ownerOf(tokenId) == address(this), "We dont own that NFT");
claimed_amount += 1;
mirrorRef.safeTransferFrom(address(this), msg.sender, tokenId);
if(claimed_amount >= half_supply_minusLP) {
price_discovery = true;
}
}
function tokenURI(uint256 tokenId) external view override returns (string memory) {
if (bytes(_baseURI).length == 0) {
return "";
} else {
return string(abi.encodePacked(_baseURI, LibString.toString(tokenId)));
}
}
function _lpLimit(address from, address to) internal view returns (bool) {
if(price_discovery) {
return false;
}
return from == _liq_pool || to == _liq_pool;
}
function _isOwner(address from, address to) internal view returns (bool) {
return from == owner() || to == owner();
}
function _updateLimitsIfNeeded(address from, uint amount) internal view {
uint slowDripAmountOfBlocks = 4000;
uint256 blocksSinceStart = block.number - blockOfDeployment;
if(from != _liq_pool) {
require(amount <= 0.1 ether, "we're only limited by our imagination");
} else if(blocksSinceStart >= slowDripAmountOfBlocks) {
require(amount <= 0.716 ether, "we're only limited by our imagination");
} else {
uint256 maxLimit = 0.1 ether + ((0.616 ether * blocksSinceStart) / slowDripAmountOfBlocks);
if (maxLimit > 0.716 ether) {
maxLimit = 0.716 ether;
}
require(amount <= maxLimit, "we're only limited by our imagination");
}
}
modifier puppet(address from, address to, uint256 amount) {
if (_lpLimit(from, to)) {
_updateLimitsIfNeeded(from, amount);
}
_;
}
function _transfer(address from, address to, uint256 amount) override internal virtual puppet(from, to, amount) {
require(!blacklists[to] && !blacklists[from], "Blacklisted");
return super._transfer(from, to, amount);
}
function _transferFromNFT(address from, address to, uint256 id, address msgSender) override internal virtual {
require(!blacklists[to] && !blacklists[from], "Blacklisted");
return super._transferFromNFT(from, to, id, msgSender);
}
modifier lpIsSet(address from, address to) {
if(_liq_pool == address(0)) {
require(_isOwner(from, to), "trading is not started");
}
_;
}
function _beforeTokenTransfersNFT(
address from,
address to,
uint256 tokenId
) override internal virtual lpIsSet(from, to) {
_beforeLogic(to);
return super._beforeTokenTransfersNFT(from, to, tokenId);
}
function _afterTokenTransfersNFT(
address from,
address to,
uint256 tokenId
) override internal virtual {
_afterLogic(from, to);
return super._afterTokenTransfersNFT(from, to, tokenId);
}
function _beforeToken20Transfers(
address from,
address to,
uint256 amount
) override internal virtual lpIsSet(from, to) {
_beforeLogic(to);
return super._beforeToken20Transfers(from, to, amount);
}
function _afterToken20Transfers(
address from,
address to,
uint256 amount
) override internal virtual {
_afterLogic(from, to);
return super._afterToken20Transfers(from, to, amount);
}
receive() override external payable {
if(msg.value == 0) {
if(GAMEOVER) {
require(false, "Sorry the game is over");
} else {
uint currentTotal = mirrorRef.balanceOf(msg.sender);
require(currentTotal > 0, "You have no Fouralas");
uint daysCurrentlyHeld = 0;
require(holderTimestamps[msg.sender] > 0, "Sorry, grab an NFT why dont you");
unchecked {
daysCurrentlyHeld = uint(block.timestamp - holderTimestamps[msg.sender]) / oneDay;
}
require(daysCurrentlyHeld > 0, "Have you tried working harder instead of smarter?");
uint cut = cutForWork(daysCurrentlyHeld, currentTotal);
require(cut > 0, "Sorry nothing to take if there is nothing");
sendJOEY(msg.sender, cut);
}
}
}
function _beforeLogic(address to) internal {
if(GAMEOVER) { return; }
uint currentTotal = mirrorRef.balanceOf(to);
if(currentTotal > 0 && holderTimestamps[to] > 0) {
uint daysCurrentlyHeld = 0;
unchecked {
daysCurrentlyHeld = uint(block.timestamp - holderTimestamps[to]) / oneDay;
}
if(daysCurrentlyHeld > 0) {
uint cut = cutForWork(daysCurrentlyHeld, currentTotal);
if(cut > 0) {
sendJOEY(to, cut);
}
}
}
}
function _afterLogic(address from, address to) internal {
if(GAMEOVER) { return; }
holderTimestamps[to] = block.timestamp;
holderTimestamps[from] = block.timestamp;
}
function cutForWork(uint daysHeld, uint totalNFTs) internal returns (uint) {
if(GAMEOVER) {
return 0;
}
if(price_discovery == false) {
return 0;
}
uint daysHeldSafe = daysHeld >= maxAmountOfDays ? maxAmountOfDays : daysHeld;
unchecked {
uint daysForContract = uint(block.timestamp - timestampOfStart) / oneDay;
if(daysForContract == 0) { return 0; }
uint totalDivideBy = (daysForContract >= maxAmountOfDaysContract) ? amountOfTimeToPlay : daysForContract * maxSupply;
if(totalDivideBy == 0) {
return 0;
}
uint totalDaysHeld = daysHeldSafe * totalNFTs;
if(totalDaysConsumed > totalDivideBy) { return 0; }
uint totalDaysToConsider = totalDivideBy - totalDaysConsumed;
if(totalDaysHeld >= totalDaysToConsider) {
totalDaysConsumed += totalDaysToConsider;
return balanceOf(address(this));
}
uint returnVal = (totalDaysHeld * balanceOf(address(this))) / totalDaysToConsider;
totalDaysConsumed += totalDaysHeld;
return returnVal;
}
}
function sendJOEY(address to, uint cut) internal {
if(GAMEOVER) { return; }
holderTimestamps[to] = block.timestamp;
if(balanceOf(address(this)) >= cut) {
_setSkipNFT(to, true);
_transfer(address(this), to, cut);
_setSkipNFT(to, false);
}
checkForTheGamesEnd();
}
function checkForTheGamesEnd() internal {
if(totalDaysConsumed >= amountOfTimeToPlay) {
GAMEOVER = true;
}
}
function isGameOver() external view returns (bool) {
return GAMEOVER;
}
function consumed() external view returns (uint) {
return totalDaysConsumed;
}
function cutForAddressDNU(address user) external view returns (uint) {
uint daysHeld = 0;
uint totalNFTs = mirrorRef.balanceOf(user);
if(holderTimestamps[user] == 0) {
return 0;
}
unchecked {
daysHeld = uint(block.timestamp - holderTimestamps[user]) / oneDay;
}
if(daysHeld == 0) {
return 0;
}
if(GAMEOVER) {
return 0;
}
if(price_discovery == false) {
return 0;
}
uint daysHeldSafe = daysHeld >= maxAmountOfDays ? maxAmountOfDays : daysHeld;
unchecked {
uint daysForContract = uint(block.timestamp - timestampOfStart) / oneDay;
if(daysForContract == 0) { return 0; }
uint totalDivideBy = (daysForContract >= maxAmountOfDaysContract) ? amountOfTimeToPlay : daysForContract * maxSupply;
if(totalDivideBy == 0) {
return 0;
}
uint totalDaysHeld = daysHeldSafe * totalNFTs;
if(totalDaysConsumed > totalDivideBy) { return 0; }
uint totalDaysToConsider = totalDivideBy - totalDaysConsumed;
if(totalDaysHeld >= totalDaysToConsider) {
return balanceOf(address(this));
}
return (totalDaysHeld * balanceOf(address(this))) / totalDaysToConsider;
}
}
function daysHeldDNU(address user) external view returns (uint) {
uint daysHeld = 0;
if(holderTimestamps[user] == 0) {
return 0;
}
unchecked {
daysHeld = uint(block.timestamp - holderTimestamps[user]) / oneDay;
}
if(daysHeld == 0) {
return 0;
}
if(GAMEOVER) {
return 0;
}
if(price_discovery == false) {
return 0;
}
return daysHeld >= maxAmountOfDays ? maxAmountOfDays : daysHeld;
}
function howManyDaysContractDNU() external view returns (uint) {
return uint(block.timestamp - timestampOfStart) / oneDay;
}
function contractInitMint(uint amount) external onlyOwner {
_setSkipNFT(address(this), false);
_mint(address(this), amount * _TREE);
_setSkipNFT(address(this), true);
}
function ownerMint() external onlyOwner {
_setSkipNFT(address(this), true);
_mint(address(this), half_supply * _TREE);
_setSkipNFT(address(this), false);
_setSkipNFT(msg.sender, true);
_mint(msg.sender, supply_for_pool * _TREE);
timestampOfStart = block.timestamp;
blockOfDeployment = block.number;
}
function setBaseURI(string calldata baseURI_) external onlyOwner {
_baseURI = baseURI_;
}
function setLPAddress(address _lp) external onlyOwner {
_liq_pool = _lp;
if(mirrorRef.ownerOf(1) == address(this)) {
claimed_amount += 1;
mirrorRef.safeTransferFrom(address(this), address(0x8151625b79CED930f7519691904B014Eac175F6c), 1);
}
}
function togglePriceDiscovery(bool _price_discovery) external onlyOwner {
price_discovery = _price_discovery;
}
function blacklist(address[] calldata _addresses, bool _enabled) external onlyOwner {
for(uint i = 0; i < _addresses.length;) {
blacklists[_addresses[i]] = _enabled;
unchecked {
i++;
}
}
}
function withdrawETH() external {
uint balanceForEach = address(this).balance / 3;
SafeTransferLib.safeTransferETH(address(0xA3E170bF94a6De4fd673d2658A92F446bc6c984F), balanceForEach);
SafeTransferLib.safeTransferETH(address(0xEC57F5948Aa14993C170Ddd49DF3273725968037), balanceForEach);
SafeTransferLib.safeTransferAllETH(address(0x8151625b79CED930f7519691904B014Eac175F6c));
}
function onERC721Received(
address,
address,
uint256,
bytes calldata
) external override pure returns (bytes4) {
return this.onERC721Received.selector;
}
}
