编译器
0.8.26+commit.8a97fa7a
文件 1 的 9：DN404.sol
pragma solidity ^0.8.4;
abstract contract DN404 {
enum SkipNFTDefault {
HasCode,
On,
Off
}
event Transfer(address indexed from, address indexed to, uint256 amount);
event Approval(address indexed owner, address indexed spender, uint256 amount);
event SkipNFTSet(address indexed owner, 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 DNNotInitialized();
error InsufficientBalance();
error InsufficientAllowance();
error TotalSupplyOverflow();
error InvalidUnit();
error SenderNotMirror();
error TransferToZeroAddress();
error MirrorAddressIsZero();
error LinkMirrorContractFailed();
error ApprovalCallerNotOwnerNorApproved();
error TransferCallerNotOwnerNorApproved();
error TransferFromIncorrectOwner();
error TokenDoesNotExist();
error FnSelectorNotRecognized();
uint8 internal constant _ADDRESS_DATA_SKIP_NFT_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;
address internal constant _ZKSYNC_PERMIT_2 = 0x0000000000225e31D15943971F47aD3022F714Fa;
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();
unchecked {
if (_unit() - 1 >= 2 ** 96 - 1) _rv(uint32(InvalidUnit.selector));
}
if ($.mirrorERC721 != address(0)) _rv(uint32(DNAlreadyInitialized.selector));
if (mirror == address(0)) _rv(uint32(MirrorAddressIsZero.selector));
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)
}
mstore(0x00, 0x8da5cb5b6cef16e6)
if and(
lt(iszero(shl(96, mload(0x20))), gt(returndatasize(), 0x1f)),
staticcall(gas(), address(), 0x18, 0x04, 0x20, 0x20)
) { if iszero(call(gas(), mirror, 0, 0x1c, 0x04, 0x00, 0x00)) { revert(0x00, 0x00) } }
}
$.nextTokenId = uint32(_toUint(_useOneIndexed()));
$.mirrorERC721 = mirror;
if (initialTokenSupply != 0) {
if (initialSupplyOwner == address(0)) _rv(uint32(TransferToZeroAddress.selector));
if (_totalSupplyOverflows(initialTokenSupply)) {
_rv(uint32(TotalSupplyOverflow.selector));
}
$.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) internal view virtual returns (string memory);
function _skipNFTDefault() internal view virtual returns (SkipNFTDefault) {
return SkipNFTDefault.HasCode;
}
function _useOneIndexed() internal pure virtual returns (bool) {
return true;
}
function _useDirectTransfersIfPossible() internal view virtual returns (bool) {
return true;
}
function _addToBurnedPool(uint256 totalNFTSupplyAfterBurn, uint256 totalSupplyAfterBurn)
internal
view
virtual
returns (bool)
{
totalSupplyAfterBurn = totalNFTSupplyAfterBurn;
return false;
}
function _useExistsLookup() internal view virtual returns (bool) {
return true;
}
function _afterNFTTransfers(address[] memory from, address[] memory to, uint256[] memory ids)
internal
virtual
{}
function _useAfterNFTTransfers() internal virtual returns (bool) {}
function decimals() public view virtual 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() && _isPermit2(spender)) {
uint8 flags = _getDN404Storage().addressData[owner].flags;
if ((flags & _ADDRESS_DATA_OVERRIDE_PERMIT2_FLAG) == uint256(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() && _isPermit2(msg.sender)
&& (_getDN404Storage().addressData[from].flags & _ADDRESS_DATA_OVERRIDE_PERMIT2_FLAG)
== uint256(0) ? type(uint256).max : a.value;
if (allowed != type(uint256).max) {
if (amount > allowed) _rv(uint32(InsufficientAllowance.selector));
unchecked {
a.value = allowed - amount;
}
}
_transfer(from, to, amount);
return true;
}
function _givePermit2DefaultInfiniteAllowance() internal view virtual returns (bool) {
return true;
}
function _isPermit2(address sender) internal view virtual returns (bool) {
return sender == _PERMIT2;
}
function _mint(address to, uint256 amount) internal virtual {
if (to == address(0)) _rv(uint32(TransferToZeroAddress.selector));
DN404Storage storage $ = _getDN404Storage();
if ($.mirrorERC721 == address(0)) _rv(uint32(DNNotInitialized.selector));
AddressData storage toAddressData = $.addressData[to];
_DNMintTemps memory t;
unchecked {
{
uint256 toBalance = uint256(toAddressData.balance) + amount;
toAddressData.balance = uint96(toBalance);
t.toEnd = toBalance / _unit();
}
uint256 idLimit;
{
uint256 newTotalSupply = uint256($.totalSupply) + amount;
$.totalSupply = uint96(newTotalSupply);
uint256 overflows = _toUint(_totalSupplyOverflows(newTotalSupply));
if (overflows | _toUint(newTotalSupply < amount) != 0) {
_rv(uint32(TotalSupplyOverflow.selector));
}
idLimit = newTotalSupply / _unit();
}
while (!getSkipNFT(to)) {
Uint32Map storage toOwned = $.owned[to];
Uint32Map storage oo = $.oo;
uint256 toIndex = toAddressData.ownedLength;
if ((t.numNFTMints = _zeroFloorSub(t.toEnd, toIndex)) == uint256(0)) break;
t.packedLogs = _packedLogsMalloc(t.numNFTMints);
_packedLogsSet(t.packedLogs, to, 0);
$.totalNFTSupply += uint32(t.numNFTMints);
toAddressData.ownedLength = uint32(t.toEnd);
t.toAlias = _registerAndResolveAlias(toAddressData, to);
uint32 burnedPoolHead = $.burnedPoolHead;
t.burnedPoolTail = $.burnedPoolTail;
t.nextTokenId = _wrapNFTId($.nextTokenId, idLimit);
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, idLimit), idLimit)
: _wrapNFTId(id + 1, idLimit);
}
t.nextTokenId = _wrapNFTId(id + 1, idLimit);
}
if (_useExistsLookup()) _set($.exists, id, true);
_set(toOwned, toIndex, uint32(id));
_setOwnerAliasAndOwnedIndex(oo, id, t.toAlias, uint32(toIndex++));
_packedLogsAppend(t.packedLogs, id);
} while (toIndex != t.toEnd);
$.nextTokenId = uint32(t.nextTokenId);
$.burnedPoolHead = burnedPoolHead;
_packedLogsSend(t.packedLogs, $);
break;
}
}
assembly {
mstore(0x00, amount)
log3(0x00, 0x20, _TRANSFER_EVENT_SIGNATURE, 0, shr(96, shl(96, to)))
}
if (_useAfterNFTTransfers()) {
_afterNFTTransfers(
_zeroAddresses(t.numNFTMints),
_filled(t.numNFTMints, to),
_packedLogsIds(t.packedLogs)
);
}
}
function _mintNext(address to, uint256 amount) internal virtual {
if (to == address(0)) _rv(uint32(TransferToZeroAddress.selector));
DN404Storage storage $ = _getDN404Storage();
if ($.mirrorERC721 == address(0)) _rv(uint32(DNNotInitialized.selector));
AddressData storage toAddressData = $.addressData[to];
_DNMintTemps memory t;
unchecked {
{
uint256 toBalance = uint256(toAddressData.balance) + amount;
toAddressData.balance = uint96(toBalance);
t.toEnd = toBalance / _unit();
}
uint256 id;
uint256 idLimit;
{
uint256 preTotalSupply = uint256($.totalSupply);
uint256 newTotalSupply = uint256(preTotalSupply) + amount;
$.totalSupply = uint96(newTotalSupply);
uint256 overflows = _toUint(_totalSupplyOverflows(newTotalSupply));
if (overflows | _toUint(newTotalSupply < amount) != 0) {
_rv(uint32(TotalSupplyOverflow.selector));
}
idLimit = newTotalSupply / _unit();
id = _wrapNFTId(preTotalSupply / _unit() + _toUint(_useOneIndexed()), idLimit);
}
while (!getSkipNFT(to)) {
Uint32Map storage toOwned = $.owned[to];
Uint32Map storage oo = $.oo;
uint256 toIndex = toAddressData.ownedLength;
if ((t.numNFTMints = _zeroFloorSub(t.toEnd, toIndex)) == uint256(0)) break;
t.packedLogs = _packedLogsMalloc(t.numNFTMints);
$.burnedPoolHead = 0;
$.burnedPoolTail = 0;
_packedLogsSet(t.packedLogs, to, 0);
$.totalNFTSupply += uint32(t.numNFTMints);
toAddressData.ownedLength = uint32(t.toEnd);
t.toAlias = _registerAndResolveAlias(toAddressData, to);
do {
while (_get(oo, _ownershipIndex(id)) != 0) {
id = _useExistsLookup()
? _wrapNFTId(_findFirstUnset($.exists, id + 1, idLimit), idLimit)
: _wrapNFTId(id + 1, idLimit);
}
if (_useExistsLookup()) _set($.exists, id, true);
_set(toOwned, toIndex, uint32(id));
_setOwnerAliasAndOwnedIndex(oo, id, t.toAlias, uint32(toIndex++));
_packedLogsAppend(t.packedLogs, id);
id = _wrapNFTId(id + 1, idLimit);
} while (toIndex != t.toEnd);
_packedLogsSend(t.packedLogs, $);
break;
}
}
assembly {
mstore(0x00, amount)
log3(0x00, 0x20, _TRANSFER_EVENT_SIGNATURE, 0, shr(96, shl(96, to)))
}
if (_useAfterNFTTransfers()) {
_afterNFTTransfers(
_zeroAddresses(t.numNFTMints),
_filled(t.numNFTMints, to),
_packedLogsIds(t.packedLogs)
);
}
}
function _burn(address from, uint256 amount) internal virtual {
DN404Storage storage $ = _getDN404Storage();
if ($.mirrorERC721 == address(0)) _rv(uint32(DNNotInitialized.selector));
AddressData storage fromAddressData = $.addressData[from];
_DNBurnTemps memory t;
unchecked {
t.fromBalance = fromAddressData.balance;
if (amount > t.fromBalance) _rv(uint32(InsufficientBalance.selector));
fromAddressData.balance = uint96(t.fromBalance -= amount);
t.totalSupply = uint256($.totalSupply) - amount;
$.totalSupply = uint96(t.totalSupply);
Uint32Map storage fromOwned = $.owned[from];
uint256 fromIndex = fromAddressData.ownedLength;
t.numNFTBurns = _zeroFloorSub(fromIndex, t.fromBalance / _unit());
if (t.numNFTBurns != 0) {
t.packedLogs = _packedLogsMalloc(t.numNFTBurns);
_packedLogsSet(t.packedLogs, from, 1);
bool addToBurnedPool;
{
uint256 totalNFTSupply = uint256($.totalNFTSupply) - t.numNFTBurns;
$.totalNFTSupply = uint32(totalNFTSupply);
addToBurnedPool = _addToBurnedPool(totalNFTSupply, t.totalSupply);
}
Uint32Map storage oo = $.oo;
uint256 fromEnd = fromIndex - t.numNFTBurns;
fromAddressData.ownedLength = uint32(fromEnd);
uint32 burnedPoolTail = $.burnedPoolTail;
do {
uint256 id = _get(fromOwned, --fromIndex);
_setOwnerAliasAndOwnedIndex(oo, id, 0, 0);
_packedLogsAppend(t.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 != fromEnd);
if (addToBurnedPool) $.burnedPoolTail = burnedPoolTail;
_packedLogsSend(t.packedLogs, $);
}
}
assembly {
mstore(0x00, amount)
log3(0x00, 0x20, _TRANSFER_EVENT_SIGNATURE, shr(96, shl(96, from)), 0)
}
if (_useAfterNFTTransfers()) {
_afterNFTTransfers(
_filled(t.numNFTBurns, from),
_zeroAddresses(t.numNFTBurns),
_packedLogsIds(t.packedLogs)
);
}
}
function _transfer(address from, address to, uint256 amount) internal virtual {
if (to == address(0)) _rv(uint32(TransferToZeroAddress.selector));
DN404Storage storage $ = _getDN404Storage();
AddressData storage fromAddressData = $.addressData[from];
AddressData storage toAddressData = $.addressData[to];
if ($.mirrorERC721 == address(0)) _rv(uint32(DNNotInitialized.selector));
_DNTransferTemps memory t;
t.fromOwnedLength = fromAddressData.ownedLength;
t.toOwnedLength = toAddressData.ownedLength;
unchecked {
{
uint256 fromBalance = fromAddressData.balance;
if (amount > fromBalance) _rv(uint32(InsufficientBalance.selector));
fromAddressData.balance = uint96(fromBalance -= amount);
uint256 toBalance = uint256(toAddressData.balance) + amount;
toAddressData.balance = uint96(toBalance);
t.numNFTBurns = _zeroFloorSub(t.fromOwnedLength, fromBalance / _unit());
if (!getSkipNFT(to)) {
if (from == to) t.toOwnedLength = t.fromOwnedLength - t.numNFTBurns;
t.numNFTMints = _zeroFloorSub(toBalance / _unit(), t.toOwnedLength);
}
}
while (_useDirectTransfersIfPossible()) {
uint256 n = _min(t.fromOwnedLength, _min(t.numNFTBurns, t.numNFTMints));
if (n == uint256(0)) break;
t.numNFTBurns -= n;
t.numNFTMints -= n;
if (from == to) {
t.toOwnedLength += n;
break;
}
t.directLogs = _directLogsMalloc(n, from, to);
Uint32Map storage fromOwned = $.owned[from];
Uint32Map storage toOwned = $.owned[to];
t.toAlias = _registerAndResolveAlias(toAddressData, to);
uint256 toIndex = t.toOwnedLength;
n = toIndex + n;
do {
uint256 id = _get(fromOwned, --t.fromOwnedLength);
_set(toOwned, toIndex, uint32(id));
_setOwnerAliasAndOwnedIndex($.oo, id, t.toAlias, uint32(toIndex));
_directLogsAppend(t.directLogs, id);
if (_get($.mayHaveNFTApproval, id)) {
_set($.mayHaveNFTApproval, id, false);
delete $.nftApprovals[id];
}
} while (++toIndex != n);
toAddressData.ownedLength = uint32(t.toOwnedLength = toIndex);
fromAddressData.ownedLength = uint32(t.fromOwnedLength);
break;
}
t.totalNFTSupply = uint256($.totalNFTSupply) + t.numNFTMints - t.numNFTBurns;
$.totalNFTSupply = uint32(t.totalNFTSupply);
Uint32Map storage oo = $.oo;
t.packedLogs = _packedLogsMalloc(t.numNFTBurns + t.numNFTMints);
t.burnedPoolTail = $.burnedPoolTail;
if (t.numNFTBurns != 0) {
_packedLogsSet(t.packedLogs, from, 1);
bool addToBurnedPool = _addToBurnedPool(t.totalNFTSupply, $.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(t.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(t.packedLogs, to, 0);
Uint32Map storage toOwned = $.owned[to];
t.toAlias = _registerAndResolveAlias(toAddressData, to);
uint256 idLimit = $.totalSupply / _unit();
t.nextTokenId = _wrapNFTId($.nextTokenId, idLimit);
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, idLimit), idLimit)
: _wrapNFTId(id + 1, idLimit);
}
t.nextTokenId = _wrapNFTId(id + 1, idLimit);
}
if (_useExistsLookup()) _set($.exists, id, true);
_set(toOwned, toIndex, uint32(id));
_setOwnerAliasAndOwnedIndex(oo, id, t.toAlias, uint32(toIndex++));
_packedLogsAppend(t.packedLogs, id);
} while (toIndex != t.toEnd);
$.burnedPoolHead = burnedPoolHead;
$.nextTokenId = uint32(t.nextTokenId);
}
if (t.directLogs != bytes32(0)) _directLogsSend(t.directLogs, $);
if (t.packedLogs != bytes32(0)) _packedLogsSend(t.packedLogs, $);
}
assembly {
mstore(0x00, amount)
log3(0x00, 0x20, _TRANSFER_EVENT_SIGNATURE, shr(96, shl(96, from)), shr(96, shl(96, to)))
}
if (_useAfterNFTTransfers()) {
uint256[] memory ids = _directLogsIds(t.directLogs);
unchecked {
_afterNFTTransfers(
_concat(
_filled(ids.length + t.numNFTBurns, from), _zeroAddresses(t.numNFTMints)
),
_concat(
_concat(_filled(ids.length, to), _zeroAddresses(t.numNFTBurns)),
_filled(t.numNFTMints, to)
),
_concat(ids, _packedLogsIds(t.packedLogs))
);
}
}
}
function _initiateTransferFromNFT(address from, address to, uint256 id, address msgSender)
internal
virtual
{
bytes32 directLogs = _directLogsMalloc(1, from, to);
_directLogsAppend(directLogs, id);
_directLogsSend(directLogs, _getDN404Storage());
_transferFromNFT(from, to, id, msgSender);
}
function _transferFromNFT(address from, address to, uint256 id, address msgSender)
internal
virtual
{
if (to == address(0)) _rv(uint32(TransferToZeroAddress.selector));
DN404Storage storage $ = _getDN404Storage();
if ($.mirrorERC721 == address(0)) _rv(uint32(DNNotInitialized.selector));
Uint32Map storage oo = $.oo;
if (from != $.aliasToAddress[_get(oo, _ownershipIndex(_restrictNFTId(id)))]) {
_rv(uint32(TransferFromIncorrectOwner.selector));
}
if (msgSender != from) {
if (!_isApprovedForAll(from, msgSender)) {
if (_getApproved(id) != msgSender) {
_rv(uint32(TransferCallerNotOwnerNorApproved.selector));
}
}
}
AddressData storage fromAddressData = $.addressData[from];
AddressData storage toAddressData = $.addressData[to];
uint256 unit = _unit();
mapping(address => Uint32Map) storage owned = $.owned;
unchecked {
uint256 fromBalance = fromAddressData.balance;
if (unit > fromBalance) _rv(uint32(InsufficientBalance.selector));
fromAddressData.balance = uint96(fromBalance - unit);
toAddressData.balance += uint96(unit);
}
if (_get($.mayHaveNFTApproval, id)) {
_set($.mayHaveNFTApproval, id, false);
delete $.nftApprovals[id];
}
unchecked {
Uint32Map storage fromOwned = owned[from];
uint32 updatedId = _get(fromOwned, --fromAddressData.ownedLength);
uint32 i = _get(oo, _ownedIndex(id));
_set(fromOwned, i, updatedId);
_set(oo, _ownedIndex(updatedId), i);
}
unchecked {
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)))
}
if (_useAfterNFTTransfers()) {
_afterNFTTransfers(_filled(1, from), _filled(1, to), _filled(1, id));
}
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
if (_givePermit2DefaultInfiniteAllowance() && _isPermit2(spender)) {
_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 result) {
uint8 flags = _getDN404Storage().addressData[owner].flags;
result = flags & _ADDRESS_DATA_SKIP_NFT_FLAG != 0;
if (flags & _ADDRESS_DATA_SKIP_NFT_INITIALIZED_FLAG == uint256(0)) {
if (_skipNFTDefault() == SkipNFTDefault.HasCode) {
assembly {
result := iszero(iszero(extcodesize(owner)))
}
}
if (_skipNFTDefault() == SkipNFTDefault.On) result = true;
if (_skipNFTDefault() == SkipNFTDefault.Off) result = false;
}
}
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 = _getDN404Storage().addressData[owner];
uint8 flags = d.flags;
assembly {
let s := xor(iszero(and(flags, _ADDRESS_DATA_SKIP_NFT_FLAG)), iszero(state))
flags := xor(mul(_ADDRESS_DATA_SKIP_NFT_FLAG, s), flags)
flags := or(_ADDRESS_DATA_SKIP_NFT_INITIALIZED_FLAG, flags)
mstore(0x00, iszero(iszero(state)))
log2(0x00, 0x20, _SKIP_NFT_SET_EVENT_SIGNATURE, shr(96, shl(96, owner)))
}
d.flags = flags;
}
function _registerAndResolveAlias(AddressData storage toAddressData, address to)
internal
virtual
returns (uint32 addressAlias)
{
DN404Storage storage $ = _getDN404Storage();
addressAlias = toAddressData.addressAlias;
if (addressAlias == uint256(0)) {
unchecked {
addressAlias = ++$.numAliases;
}
toAddressData.addressAlias = addressAlias;
$.aliasToAddress[addressAlias] = to;
if (addressAlias == uint256(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)) _rv(uint32(TokenDoesNotExist.selector));
return _ownerAt(id);
}
function _isApprovedForAll(address owner, address operator)
internal
view
virtual
returns (bool)
{
return _ref(_getDN404Storage().operatorApprovals, owner, operator).value != 0;
}
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)) _rv(uint32(TokenDoesNotExist.selector));
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 (!_isApprovedForAll(owner, msgSender)) {
_rv(uint32(ApprovalCallerNotOwnerNorApproved.selector));
}
}
$.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];
end = _min($.addressData[owner].ownedLength, end);
assembly {
ids := mload(0x40)
let i := begin
for {} lt(i, end) { 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) _rv(uint32(SenderNotMirror.selector));
_transferFromNFT(
address(uint160(_calldataload(0x04))),
address(uint160(_calldataload(0x24))),
_calldataload(0x44),
address(uint160(_calldataload(0x64)))
);
_return(1);
}
if (fnSelector == 0xf6916ddd) {
if (msg.sender != $.mirrorERC721) _rv(uint32(SenderNotMirror.selector));
_setApprovalForAll(
address(uint160(_calldataload(0x04))),
_calldataload(0x24) != 0,
address(uint160(_calldataload(0x44)))
);
_return(1);
}
if (fnSelector == 0x62fb246d) {
bool result = _isApprovedForAll(
address(uint160(_calldataload(0x04))),
address(uint160(_calldataload(0x24)))
);
_return(_toUint(result));
}
if (fnSelector == 0x2d8a746e) {
_return(uint160(_ownerOf(_calldataload(0x04))));
}
if (fnSelector == 0xc016aa52) {
_return(uint160(_ownerAt(_calldataload(0x04))));
}
if (fnSelector == 0xd10b6e0c) {
if (msg.sender != $.mirrorERC721) _rv(uint32(SenderNotMirror.selector));
address owner = _approveNFT(
address(uint160(_calldataload(0x04))),
_calldataload(0x24),
address(uint160(_calldataload(0x44)))
);
_return(uint160(owner));
}
if (fnSelector == 0x27ef5495) {
_return(uint160(_getApproved(_calldataload(0x04))));
}
if (fnSelector == 0xf5b100ea) {
_return(_balanceOfNFT(address(uint160(_calldataload(0x04)))));
}
if (fnSelector == 0xe2c79281) {
_return(_totalNFTSupply());
}
if (fnSelector == 0xcb30b460) {
assembly {
mstore(0x40, add(mload(0x40), 0x20))
}
string memory uri = _tokenURI(_calldataload(0x04));
assembly {
let o := sub(uri, 0x20)
let z := add(mload(uri), 0x40)
mstore(add(o, z), 0)
mstore(o, 0x20)
return(o, and(not(0x1f), add(0x1f, z)))
}
}
if (fnSelector == 0xb7a94eb8) {
_return(1);
}
_;
}
fallback() external payable virtual dn404Fallback {
_rv(uint32(FnSelectorNotRecognized.selector));
}
receive() external payable virtual {
if (msg.value != 0) revert();
}
function _ownershipIndex(uint256 i) internal pure returns (uint256) {
unchecked {
return (i - _toUint(_useOneIndexed())) << 1;
}
}
function _ownedIndex(uint256 i) internal pure returns (uint256) {
unchecked {
return ((i - _toUint(_useOneIndexed())) << 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)
sstore(s, xor(v, shl(o, and(0xffffffff, xor(value, shr(o, v))))))
}
}
function _setOwnerAliasAndOwnedIndex(
Uint32Map storage map,
uint256 id,
uint32 ownership,
uint32 ownedIndex
) internal {
uint256 t = _toUint(_useOneIndexed());
assembly {
let i := sub(id, t)
let s := add(shl(96, map.slot), shr(2, i))
let v := sload(s)
let o := shl(6, and(i, 3))
let combined := or(shl(32, ownedIndex), and(0xffffffff, ownership))
sstore(s, xor(v, shl(o, and(0xffffffffffffffff, 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 upTo)
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, upTo))
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(upTo)), shl(and(0xff, not(upTo)), negBits))
}
}
if negBits {
let b := and(negBits, add(not(negBits), 1))
let r := shl(5, shr(252, shl(shl(2, shr(250, mul(b,
0x2aaaaaaaba69a69a6db6db6db2cb2cb2ce739ce73def7bdeffffffff))),
0x1412563212c14164235266736f7425221143267a45243675267677)))
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(gt(r, upTo), 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 idLimit) internal pure returns (uint256 result) {
result = _toUint(_useOneIndexed());
assembly {
result :=
or(
mul(or(mul(iszero(gt(id, idLimit)), id), gt(id, idLimit)), result),
mul(mul(lt(id, idLimit), id), iszero(result))
)
}
}
function _restrictNFTId(uint256 id) internal pure returns (uint256 result) {
assembly {
result := mul(id, lt(id, 0x100000000))
}
}
function _totalSupplyOverflows(uint256 amount) internal view returns (bool result) {
uint256 unit = _unit();
assembly {
result := iszero(iszero(or(shr(96, amount), lt(0xfffffffe, div(amount, unit)))))
}
}
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))
}
}
function _directLogsMalloc(uint256 n, address from, address to)
private
pure
returns (bytes32 p)
{
assembly {
p := mload(0x40)
let m := add(p, 0x40)
mstore(m, 0x144027d3)
mstore(add(m, 0x20), shr(96, shl(96, from)))
mstore(add(m, 0x40), shr(96, shl(96, to)))
mstore(add(m, 0x60), 0x60)
let logs := add(0x80, m)
mstore(logs, n)
let offset := add(0x20, logs)
mstore(0x40, add(offset, shl(5, n)))
mstore(add(0x20, p), logs)
mstore(p, offset)
}
}
function _directLogsAppend(bytes32 p, uint256 id) private pure {
assembly {
let offset := mload(p)
mstore(offset, id)
mstore(p, add(offset, 0x20))
}
}
function _directLogsSend(bytes32 p, DN404Storage storage $) private {
address mirror = $.mirrorERC721;
assembly {
let logs := mload(add(p, 0x20))
let n := add(0x84, shl(5, mload(logs)))
let o := sub(logs, 0x80)
if iszero(and(eq(mload(o), 1), call(gas(), mirror, 0, add(o, 0x1c), n, o, 0x20))) {
revert(o, 0x00)
}
}
}
function _directLogsIds(bytes32 p) private pure returns (uint256[] memory ids) {
assembly {
if p { ids := mload(add(p, 0x20)) }
}
}
function _packedLogsMalloc(uint256 n) private pure returns (bytes32 p) {
assembly {
p := mload(0x40)
let logs := add(p, 0xa0)
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(bytes32 p, address a, uint256 burnBit) private pure {
assembly {
mstore(add(p, 0x20), or(shl(96, a), burnBit))
}
}
function _packedLogsAppend(bytes32 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(bytes32 p, DN404Storage storage $) private {
address mirror = $.mirrorERC721;
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)
}
}
}
function _packedLogsIds(bytes32 p) private pure returns (uint256[] memory ids) {
assembly {
if p {
ids := mload(add(p, 0x40))
let o := add(ids, 0x20)
let end := add(o, shl(5, mload(ids)))
for {} iszero(eq(o, end)) { o := add(o, 0x20) } {
mstore(o, shr(168, shl(160, mload(o))))
}
}
}
}
function _zeroAddresses(uint256 n) private pure returns (address[] memory result) {
assembly {
result := mload(0x40)
mstore(0x40, add(add(result, 0x20), shl(5, n)))
mstore(result, n)
calldatacopy(add(result, 0x20), calldatasize(), shl(5, n))
}
}
function _filled(uint256 n, uint256 value) private pure returns (uint256[] memory result) {
assembly {
result := mload(0x40)
let o := add(result, 0x20)
let end := add(o, shl(5, n))
mstore(0x40, end)
mstore(result, n)
for {} iszero(eq(o, end)) { o := add(o, 0x20) } { mstore(o, value) }
}
}
function _filled(uint256 n, address value) private pure returns (address[] memory result) {
result = _toAddresses(_filled(n, uint160(value)));
}
function _concat(uint256[] memory a, uint256[] memory b)
private
pure
returns (uint256[] memory result)
{
uint256 aN = a.length;
uint256 bN = b.length;
if (aN == uint256(0)) return b;
if (bN == uint256(0)) return a;
assembly {
let n := add(aN, bN)
if n {
result := mload(0x40)
mstore(result, n)
function copy(dst_, src_, n_) -> _end {
_end := add(dst_, shl(5, n_))
if n_ {
for { let d_ := sub(src_, dst_) } 1 {} {
mstore(dst_, mload(add(dst_, d_)))
dst_ := add(dst_, 0x20)
if eq(dst_, _end) { break }
}
}
}
mstore(0x40, copy(copy(add(result, 0x20), add(a, 0x20), aN), add(b, 0x20), bN))
}
}
}
function _concat(address[] memory a, address[] memory b)
private
pure
returns (address[] memory result)
{
result = _toAddresses(_concat(_toUints(a), _toUints(b)));
}
function _toUints(address[] memory a) private pure returns (uint256[] memory casted) {
assembly {
casted := a
}
}
function _toAddresses(uint256[] memory a) private pure returns (address[] memory casted) {
assembly {
casted := a
}
}
struct _DNTransferTemps {
uint256 numNFTBurns;
uint256 numNFTMints;
uint256 fromOwnedLength;
uint256 toOwnedLength;
uint256 totalNFTSupply;
uint256 fromEnd;
uint256 toEnd;
uint32 toAlias;
uint256 nextTokenId;
uint32 burnedPoolTail;
bytes32 directLogs;
bytes32 packedLogs;
}
struct _DNMintTemps {
uint256 nextTokenId;
uint32 burnedPoolTail;
uint256 toEnd;
uint32 toAlias;
uint256 numNFTMints;
bytes32 packedLogs;
}
struct _DNBurnTemps {
uint256 fromBalance;
uint256 totalSupply;
uint256 numNFTBurns;
bytes32 packedLogs;
}
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)
}
}
function _rv(uint32 s) private pure {
assembly {
mstore(0x00, s)
revert(0x1c, 0x04)
}
}
}
文件 2 的 9：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 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) {
return _readString(0x06fdde03, 0);
}
function symbol() public view virtual returns (string memory) {
return _readString(0x95d89b41, 0);
}
function tokenURI(uint256 id) public view virtual returns (string memory) {
ownerOf(id);
return _readString(0xcb30b460, id);
}
function totalSupply() public view virtual returns (uint256) {
return _readWord(0xe2c79281, 0, 0);
}
function balanceOf(address nftOwner) public view virtual returns (uint256) {
return _readWord(0xf5b100ea, uint160(nftOwner), 0);
}
function ownerOf(uint256 id) public view virtual returns (address) {
return address(uint160(_readWord(0x2d8a746e, id, 0)));
}
function ownerAt(uint256 id) public view virtual returns (address) {
return address(uint160(_readWord(0xc016aa52, id, 0)));
}
function approve(address spender, uint256 id) public payable 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(0x27ef5495, 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, 0xf6916ddd)
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)
{
return _readWord(0x62fb246d, uint160(nftOwner), uint160(operator)) != 0;
}
function transferFrom(address from, address to, uint256 id) public payable 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 {
bytes calldata emptyData;
assembly {
emptyData.length := 0
}
safeTransferFrom(from, to, id, emptyData);
}
function safeTransferFrom(address from, address to, uint256 id, bytes calldata data)
public
payable
virtual
{
transferFrom(from, to, id);
assembly {
if extcodesize(to) {
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)
mstore(add(m, 0xa0), data.length)
calldatacopy(add(m, 0xc0), data.offset, data.length)
if iszero(call(gas(), to, 0, add(m, 0x1c), add(data.length, 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)
}
}
}
}
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().owner;
}
function pullOwner() public virtual returns (bool) {
address newOwner;
address base = baseERC20();
uint32 baseOwnerFunctionSelector = uint32(_baseOwnerFunctionSelector());
DN404NFTStorage storage $ = _getDN404NFTStorage();
address oldOwner = $.owner;
assembly {
mstore(0x00, baseOwnerFunctionSelector)
let success := staticcall(gas(), base, 0x1c, 0x04, 0x00, 0x20)
newOwner := mul(shr(96, mload(0x0c)), and(gt(returndatasize(), 0x1f), success))
if iszero(success) { if shl(96, oldOwner) { revert(0x00, 0x00) } }
}
if (oldOwner != newOwner) {
$.owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
return true;
}
function _baseOwnerFunctionSelector() internal view virtual returns (bytes4) {
return 0x8da5cb5b;
}
function baseERC20() public view virtual returns (address base) {
base = _getDN404NFTStorage().baseERC20;
if (base == address(0)) _rv(uint32(NotLinked.selector));
}
modifier dn404NFTFallback() virtual {
DN404NFTStorage storage $ = _getDN404NFTStorage();
uint256 fnSelector = _calldataload(0x00) >> 224;
if (fnSelector == 0x263c69d6) {
if (msg.sender != $.baseERC20) _rv(uint32(SenderNotBase.selector));
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) _rv(uint32(SenderNotBase.selector));
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) {
_rv(uint32(SenderNotDeployer.selector));
}
}
if ($.baseERC20 != address(0)) _rv(uint32(AlreadyLinked.selector));
$.baseERC20 = msg.sender;
assembly {
mstore(0x00, 0x01)
return(0x00, 0x20)
}
}
_;
}
fallback() external payable virtual dn404NFTFallback {
_rv(uint32(FnSelectorNotRecognized.selector));
}
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))
let end := add(add(result, 0x20), mload(result))
mstore(end, 0)
mstore(0x40, add(end, 0x20))
}
}
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 _rv(uint32 s) private pure {
assembly {
mstore(0x00, s)
revert(0x1c, 0x04)
}
}
}
文件 3 的 9：EXEC404.sol
pragma solidity ^0.8.24;
import { DN404 } from "dn404/src/DN404.sol";
import { DN404Mirror } from "dn404/src/DN404Mirror.sol";
import { FixedPointMathLib } from "solady/utils/FixedPointMathLib.sol";
import { SafeTransferLib } from "solady/utils/SafeTransferLib.sol";
import { LibString } from "solady/utils/LibString.sol";
import { MerkleProofLib } from "solady/utils/MerkleProofLib.sol";
import { IUniswapV3SwapCallback } from "@uniswap/v3-core/contracts/interfaces/callback/IUniswapV3SwapCallback.sol";
contract EXEC404 is DN404, IUniswapV3SwapCallback {
struct BondingMessage {
address sender;
uint128 packedData;
string message;
}
address public constant CULT = 0x0000000000c5dc95539589fbD24BE07c6C14eCa4;
address private constant router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address private constant positionManager = 0xC36442b4a4522E871399CD717aBDD847Ab11FE88;
address private constant factory3 = 0x1F98431c8aD98523631AE4a59f267346ea31F984;
address private constant weth = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address private constant OPERATOR_NFT = 0xB24BaB1732D34cAD0A7C7035C3539aEC553bF3a0;
uint256 public constant MAX_SUPPLY = 4_440_000_000 ether;
uint256 public constant maxSupply = 4440;
uint256 public constant startTokenId = 1;
uint256 private constant INITIAL_PRICE = 0.025 ether;
uint256 private constant LIQUIDITY_RESERVE = MAX_SUPPLY * 10 / 100;
uint256 private constant TAX_RATE = 400;
uint256 private constant MIN_SELL_THRESHOLD = 12000 ether;
uint256 private constant MIN_CULT_THRESHOLD = 8000 ether;
uint256 private constant MIN_LP_THRESHOLD = 4000 ether;
uint24 private constant POOL_FEE = 10000;
int24 private constant TICK_SPACING = 60;
address private immutable factory;
uint256 public immutable LAUNCH_TIME;
address public liquidityPair;
bytes32[] private tierRoots;
uint256 public totalBondingSupply;
uint256 private reserve;
address public cultPool;
uint256 public cultV3Position;
bool private swapping;
mapping(uint256 => uint256) private blockSwaps;
mapping(address => bool) public freeMint;
uint256 public freeSupply = 1000 * 1000000 ether;
string public uri;
string public unrevealedUri;
bool public revealed = false;
mapping(uint256 => BondingMessage) public bondingMessages;
uint256 public totalMessages;
event WhitelistInitialized(bytes32[] roots);
event V3FeesCollected(address indexed collector, uint256 amount0, uint256 amount1);
event BondingSale(address indexed participant, uint256 amount, uint256 cost, bool isBuy);
event LiquidityDeployed(uint256 amountToken, uint256 amountETH, uint256 liquidity);
modifier whitelistGated(bytes32[] calldata proof) {
require(liquidityPair == address(0), "Presale ended");
uint256 currentTier = getCurrentTier();
if (currentTier < tierRoots.length - 1) {
require(isWhitelisted(proof, msg.sender), "Non-white");
}
_;
}
constructor(
bytes32[] memory _tierRoots
) {
require(_tierRoots.length == 12, "Bad roots");
tierRoots = _tierRoots;
LAUNCH_TIME = block.timestamp;
address routerAddr = address(router);
address factoryAddr;
assembly {
mstore(0x00, 0xc45a015500000000000000000000000000000000000000000000000000000000)
let success := staticcall(
gas(),
routerAddr,
0x00,
0x04,
0x00,
0x20
)
if iszero(success) {
revert(0, 0)
}
factoryAddr := mload(0x00)
}
factory = factoryAddr;
(,bytes memory d) = factory3.staticcall(abi.encodeWithSelector(0x1698ee82, CULT, weth, POOL_FEE));
cultPool = abi.decode(d, (address));
require(cultPool != address(0), "no CULT");
emit WhitelistInitialized(_tierRoots);
address mirror = address(new DN404Mirror(msg.sender));
_initializeDN404(MAX_SUPPLY, address(this), mirror);
}
function buyBonding(
uint256 amount,
uint256 maxCost,
bool mintNFT,
bytes32[] calldata proof,
string calldata message
) external payable whitelistGated(proof) {
require(totalBondingSupply + amount <= MAX_SUPPLY - LIQUIDITY_RESERVE, "Exceeds bonding");
uint256 totalCost = calculateCost(amount);
require(maxCost >= totalCost, "MaxCost exceeded");
require(msg.value >= totalCost, "Low ETH value");
bool originalSkipNFT = mintNFT ? getSkipNFT(msg.sender) : false;
if (originalSkipNFT) {
_setSkipNFT(msg.sender, false);
}
if(freeSupply > 1000000 ether && !freeMint[msg.sender]) {
totalBondingSupply += amount;
amount += 1000000 ether;
freeSupply -= 1000000 ether;
freeMint[msg.sender] = true;
} else {
totalBondingSupply += amount;
}
_transfer(address(this), msg.sender, amount);
reserve += totalCost;
if (bytes(message).length > 0) {
uint64 scaledAmount = uint64(amount / 1e18);
require(scaledAmount <= type(uint64).max, "Too size for msg");
bondingMessages[totalMessages++] = BondingMessage({
sender: msg.sender,
packedData: packData(
uint32(block.timestamp),
scaledAmount,
true
),
message: message
});
}
if (originalSkipNFT) {
_setSkipNFT(msg.sender, true);
}
if (msg.value > totalCost) {
SafeTransferLib.safeTransferETH(msg.sender, msg.value - totalCost);
}
emit BondingSale(msg.sender, amount, totalCost, true);
}
function sellBonding(
uint256 amount,
uint256 minRefund,
bytes32[] calldata proof,
string calldata message
) external whitelistGated(proof) {
uint256 balance = balanceOf(msg.sender);
require(balance >= amount, "smolbalance");
if(freeMint[msg.sender] && (balance - amount < 1000000 ether)) {
revert("Cannot sell your freebie back into bonding");
}
uint256 refund = calculateRefund(amount);
require(refund >= minRefund && reserve >= refund, "Invalid refund");
_transfer(msg.sender, address(this), amount);
totalBondingSupply -= amount;
reserve -= refund;
if (bytes(message).length > 0) {
require(amount / 1 ether <= type(uint64).max, "Too size for msg");
bondingMessages[totalMessages++] = BondingMessage({
sender: msg.sender,
packedData: packData(
uint32(block.timestamp),
uint64(amount / 1 ether),
false
),
message: message
});
}
uint256 userRefund = (refund * 9600) / 10000;
SafeTransferLib.safeTransferETH(
_erc721OwnerOf(OPERATOR_NFT, 598),
(refund * 100) / 10000
);
SafeTransferLib.safeTransferETH(msg.sender, userRefund);
emit BondingSale(msg.sender, amount, refund, false);
}
function balanceMint(uint256 amount) external {
DN404Storage storage $ = _getDN404Storage();
AddressData storage addressData = $.addressData[msg.sender];
uint256 balance = addressData.balance;
uint256 currentOwnedLength = addressData.ownedLength;
uint256 maxMintPossible = balance / _unit() - currentOwnedLength;
require(amount <= maxMintPossible, "NFTs over balance");
uint256 amountToMint = amount * _unit();
uint256 amountToHold = balance - (currentOwnedLength + amount) * _unit();
_transfer(msg.sender, address(this), amountToHold);
bool originalSkipNFT = getSkipNFT(msg.sender);
_setSkipNFT(msg.sender, false);
_transfer(msg.sender, msg.sender, amountToMint);
_setSkipNFT(msg.sender, originalSkipNFT);
_transfer(address(this), msg.sender, amountToHold);
require(addressData.balance == balance);
require(addressData.ownedLength == currentOwnedLength + amount);
}
function deployLiquidity() external returns (uint256 amountToken, uint256 amountETH, uint256 liquidity) {
require(block.timestamp >= LAUNCH_TIME + 12 hours, "Too early for liq");
require(liquidityPair == address(0), "Liq already deployed!");
uint256 ethBalance = address(this).balance;
require(ethBalance > 0.015 ether, "No ETH to deploy");
uint256 remainingSupply = MAX_SUPPLY - (totalBondingSupply + (1000000000 ether - freeSupply));
require(remainingSupply > 0, "No tokens to deploy");
(,bytes memory d) = factory.call(abi.encodeWithSelector(0xc9c65396, address(this), weth));
liquidityPair = abi.decode(d, (address));
uint256 ethForCult = 0.005 ether;
uint256 ethForOperations = 0.01 ether;
uint256 ethForV2 = ethBalance - ethForCult - ethForOperations;
_approve(address(this), address(router), remainingSupply);
assembly {
let ptr := mload(0x40)
mstore(ptr, 0xf305d71900000000000000000000000000000000000000000000000000000000)
mstore(add(ptr, 0x04), address())
mstore(add(ptr, 0x24), remainingSupply)
mstore(add(ptr, 0x44), 0)
mstore(add(ptr, 0x64), 0)
mstore(add(ptr, 0x84), address())
mstore(add(ptr, 0xa4), timestamp())
let success := call(
gas(),
router,
ethForV2,
ptr,
0xc4,
ptr,
0x60
)
if iszero(success) {
returndatacopy(0, 0, returndatasize())
revert(0, 0)
}
amountToken := mload(ptr)
amountETH := mload(add(ptr, 0x20))
liquidity := mload(add(ptr, 0x40))
}
if (!_initializeCultPoolLogic()) {
require(cultV3Position != 0);
}
return (amountToken, amountETH, liquidity);
emit LiquidityDeployed(amountToken, amountETH, liquidity);
}
function collectV3Fees(uint128 amount0Max, uint128 amount1Max) external payable returns (uint256 amount0, uint256 amount1) {
require(_erc721OwnerOf(OPERATOR_NFT, 598) == msg.sender, "Not oper");
require(amount0Max > 0 || amount1Max > 0, "Amount0Max and amount1Max both 0");
uint256 _cultPosition = cultV3Position;
assembly {
let ptr := mload(0x40)
mstore(ptr, 0xfc6f786500000000000000000000000000000000000000000000000000000000)
mstore(add(ptr, 0x04), _cultPosition)
mstore(add(ptr, 0x24), caller())
mstore(add(ptr, 0x44), amount0Max)
mstore(add(ptr, 0x64), amount1Max)
let success := call(
gas(),
positionManager,
callvalue(),
ptr,
0x84,
ptr,
0x40
)
if iszero(success) {
returndatacopy(0, 0, returndatasize())
revert(0, 0)
}
amount0 := mload(ptr)
amount1 := mload(add(ptr, 0x20))
}
emit V3FeesCollected(msg.sender, amount0, amount1);
}
function configure(string memory _uri, string memory _unrevealedUri, bool _revealed) public {
require(_erc721OwnerOf(OPERATOR_NFT, 598) == msg.sender, "not oper");
uri = _uri;
unrevealedUri = _unrevealedUri;
revealed = _revealed;
}
function initializeCultPool() external payable {
require(_initializeCultPoolLogic(), "Pool init failed");
}
receive() external payable override {
}
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata
) external override {
assembly {
let sender := caller()
if iszero(eq(sender, sload(cultPool.slot))) {
mstore(0x00, 0x20)
mstore(0x20, 0x0e)
mstore(0x40, "Unauthed pool")
revert(0x00, 0x4e)
}
mstore(0x00, 0x0dfe168100000000000000000000000000000000000000000000000000000000)
if iszero(staticcall(gas(), sender, 0x00, 0x04, 0x00, 0x20)) {
revert(0, 0)
}
let token0 := mload(0x00)
mstore(0x00, 0xd21220a700000000000000000000000000000000000000000000000000000000)
if iszero(staticcall(gas(), sender, 0x00, 0x04, 0x00, 0x20)) {
revert(0, 0)
}
let token1 := mload(0x00)
mstore(0x00, 0xa9059cbb00000000000000000000000000000000000000000000000000000000)
mstore(0x04, sender)
if sgt(amount0Delta, 0) {
mstore(0x24, amount0Delta)
pop(call(gas(), token0, 0, 0x00, 0x44, 0x00, 0x00))
}
if sgt(amount1Delta, 0) {
mstore(0x24, amount1Delta)
pop(call(gas(), token1, 0, 0x00, 0x44, 0x00, 0x00))
}
}
}
function onERC721Received(
address,
address,
uint256,
bytes calldata
) external pure returns (bytes4) {
return 0x150b7a02;
}
function getMessageDetails(uint256 messageId) external view returns (
address sender,
uint32 timestamp,
uint96 amount,
bool isBuy,
string memory message
) {
require(messageId < totalMessages, "Msg doesnt exist");
BondingMessage memory bondingMsg = bondingMessages[messageId];
(timestamp, amount, isBuy) = unpackData(bondingMsg.packedData);
return (bondingMsg.sender, timestamp, amount, isBuy, bondingMsg.message);
}
function getMessagesBatch(uint256 start, uint256 end) external view returns (
address[] memory senders,
uint32[] memory timestamps,
uint96[] memory amounts,
bool[] memory isBuys,
string[] memory messages
) {
require(end >= start, "Invalid range");
require(end < totalMessages, "End out of bounds");
uint256 size = end - start + 1;
senders = new address[](size);
timestamps = new uint32[](size);
amounts = new uint96[](size);
isBuys = new bool[](size);
messages = new string[](size);
for (uint256 i = 0; i < size; i++) {
BondingMessage memory bondingMsg = bondingMessages[start + i];
senders[i] = bondingMsg.sender;
(timestamps[i], amounts[i], isBuys[i]) = unpackData(bondingMsg.packedData);
messages[i] = bondingMsg.message;
}
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
uint256 taxAmount = amount - _beforeTransfer(msg.sender, to, amount);
_processTaxes(msg.sender, to);
if (taxAmount > 0) {
_transfer(msg.sender, address(this), taxAmount);
}
_transfer(msg.sender, to, amount - taxAmount);
return true;
}
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
uint256 taxAmount = amount - _beforeTransfer(from, to, amount);
_processTaxes(from, to);
if (taxAmount > 0) {
_transfer(from, address(this), taxAmount);
}
return super.transferFrom(from, to, amount - taxAmount);
}
function _beforeTransfer(address from, address to, uint256 amount) internal view returns (uint256) {
address liq = liquidityPair;
if (liq == address(0)) {
if (freeMint[from] && from != to) {
require(balanceOf(from) - amount >= 1000000 ether, "Cannot transfer free $EXEC until presale ends");
}
return amount;
}
if (from == address(this) || to == address(this)) return amount;
if (to == liq || from == liq) {
assembly {
let tax := div(mul(amount, TAX_RATE), 10000)
amount := sub(amount, tax)
}
}
return amount;
}
function _unit() internal pure override returns (uint256) {
return 1000000 * 10 ** 18;
}
function _tokenURI(uint256 tokenId) internal view override returns (string memory) {
if (!_exists(tokenId) || !revealed) {
return unrevealedUri;
}
return bytes(uri).length != 0 ? string(abi.encodePacked(uri, LibString.concat(_toString(tokenId),".json"))) : "test";
}
function _skipNFTDefault() internal pure override returns (SkipNFTDefault) {
return SkipNFTDefault.On;
}
function _processTaxes(address from, address to) internal {
address liq = liquidityPair;
if (liq == address(0)) return;
if (from == address(this) || to == address(this)) return;
uint256 blockSwap = blockSwaps[block.number];
bool isSell = to == liq;
if (isSell && !swapping && blockSwap < 3) {
uint256 execBalance = balanceOf(address(this));
if (execBalance >= MIN_SELL_THRESHOLD) {
swapping = true;
uint256 ethBalance = address(this).balance;
uint256 cultBalance = _erc20BalanceOf(CULT,address(this));
(uint8 operation, uint256 amount) = _selectOperation(ethBalance,cultBalance,execBalance);
if (operation == 0) {
_sellExecTax(execBalance);
} else if (operation == 1) {
_buyCultWithExactEth(amount);
} else {
_increaseCultLiquidity(cultBalance, ethBalance);
}
swapping = false;
blockSwaps[block.number] = blockSwap + 1;
}
}
}
function _selectOperation(uint256 ethBalance, uint256 cultBalance, uint256 execBalance) internal view returns (uint8 operation, uint256 amount) {
if (execBalance >= MIN_SELL_THRESHOLD && ethBalance < 0.01 ether) {
return (0, execBalance);
}
if (ethBalance >= 0.01 ether && cultBalance < MIN_CULT_THRESHOLD) {
uint256 ethToUse = ethBalance - 0.005 ether;
return (1, ethToUse);
}
if (ethBalance >= 0.01 ether && cultBalance >= MIN_LP_THRESHOLD) {
(uint256 optimalCult,) = _getOptimalCultRatio(ethBalance);
uint256 cultToUse = cultBalance > optimalCult ? optimalCult : cultBalance;
return (2, cultToUse);
}
return (0, 0);
}
function _sellExecTax(uint256 tokenBalance) internal {
if (tokenBalance < MIN_SELL_THRESHOLD) return;
_approve(address(this), address(router), tokenBalance);
assembly {
let ptr := mload(0x40)
mstore(ptr, 0x791ac94700000000000000000000000000000000000000000000000000000000)
mstore(add(ptr, 0x04), tokenBalance)
mstore(add(ptr, 0x24), 0)
mstore(add(ptr, 0x44), 0xa0)
mstore(add(ptr, 0x64), address())
mstore(add(ptr, 0x84), timestamp())
mstore(add(ptr, 0xa4), 2)
mstore(add(ptr, 0xc4), address())
mstore(add(ptr, 0xe4), weth)
let success := call(
gas(),
router,
0,
ptr,
0x104,
0,
0
)
if iszero(success) {
returndatacopy(0, 0, returndatasize())
revert(0, returndatasize())
}
}
}
function _buyCultWithExactEth(uint256 ethAmount) internal returns (uint256 cultBought) {
_wethDeposit(ethAmount);
address pool = cultPool;
_erc20Approve(weth, pool, ethAmount);
bool zeroForOne = weth < CULT;
uint256 result;
assembly {
let ptr := mload(0x40)
mstore(ptr, 0x128acb0800000000000000000000000000000000000000000000000000000000)
mstore(add(ptr, 0x04), address())
mstore(add(ptr, 0x24), iszero(iszero(zeroForOne)))
mstore(add(ptr, 0x44), ethAmount)
switch zeroForOne
case 1 {
mstore(add(ptr, 0x64), 4295128740)
}
default {
mstore(add(ptr, 0x64), 1461446703485210103287273052203988822378723970341)
}
mstore(add(ptr, 0x84), 0xa0)
mstore(add(ptr, 0xa4), 0)
let callSuccess := call(
gas(),
pool,
0,
ptr,
0xc4,
ptr,
0x40
)
if callSuccess {
let amount0 := mload(ptr)
let amount1 := mload(add(ptr, 0x20))
switch zeroForOne
case 1 {
result := sub(0, amount1)
}
default {
result := sub(0, amount0)
}
}
if iszero(callSuccess) {
mstore(0x00, 0x2e1a7d4d)
mstore(0x04, ethAmount)
pop(call(gas(), weth, 0, 0x00, 0x24, 0x00, 0x00))
result := 0
}
}
cultBought = result;
}
function _getOptimalCultRatio(uint256 ethAmount) internal view returns (uint256 optimalCult, uint256 price) {
(uint160 sqrtPriceX96,) = _staticcallSlot0Values(cultPool);
assembly {
let priceX96 := mul(sqrtPriceX96, sqrtPriceX96)
price := shr(192, mul(priceX96, exp(10, 18)))
optimalCult := div(mul(ethAmount, price), exp(10, 18))
}
}
function _increaseCultLiquidity(uint256 cultBalance, uint256 ethBalance) internal returns (bool success) {
if (cultBalance == 0 || ethBalance < 0.01 ether) {
return false;
}
if (cultV3Position == 0) {
return false;
}
uint256 ethAmount = ethBalance - 0.01 ether;
if (ethAmount < 0.01 ether) {
return false;
}
_wethDeposit(ethAmount);
_erc20Approve(CULT, address(positionManager), cultBalance);
_erc20Approve(weth, address(positionManager), ethAmount);
address posAddr = address(positionManager);
assembly {
let ptr := mload(0x40)
mstore(ptr, 0x219f5d1700000000000000000000000000000000000000000000000000000000)
mstore(add(ptr, 0x04), sload(cultV3Position.slot))
mstore(add(ptr, 0x24), cultBalance)
mstore(add(ptr, 0x44), ethAmount)
mstore(add(ptr, 0x64), 0)
mstore(add(ptr, 0x84), 0)
mstore(add(ptr, 0xa4), timestamp())
let callSuccess := call(
gas(),
posAddr,
0,
ptr,
0xc4,
0,
0
)
if callSuccess {
let wethPtr := mload(0x40)
mstore(wethPtr, 0x70a0823100000000000000000000000000000000000000000000000000000000)
mstore(add(wethPtr, 0x04), address())
pop(staticcall(
gas(),
weth,
wethPtr,
0x24,
0,
0x20
))
let unusedWeth := mload(0)
if gt(unusedWeth, 0) {
mstore(wethPtr, 0x2e1a7d4d00000000000000000000000000000000000000000000000000000000)
mstore(add(wethPtr, 0x04), unusedWeth)
pop(call(gas(), weth, 0, wethPtr, 0x24, 0, 0))
}
success := 1
}
let wethPtr := mload(0x40)
mstore(wethPtr, 0x2e1a7d4d00000000000000000000000000000000000000000000000000000000)
mstore(add(wethPtr, 0x04), ethAmount)
pop(call(gas(), weth, 0, wethPtr, 0x24, 0, 0))
success := 0
}
return success;
}
function _erc20Approve(address token, address spender, uint256 amount) internal {
assembly {
let ptr := mload(0x40)
mstore(ptr, 0x095ea7b300000000000000000000000000000000000000000000000000000000)
mstore(add(ptr, 0x04), and(spender, 0xffffffffffffffffffffffffffffffffffffffff))
mstore(add(ptr, 0x24), amount)
let success := call(
gas(),
token,
0,
ptr,
0x44,
0,
0
)
if iszero(success) {
returndatacopy(0, 0, returndatasize())
revert(0, returndatasize())
}
}
}
function _erc20BalanceOf(address token, address account) internal view returns (uint256 result) {
assembly {
mstore(0x00, 0x70a0823100000000000000000000000000000000000000000000000000000000)
mstore(0x04, and(account, 0xffffffffffffffffffffffffffffffffffffffff))
let success := staticcall(
gas(),
token,
0x00,
0x24,
0x00,
0x20
)
if iszero(success) {
revert(0, 0)
}
result := mload(0x00)
}
}
function _erc20Transfer(address token, address to, uint256 amount) internal {
assembly {
let ptr := mload(0x40)
mstore(ptr, 0xa9059cbb00000000000000000000000000000000000000000000000000000000)
mstore(add(ptr, 0x04), and(to, 0xffffffffffffffffffffffffffffffffffffffff))
mstore(add(ptr, 0x24), amount)
let success := call(
gas(),
token,
0,
ptr,
0x44,
ptr,
0x20
)
if iszero(success) {
returndatacopy(0, 0, returndatasize())
revert(0, returndatasize())
}
let returnValue := mload(ptr)
if iszero(returnValue) {
revert(0, 0)
}
}
}
function _erc721OwnerOf(address collection, uint256 tokenId) internal view returns (address owner) {
assembly {
mstore(0x00, 0x6352211e00000000000000000000000000000000000000000000000000000000)
mstore(0x04, tokenId)
let success := staticcall(
gas(),
collection,
0x00,
0x24,
0x00,
0x20
)
if iszero(success) {
revert(0, 0)
}
owner := and(mload(0x00), 0xffffffffffffffffffffffffffffffffffffffff)
}
}
function _wethDeposit(uint256 amount) internal {
assembly {
mstore(0x00, 0xd0e30db000000000000000000000000000000000000000000000000000000000)
let success := call(
gas(),
weth,
amount,
0x00,
0x04,
0x00,
0x00
)
if iszero(success) {
returndatacopy(0, 0, returndatasize())
revert(0, returndatasize())
}
}
}
function _wethWithdraw(uint256 amount) internal {
assembly {
mstore(0x00, 0x2e1a7d4d00000000000000000000000000000000000000000000000000000000)
mstore(0x04, amount)
let success := call(
gas(),
weth,
0,
0x00,
0x24,
0x00,
0x00
)
if iszero(success) {
returndatacopy(0, 0, returndatasize())
revert(0, returndatasize())
}
}
}
function _staticcallSlot0Values(address pool) internal view returns (uint160 sqrtPriceX96, int24 tick) {
assembly {
mstore(0x0, 0x3850c7bd00000000000000000000000000000000000000000000000000000000)
let success := staticcall(gas(), pool, 0x0, 0x4, 0x0, 0x40)
if iszero(success) {
revert(0, 0)
}
sqrtPriceX96 := mload(0x0)
tick := mload(0x20)
}
}
function _staticcallTickSpacing(address pool) internal view returns (int24 spacing) {
assembly {
mstore(0, 0xd0c93a7c00000000000000000000000000000000000000000000000000000000)
let success := staticcall(gas(), pool, 0, 4, 0, 32)
if iszero(success) { revert(0, 0) }
spacing := mload(0)
}
}
function _toString(uint256 value) internal view 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)
}
}
function packData(uint32 timestamp, uint96 amount, bool isBuy) internal pure returns (uint128) {
return uint128(
(uint128(timestamp) << 96) |
(uint128(amount) << 1) |
(isBuy ? 1 : 0)
);
}
function unpackData(uint128 packed) internal pure returns (uint32 timestamp, uint96 amount, bool isBuy) {
timestamp = uint32(packed >> 96);
uint256 amountMask = (uint256(1) << 95) - 1;
amount = uint96((packed >> 1) & amountMask);
isBuy = (packed & 1) == 1;
}
function calculateIntegral(uint256 lowerBound, uint256 upperBound) internal pure returns (uint256) {
require(upperBound >= lowerBound, "Invalid bounds");
return _calculateIntegralFromZero(upperBound) - _calculateIntegralFromZero(lowerBound);
}
function _calculateIntegralFromZero(uint256 supply) internal pure returns (uint256) {
uint256 scaledSupplyWad = supply / 1e7;
uint256 basePart = INITIAL_PRICE * scaledSupplyWad / 1e18;
uint256 quarticTerm = FixedPointMathLib.mulWad(
3 gwei,
FixedPointMathLib.mulWad(
FixedPointMathLib.mulWad(
FixedPointMathLib.mulWad(scaledSupplyWad, scaledSupplyWad),
scaledSupplyWad
),
scaledSupplyWad
)
);
uint256 cubicTerm = FixedPointMathLib.mulWad(
1333333333,
FixedPointMathLib.mulWad(
FixedPointMathLib.mulWad(scaledSupplyWad, scaledSupplyWad),
scaledSupplyWad
)
);
uint256 quadraticTerm = FixedPointMathLib.mulWad(
2 gwei,
FixedPointMathLib.mulWad(scaledSupplyWad, scaledSupplyWad)
);
return basePart + quarticTerm + cubicTerm + quadraticTerm;
}
function _initializeCultPoolLogic() private returns (bool success) {
if (cultV3Position != 0 || cultPool == address(0)) {
return false;
}
int24 tickSpacing = _staticcallTickSpacing(cultPool);
(,int24 currentTick) = _staticcallSlot0Values(cultPool);
int24 tickRange = tickSpacing * 16;
uint256 cultBought = _buyCultWithExactEth(0.0025 ether);
_wethDeposit(0.0025 ether);
_erc20Approve(CULT, address(positionManager), cultBought);
_erc20Approve(weth, address(positionManager), 0.0025 ether);
int24 tickLower = ((currentTick - tickRange) / tickSpacing) * tickSpacing;
int24 tickUpper = ((currentTick + tickRange) / tickSpacing) * tickSpacing;
address _CULT = CULT;
address _posMan = address(positionManager);
bool isToken0 = CULT < weth;
assembly {
let ptr := mload(0x40)
mstore(ptr, 0x8831645600000000000000000000000000000000000000000000000000000000)
switch isToken0
case 1 {
mstore(add(ptr, 0x04), _CULT)
mstore(add(ptr, 0x24), weth)
mstore(add(ptr, 0xa4), cultBought)
mstore(add(ptr, 0xc4), 5000000000000000)
}
default {
mstore(add(ptr, 0x04), weth)
mstore(add(ptr, 0x24), _CULT)
mstore(add(ptr, 0xa4), 5000000000000000)
mstore(add(ptr, 0xc4), cultBought)
}
mstore(add(ptr, 0x44), POOL_FEE)
mstore(add(ptr, 0x64), tickLower)
mstore(add(ptr, 0x84), tickUpper)
mstore(add(ptr, 0xe4), 0)
mstore(add(ptr, 0x104), 0)
mstore(add(ptr, 0x124), address())
mstore(add(ptr, 0x144), timestamp())
success := call(gas(), _posMan, 0, ptr, 0x164, ptr, 0xA0)
if success {
sstore(cultV3Position.slot, mload(ptr))
if iszero(lt(returndatasize(), 0xA0)) {
let amount1 := mload(add(ptr, 0x80))
let unusedWeth := sub(5000000000000000, amount1)
if gt(unusedWeth, 0) {
if gt(unusedWeth, 5000000000000000) {
unusedWeth := 0
}
mstore(0x00, 0x2e1a7d4d00000000000000000000000000000000000000000000000000000000)
mstore(0x04, unusedWeth)
pop(call(gas(), weth, 0, 0x00, 0x24, 0x00, 0x00))
}
}
}
if iszero(success) {
mstore(0x00, 0x2e1a7d4d00000000000000000000000000000000000000000000000000000000)
mstore(0x04, 5000000000000000)
pop(call(gas(), weth, 0, 0x00, 0x24, 0x00, 0x00))
}
}
}
function name() public pure override returns (string memory) {
return "CULT EXECUTIVES";
}
function symbol() public pure override returns (string memory) {
return "EXEC";
}
function calculateCost(uint256 amount) public view returns (uint256) {
return calculateIntegral(totalBondingSupply, totalBondingSupply + amount);
}
function calculateRefund(uint256 amount) public view returns (uint256) {
return calculateIntegral(totalBondingSupply - amount, totalBondingSupply);
}
function getOwnerTokens(address owner) public view returns (uint256[] memory) {
uint256 ownerBalanceLength = _balanceOfNFT(owner);
return _ownedIds(owner, 0, ownerBalanceLength);
}
function tokenURI(uint256 tokenId) public view returns (string memory) {
return _tokenURI(tokenId);
}
function isWhitelisted(bytes32[] calldata proof, address account) public view returns (bool) {
return MerkleProofLib.verify(
proof,
currentRoot(),
keccak256(abi.encodePacked(bytes20(account)))
);
}
function getCurrentTier() public view returns (uint256) {
if (block.timestamp < LAUNCH_TIME) return 0;
uint256 hoursSinceLaunch = (block.timestamp - LAUNCH_TIME) / 1 hours;
return hoursSinceLaunch >= tierRoots.length ? tierRoots.length - 1 : hoursSinceLaunch;
}
function currentRoot() public view returns (bytes32) {
return tierRoots[getCurrentTier()];
}
function getEthForExec(uint256 execAmount) public view returns (uint256 ethAmount) {
require(execAmount <= totalBondingSupply, "Exceeds bonding");
return calculateRefund(execAmount);
}
function getExecForEth(uint256 ethAmount) public view returns (uint256 execAmount) {
uint256 remainingSupply = MAX_SUPPLY - LIQUIDITY_RESERVE - totalBondingSupply;
if (calculateCost(remainingSupply) <= ethAmount) {
return remainingSupply;
}
uint256 low = 0;
uint256 high = remainingSupply;
while (low < high) {
uint256 mid = (low + high + 1) / 2;
uint256 cost = calculateCost(mid);
if (cost <= ethAmount) {
low = mid;
} else {
high = mid - 1;
}
}
return low;
}
}
文件 4 的 9：FixedPointMathLib.sol
pragma solidity ^0.8.4;
library FixedPointMathLib {
error ExpOverflow();
error FactorialOverflow();
error RPowOverflow();
error MantissaOverflow();
error MulWadFailed();
error SMulWadFailed();
error DivWadFailed();
error SDivWadFailed();
error MulDivFailed();
error DivFailed();
error FullMulDivFailed();
error LnWadUndefined();
error OutOfDomain();
uint256 internal constant WAD = 1e18;
function mulWad(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
if gt(x, div(not(0), y)) {
if y {
mstore(0x00, 0xbac65e5b)
revert(0x1c, 0x04)
}
}
z := div(mul(x, y), WAD)
}
}
function sMulWad(int256 x, int256 y) internal pure returns (int256 z) {
assembly {
z := mul(x, y)
if iszero(gt(or(iszero(x), eq(sdiv(z, x), y)), lt(not(x), eq(y, shl(255, 1))))) {
mstore(0x00, 0xedcd4dd4)
revert(0x1c, 0x04)
}
z := sdiv(z, WAD)
}
}
function rawMulWad(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := div(mul(x, y), WAD)
}
}
function rawSMulWad(int256 x, int256 y) internal pure returns (int256 z) {
assembly {
z := sdiv(mul(x, y), WAD)
}
}
function mulWadUp(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := mul(x, y)
if iszero(eq(div(z, y), x)) {
if y {
mstore(0x00, 0xbac65e5b)
revert(0x1c, 0x04)
}
}
z := add(iszero(iszero(mod(z, WAD))), div(z, WAD))
}
}
function rawMulWadUp(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := add(iszero(iszero(mod(mul(x, y), WAD))), div(mul(x, y), WAD))
}
}
function divWad(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
if iszero(mul(y, lt(x, add(1, div(not(0), WAD))))) {
mstore(0x00, 0x7c5f487d)
revert(0x1c, 0x04)
}
z := div(mul(x, WAD), y)
}
}
function sDivWad(int256 x, int256 y) internal pure returns (int256 z) {
assembly {
z := mul(x, WAD)
if iszero(mul(y, eq(sdiv(z, WAD), x))) {
mstore(0x00, 0x5c43740d)
revert(0x1c, 0x04)
}
z := sdiv(z, y)
}
}
function rawDivWad(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := div(mul(x, WAD), y)
}
}
function rawSDivWad(int256 x, int256 y) internal pure returns (int256 z) {
assembly {
z := sdiv(mul(x, WAD), y)
}
}
function divWadUp(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
if iszero(mul(y, lt(x, add(1, div(not(0), WAD))))) {
mstore(0x00, 0x7c5f487d)
revert(0x1c, 0x04)
}
z := add(iszero(iszero(mod(mul(x, WAD), y))), div(mul(x, WAD), y))
}
}
function rawDivWadUp(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := add(iszero(iszero(mod(mul(x, WAD), y))), div(mul(x, WAD), y))
}
}
function powWad(int256 x, int256 y) internal pure returns (int256) {
return expWad((lnWad(x) * y) / int256(WAD));
}
function expWad(int256 x) internal pure returns (int256 r) {
unchecked {
if (x <= -41446531673892822313) return r;
assembly {
if iszero(slt(x, 135305999368893231589)) {
mstore(0x00, 0xa37bfec9)
revert(0x1c, 0x04)
}
}
x = (x << 78) / 5 ** 18;
int256 k = ((x << 96) / 54916777467707473351141471128 + 2 ** 95) >> 96;
x = x - k * 54916777467707473351141471128;
int256 y = x + 1346386616545796478920950773328;
y = ((y * x) >> 96) + 57155421227552351082224309758442;
int256 p = y + x - 94201549194550492254356042504812;
p = ((p * y) >> 96) + 28719021644029726153956944680412240;
p = p * x + (4385272521454847904659076985693276 << 96);
int256 q = x - 2855989394907223263936484059900;
q = ((q * x) >> 96) + 50020603652535783019961831881945;
q = ((q * x) >> 96) - 533845033583426703283633433725380;
q = ((q * x) >> 96) + 3604857256930695427073651918091429;
q = ((q * x) >> 96) - 14423608567350463180887372962807573;
q = ((q * x) >> 96) + 26449188498355588339934803723976023;
assembly {
r := sdiv(p, q)
}
r = int256(
(uint256(r) * 3822833074963236453042738258902158003155416615667) >> uint256(195 - k)
);
}
}
function lnWad(int256 x) internal pure returns (int256 r) {
assembly {
r := shl(7, lt(0xffffffffffffffffffffffffffffffff, x))
r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, x))))
r := or(r, shl(5, lt(0xffffffff, shr(r, x))))
r := or(r, shl(4, lt(0xffff, shr(r, x))))
r := or(r, shl(3, lt(0xff, shr(r, x))))
if iszero(sgt(x, 0)) {
mstore(0x00, 0x1615e638)
revert(0x1c, 0x04)
}
r := xor(r, byte(and(0x1f, shr(shr(r, x), 0x8421084210842108cc6318c6db6d54be)),
0xf8f9f9faf9fdfafbf9fdfcfdfafbfcfef9fafdfafcfcfbfefafafcfbffffffff))
x := shr(159, shl(r, x))
let p := sub(
sar(96, mul(add(43456485725739037958740375743393,
sar(96, mul(add(24828157081833163892658089445524,
sar(96, mul(add(3273285459638523848632254066296,
x), x))), x))), x)), 11111509109440967052023855526967)
p := sub(sar(96, mul(p, x)), 45023709667254063763336534515857)
p := sub(sar(96, mul(p, x)), 14706773417378608786704636184526)
p := sub(mul(p, x), shl(96, 795164235651350426258249787498))
let q := add(5573035233440673466300451813936, x)
q := add(71694874799317883764090561454958, sar(96, mul(x, q)))
q := add(283447036172924575727196451306956, sar(96, mul(x, q)))
q := add(401686690394027663651624208769553, sar(96, mul(x, q)))
q := add(204048457590392012362485061816622, sar(96, mul(x, q)))
q := add(31853899698501571402653359427138, sar(96, mul(x, q)))
q := add(909429971244387300277376558375, sar(96, mul(x, q)))
p := sdiv(p, q)
p := mul(1677202110996718588342820967067443963516166, p)
p := add(mul(16597577552685614221487285958193947469193820559219878177908093499208371, sub(159, r)), p)
p := add(600920179829731861736702779321621459595472258049074101567377883020018308, p)
r := sar(174, p)
}
}
function lambertW0Wad(int256 x) internal pure returns (int256 w) {
unchecked {
if ((w = x) <= -367879441171442322) revert OutOfDomain();
(int256 wad, int256 p) = (int256(WAD), x);
uint256 c;
uint256 i = 4;
if (w <= 0x1ffffffffffff) {
if (-0x4000000000000 <= w) {
i = 1;
} else if (w <= -0x3ffffffffffffff) {
i = 32;
}
} else if (uint256(w >> 63) == uint256(0)) {
assembly {
let v := shr(49, w)
let l := shl(3, lt(0xff, v))
l := add(or(l, byte(and(0x1f, shr(shr(l, v), 0x8421084210842108cc6318c6db6d54be)),
0x0706060506020504060203020504030106050205030304010505030400000000)), 49)
w := sdiv(shl(l, 7), byte(sub(l, 31), 0x0303030303030303040506080c13))
c := gt(l, 60)
i := add(2, add(gt(l, 53), c))
}
} else {
int256 ll = lnWad(w = lnWad(w));
assembly {
w := add(sdiv(mul(ll, 1023715080943847266), w), sub(w, ll))
i := add(3, iszero(shr(68, x)))
c := iszero(shr(143, x))
}
if (c == uint256(0)) {
do {
int256 e = expWad(w);
assembly {
let t := mul(w, div(e, wad))
w := sub(w, sdiv(sub(t, x), div(add(e, t), wad)))
}
if (p <= w) break;
p = w;
} while (--i != uint256(0));
assembly {
w := sub(w, sgt(w, 2))
}
return w;
}
}
do {
int256 e = expWad(w);
assembly {
let t := add(w, wad)
let s := sub(mul(w, e), mul(x, wad))
w := sub(w, sdiv(mul(s, wad), sub(mul(e, t), sdiv(mul(add(t, wad), s), add(t, t)))))
}
if (p <= w) break;
p = w;
} while (--i != c);
assembly {
w := sub(w, sgt(w, 2))
}
if (c == uint256(0)) return w;
int256 t = w | 1;
assembly {
x := sdiv(mul(x, wad), t)
}
x = (t * (wad + lnWad(x)));
assembly {
w := sdiv(x, add(wad, t))
}
}
}
function fullMulEq(uint256 a, uint256 b, uint256 x, uint256 y)
internal
pure
returns (bool result)
{
assembly {
result := and(eq(mul(a, b), mul(x, y)), eq(mulmod(x, y, not(0)), mulmod(a, b, not(0))))
}
}
function fullMulDiv(uint256 x, uint256 y, uint256 d) internal pure returns (uint256 z) {
assembly {
z := mul(x, y)
for {} 1 {} {
if iszero(mul(or(iszero(x), eq(div(z, x), y)), d)) {
let mm := mulmod(x, y, not(0))
let p1 := sub(mm, add(z, lt(mm, z)))
let r := mulmod(x, y, d)
let t := and(d, sub(0, d))
if iszero(gt(d, p1)) {
mstore(0x00, 0xae47f702)
revert(0x1c, 0x04)
}
d := div(d, t)
let inv := xor(2, mul(3, d))
inv := mul(inv, sub(2, mul(d, inv)))
inv := mul(inv, sub(2, mul(d, inv)))
inv := mul(inv, sub(2, mul(d, inv)))
inv := mul(inv, sub(2, mul(d, inv)))
inv := mul(inv, sub(2, mul(d, inv)))
z :=
mul(
or(mul(sub(p1, gt(r, z)), add(div(sub(0, t), t), 1)), div(sub(z, r), t)),
mul(sub(2, mul(d, inv)), inv)
)
break
}
z := div(z, d)
break
}
}
}
function fullMulDivUnchecked(uint256 x, uint256 y, uint256 d)
internal
pure
returns (uint256 z)
{
assembly {
z := mul(x, y)
let mm := mulmod(x, y, not(0))
let p1 := sub(mm, add(z, lt(mm, z)))
let t := and(d, sub(0, d))
let r := mulmod(x, y, d)
d := div(d, t)
let inv := xor(2, mul(3, d))
inv := mul(inv, sub(2, mul(d, inv)))
inv := mul(inv, sub(2, mul(d, inv)))
inv := mul(inv, sub(2, mul(d, inv)))
inv := mul(inv, sub(2, mul(d, inv)))
inv := mul(inv, sub(2, mul(d, inv)))
z :=
mul(
or(mul(sub(p1, gt(r, z)), add(div(sub(0, t), t), 1)), div(sub(z, r), t)),
mul(sub(2, mul(d, inv)), inv)
)
}
}
function fullMulDivUp(uint256 x, uint256 y, uint256 d) internal pure returns (uint256 z) {
z = fullMulDiv(x, y, d);
assembly {
if mulmod(x, y, d) {
z := add(z, 1)
if iszero(z) {
mstore(0x00, 0xae47f702)
revert(0x1c, 0x04)
}
}
}
}
function fullMulDivN(uint256 x, uint256 y, uint8 n) internal pure returns (uint256 z) {
assembly {
z := mul(x, y)
for {} 1 {} {
if iszero(or(iszero(x), eq(div(z, x), y))) {
let k := and(n, 0xff)
let mm := mulmod(x, y, not(0))
let p1 := sub(mm, add(z, lt(mm, z)))
if iszero(shr(k, p1)) {
z := add(shl(sub(256, k), p1), shr(k, z))
break
}
mstore(0x00, 0xae47f702)
revert(0x1c, 0x04)
}
z := shr(and(n, 0xff), z)
break
}
}
}
function mulDiv(uint256 x, uint256 y, uint256 d) internal pure returns (uint256 z) {
assembly {
z := mul(x, y)
if iszero(mul(or(iszero(x), eq(div(z, x), y)), d)) {
mstore(0x00, 0xad251c27)
revert(0x1c, 0x04)
}
z := div(z, d)
}
}
function mulDivUp(uint256 x, uint256 y, uint256 d) internal pure returns (uint256 z) {
assembly {
z := mul(x, y)
if iszero(mul(or(iszero(x), eq(div(z, x), y)), d)) {
mstore(0x00, 0xad251c27)
revert(0x1c, 0x04)
}
z := add(iszero(iszero(mod(z, d))), div(z, d))
}
}
function invMod(uint256 a, uint256 n) internal pure returns (uint256 x) {
assembly {
let g := n
let r := mod(a, n)
for { let y := 1 } 1 {} {
let q := div(g, r)
let t := g
g := r
r := sub(t, mul(r, q))
let u := x
x := y
y := sub(u, mul(y, q))
if iszero(r) { break }
}
x := mul(eq(g, 1), add(x, mul(slt(x, 0), n)))
}
}
function divUp(uint256 x, uint256 d) internal pure returns (uint256 z) {
assembly {
if iszero(d) {
mstore(0x00, 0x65244e4e)
revert(0x1c, 0x04)
}
z := add(iszero(iszero(mod(x, d))), div(x, d))
}
}
function zeroFloorSub(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := mul(gt(x, y), sub(x, y))
}
}
function saturatingSub(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := mul(gt(x, y), sub(x, y))
}
}
function saturatingAdd(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := or(sub(0, lt(add(x, y), x)), add(x, y))
}
}
function saturatingMul(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := or(sub(or(iszero(x), eq(div(mul(x, y), x), y)), 1), mul(x, y))
}
}
function ternary(bool condition, uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := xor(x, mul(xor(x, y), iszero(condition)))
}
}
function ternary(bool condition, bytes32 x, bytes32 y) internal pure returns (bytes32 z) {
assembly {
z := xor(x, mul(xor(x, y), iszero(condition)))
}
}
function ternary(bool condition, address x, address y) internal pure returns (address z) {
assembly {
z := xor(x, mul(xor(x, y), iszero(condition)))
}
}
function rpow(uint256 x, uint256 y, uint256 b) internal pure returns (uint256 z) {
assembly {
z := mul(b, iszero(y))
if x {
z := xor(b, mul(xor(b, x), and(y, 1)))
let half := shr(1, b)
for { y := shr(1, y) } y { y := shr(1, y) } {
let xx := mul(x, x)
let xxRound := add(xx, half)
if or(lt(xxRound, xx), shr(128, x)) {
mstore(0x00, 0x49f7642b)
revert(0x1c, 0x04)
}
x := div(xxRound, b)
if and(y, 1) {
let zx := mul(z, x)
let zxRound := add(zx, half)
if or(xor(div(zx, x), z), lt(zxRound, zx)) {
if x {
mstore(0x00, 0x49f7642b)
revert(0x1c, 0x04)
}
}
z := div(zxRound, b)
}
}
}
}
}
function sqrt(uint256 x) internal pure returns (uint256 z) {
assembly {
z := 181
let r := shl(7, lt(0xffffffffffffffffffffffffffffffffff, x))
r := or(r, shl(6, lt(0xffffffffffffffffff, shr(r, x))))
r := or(r, shl(5, lt(0xffffffffff, shr(r, x))))
r := or(r, shl(4, lt(0xffffff, shr(r, x))))
z := shl(shr(1, r), z)
z := shr(18, mul(z, add(shr(r, x), 65536)))
z := shr(1, add(z, div(x, z)))
z := shr(1, add(z, div(x, z)))
z := shr(1, add(z, div(x, z)))
z := shr(1, add(z, div(x, z)))
z := shr(1, add(z, div(x, z)))
z := shr(1, add(z, div(x, z)))
z := shr(1, add(z, div(x, z)))
z := sub(z, lt(div(x, z), z))
}
}
function cbrt(uint256 x) internal pure returns (uint256 z) {
assembly {
let r := shl(7, lt(0xffffffffffffffffffffffffffffffff, x))
r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, x))))
r := or(r, shl(5, lt(0xffffffff, shr(r, x))))
r := or(r, shl(4, lt(0xffff, shr(r, x))))
r := or(r, shl(3, lt(0xff, shr(r, x))))
z := div(shl(div(r, 3), shl(lt(0xf, shr(r, x)), 0xf)), xor(7, mod(r, 3)))
z := div(add(add(div(x, mul(z, z)), z), z), 3)
z := div(add(add(div(x, mul(z, z)), z), z), 3)
z := div(add(add(div(x, mul(z, z)), z), z), 3)
z := div(add(add(div(x, mul(z, z)), z), z), 3)
z := div(add(add(div(x, mul(z, z)), z), z), 3)
z := div(add(add(div(x, mul(z, z)), z), z), 3)
z := div(add(add(div(x, mul(z, z)), z), z), 3)
z := sub(z, lt(div(x, mul(z, z)), z))
}
}
function sqrtWad(uint256 x) internal pure returns (uint256 z) {
unchecked {
if (x <= type(uint256).max / 10 ** 18) return sqrt(x * 10 ** 18);
z = (1 + sqrt(x)) * 10 ** 9;
z = (fullMulDivUnchecked(x, 10 ** 18, z) + z) >> 1;
}
assembly {
z := sub(z, gt(999999999999999999, sub(mulmod(z, z, x), 1)))
}
}
function cbrtWad(uint256 x) internal pure returns (uint256 z) {
unchecked {
if (x <= type(uint256).max / 10 ** 36) return cbrt(x * 10 ** 36);
z = (1 + cbrt(x)) * 10 ** 12;
z = (fullMulDivUnchecked(x, 10 ** 36, z * z) + z + z) / 3;
}
assembly {
let p := x
for {} 1 {} {
if iszero(shr(229, p)) {
if iszero(shr(199, p)) {
p := mul(p, 100000000000000000)
break
}
p := mul(p, 100000000)
break
}
if iszero(shr(249, p)) { p := mul(p, 100) }
break
}
let t := mulmod(mul(z, z), z, p)
z := sub(z, gt(lt(t, shr(1, p)), iszero(t)))
}
}
function factorial(uint256 x) internal pure returns (uint256 z) {
assembly {
z := 1
if iszero(lt(x, 58)) {
mstore(0x00, 0xaba0f2a2)
revert(0x1c, 0x04)
}
for {} x { x := sub(x, 1) } { z := mul(z, x) }
}
}
function log2(uint256 x) internal pure returns (uint256 r) {
assembly {
r := shl(7, lt(0xffffffffffffffffffffffffffffffff, x))
r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, x))))
r := or(r, shl(5, lt(0xffffffff, shr(r, x))))
r := or(r, shl(4, lt(0xffff, shr(r, x))))
r := or(r, shl(3, lt(0xff, shr(r, x))))
r := or(r, byte(and(0x1f, shr(shr(r, x), 0x8421084210842108cc6318c6db6d54be)),
0x0706060506020504060203020504030106050205030304010505030400000000))
}
}
function log2Up(uint256 x) internal pure returns (uint256 r) {
r = log2(x);
assembly {
r := add(r, lt(shl(r, 1), x))
}
}
function log10(uint256 x) internal pure returns (uint256 r) {
assembly {
if iszero(lt(x, 100000000000000000000000000000000000000)) {
x := div(x, 100000000000000000000000000000000000000)
r := 38
}
if iszero(lt(x, 100000000000000000000)) {
x := div(x, 100000000000000000000)
r := add(r, 20)
}
if iszero(lt(x, 10000000000)) {
x := div(x, 10000000000)
r := add(r, 10)
}
if iszero(lt(x, 100000)) {
x := div(x, 100000)
r := add(r, 5)
}
r := add(r, add(gt(x, 9), add(gt(x, 99), add(gt(x, 999), gt(x, 9999)))))
}
}
function log10Up(uint256 x) internal pure returns (uint256 r) {
r = log10(x);
assembly {
r := add(r, lt(exp(10, r), x))
}
}
function log256(uint256 x) internal pure returns (uint256 r) {
assembly {
r := shl(7, lt(0xffffffffffffffffffffffffffffffff, x))
r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, x))))
r := or(r, shl(5, lt(0xffffffff, shr(r, x))))
r := or(r, shl(4, lt(0xffff, shr(r, x))))
r := or(shr(3, r), lt(0xff, shr(r, x)))
}
}
function log256Up(uint256 x) internal pure returns (uint256 r) {
r = log256(x);
assembly {
r := add(r, lt(shl(shl(3, r), 1), x))
}
}
function sci(uint256 x) internal pure returns (uint256 mantissa, uint256 exponent) {
assembly {
mantissa := x
if mantissa {
if iszero(mod(mantissa, 1000000000000000000000000000000000)) {
mantissa := div(mantissa, 1000000000000000000000000000000000)
exponent := 33
}
if iszero(mod(mantissa, 10000000000000000000)) {
mantissa := div(mantissa, 10000000000000000000)
exponent := add(exponent, 19)
}
if iszero(mod(mantissa, 1000000000000)) {
mantissa := div(mantissa, 1000000000000)
exponent := add(exponent, 12)
}
if iszero(mod(mantissa, 1000000)) {
mantissa := div(mantissa, 1000000)
exponent := add(exponent, 6)
}
if iszero(mod(mantissa, 10000)) {
mantissa := div(mantissa, 10000)
exponent := add(exponent, 4)
}
if iszero(mod(mantissa, 100)) {
mantissa := div(mantissa, 100)
exponent := add(exponent, 2)
}
if iszero(mod(mantissa, 10)) {
mantissa := div(mantissa, 10)
exponent := add(exponent, 1)
}
}
}
}
function packSci(uint256 x) internal pure returns (uint256 packed) {
(x, packed) = sci(x);
assembly {
if shr(249, x) {
mstore(0x00, 0xce30380c)
revert(0x1c, 0x04)
}
packed := or(shl(7, x), packed)
}
}
function unpackSci(uint256 packed) internal pure returns (uint256 unpacked) {
unchecked {
unpacked = (packed >> 7) * 10 ** (packed & 0x7f);
}
}
function avg(uint256 x, uint256 y) internal pure returns (uint256 z) {
unchecked {
z = (x & y) + ((x ^ y) >> 1);
}
}
function avg(int256 x, int256 y) internal pure returns (int256 z) {
unchecked {
z = (x >> 1) + (y >> 1) + (x & y & 1);
}
}
function abs(int256 x) internal pure returns (uint256 z) {
unchecked {
z = (uint256(x) + uint256(x >> 255)) ^ uint256(x >> 255);
}
}
function dist(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := add(xor(sub(0, gt(x, y)), sub(y, x)), gt(x, y))
}
}
function dist(int256 x, int256 y) internal pure returns (uint256 z) {
assembly {
z := add(xor(sub(0, sgt(x, y)), sub(y, x)), sgt(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 min(int256 x, int256 y) internal pure returns (int256 z) {
assembly {
z := xor(x, mul(xor(x, y), slt(y, x)))
}
}
function max(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := xor(x, mul(xor(x, y), gt(y, x)))
}
}
function max(int256 x, int256 y) internal pure returns (int256 z) {
assembly {
z := xor(x, mul(xor(x, y), sgt(y, x)))
}
}
function clamp(uint256 x, uint256 minValue, uint256 maxValue)
internal
pure
returns (uint256 z)
{
assembly {
z := xor(x, mul(xor(x, minValue), gt(minValue, x)))
z := xor(z, mul(xor(z, maxValue), lt(maxValue, z)))
}
}
function clamp(int256 x, int256 minValue, int256 maxValue) internal pure returns (int256 z) {
assembly {
z := xor(x, mul(xor(x, minValue), sgt(minValue, x)))
z := xor(z, mul(xor(z, maxValue), slt(maxValue, z)))
}
}
function gcd(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
for { z := x } y {} {
let t := y
y := mod(z, y)
z := t
}
}
}
function lerp(uint256 a, uint256 b, uint256 t, uint256 begin, uint256 end)
internal
pure
returns (uint256)
{
if (begin > end) (t, begin, end) = (~t, ~begin, ~end);
if (t <= begin) return a;
if (t >= end) return b;
unchecked {
if (b >= a) return a + fullMulDiv(b - a, t - begin, end - begin);
return a - fullMulDiv(a - b, t - begin, end - begin);
}
}
function lerp(int256 a, int256 b, int256 t, int256 begin, int256 end)
internal
pure
returns (int256)
{
if (begin > end) (t, begin, end) = (~t, ~begin, ~end);
if (t <= begin) return a;
if (t >= end) return b;
unchecked {
if (b >= a) return int256(uint256(a) + fullMulDiv(uint256(b - a),
uint256(t - begin), uint256(end - begin)));
return int256(uint256(a) - fullMulDiv(uint256(a - b),
uint256(t - begin), uint256(end - begin)));
}
}
function isEven(uint256 x) internal pure returns (bool) {
return x & uint256(1) == uint256(0);
}
function rawAdd(uint256 x, uint256 y) internal pure returns (uint256 z) {
unchecked {
z = x + y;
}
}
function rawAdd(int256 x, int256 y) internal pure returns (int256 z) {
unchecked {
z = x + y;
}
}
function rawSub(uint256 x, uint256 y) internal pure returns (uint256 z) {
unchecked {
z = x - y;
}
}
function rawSub(int256 x, int256 y) internal pure returns (int256 z) {
unchecked {
z = x - y;
}
}
function rawMul(uint256 x, uint256 y) internal pure returns (uint256 z) {
unchecked {
z = x * y;
}
}
function rawMul(int256 x, int256 y) internal pure returns (int256 z) {
unchecked {
z = x * y;
}
}
function rawDiv(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := div(x, y)
}
}
function rawSDiv(int256 x, int256 y) internal pure returns (int256 z) {
assembly {
z := sdiv(x, y)
}
}
function rawMod(uint256 x, uint256 y) internal pure returns (uint256 z) {
assembly {
z := mod(x, y)
}
}
function rawSMod(int256 x, int256 y) internal pure returns (int256 z) {
assembly {
z := smod(x, y)
}
}
function rawAddMod(uint256 x, uint256 y, uint256 d) internal pure returns (uint256 z) {
assembly {
z := addmod(x, y, d)
}
}
function rawMulMod(uint256 x, uint256 y, uint256 d) internal pure returns (uint256 z) {
assembly {
z := mulmod(x, y, d)
}
}
}
文件 5 的 9：IUniswapV3SwapCallback.sol
pragma solidity >=0.5.0;
interface IUniswapV3SwapCallback {
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata data
) external;
}
文件 6 的 9：LibBytes.sol
pragma solidity ^0.8.4;
library LibBytes {
struct BytesStorage {
bytes32 _spacer;
}
uint256 internal constant NOT_FOUND = type(uint256).max;
function set(BytesStorage storage $, bytes memory s) internal {
assembly {
let n := mload(s)
let packed := or(0xff, shl(8, n))
for { let i := 0 } 1 {} {
if iszero(gt(n, 0xfe)) {
i := 0x1f
packed := or(n, shl(8, mload(add(s, i))))
if iszero(gt(n, i)) { break }
}
let o := add(s, 0x20)
mstore(0x00, $.slot)
for { let p := keccak256(0x00, 0x20) } 1 {} {
sstore(add(p, shr(5, i)), mload(add(o, i)))
i := add(i, 0x20)
if iszero(lt(i, n)) { break }
}
break
}
sstore($.slot, packed)
}
}
function setCalldata(BytesStorage storage $, bytes calldata s) internal {
assembly {
let packed := or(0xff, shl(8, s.length))
for { let i := 0 } 1 {} {
if iszero(gt(s.length, 0xfe)) {
i := 0x1f
packed := or(s.length, shl(8, shr(8, calldataload(s.offset))))
if iszero(gt(s.length, i)) { break }
}
mstore(0x00, $.slot)
for { let p := keccak256(0x00, 0x20) } 1 {} {
sstore(add(p, shr(5, i)), calldataload(add(s.offset, i)))
i := add(i, 0x20)
if iszero(lt(i, s.length)) { break }
}
break
}
sstore($.slot, packed)
}
}
function clear(BytesStorage storage $) internal {
delete $._spacer;
}
function isEmpty(BytesStorage storage $) internal view returns (bool) {
return uint256($._spacer) & 0xff == uint256(0);
}
function length(BytesStorage storage $) internal view returns (uint256 result) {
result = uint256($._spacer);
assembly {
let n := and(0xff, result)
result := or(mul(shr(8, result), eq(0xff, n)), mul(n, iszero(eq(0xff, n))))
}
}
function get(BytesStorage storage $) internal view returns (bytes memory result) {
assembly {
result := mload(0x40)
let o := add(result, 0x20)
let packed := sload($.slot)
let n := shr(8, packed)
for { let i := 0 } 1 {} {
if iszero(eq(or(packed, 0xff), packed)) {
mstore(o, packed)
n := and(0xff, packed)
i := 0x1f
if iszero(gt(n, i)) { break }
}
mstore(0x00, $.slot)
for { let p := keccak256(0x00, 0x20) } 1 {} {
mstore(add(o, i), sload(add(p, shr(5, i))))
i := add(i, 0x20)
if iszero(lt(i, n)) { break }
}
break
}
mstore(result, n)
mstore(add(o, n), 0)
mstore(0x40, add(add(o, n), 0x20))
}
}
function replace(bytes memory subject, bytes memory needle, bytes memory replacement)
internal
pure
returns (bytes memory result)
{
assembly {
result := mload(0x40)
let needleLen := mload(needle)
let replacementLen := mload(replacement)
let d := sub(result, subject)
let i := add(subject, 0x20)
mstore(0x00, add(i, mload(subject)))
if iszero(gt(needleLen, mload(subject))) {
let subjectSearchEnd := add(sub(mload(0x00), needleLen), 1)
let h := 0
if iszero(lt(needleLen, 0x20)) { h := keccak256(add(needle, 0x20), needleLen) }
let s := mload(add(needle, 0x20))
for { let m := shl(3, sub(0x20, and(needleLen, 0x1f))) } 1 {} {
let t := mload(i)
if iszero(shr(m, xor(t, s))) {
if h {
if iszero(eq(keccak256(i, needleLen), h)) {
mstore(add(i, d), t)
i := add(i, 1)
if iszero(lt(i, subjectSearchEnd)) { break }
continue
}
}
for { let j := 0 } 1 {} {
mstore(add(add(i, d), j), mload(add(add(replacement, 0x20), j)))
j := add(j, 0x20)
if iszero(lt(j, replacementLen)) { break }
}
d := sub(add(d, replacementLen), needleLen)
if needleLen {
i := add(i, needleLen)
if iszero(lt(i, subjectSearchEnd)) { break }
continue
}
}
mstore(add(i, d), t)
i := add(i, 1)
if iszero(lt(i, subjectSearchEnd)) { break }
}
}
let end := mload(0x00)
let n := add(sub(d, add(result, 0x20)), end)
for {} lt(i, end) { i := add(i, 0x20) } { mstore(add(i, d), mload(i)) }
let o := add(i, d)
mstore(o, 0)
mstore(0x40, add(o, 0x20))
mstore(result, n)
}
}
function indexOf(bytes memory subject, bytes memory needle, uint256 from)
internal
pure
returns (uint256 result)
{
assembly {
result := not(0)
for { let subjectLen := mload(subject) } 1 {} {
if iszero(mload(needle)) {
result := from
if iszero(gt(from, subjectLen)) { break }
result := subjectLen
break
}
let needleLen := mload(needle)
let subjectStart := add(subject, 0x20)
subject := add(subjectStart, from)
let end := add(sub(add(subjectStart, subjectLen), needleLen), 1)
let m := shl(3, sub(0x20, and(needleLen, 0x1f)))
let s := mload(add(needle, 0x20))
if iszero(and(lt(subject, end), lt(from, subjectLen))) { break }
if iszero(lt(needleLen, 0x20)) {
for { let h := keccak256(add(needle, 0x20), needleLen) } 1 {} {
if iszero(shr(m, xor(mload(subject), s))) {
if eq(keccak256(subject, needleLen), h) {
result := sub(subject, subjectStart)
break
}
}
subject := add(subject, 1)
if iszero(lt(subject, end)) { break }
}
break
}
for {} 1 {} {
if iszero(shr(m, xor(mload(subject), s))) {
result := sub(subject, subjectStart)
break
}
subject := add(subject, 1)
if iszero(lt(subject, end)) { break }
}
break
}
}
}
function indexOf(bytes memory subject, bytes memory needle) internal pure returns (uint256) {
return indexOf(subject, needle, 0);
}
function lastIndexOf(bytes memory subject, bytes memory needle, uint256 from)
internal
pure
returns (uint256 result)
{
assembly {
for {} 1 {} {
result := not(0)
let needleLen := mload(needle)
if gt(needleLen, mload(subject)) { break }
let w := result
let fromMax := sub(mload(subject), needleLen)
if iszero(gt(fromMax, from)) { from := fromMax }
let end := add(add(subject, 0x20), w)
subject := add(add(subject, 0x20), from)
if iszero(gt(subject, end)) { break }
for { let h := keccak256(add(needle, 0x20), needleLen) } 1 {} {
if eq(keccak256(subject, needleLen), h) {
result := sub(subject, add(end, 1))
break
}
subject := add(subject, w)
if iszero(gt(subject, end)) { break }
}
break
}
}
}
function lastIndexOf(bytes memory subject, bytes memory needle)
internal
pure
returns (uint256)
{
return lastIndexOf(subject, needle, type(uint256).max);
}
function contains(bytes memory subject, bytes memory needle) internal pure returns (bool) {
return indexOf(subject, needle) != NOT_FOUND;
}
function startsWith(bytes memory subject, bytes memory needle)
internal
pure
returns (bool result)
{
assembly {
let n := mload(needle)
let t := eq(keccak256(add(subject, 0x20), n), keccak256(add(needle, 0x20), n))
result := lt(gt(n, mload(subject)), t)
}
}
function endsWith(bytes memory subject, bytes memory needle)
internal
pure
returns (bool result)
{
assembly {
let n := mload(needle)
let notInRange := gt(n, mload(subject))
let t := add(add(subject, 0x20), mul(iszero(notInRange), sub(mload(subject), n)))
result := gt(eq(keccak256(t, n), keccak256(add(needle, 0x20), n)), notInRange)
}
}
function repeat(bytes memory subject, uint256 times)
internal
pure
returns (bytes memory result)
{
assembly {
let l := mload(subject)
if iszero(or(iszero(times), iszero(l))) {
result := mload(0x40)
subject := add(subject, 0x20)
let o := add(result, 0x20)
for {} 1 {} {
for { let j := 0 } 1 {} {
mstore(add(o, j), mload(add(subject, j)))
j := add(j, 0x20)
if iszero(lt(j, l)) { break }
}
o := add(o, l)
times := sub(times, 1)
if iszero(times) { break }
}
mstore(o, 0)
mstore(0x40, add(o, 0x20))
mstore(result, sub(o, add(result, 0x20)))
}
}
}
function slice(bytes memory subject, uint256 start, uint256 end)
internal
pure
returns (bytes memory result)
{
assembly {
let l := mload(subject)
if iszero(gt(l, end)) { end := l }
if iszero(gt(l, start)) { start := l }
if lt(start, end) {
result := mload(0x40)
let n := sub(end, start)
let i := add(subject, start)
let w := not(0x1f)
for { let j := and(add(n, 0x1f), w) } 1 {} {
mstore(add(result, j), mload(add(i, j)))
j := add(j, w)
if iszero(j) { break }
}
let o := add(add(result, 0x20), n)
mstore(o, 0)
mstore(0x40, add(o, 0x20))
mstore(result, n)
}
}
}
function slice(bytes memory subject, uint256 start)
internal
pure
returns (bytes memory result)
{
result = slice(subject, start, type(uint256).max);
}
function sliceCalldata(bytes calldata subject, uint256 start, uint256 end)
internal
pure
returns (bytes calldata result)
{
assembly {
end := xor(end, mul(xor(end, subject.length), lt(subject.length, end)))
start := xor(start, mul(xor(start, subject.length), lt(subject.length, start)))
result.offset := add(subject.offset, start)
result.length := mul(lt(start, end), sub(end, start))
}
}
function sliceCalldata(bytes calldata subject, uint256 start)
internal
pure
returns (bytes calldata result)
{
assembly {
start := xor(start, mul(xor(start, subject.length), lt(subject.length, start)))
result.offset := add(subject.offset, start)
result.length := mul(lt(start, subject.length), sub(subject.length, start))
}
}
function truncate(bytes memory subject, uint256 n)
internal
pure
returns (bytes memory result)
{
assembly {
result := subject
mstore(mul(lt(n, mload(result)), result), n)
}
}
function truncatedCalldata(bytes calldata subject, uint256 n)
internal
pure
returns (bytes calldata result)
{
assembly {
result.offset := subject.offset
result.length := xor(n, mul(xor(n, subject.length), lt(subject.length, n)))
}
}
function indicesOf(bytes memory subject, bytes memory needle)
internal
pure
returns (uint256[] memory result)
{
assembly {
let searchLen := mload(needle)
if iszero(gt(searchLen, mload(subject))) {
result := mload(0x40)
let i := add(subject, 0x20)
let o := add(result, 0x20)
let subjectSearchEnd := add(sub(add(i, mload(subject)), searchLen), 1)
let h := 0
if iszero(lt(searchLen, 0x20)) { h := keccak256(add(needle, 0x20), searchLen) }
let s := mload(add(needle, 0x20))
for { let m := shl(3, sub(0x20, and(searchLen, 0x1f))) } 1 {} {
let t := mload(i)
if iszero(shr(m, xor(t, s))) {
if h {
if iszero(eq(keccak256(i, searchLen), h)) {
i := add(i, 1)
if iszero(lt(i, subjectSearchEnd)) { break }
continue
}
}
mstore(o, sub(i, add(subject, 0x20)))
o := add(o, 0x20)
i := add(i, searchLen)
if searchLen {
if iszero(lt(i, subjectSearchEnd)) { break }
continue
}
}
i := add(i, 1)
if iszero(lt(i, subjectSearchEnd)) { break }
}
mstore(result, shr(5, sub(o, add(result, 0x20))))
mstore(0x40, add(o, 0x20))
}
}
}
function split(bytes memory subject, bytes memory delimiter)
internal
pure
returns (bytes[] memory result)
{
uint256[] memory indices = indicesOf(subject, delimiter);
assembly {
let w := not(0x1f)
let indexPtr := add(indices, 0x20)
let indicesEnd := add(indexPtr, shl(5, add(mload(indices), 1)))
mstore(add(indicesEnd, w), mload(subject))
mstore(indices, add(mload(indices), 1))
for { let prevIndex := 0 } 1 {} {
let index := mload(indexPtr)
mstore(indexPtr, 0x60)
if iszero(eq(index, prevIndex)) {
let element := mload(0x40)
let l := sub(index, prevIndex)
mstore(element, l)
for { let o := and(add(l, 0x1f), w) } 1 {} {
mstore(add(element, o), mload(add(add(subject, prevIndex), o)))
o := add(o, w)
if iszero(o) { break }
}
mstore(add(add(element, 0x20), l), 0)
mstore(0x40, add(element, and(add(l, 0x3f), w)))
mstore(indexPtr, element)
}
prevIndex := add(index, mload(delimiter))
indexPtr := add(indexPtr, 0x20)
if iszero(lt(indexPtr, indicesEnd)) { break }
}
result := indices
if iszero(mload(delimiter)) {
result := add(indices, 0x20)
mstore(result, sub(mload(indices), 2))
}
}
}
function concat(bytes memory a, bytes memory b) internal pure returns (bytes memory result) {
assembly {
result := mload(0x40)
let w := not(0x1f)
let aLen := mload(a)
for { let o := and(add(aLen, 0x20), w) } 1 {} {
mstore(add(result, o), mload(add(a, o)))
o := add(o, w)
if iszero(o) { break }
}
let bLen := mload(b)
let output := add(result, aLen)
for { let o := and(add(bLen, 0x20), w) } 1 {} {
mstore(add(output, o), mload(add(b, o)))
o := add(o, w)
if iszero(o) { break }
}
let totalLen := add(aLen, bLen)
let last := add(add(result, 0x20), totalLen)
mstore(last, 0)
mstore(result, totalLen)
mstore(0x40, add(last, 0x20))
}
}
function eq(bytes memory a, bytes memory b) internal pure returns (bool result) {
assembly {
result := eq(keccak256(add(a, 0x20), mload(a)), keccak256(add(b, 0x20), mload(b)))
}
}
function eqs(bytes memory a, bytes32 b) internal pure returns (bool result) {
assembly {
let m := not(shl(7, div(not(iszero(b)), 255)))
let x := not(or(m, or(b, add(m, and(b, m)))))
let r := shl(7, iszero(iszero(shr(128, x))))
r := or(r, shl(6, iszero(iszero(shr(64, shr(r, x))))))
r := or(r, shl(5, lt(0xffffffff, shr(r, x))))
r := or(r, shl(4, lt(0xffff, shr(r, x))))
r := or(r, shl(3, lt(0xff, shr(r, x))))
result := gt(eq(mload(a), add(iszero(x), xor(31, shr(3, r)))),
xor(shr(add(8, r), b), shr(add(8, r), mload(add(a, 0x20)))))
}
}
function cmp(bytes memory a, bytes memory b) internal pure returns (int256 result) {
assembly {
let aLen := mload(a)
let bLen := mload(b)
let n := and(xor(aLen, mul(xor(aLen, bLen), lt(bLen, aLen))), not(0x1f))
if n {
for { let i := 0x20 } 1 {} {
let x := mload(add(a, i))
let y := mload(add(b, i))
if iszero(or(xor(x, y), eq(i, n))) {
i := add(i, 0x20)
continue
}
result := sub(gt(x, y), lt(x, y))
break
}
}
if iszero(result) {
let l := 0x201f1e1d1c1b1a191817161514131211100f0e0d0c0b0a090807060504030201
let x := and(mload(add(add(a, 0x20), n)), shl(shl(3, byte(sub(aLen, n), l)), not(0)))
let y := and(mload(add(add(b, 0x20), n)), shl(shl(3, byte(sub(bLen, n), l)), not(0)))
result := sub(gt(x, y), lt(x, y))
if iszero(result) { result := sub(gt(aLen, bLen), lt(aLen, bLen)) }
}
}
}
function directReturn(bytes memory a) internal pure {
assembly {
let retStart := sub(a, 0x20)
let retUnpaddedSize := add(mload(a), 0x40)
mstore(add(retStart, retUnpaddedSize), 0)
mstore(retStart, 0x20)
return(retStart, and(not(0x1f), add(0x1f, retUnpaddedSize)))
}
}
function directReturn(bytes[] memory a) internal pure {
assembly {
let n := mload(a)
let o := add(a, 0x20)
let u := a
let w := not(0x1f)
for { let i := 0 } iszero(eq(i, n)) { i := add(i, 1) } {
let c := add(o, shl(5, i))
let s := mload(c)
let l := mload(s)
let r := and(l, 0x1f)
let z := add(0x20, and(l, w))
if iszero(lt(lt(s, o), or(iszero(r), iszero(shl(shl(3, r), mload(add(s, z))))))) {
let m := mload(0x40)
mstore(m, l)
for {} 1 {} {
mstore(add(m, z), mload(add(s, z)))
z := add(z, w)
if iszero(z) { break }
}
let e := add(add(m, 0x20), l)
mstore(e, 0)
mstore(0x40, add(e, 0x20))
s := m
}
mstore(c, sub(s, o))
let t := add(l, add(s, 0x20))
if iszero(lt(t, u)) { u := t }
}
let retStart := add(a, w)
mstore(retStart, 0x20)
return(retStart, add(0x40, sub(u, retStart)))
}
}
function load(bytes memory a, uint256 offset) internal pure returns (bytes32 result) {
assembly {
result := mload(add(add(a, 0x20), offset))
}
}
function loadCalldata(bytes calldata a, uint256 offset)
internal
pure
returns (bytes32 result)
{
assembly {
result := calldataload(add(a.offset, offset))
}
}
function emptyCalldata() internal pure returns (bytes calldata result) {
assembly {
result.length := 0
}
}
}
文件 7 的 9：LibString.sol
pragma solidity ^0.8.4;
import {LibBytes} from "./LibBytes.sol";
library LibString {
struct StringStorage {
bytes32 _spacer;
}
error HexLengthInsufficient();
error TooBigForSmallString();
error StringNot7BitASCII();
uint256 internal constant NOT_FOUND = type(uint256).max;
uint128 internal constant ALPHANUMERIC_7_BIT_ASCII = 0x7fffffe07fffffe03ff000000000000;
uint128 internal constant LETTERS_7_BIT_ASCII = 0x7fffffe07fffffe0000000000000000;
uint128 internal constant LOWERCASE_7_BIT_ASCII = 0x7fffffe000000000000000000000000;
uint128 internal constant UPPERCASE_7_BIT_ASCII = 0x7fffffe0000000000000000;
uint128 internal constant DIGITS_7_BIT_ASCII = 0x3ff000000000000;
uint128 internal constant HEXDIGITS_7_BIT_ASCII = 0x7e0000007e03ff000000000000;
uint128 internal constant OCTDIGITS_7_BIT_ASCII = 0xff000000000000;
uint128 internal constant PRINTABLE_7_BIT_ASCII = 0x7fffffffffffffffffffffff00003e00;
uint128 internal constant PUNCTUATION_7_BIT_ASCII = 0x78000001f8000001fc00fffe00000000;
uint128 internal constant WHITESPACE_7_BIT_ASCII = 0x100003e00;
function set(StringStorage storage $, string memory s) internal {
LibBytes.set(bytesStorage($), bytes(s));
}
function setCalldata(StringStorage storage $, string calldata s) internal {
LibBytes.setCalldata(bytesStorage($), bytes(s));
}
function clear(StringStorage storage $) internal {
delete $._spacer;
}
function isEmpty(StringStorage storage $) internal view returns (bool) {
return uint256($._spacer) & 0xff == uint256(0);
}
function length(StringStorage storage $) internal view returns (uint256) {
return LibBytes.length(bytesStorage($));
}
function get(StringStorage storage $) internal view returns (string memory) {
return string(LibBytes.get(bytesStorage($)));
}
function bytesStorage(StringStorage storage $)
internal
pure
returns (LibBytes.BytesStorage storage casted)
{
assembly {
casted.slot := $.slot
}
}
function toString(uint256 value) internal pure returns (string memory result) {
assembly {
result := add(mload(0x40), 0x80)
mstore(0x40, add(result, 0x20))
mstore(result, 0)
let end := result
let w := not(0)
for { let temp := value } 1 {} {
result := add(result, w)
mstore8(result, add(48, mod(temp, 10)))
temp := div(temp, 10)
if iszero(temp) { break }
}
let n := sub(end, result)
result := sub(result, 0x20)
mstore(result, n)
}
}
function toString(int256 value) internal pure returns (string memory result) {
if (value >= 0) return toString(uint256(value));
unchecked {
result = toString(~uint256(value) + 1);
}
assembly {
let n := mload(result)
mstore(result, 0x2d)
result := sub(result, 1)
mstore(result, add(n, 1))
}
}
function toHexString(uint256 value, uint256 byteCount)
internal
pure
returns (string memory result)
{
result = toHexStringNoPrefix(value, byteCount);
assembly {
let n := add(mload(result), 2)
mstore(result, 0x3078)
result := sub(result, 2)
mstore(result, n)
}
}
function toHexStringNoPrefix(uint256 value, uint256 byteCount)
internal
pure
returns (string memory result)
{
assembly {
result := add(mload(0x40), and(add(shl(1, byteCount), 0x42), not(0x1f)))
mstore(0x40, add(result, 0x20))
mstore(result, 0)
let end := result
mstore(0x0f, 0x30313233343536373839616263646566)
let start := sub(result, add(byteCount, byteCount))
let w := not(1)
let temp := value
for {} 1 {} {
result := add(result, w)
mstore8(add(result, 1), mload(and(temp, 15)))
mstore8(result, mload(and(shr(4, temp), 15)))
temp := shr(8, temp)
if iszero(xor(result, start)) { break }
}
if temp {
mstore(0x00, 0x2194895a)
revert(0x1c, 0x04)
}
let n := sub(end, result)
result := sub(result, 0x20)
mstore(result, n)
}
}
function toHexString(uint256 value) internal pure returns (string memory result) {
result = toHexStringNoPrefix(value);
assembly {
let n := add(mload(result), 2)
mstore(result, 0x3078)
result := sub(result, 2)
mstore(result, n)
}
}
function toMinimalHexString(uint256 value) internal pure returns (string memory result) {
result = toHexStringNoPrefix(value);
assembly {
let o := eq(byte(0, mload(add(result, 0x20))), 0x30)
let n := add(mload(result), 2)
mstore(add(result, o), 0x3078)
result := sub(add(result, o), 2)
mstore(result, sub(n, o))
}
}
function toMinimalHexStringNoPrefix(uint256 value)
internal
pure
returns (string memory result)
{
result = toHexStringNoPrefix(value);
assembly {
let o := eq(byte(0, mload(add(result, 0x20))), 0x30)
let n := mload(result)
result := add(result, o)
mstore(result, sub(n, o))
}
}
function toHexStringNoPrefix(uint256 value) internal pure returns (string memory result) {
assembly {
result := add(mload(0x40), 0x80)
mstore(0x40, add(result, 0x20))
mstore(result, 0)
let end := result
mstore(0x0f, 0x30313233343536373839616263646566)
let w := not(1)
for { let temp := value } 1 {} {
result := add(result, w)
mstore8(add(result, 1), mload(and(temp, 15)))
mstore8(result, mload(and(shr(4, temp), 15)))
temp := shr(8, temp)
if iszero(temp) { break }
}
let n := sub(end, result)
result := sub(result, 0x20)
mstore(result, n)
}
}
function toHexStringChecksummed(address value) internal pure returns (string memory result) {
result = toHexString(value);
assembly {
let mask := shl(6, div(not(0), 255))
let o := add(result, 0x22)
let hashed := and(keccak256(o, 40), mul(34, mask))
let t := shl(240, 136)
for { let i := 0 } 1 {} {
mstore(add(i, i), mul(t, byte(i, hashed)))
i := add(i, 1)
if eq(i, 20) { break }
}
mstore(o, xor(mload(o), shr(1, and(mload(0x00), and(mload(o), mask)))))
o := add(o, 0x20)
mstore(o, xor(mload(o), shr(1, and(mload(0x20), and(mload(o), mask)))))
}
}
function toHexString(address value) internal pure returns (string memory result) {
result = toHexStringNoPrefix(value);
assembly {
let n := add(mload(result), 2)
mstore(result, 0x3078)
result := sub(result, 2)
mstore(result, n)
}
}
function toHexStringNoPrefix(address value) internal pure returns (string memory result) {
assembly {
result := mload(0x40)
mstore(0x40, add(result, 0x80))
mstore(0x0f, 0x30313233343536373839616263646566)
result := add(result, 2)
mstore(result, 40)
let o := add(result, 0x20)
mstore(add(o, 40), 0)
value := shl(96, value)
for { let i := 0 } 1 {} {
let p := add(o, add(i, i))
let temp := byte(i, value)
mstore8(add(p, 1), mload(and(temp, 15)))
mstore8(p, mload(shr(4, temp)))
i := add(i, 1)
if eq(i, 20) { break }
}
}
}
function toHexString(bytes memory raw) internal pure returns (string memory result) {
result = toHexStringNoPrefix(raw);
assembly {
let n := add(mload(result), 2)
mstore(result, 0x3078)
result := sub(result, 2)
mstore(result, n)
}
}
function toHexStringNoPrefix(bytes memory raw) internal pure returns (string memory result) {
assembly {
let n := mload(raw)
result := add(mload(0x40), 2)
mstore(result, add(n, n))
mstore(0x0f, 0x30313233343536373839616263646566)
let o := add(result, 0x20)
let end := add(raw, n)
for {} iszero(eq(raw, end)) {} {
raw := add(raw, 1)
mstore8(add(o, 1), mload(and(mload(raw), 15)))
mstore8(o, mload(and(shr(4, mload(raw)), 15)))
o := add(o, 2)
}
mstore(o, 0)
mstore(0x40, add(o, 0x20))
}
}
function runeCount(string memory s) internal pure returns (uint256 result) {
assembly {
if mload(s) {
mstore(0x00, div(not(0), 255))
mstore(0x20, 0x0202020202020202020202020202020202020202020202020303030304040506)
let o := add(s, 0x20)
let end := add(o, mload(s))
for { result := 1 } 1 { result := add(result, 1) } {
o := add(o, byte(0, mload(shr(250, mload(o)))))
if iszero(lt(o, end)) { break }
}
}
}
}
function is7BitASCII(string memory s) internal pure returns (bool result) {
assembly {
result := 1
let mask := shl(7, div(not(0), 255))
let n := mload(s)
if n {
let o := add(s, 0x20)
let end := add(o, n)
let last := mload(end)
mstore(end, 0)
for {} 1 {} {
if and(mask, mload(o)) {
result := 0
break
}
o := add(o, 0x20)
if iszero(lt(o, end)) { break }
}
mstore(end, last)
}
}
}
function is7BitASCII(string memory s, uint128 allowed) internal pure returns (bool result) {
assembly {
result := 1
if mload(s) {
let allowed_ := shr(128, shl(128, allowed))
let o := add(s, 0x20)
for { let end := add(o, mload(s)) } 1 {} {
result := and(result, shr(byte(0, mload(o)), allowed_))
o := add(o, 1)
if iszero(and(result, lt(o, end))) { break }
}
}
}
}
function to7BitASCIIAllowedLookup(string memory s) internal pure returns (uint128 result) {
assembly {
if mload(s) {
let o := add(s, 0x20)
for { let end := add(o, mload(s)) } 1 {} {
result := or(result, shl(byte(0, mload(o)), 1))
o := add(o, 1)
if iszero(lt(o, end)) { break }
}
if shr(128, result) {
mstore(0x00, 0xc9807e0d)
revert(0x1c, 0x04)
}
}
}
}
function replace(string memory subject, string memory needle, string memory replacement)
internal
pure
returns (string memory)
{
return string(LibBytes.replace(bytes(subject), bytes(needle), bytes(replacement)));
}
function indexOf(string memory subject, string memory needle, uint256 from)
internal
pure
returns (uint256)
{
return LibBytes.indexOf(bytes(subject), bytes(needle), from);
}
function indexOf(string memory subject, string memory needle) internal pure returns (uint256) {
return LibBytes.indexOf(bytes(subject), bytes(needle), 0);
}
function lastIndexOf(string memory subject, string memory needle, uint256 from)
internal
pure
returns (uint256)
{
return LibBytes.lastIndexOf(bytes(subject), bytes(needle), from);
}
function lastIndexOf(string memory subject, string memory needle)
internal
pure
returns (uint256)
{
return LibBytes.lastIndexOf(bytes(subject), bytes(needle), type(uint256).max);
}
function contains(string memory subject, string memory needle) internal pure returns (bool) {
return LibBytes.contains(bytes(subject), bytes(needle));
}
function startsWith(string memory subject, string memory needle) internal pure returns (bool) {
return LibBytes.startsWith(bytes(subject), bytes(needle));
}
function endsWith(string memory subject, string memory needle) internal pure returns (bool) {
return LibBytes.endsWith(bytes(subject), bytes(needle));
}
function repeat(string memory subject, uint256 times) internal pure returns (string memory) {
return string(LibBytes.repeat(bytes(subject), times));
}
function slice(string memory subject, uint256 start, uint256 end)
internal
pure
returns (string memory)
{
return string(LibBytes.slice(bytes(subject), start, end));
}
function slice(string memory subject, uint256 start) internal pure returns (string memory) {
return string(LibBytes.slice(bytes(subject), start, type(uint256).max));
}
function indicesOf(string memory subject, string memory needle)
internal
pure
returns (uint256[] memory)
{
return LibBytes.indicesOf(bytes(subject), bytes(needle));
}
function split(string memory subject, string memory delimiter)
internal
pure
returns (string[] memory result)
{
bytes[] memory a = LibBytes.split(bytes(subject), bytes(delimiter));
assembly {
result := a
}
}
function concat(string memory a, string memory b) internal pure returns (string memory) {
return string(LibBytes.concat(bytes(a), bytes(b)));
}
function toCase(string memory subject, bool toUpper)
internal
pure
returns (string memory result)
{
assembly {
let n := mload(subject)
if n {
result := mload(0x40)
let o := add(result, 0x20)
let d := sub(subject, result)
let flags := shl(add(70, shl(5, toUpper)), 0x3ffffff)
for { let end := add(o, n) } 1 {} {
let b := byte(0, mload(add(d, o)))
mstore8(o, xor(and(shr(b, flags), 0x20), b))
o := add(o, 1)
if eq(o, end) { break }
}
mstore(result, n)
mstore(o, 0)
mstore(0x40, add(o, 0x20))
}
}
}
function fromSmallString(bytes32 s) internal pure returns (string memory result) {
assembly {
result := mload(0x40)
let n := 0
for {} byte(n, s) { n := add(n, 1) } {}
mstore(result, n)
let o := add(result, 0x20)
mstore(o, s)
mstore(add(o, n), 0)
mstore(0x40, add(result, 0x40))
}
}
function normalizeSmallString(bytes32 s) internal pure returns (bytes32 result) {
assembly {
for {} byte(result, s) { result := add(result, 1) } {}
mstore(0x00, s)
mstore(result, 0x00)
result := mload(0x00)
}
}
function toSmallString(string memory s) internal pure returns (bytes32 result) {
assembly {
result := mload(s)
if iszero(lt(result, 33)) {
mstore(0x00, 0xec92f9a3)
revert(0x1c, 0x04)
}
result := shl(shl(3, sub(32, result)), mload(add(s, result)))
}
}
function lower(string memory subject) internal pure returns (string memory result) {
result = toCase(subject, false);
}
function upper(string memory subject) internal pure returns (string memory result) {
result = toCase(subject, true);
}
function escapeHTML(string memory s) internal pure returns (string memory result) {
assembly {
result := mload(0x40)
let end := add(s, mload(s))
let o := add(result, 0x20)
mstore(0x1f, 0x900094)
mstore(0x08, 0xc0000000a6ab)
mstore(0x00, shl(64, 0x2671756f743b26616d703b262333393b266c743b2667743b))
for {} iszero(eq(s, end)) {} {
s := add(s, 1)
let c := and(mload(s), 0xff)
if iszero(and(shl(c, 1), 0x500000c400000000)) {
mstore8(o, c)
o := add(o, 1)
continue
}
let t := shr(248, mload(c))
mstore(o, mload(and(t, 0x1f)))
o := add(o, shr(5, t))
}
mstore(o, 0)
mstore(result, sub(o, add(result, 0x20)))
mstore(0x40, add(o, 0x20))
}
}
function escapeJSON(string memory s, bool addDoubleQuotes)
internal
pure
returns (string memory result)
{
assembly {
result := mload(0x40)
let o := add(result, 0x20)
if addDoubleQuotes {
mstore8(o, 34)
o := add(1, o)
}
mstore(0x15, 0x5c75303030303031323334353637383961626364656662746e006672)
let e := or(shl(0x22, 1), shl(0x5c, 1))
for { let end := add(s, mload(s)) } iszero(eq(s, end)) {} {
s := add(s, 1)
let c := and(mload(s), 0xff)
if iszero(lt(c, 0x20)) {
if iszero(and(shl(c, 1), e)) {
mstore8(o, c)
o := add(o, 1)
continue
}
mstore8(o, 0x5c)
mstore8(add(o, 1), c)
o := add(o, 2)
continue
}
if iszero(and(shl(c, 1), 0x3700)) {
mstore8(0x1d, mload(shr(4, c)))
mstore8(0x1e, mload(and(c, 15)))
mstore(o, mload(0x19))
o := add(o, 6)
continue
}
mstore8(o, 0x5c)
mstore8(add(o, 1), mload(add(c, 8)))
o := add(o, 2)
}
if addDoubleQuotes {
mstore8(o, 34)
o := add(1, o)
}
mstore(o, 0)
mstore(result, sub(o, add(result, 0x20)))
mstore(0x40, add(o, 0x20))
}
}
function escapeJSON(string memory s) internal pure returns (string memory result) {
result = escapeJSON(s, false);
}
function encodeURIComponent(string memory s) internal pure returns (string memory result) {
assembly {
result := mload(0x40)
mstore(0x0f, 0x30313233343536373839414243444546)
let o := add(result, 0x20)
for { let end := add(s, mload(s)) } iszero(eq(s, end)) {} {
s := add(s, 1)
let c := and(mload(s), 0xff)
if iszero(and(1, shr(c, 0x47fffffe87fffffe03ff678200000000))) {
mstore8(o, 0x25)
mstore8(add(o, 1), mload(and(shr(4, c), 15)))
mstore8(add(o, 2), mload(and(c, 15)))
o := add(o, 3)
continue
}
mstore8(o, c)
o := add(o, 1)
}
mstore(result, sub(o, add(result, 0x20)))
mstore(o, 0)
mstore(0x40, add(o, 0x20))
}
}
function eq(string memory a, string memory b) internal pure returns (bool result) {
assembly {
result := eq(keccak256(add(a, 0x20), mload(a)), keccak256(add(b, 0x20), mload(b)))
}
}
function eqs(string memory a, bytes32 b) internal pure returns (bool result) {
assembly {
let m := not(shl(7, div(not(iszero(b)), 255)))
let x := not(or(m, or(b, add(m, and(b, m)))))
let r := shl(7, iszero(iszero(shr(128, x))))
r := or(r, shl(6, iszero(iszero(shr(64, shr(r, x))))))
r := or(r, shl(5, lt(0xffffffff, shr(r, x))))
r := or(r, shl(4, lt(0xffff, shr(r, x))))
r := or(r, shl(3, lt(0xff, shr(r, x))))
result := gt(eq(mload(a), add(iszero(x), xor(31, shr(3, r)))),
xor(shr(add(8, r), b), shr(add(8, r), mload(add(a, 0x20)))))
}
}
function cmp(string memory a, string memory b) internal pure returns (int256) {
return LibBytes.cmp(bytes(a), bytes(b));
}
function packOne(string memory a) internal pure returns (bytes32 result) {
assembly {
result :=
mul(
mload(add(a, 0x1f)),
lt(sub(mload(a), 1), 0x1f)
)
}
}
function unpackOne(bytes32 packed) internal pure returns (string memory result) {
assembly {
result := mload(0x40)
mstore(0x40, add(result, 0x40))
mstore(result, 0)
mstore(add(result, 0x1f), packed)
mstore(add(add(result, 0x20), mload(result)), 0)
}
}
function packTwo(string memory a, string memory b) internal pure returns (bytes32 result) {
assembly {
let aLen := mload(a)
result :=
mul(
or(
shl(shl(3, sub(0x1f, aLen)), mload(add(a, aLen))), mload(sub(add(b, 0x1e), aLen))),
lt(sub(add(aLen, mload(b)), 1), 0x1e)
)
}
}
function unpackTwo(bytes32 packed)
internal
pure
returns (string memory resultA, string memory resultB)
{
assembly {
resultA := mload(0x40)
resultB := add(resultA, 0x40)
mstore(0x40, add(resultB, 0x40))
mstore(resultA, 0)
mstore(resultB, 0)
mstore(add(resultA, 0x1f), packed)
mstore(add(resultB, 0x1f), mload(add(add(resultA, 0x20), mload(resultA))))
mstore(add(add(resultA, 0x20), mload(resultA)), 0)
mstore(add(add(resultB, 0x20), mload(resultB)), 0)
}
}
function directReturn(string memory a) internal pure {
assembly {
let retStart := sub(a, 0x20)
let retUnpaddedSize := add(mload(a), 0x40)
mstore(add(retStart, retUnpaddedSize), 0)
mstore(retStart, 0x20)
return(retStart, and(not(0x1f), add(0x1f, retUnpaddedSize)))
}
}
}
文件 8 的 9：MerkleProofLib.sol
pragma solidity ^0.8.4;
library MerkleProofLib {
function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf)
internal
pure
returns (bool isValid)
{
assembly {
if mload(proof) {
let offset := add(proof, 0x20)
let end := add(offset, shl(5, mload(proof)))
for {} 1 {} {
let scratch := shl(5, gt(leaf, mload(offset)))
mstore(scratch, leaf)
mstore(xor(scratch, 0x20), mload(offset))
leaf := keccak256(0x00, 0x40)
offset := add(offset, 0x20)
if iszero(lt(offset, end)) { break }
}
}
isValid := eq(leaf, root)
}
}
function verifyCalldata(bytes32[] calldata proof, bytes32 root, bytes32 leaf)
internal
pure
returns (bool isValid)
{
assembly {
if proof.length {
let end := add(proof.offset, shl(5, proof.length))
let offset := proof.offset
for {} 1 {} {
let scratch := shl(5, gt(leaf, calldataload(offset)))
mstore(scratch, leaf)
mstore(xor(scratch, 0x20), calldataload(offset))
leaf := keccak256(0x00, 0x40)
offset := add(offset, 0x20)
if iszero(lt(offset, end)) { break }
}
}
isValid := eq(leaf, root)
}
}
function verifyMultiProof(
bytes32[] memory proof,
bytes32 root,
bytes32[] memory leaves,
bool[] memory flags
) internal pure returns (bool isValid) {
assembly {
let leavesLength := mload(leaves)
let proofLength := mload(proof)
let flagsLength := mload(flags)
leaves := add(0x20, leaves)
proof := add(0x20, proof)
flags := add(0x20, flags)
for {} eq(add(leavesLength, proofLength), add(flagsLength, 1)) {} {
if iszero(flagsLength) {
isValid := eq(mload(xor(leaves, mul(xor(proof, leaves), proofLength))), root)
break
}
let proofEnd := add(proof, shl(5, proofLength))
let hashesFront := mload(0x40)
leavesLength := shl(5, leavesLength)
for { let i := 0 } iszero(eq(i, leavesLength)) { i := add(i, 0x20) } {
mstore(add(hashesFront, i), mload(add(leaves, i)))
}
let hashesBack := add(hashesFront, leavesLength)
flagsLength := add(hashesBack, shl(5, flagsLength))
for {} 1 {} {
let a := mload(hashesFront)
let b := mload(add(hashesFront, 0x20))
hashesFront := add(hashesFront, 0x40)
if iszero(mload(flags)) {
b := mload(proof)
proof := add(proof, 0x20)
hashesFront := sub(hashesFront, 0x20)
}
flags := add(flags, 0x20)
let scratch := shl(5, gt(a, b))
mstore(scratch, a)
mstore(xor(scratch, 0x20), b)
mstore(hashesBack, keccak256(0x00, 0x40))
hashesBack := add(hashesBack, 0x20)
if iszero(lt(hashesBack, flagsLength)) { break }
}
isValid :=
and(
eq(mload(sub(hashesBack, 0x20)), root),
eq(proofEnd, proof)
)
break
}
}
}
function verifyMultiProofCalldata(
bytes32[] calldata proof,
bytes32 root,
bytes32[] calldata leaves,
bool[] calldata flags
) internal pure returns (bool isValid) {
assembly {
for {} eq(add(leaves.length, proof.length), add(flags.length, 1)) {} {
if iszero(flags.length) {
isValid := eq(
calldataload(
xor(leaves.offset, mul(xor(proof.offset, leaves.offset), proof.length))
),
root
)
break
}
let proofEnd := add(proof.offset, shl(5, proof.length))
let hashesFront := mload(0x40)
calldatacopy(hashesFront, leaves.offset, shl(5, leaves.length))
let hashesBack := add(hashesFront, shl(5, leaves.length))
flags.length := add(hashesBack, shl(5, flags.length))
for {} 1 {} {
let a := mload(hashesFront)
let b := mload(add(hashesFront, 0x20))
hashesFront := add(hashesFront, 0x40)
if iszero(calldataload(flags.offset)) {
b := calldataload(proof.offset)
proof.offset := add(proof.offset, 0x20)
hashesFront := sub(hashesFront, 0x20)
}
flags.offset := add(flags.offset, 0x20)
let scratch := shl(5, gt(a, b))
mstore(scratch, a)
mstore(xor(scratch, 0x20), b)
mstore(hashesBack, keccak256(0x00, 0x40))
hashesBack := add(hashesBack, 0x20)
if iszero(lt(hashesBack, flags.length)) { break }
}
isValid :=
and(
eq(mload(sub(hashesBack, 0x20)), root),
eq(proofEnd, proof.offset)
)
break
}
}
}
function emptyProof() internal pure returns (bytes32[] calldata proof) {
assembly {
proof.length := 0
}
}
function emptyLeaves() internal pure returns (bytes32[] calldata leaves) {
assembly {
leaves.length := 0
}
}
function emptyFlags() internal pure returns (bool[] calldata flags) {
assembly {
flags.length := 0
}
}
}
文件 9 的 9：SafeTransferLib.sol
pragma solidity ^0.8.4;
library SafeTransferLib {
error ETHTransferFailed();
error TransferFromFailed();
error TransferFailed();
error ApproveFailed();
error TotalSupplyQueryFailed();
error Permit2Failed();
error Permit2AmountOverflow();
error Permit2ApproveFailed();
error Permit2LockdownFailed();
uint256 internal constant GAS_STIPEND_NO_STORAGE_WRITES = 2300;
uint256 internal constant GAS_STIPEND_NO_GRIEF = 100000;
bytes32 internal constant DAI_DOMAIN_SEPARATOR =
0xdbb8cf42e1ecb028be3f3dbc922e1d878b963f411dc388ced501601c60f7c6f7;
address internal constant WETH9 = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address internal constant PERMIT2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;
function safeTransferETH(address to, uint256 amount) internal {
assembly {
if iszero(call(gas(), to, amount, codesize(), 0x00, codesize(), 0x00)) {
mstore(0x00, 0xb12d13eb)
revert(0x1c, 0x04)
}
}
}
function safeTransferAllETH(address to) internal {
assembly {
if iszero(call(gas(), to, selfbalance(), codesize(), 0x00, codesize(), 0x00)) {
mstore(0x00, 0xb12d13eb)
revert(0x1c, 0x04)
}
}
}
function forceSafeTransferETH(address to, uint256 amount, uint256 gasStipend) internal {
assembly {
if lt(selfbalance(), amount) {
mstore(0x00, 0xb12d13eb)
revert(0x1c, 0x04)
}
if iszero(call(gasStipend, to, amount, codesize(), 0x00, codesize(), 0x00)) {
mstore(0x00, to)
mstore8(0x0b, 0x73)
mstore8(0x20, 0xff)
if iszero(create(amount, 0x0b, 0x16)) { revert(codesize(), codesize()) }
}
}
}
function forceSafeTransferAllETH(address to, uint256 gasStipend) internal {
assembly {
if iszero(call(gasStipend, to, selfbalance(), codesize(), 0x00, codesize(), 0x00)) {
mstore(0x00, to)
mstore8(0x0b, 0x73)
mstore8(0x20, 0xff)
if iszero(create(selfbalance(), 0x0b, 0x16)) { revert(codesize(), codesize()) }
}
}
}
function forceSafeTransferETH(address to, uint256 amount) internal {
assembly {
if lt(selfbalance(), amount) {
mstore(0x00, 0xb12d13eb)
revert(0x1c, 0x04)
}
if iszero(call(GAS_STIPEND_NO_GRIEF, to, amount, codesize(), 0x00, codesize(), 0x00)) {
mstore(0x00, to)
mstore8(0x0b, 0x73)
mstore8(0x20, 0xff)
if iszero(create(amount, 0x0b, 0x16)) { revert(codesize(), codesize()) }
}
}
}
function forceSafeTransferAllETH(address to) internal {
assembly {
if iszero(call(GAS_STIPEND_NO_GRIEF, to, selfbalance(), codesize(), 0x00, codesize(), 0x00)) {
mstore(0x00, to)
mstore8(0x0b, 0x73)
mstore8(0x20, 0xff)
if iszero(create(selfbalance(), 0x0b, 0x16)) { revert(codesize(), codesize()) }
}
}
}
function trySafeTransferETH(address to, uint256 amount, uint256 gasStipend)
internal
returns (bool success)
{
assembly {
success := call(gasStipend, to, amount, codesize(), 0x00, codesize(), 0x00)
}
}
function trySafeTransferAllETH(address to, uint256 gasStipend)
internal
returns (bool success)
{
assembly {
success := call(gasStipend, to, selfbalance(), codesize(), 0x00, codesize(), 0x00)
}
}
function safeTransferFrom(address token, address from, address to, uint256 amount) internal {
assembly {
let m := mload(0x40)
mstore(0x60, amount)
mstore(0x40, to)
mstore(0x2c, shl(96, from))
mstore(0x0c, 0x23b872dd000000000000000000000000)
let success := call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)
if iszero(and(eq(mload(0x00), 1), success)) {
if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {
mstore(0x00, 0x7939f424)
revert(0x1c, 0x04)
}
}
mstore(0x60, 0)
mstore(0x40, m)
}
}
function trySafeTransferFrom(address token, address from, address to, uint256 amount)
internal
returns (bool success)
{
assembly {
let m := mload(0x40)
mstore(0x60, amount)
mstore(0x40, to)
mstore(0x2c, shl(96, from))
mstore(0x0c, 0x23b872dd000000000000000000000000)
success := call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)
if iszero(and(eq(mload(0x00), 1), success)) {
success := lt(or(iszero(extcodesize(token)), returndatasize()), success)
}
mstore(0x60, 0)
mstore(0x40, m)
}
}
function safeTransferAllFrom(address token, address from, address to)
internal
returns (uint256 amount)
{
assembly {
let m := mload(0x40)
mstore(0x40, to)
mstore(0x2c, shl(96, from))
mstore(0x0c, 0x70a08231000000000000000000000000)
if iszero(
and(
gt(returndatasize(), 0x1f),
staticcall(gas(), token, 0x1c, 0x24, 0x60, 0x20)
)
) {
mstore(0x00, 0x7939f424)
revert(0x1c, 0x04)
}
mstore(0x00, 0x23b872dd)
amount := mload(0x60)
let success := call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)
if iszero(and(eq(mload(0x00), 1), success)) {
if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {
mstore(0x00, 0x7939f424)
revert(0x1c, 0x04)
}
}
mstore(0x60, 0)
mstore(0x40, m)
}
}
function safeTransfer(address token, address to, uint256 amount) internal {
assembly {
mstore(0x14, to)
mstore(0x34, amount)
mstore(0x00, 0xa9059cbb000000000000000000000000)
let success := call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
if iszero(and(eq(mload(0x00), 1), success)) {
if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {
mstore(0x00, 0x90b8ec18)
revert(0x1c, 0x04)
}
}
mstore(0x34, 0)
}
}
function safeTransferAll(address token, address to) internal returns (uint256 amount) {
assembly {
mstore(0x00, 0x70a08231)
mstore(0x20, address())
if iszero(
and(
gt(returndatasize(), 0x1f),
staticcall(gas(), token, 0x1c, 0x24, 0x34, 0x20)
)
) {
mstore(0x00, 0x90b8ec18)
revert(0x1c, 0x04)
}
mstore(0x14, to)
amount := mload(0x34)
mstore(0x00, 0xa9059cbb000000000000000000000000)
let success := call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
if iszero(and(eq(mload(0x00), 1), success)) {
if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {
mstore(0x00, 0x90b8ec18)
revert(0x1c, 0x04)
}
}
mstore(0x34, 0)
}
}
function safeApprove(address token, address to, uint256 amount) internal {
assembly {
mstore(0x14, to)
mstore(0x34, amount)
mstore(0x00, 0x095ea7b3000000000000000000000000)
let success := call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
if iszero(and(eq(mload(0x00), 1), success)) {
if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {
mstore(0x00, 0x3e3f8f73)
revert(0x1c, 0x04)
}
}
mstore(0x34, 0)
}
}
function safeApproveWithRetry(address token, address to, uint256 amount) internal {
assembly {
mstore(0x14, to)
mstore(0x34, amount)
mstore(0x00, 0x095ea7b3000000000000000000000000)
let success := call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
if iszero(and(eq(mload(0x00), 1), success)) {
if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {
mstore(0x34, 0)
mstore(0x00, 0x095ea7b3000000000000000000000000)
pop(call(gas(), token, 0, 0x10, 0x44, codesize(), 0x00))
mstore(0x34, amount)
success := call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
if iszero(and(eq(mload(0x00), 1), success)) {
if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {
mstore(0x00, 0x3e3f8f73)
revert(0x1c, 0x04)
}
}
}
}
mstore(0x34, 0)
}
}
function balanceOf(address token, address account) internal view returns (uint256 amount) {
assembly {
mstore(0x14, account)
mstore(0x00, 0x70a08231000000000000000000000000)
amount :=
mul(
mload(0x20),
and(
gt(returndatasize(), 0x1f),
staticcall(gas(), token, 0x10, 0x24, 0x20, 0x20)
)
)
}
}
function totalSupply(address token) internal view returns (uint256 result) {
assembly {
mstore(0x00, 0x18160ddd)
if iszero(
and(gt(returndatasize(), 0x1f), staticcall(gas(), token, 0x1c, 0x04, 0x00, 0x20))
) {
mstore(0x00, 0x54cd9435)
revert(0x1c, 0x04)
}
result := mload(0x00)
}
}
function safeTransferFrom2(address token, address from, address to, uint256 amount) internal {
if (!trySafeTransferFrom(token, from, to, amount)) {
permit2TransferFrom(token, from, to, amount);
}
}
function permit2TransferFrom(address token, address from, address to, uint256 amount)
internal
{
assembly {
let m := mload(0x40)
mstore(add(m, 0x74), shr(96, shl(96, token)))
mstore(add(m, 0x54), amount)
mstore(add(m, 0x34), to)
mstore(add(m, 0x20), shl(96, from))
mstore(m, 0x36c78516000000000000000000000000)
let p := PERMIT2
let exists := eq(chainid(), 1)
if iszero(exists) { exists := iszero(iszero(extcodesize(p))) }
if iszero(
and(
call(gas(), p, 0, add(m, 0x10), 0x84, codesize(), 0x00),
lt(iszero(extcodesize(token)), exists)
)
) {
mstore(0x00, 0x7939f4248757f0fd)
revert(add(0x18, shl(2, iszero(iszero(shr(160, amount))))), 0x04)
}
}
}
function permit2(
address token,
address owner,
address spender,
uint256 amount,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) internal {
bool success;
assembly {
for {} shl(96, xor(token, WETH9)) {} {
mstore(0x00, 0x3644e515)
if iszero(
and(
lt(iszero(mload(0x00)), eq(returndatasize(), 0x20)),
staticcall(5000, token, 0x1c, 0x04, 0x00, 0x20)
)
) { break }
let m := mload(0x40)
mstore(add(m, 0x34), spender)
mstore(add(m, 0x20), shl(96, owner))
mstore(add(m, 0x74), deadline)
if eq(mload(0x00), DAI_DOMAIN_SEPARATOR) {
mstore(0x14, owner)
mstore(0x00, 0x7ecebe00000000000000000000000000)
mstore(
add(m, 0x94),
lt(iszero(amount), staticcall(gas(), token, 0x10, 0x24, add(m, 0x54), 0x20))
)
mstore(m, 0x8fcbaf0c000000000000000000000000)
mstore(add(m, 0xb4), and(0xff, v))
mstore(add(m, 0xd4), r)
mstore(add(m, 0xf4), s)
success := call(gas(), token, 0, add(m, 0x10), 0x104, codesize(), 0x00)
break
}
mstore(m, 0xd505accf000000000000000000000000)
mstore(add(m, 0x54), amount)
mstore(add(m, 0x94), and(0xff, v))
mstore(add(m, 0xb4), r)
mstore(add(m, 0xd4), s)
success := call(gas(), token, 0, add(m, 0x10), 0xe4, codesize(), 0x00)
break
}
}
if (!success) simplePermit2(token, owner, spender, amount, deadline, v, r, s);
}
function simplePermit2(
address token,
address owner,
address spender,
uint256 amount,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) internal {
assembly {
let m := mload(0x40)
mstore(m, 0x927da105)
{
let addressMask := shr(96, not(0))
mstore(add(m, 0x20), and(addressMask, owner))
mstore(add(m, 0x40), and(addressMask, token))
mstore(add(m, 0x60), and(addressMask, spender))
mstore(add(m, 0xc0), and(addressMask, spender))
}
let p := mul(PERMIT2, iszero(shr(160, amount)))
if iszero(
and(
gt(returndatasize(), 0x5f),
staticcall(gas(), p, add(m, 0x1c), 0x64, add(m, 0x60), 0x60)
)
) {
mstore(0x00, 0x6b836e6b8757f0fd)
revert(add(0x18, shl(2, iszero(p))), 0x04)
}
mstore(m, 0x2b67b570)
mstore(add(m, 0x60), amount)
mstore(add(m, 0x80), 0xffffffffffff)
mstore(add(m, 0xe0), deadline)
mstore(add(m, 0x100), 0x100)
mstore(add(m, 0x120), 0x41)
mstore(add(m, 0x140), r)
mstore(add(m, 0x160), s)
mstore(add(m, 0x180), shl(248, v))
if iszero(
mul(extcodesize(token), call(gas(), p, 0, add(m, 0x1c), 0x184, codesize(), 0x00))) {
mstore(0x00, 0x6b836e6b)
revert(0x1c, 0x04)
}
}
}
function permit2Approve(address token, address spender, uint160 amount, uint48 expiration)
internal
{
assembly {
let addressMask := shr(96, not(0))
let m := mload(0x40)
mstore(m, 0x87517c45)
mstore(add(m, 0x20), and(addressMask, token))
mstore(add(m, 0x40), and(addressMask, spender))
mstore(add(m, 0x60), and(addressMask, amount))
mstore(add(m, 0x80), and(0xffffffffffff, expiration))
if iszero(call(gas(), PERMIT2, 0, add(m, 0x1c), 0xa0, codesize(), 0x00)) {
mstore(0x00, 0x324f14ae)
revert(0x1c, 0x04)
}
}
}
function permit2Lockdown(address token, address spender) internal {
assembly {
let m := mload(0x40)
mstore(m, 0xcc53287f)
mstore(add(m, 0x20), 0x20)
mstore(add(m, 0x40), 1)
mstore(add(m, 0x60), shr(96, shl(96, token)))
mstore(add(m, 0x80), shr(96, shl(96, spender)))
if iszero(call(gas(), PERMIT2, 0, add(m, 0x1c), 0xa0, codesize(), 0x00)) {
mstore(0x00, 0x96b3de23)
revert(0x1c, 0x04)
}
}
}
}
{
"compilationTarget": {
"src/EXEC404.sol": "EXEC404"
},
"evmVersion": "cancun",
"libraries": {},
"metadata": {
"bytecodeHash": "ipfs"
},
"optimizer": {
"enabled": true,
"runs": 1000
},
"remappings": [
":@ensdomains/=lib/v4-core/node_modules/@ensdomains/",
":@openzeppelin/=lib/v4-core/lib/openzeppelin-contracts/",
":@uniswap/v2-core/=lib/uniswap-v2-core/",
":@uniswap/v2-periphery/=lib/uniswap-v2-periphery/",
":@uniswap/v3-core/=lib/v3-core/",
":@uniswap/v3-periphery/=lib/v3-periphery/",
":@uniswap/v4-core/=lib/v4-core/",
":dn404/=lib/dn404/",
":ds-test/=lib/v4-core/lib/forge-std/lib/ds-test/src/",
":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
":forge-gas-snapshot/=lib/v4-core/lib/forge-gas-snapshot/src/",
":forge-std/=lib/v4-core/lib/forge-std/src/",
":forge-std/=test/utils/forge-std/",
":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/",
":hardhat/=lib/v4-core/node_modules/hardhat/",
":openzeppelin-contracts/=lib/openzeppelin-contracts/",
":permit2/=lib/v4-periphery/lib/permit2/",
":solady/=lib/solady/src/",
":solmate/=lib/v4-core/lib/solmate/",
":uniswap-v2-core/=lib/uniswap-v2-core/contracts/",
":uniswap-v2-periphery/=lib/uniswap-v2-periphery/contracts/",
":v3-core/=lib/v3-core/",
":v3-periphery/=lib/v3-periphery/contracts/",
":v4-core/=lib/v4-core/src/",
":v4-periphery/=lib/v4-periphery/"
]
}[{"inputs":[{"internalType":"bytes32[]","name":"_tierRoots","type":"bytes32[]"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ApprovalCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"DNAlreadyInitialized","type":"error"},{"inputs":[],"name":"DNNotInitialized","type":"error"},{"inputs":[],"name":"FnSelectorNotRecognized","type":"error"},{"inputs":[],"name":"InsufficientAllowance","type":"error"},{"inputs":[],"name":"InsufficientBalance","type":"error"},{"inputs":[],"name":"InvalidUnit","type":"error"},{"inputs":[],"name":"LinkMirrorContractFailed","type":"error"},{"inputs":[],"name":"MirrorAddressIsZero","type":"error"},{"inputs":[],"name":"SenderNotMirror","type":"error"},{"inputs":[],"name":"TokenDoesNotExist","type":"error"},{"inputs":[],"name":"TotalSupplyOverflow","type":"error"},{"inputs":[],"name":"TransferCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"TransferFromIncorrectOwner","type":"error"},{"inputs":[],"name":"TransferToZeroAddress","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"participant","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"cost","type":"uint256"},{"indexed":false,"internalType":"bool","name":"isBuy","type":"bool"}],"name":"BondingSale","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amountToken","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amountETH","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"liquidity","type":"uint256"}],"name":"LiquidityDeployed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"bool","name":"status","type":"bool"}],"name":"SkipNFTSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"collector","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount0","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount1","type":"uint256"}],"name":"V3FeesCollected","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32[]","name":"roots","type":"bytes32[]"}],"name":"WhitelistInitialized","type":"event"},{"stateMutability":"payable","type":"fallback"},{"inputs":[],"name":"CULT","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"LAUNCH_TIME","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"balanceMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"bondingMessages","outputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint128","name":"packedData","type":"uint128"},{"internalType":"string","name":"message","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"maxCost","type":"uint256"},{"internalType":"bool","name":"mintNFT","type":"bool"},{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"},{"internalType":"string","name":"message","type":"string"}],"name":"buyBonding","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"calculateCost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"calculateRefund","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint128","name":"amount0Max","type":"uint128"},{"internalType":"uint128","name":"amount1Max","type":"uint128"}],"name":"collectV3Fees","outputs":[{"internalType":"uint256","name":"amount0","type":"uint256"},{"internalType":"uint256","name":"amount1","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"string","name":"_uri","type":"string"},{"internalType":"string","name":"_unrevealedUri","type":"string"},{"internalType":"bool","name":"_revealed","type":"bool"}],"name":"configure","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"cultPool","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cultV3Position","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"currentRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"deployLiquidity","outputs":[{"internalType":"uint256","name":"amountToken","type":"uint256"},{"internalType":"uint256","name":"amountETH","type":"uint256"},{"internalType":"uint256","name":"liquidity","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"freeMint","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"freeSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getCurrentTier","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"execAmount","type":"uint256"}],"name":"getEthForExec","outputs":[{"internalType":"uint256","name":"ethAmount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"ethAmount","type":"uint256"}],"name":"getExecForEth","outputs":[{"internalType":"uint256","name":"execAmount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"messageId","type":"uint256"}],"name":"getMessageDetails","outputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint32","name":"timestamp","type":"uint32"},{"internalType":"uint96","name":"amount","type":"uint96"},{"internalType":"bool","name":"isBuy","type":"bool"},{"internalType":"string","name":"message","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"start","type":"uint256"},{"internalType":"uint256","name":"end","type":"uint256"}],"name":"getMessagesBatch","outputs":[{"internalType":"address[]","name":"senders","type":"address[]"},{"internalType":"uint32[]","name":"timestamps","type":"uint32[]"},{"internalType":"uint96[]","name":"amounts","type":"uint96[]"},{"internalType":"bool[]","name":"isBuys","type":"bool[]"},{"internalType":"string[]","name":"messages","type":"string[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"getOwnerTokens","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"getSkipNFT","outputs":[{"internalType":"bool","name":"result","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"initializeCultPool","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"},{"internalType":"address","name":"account","type":"address"}],"name":"isWhitelisted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"liquidityPair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mirrorERC721","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC721Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"revealed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"minRefund","type":"uint256"},{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"},{"internalType":"string","name":"message","type":"string"}],"name":"sellBonding","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"skipNFT","type":"bool"}],"name":"setSkipNFT","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startTokenId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalBondingSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalMessages","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"int256","name":"amount0Delta","type":"int256"},{"internalType":"int256","name":"amount1Delta","type":"int256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"uniswapV3SwapCallback","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unrevealedUri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"uri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]
