Sponsored
Сoins.game
100 free spins for registration. Spin now!
Everyday giveaways up to 100 ETH, Lucky Spins. Deposit BONUS 300% and Cashbacks!
BC.GAME
- The Best ETH Casino Claim Now!
5000+ Slots & Live Casino Games, 50+cryptos. Register with Etherscan and get 760% deposit bonus. Win Big$, withdraw it fast.
Sponsored
BC.GAME
- The Best ETH Casino Claim Now!
5000+ Slots & Live Casino Games, 50+cryptos. Register with Etherscan and get 760% deposit bonus. Win Big$, withdraw it fast.
CryptoWins
$5 Freebie + 137% Match up to 1 BTC Welcome Booster! Claim Now!
Dive into 100s of games and play anonymously with major cryptos. Join CryptoWins today!
CryptoSlots
Play & Get 25 Free Spins at CryptoSlots Play Now
Anonymous play on awesome games - sign up now for 25 free jackpot spins - worth $100s!
ERC-20
Add Token to MetaMask (Web3)Overview
Max Total Supply
999 GEN
Holders
11
Total Transfers
-
Market
Onchain Market Cap
$0.00
Circulating Supply Market Cap
-
Other Info
Token Contract (WITH 18 Decimals)
Loading...
Loading
Loading...
Loading
Loading...
Loading
| # | Exchange | Pair | Price | 24H Volume | % Volume |
|---|
Contract Name:
GEN404
Compiler Version
v0.8.20+commit.a1b79de6
Contract Source Code (Solidity)
/**
*Submitted for verification at Etherscan.io on 2024-02-13
*/
// SPDX-License-Identifier: MIT
// ░██████╗░███████╗███╗░░██╗ ░░██╗██╗░█████╗░░░██╗██╗
// ██╔════╝░██╔════╝████╗░██║ ░██╔╝██║██╔══██╗░██╔╝██║
// ██║░░██╗░█████╗░░██╔██╗██║ ██╔╝░██║██║░░██║██╔╝░██║
// ██║░░╚██╗██╔══╝░░██║╚████║ ███████║██║░░██║███████║
// ╚██████╔╝███████╗██║░╚███║ ╚════██║╚█████╔╝╚════██║
// ░╚═════╝░╚══════╝╚═╝░░╚══╝ ░░░░░╚═╝░╚════╝░░░░░░╚═╝
// GEN404 is a generative art collection that utilizes the 404 standard to offer sustained liquidity, redefining the boundaries of digital art ownership and exchange.
// Website: https://www.gen404.XYZ
// Twitter/X: https://x.com/GEN404NFT
// Telegram: https://t.me/gen404nft
// Contract created thanks to DN404 Team https://github.com/Vectorized/dn404
pragma solidity ^0.8.4;
/// @notice Safe ETH and ERC20 transfer library that gracefully handles missing return values.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/SafeTransferLib.sol)
/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/SafeTransferLib.sol)
///
/// @dev Note:
/// - For ETH transfers, please use `forceSafeTransferETH` for DoS protection.
/// - For ERC20s, this implementation won't check that a token has code,
/// responsibility is delegated to the caller.
library SafeTransferLib {
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* CUSTOM ERRORS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @dev The ETH transfer has failed.
error ETHTransferFailed();
/// @dev The ERC20 `transferFrom` has failed.
error TransferFromFailed();
/// @dev The ERC20 `transfer` has failed.
error TransferFailed();
/// @dev The ERC20 `approve` has failed.
error ApproveFailed();
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* CONSTANTS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @dev Suggested gas stipend for contract receiving ETH that disallows any storage writes.
uint256 internal constant GAS_STIPEND_NO_STORAGE_WRITES = 2300;
/// @dev Suggested gas stipend for contract receiving ETH to perform a few
/// storage reads and writes, but low enough to prevent griefing.
uint256 internal constant GAS_STIPEND_NO_GRIEF = 100000;
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* ETH OPERATIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
// If the ETH transfer MUST succeed with a reasonable gas budget, use the force variants.
//
// The regular variants:
// - Forwards all remaining gas to the target.
// - Reverts if the target reverts.
// - Reverts if the current contract has insufficient balance.
//
// The force variants:
// - Forwards with an optional gas stipend
// (defaults to `GAS_STIPEND_NO_GRIEF`, which is sufficient for most cases).
// - If the target reverts, or if the gas stipend is exhausted,
// creates a temporary contract to force send the ETH via `SELFDESTRUCT`.
// Future compatible with `SENDALL`: https://eips.ethereum.org/EIPS/eip-4758.
// - Reverts if the current contract has insufficient balance.
//
// The try variants:
// - Forwards with a mandatory gas stipend.
// - Instead of reverting, returns whether the transfer succeeded.
/// @dev Sends `amount` (in wei) ETH to `to`.
function safeTransferETH(address to, uint256 amount) internal {
/// @solidity memory-safe-assembly
assembly {
if iszero(call(gas(), to, amount, codesize(), 0x00, codesize(), 0x00)) {
mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.
revert(0x1c, 0x04)
}
}
}
/// @dev Sends all the ETH in the current contract to `to`.
function safeTransferAllETH(address to) internal {
/// @solidity memory-safe-assembly
assembly {
// Transfer all the ETH and check if it succeeded or not.
if iszero(call(gas(), to, selfbalance(), codesize(), 0x00, codesize(), 0x00)) {
mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.
revert(0x1c, 0x04)
}
}
}
/// @dev Force sends `amount` (in wei) ETH to `to`, with a `gasStipend`.
function forceSafeTransferETH(address to, uint256 amount, uint256 gasStipend) internal {
/// @solidity memory-safe-assembly
assembly {
if lt(selfbalance(), amount) {
mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.
revert(0x1c, 0x04)
}
if iszero(call(gasStipend, to, amount, codesize(), 0x00, codesize(), 0x00)) {
mstore(0x00, to) // Store the address in scratch space.
mstore8(0x0b, 0x73) // Opcode `PUSH20`.
mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.
if iszero(create(amount, 0x0b, 0x16)) { revert(codesize(), codesize()) } // For gas estimation.
}
}
}
/// @dev Force sends all the ETH in the current contract to `to`, with a `gasStipend`.
function forceSafeTransferAllETH(address to, uint256 gasStipend) internal {
/// @solidity memory-safe-assembly
assembly {
if iszero(call(gasStipend, to, selfbalance(), codesize(), 0x00, codesize(), 0x00)) {
mstore(0x00, to) // Store the address in scratch space.
mstore8(0x0b, 0x73) // Opcode `PUSH20`.
mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.
if iszero(create(selfbalance(), 0x0b, 0x16)) { revert(codesize(), codesize()) } // For gas estimation.
}
}
}
/// @dev Force sends `amount` (in wei) ETH to `to`, with `GAS_STIPEND_NO_GRIEF`.
function forceSafeTransferETH(address to, uint256 amount) internal {
/// @solidity memory-safe-assembly
assembly {
if lt(selfbalance(), amount) {
mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.
revert(0x1c, 0x04)
}
if iszero(call(GAS_STIPEND_NO_GRIEF, to, amount, codesize(), 0x00, codesize(), 0x00)) {
mstore(0x00, to) // Store the address in scratch space.
mstore8(0x0b, 0x73) // Opcode `PUSH20`.
mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.
if iszero(create(amount, 0x0b, 0x16)) { revert(codesize(), codesize()) } // For gas estimation.
}
}
}
/// @dev Force sends all the ETH in the current contract to `to`, with `GAS_STIPEND_NO_GRIEF`.
function forceSafeTransferAllETH(address to) internal {
/// @solidity memory-safe-assembly
assembly {
// forgefmt: disable-next-item
if iszero(call(GAS_STIPEND_NO_GRIEF, to, selfbalance(), codesize(), 0x00, codesize(), 0x00)) {
mstore(0x00, to) // Store the address in scratch space.
mstore8(0x0b, 0x73) // Opcode `PUSH20`.
mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.
if iszero(create(selfbalance(), 0x0b, 0x16)) { revert(codesize(), codesize()) } // For gas estimation.
}
}
}
/// @dev Sends `amount` (in wei) ETH to `to`, with a `gasStipend`.
function trySafeTransferETH(address to, uint256 amount, uint256 gasStipend)
internal
returns (bool success)
{
/// @solidity memory-safe-assembly
assembly {
success := call(gasStipend, to, amount, codesize(), 0x00, codesize(), 0x00)
}
}
/// @dev Sends all the ETH in the current contract to `to`, with a `gasStipend`.
function trySafeTransferAllETH(address to, uint256 gasStipend)
internal
returns (bool success)
{
/// @solidity memory-safe-assembly
assembly {
success := call(gasStipend, to, selfbalance(), codesize(), 0x00, codesize(), 0x00)
}
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* ERC20 OPERATIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @dev Sends `amount` of ERC20 `token` from `from` to `to`.
/// Reverts upon failure.
///
/// The `from` account must have at least `amount` approved for
/// the current contract to manage.
function safeTransferFrom(address token, address from, address to, uint256 amount) internal {
/// @solidity memory-safe-assembly
assembly {
let m := mload(0x40) // Cache the free memory pointer.
mstore(0x60, amount) // Store the `amount` argument.
mstore(0x40, to) // Store the `to` argument.
mstore(0x2c, shl(96, from)) // Store the `from` argument.
mstore(0x0c, 0x23b872dd000000000000000000000000) // `transferFrom(address,address,uint256)`.
// Perform the transfer, reverting upon failure.
if iszero(
and( // The arguments of `and` are evaluated from right to left.
or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.
call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)
)
) {
mstore(0x00, 0x7939f424) // `TransferFromFailed()`.
revert(0x1c, 0x04)
}
mstore(0x60, 0) // Restore the zero slot to zero.
mstore(0x40, m) // Restore the free memory pointer.
}
}
/// @dev Sends all of ERC20 `token` from `from` to `to`.
/// Reverts upon failure.
///
/// The `from` account must have their entire balance approved for
/// the current contract to manage.
function safeTransferAllFrom(address token, address from, address to)
internal
returns (uint256 amount)
{
/// @solidity memory-safe-assembly
assembly {
let m := mload(0x40) // Cache the free memory pointer.
mstore(0x40, to) // Store the `to` argument.
mstore(0x2c, shl(96, from)) // Store the `from` argument.
mstore(0x0c, 0x70a08231000000000000000000000000) // `balanceOf(address)`.
// Read the balance, reverting upon failure.
if iszero(
and( // The arguments of `and` are evaluated from right to left.
gt(returndatasize(), 0x1f), // At least 32 bytes returned.
staticcall(gas(), token, 0x1c, 0x24, 0x60, 0x20)
)
) {
mstore(0x00, 0x7939f424) // `TransferFromFailed()`.
revert(0x1c, 0x04)
}
mstore(0x00, 0x23b872dd) // `transferFrom(address,address,uint256)`.
amount := mload(0x60) // The `amount` is already at 0x60. We'll need to return it.
// Perform the transfer, reverting upon failure.
if iszero(
and( // The arguments of `and` are evaluated from right to left.
or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.
call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)
)
) {
mstore(0x00, 0x7939f424) // `TransferFromFailed()`.
revert(0x1c, 0x04)
}
mstore(0x60, 0) // Restore the zero slot to zero.
mstore(0x40, m) // Restore the free memory pointer.
}
}
/// @dev Sends `amount` of ERC20 `token` from the current contract to `to`.
/// Reverts upon failure.
function safeTransfer(address token, address to, uint256 amount) internal {
/// @solidity memory-safe-assembly
assembly {
mstore(0x14, to) // Store the `to` argument.
mstore(0x34, amount) // Store the `amount` argument.
mstore(0x00, 0xa9059cbb000000000000000000000000) // `transfer(address,uint256)`.
// Perform the transfer, reverting upon failure.
if iszero(
and( // The arguments of `and` are evaluated from right to left.
or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.
call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
)
) {
mstore(0x00, 0x90b8ec18) // `TransferFailed()`.
revert(0x1c, 0x04)
}
mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.
}
}
/// @dev Sends all of ERC20 `token` from the current contract to `to`.
/// Reverts upon failure.
function safeTransferAll(address token, address to) internal returns (uint256 amount) {
/// @solidity memory-safe-assembly
assembly {
mstore(0x00, 0x70a08231) // Store the function selector of `balanceOf(address)`.
mstore(0x20, address()) // Store the address of the current contract.
// Read the balance, reverting upon failure.
if iszero(
and( // The arguments of `and` are evaluated from right to left.
gt(returndatasize(), 0x1f), // At least 32 bytes returned.
staticcall(gas(), token, 0x1c, 0x24, 0x34, 0x20)
)
) {
mstore(0x00, 0x90b8ec18) // `TransferFailed()`.
revert(0x1c, 0x04)
}
mstore(0x14, to) // Store the `to` argument.
amount := mload(0x34) // The `amount` is already at 0x34. We'll need to return it.
mstore(0x00, 0xa9059cbb000000000000000000000000) // `transfer(address,uint256)`.
// Perform the transfer, reverting upon failure.
if iszero(
and( // The arguments of `and` are evaluated from right to left.
or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.
call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
)
) {
mstore(0x00, 0x90b8ec18) // `TransferFailed()`.
revert(0x1c, 0x04)
}
mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.
}
}
/// @dev Sets `amount` of ERC20 `token` for `to` to manage on behalf of the current contract.
/// Reverts upon failure.
function safeApprove(address token, address to, uint256 amount) internal {
/// @solidity memory-safe-assembly
assembly {
mstore(0x14, to) // Store the `to` argument.
mstore(0x34, amount) // Store the `amount` argument.
mstore(0x00, 0x095ea7b3000000000000000000000000) // `approve(address,uint256)`.
// Perform the approval, reverting upon failure.
if iszero(
and( // The arguments of `and` are evaluated from right to left.
or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.
call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
)
) {
mstore(0x00, 0x3e3f8f73) // `ApproveFailed()`.
revert(0x1c, 0x04)
}
mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.
}
}
/// @dev Sets `amount` of ERC20 `token` for `to` to manage on behalf of the current contract.
/// If the initial attempt to approve fails, attempts to reset the approved amount to zero,
/// then retries the approval again (some tokens, e.g. USDT, requires this).
/// Reverts upon failure.
function safeApproveWithRetry(address token, address to, uint256 amount) internal {
/// @solidity memory-safe-assembly
assembly {
mstore(0x14, to) // Store the `to` argument.
mstore(0x34, amount) // Store the `amount` argument.
mstore(0x00, 0x095ea7b3000000000000000000000000) // `approve(address,uint256)`.
// Perform the approval, retrying upon failure.
if iszero(
and( // The arguments of `and` are evaluated from right to left.
or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.
call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
)
) {
mstore(0x34, 0) // Store 0 for the `amount`.
mstore(0x00, 0x095ea7b3000000000000000000000000) // `approve(address,uint256)`.
pop(call(gas(), token, 0, 0x10, 0x44, codesize(), 0x00)) // Reset the approval.
mstore(0x34, amount) // Store back the original `amount`.
// Retry the approval, reverting upon failure.
if iszero(
and(
or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.
call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
)
) {
mstore(0x00, 0x3e3f8f73) // `ApproveFailed()`.
revert(0x1c, 0x04)
}
}
mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.
}
}
/// @dev Returns the amount of ERC20 `token` owned by `account`.
/// Returns zero if the `token` does not exist.
function balanceOf(address token, address account) internal view returns (uint256 amount) {
/// @solidity memory-safe-assembly
assembly {
mstore(0x14, account) // Store the `account` argument.
mstore(0x00, 0x70a08231000000000000000000000000) // `balanceOf(address)`.
amount :=
mul(
mload(0x20),
and( // The arguments of `and` are evaluated from right to left.
gt(returndatasize(), 0x1f), // At least 32 bytes returned.
staticcall(gas(), token, 0x10, 0x24, 0x20, 0x20)
)
)
}
}
}
// File: https://github.com/Vectorized/solady/blob/main/src/utils/LibString.sol
pragma solidity ^0.8.4;
/// @notice Library for converting numbers into strings and other string operations.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/LibString.sol)
/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/LibString.sol)
///
/// @dev Note:
/// For performance and bytecode compactness, most of the string operations are restricted to
/// byte strings (7-bit ASCII), except where otherwise specified.
/// Usage of byte string operations on charsets with runes spanning two or more bytes
/// can lead to undefined behavior.
library LibString {
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* CUSTOM ERRORS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @dev The length of the output is too small to contain all the hex digits.
error HexLengthInsufficient();
/// @dev The length of the string is more than 32 bytes.
error TooBigForSmallString();
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* CONSTANTS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @dev The constant returned when the `search` is not found in the string.
uint256 internal constant NOT_FOUND = type(uint256).max;
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* DECIMAL OPERATIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @dev Returns the base 10 decimal representation of `value`.
function toString(uint256 value) internal pure returns (string memory str) {
/// @solidity memory-safe-assembly
assembly {
// The maximum value of a uint256 contains 78 digits (1 byte per digit), but
// we allocate 0xa0 bytes to keep the free memory pointer 32-byte word aligned.
// We will need 1 word for the trailing zeros padding, 1 word for the length,
// and 3 words for a maximum of 78 digits.
str := add(mload(0x40), 0x80)
// Update the free memory pointer to allocate.
mstore(0x40, add(str, 0x20))
// Zeroize the slot after the string.
mstore(str, 0)
// Cache the end of the memory to calculate the length later.
let end := str
let w := not(0) // Tsk.
// We write the string from rightmost digit to leftmost digit.
// The following is essentially a do-while loop that also handles the zero case.
for { let temp := value } 1 {} {
str := add(str, w) // `sub(str, 1)`.
// Write the character to the pointer.
// The ASCII index of the '0' character is 48.
mstore8(str, add(48, mod(temp, 10)))
// Keep dividing `temp` until zero.
temp := div(temp, 10)
if iszero(temp) { break }
}
let length := sub(end, str)
// Move the pointer 32 bytes leftwards to make room for the length.
str := sub(str, 0x20)
// Store the length.
mstore(str, length)
}
}
/// @dev Returns the base 10 decimal representation of `value`.
function toString(int256 value) internal pure returns (string memory str) {
if (value >= 0) {
return toString(uint256(value));
}
unchecked {
str = toString(~uint256(value) + 1);
}
/// @solidity memory-safe-assembly
assembly {
// We still have some spare memory space on the left,
// as we have allocated 3 words (96 bytes) for up to 78 digits.
let length := mload(str) // Load the string length.
mstore(str, 0x2d) // Store the '-' character.
str := sub(str, 1) // Move back the string pointer by a byte.
mstore(str, add(length, 1)) // Update the string length.
}
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* HEXADECIMAL OPERATIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @dev Returns the hexadecimal representation of `value`,
/// left-padded to an input length of `length` bytes.
/// The output is prefixed with "0x" encoded using 2 hexadecimal digits per byte,
/// giving a total length of `length * 2 + 2` bytes.
/// Reverts if `length` is too small for the output to contain all the digits.
function toHexString(uint256 value, uint256 length) internal pure returns (string memory str) {
str = toHexStringNoPrefix(value, length);
/// @solidity memory-safe-assembly
assembly {
let strLength := add(mload(str), 2) // Compute the length.
mstore(str, 0x3078) // Write the "0x" prefix.
str := sub(str, 2) // Move the pointer.
mstore(str, strLength) // Write the length.
}
}
/// @dev Returns the hexadecimal representation of `value`,
/// left-padded to an input length of `length` bytes.
/// The output is prefixed with "0x" encoded using 2 hexadecimal digits per byte,
/// giving a total length of `length * 2` bytes.
/// Reverts if `length` is too small for the output to contain all the digits.
function toHexStringNoPrefix(uint256 value, uint256 length)
internal
pure
returns (string memory str)
{
/// @solidity memory-safe-assembly
assembly {
// We need 0x20 bytes for the trailing zeros padding, `length * 2` bytes
// for the digits, 0x02 bytes for the prefix, and 0x20 bytes for the length.
// We add 0x20 to the total and round down to a multiple of 0x20.
// (0x20 + 0x20 + 0x02 + 0x20) = 0x62.
str := add(mload(0x40), and(add(shl(1, length), 0x42), not(0x1f)))
// Allocate the memory.
mstore(0x40, add(str, 0x20))
// Zeroize the slot after the string.
mstore(str, 0)
// Cache the end to calculate the length later.
let end := str
// Store "0123456789abcdef" in scratch space.
mstore(0x0f, 0x30313233343536373839616263646566)
let start := sub(str, add(length, length))
let w := not(1) // Tsk.
let temp := value
// We write the string from rightmost digit to leftmost digit.
// The following is essentially a do-while loop that also handles the zero case.
for {} 1 {} {
str := add(str, w) // `sub(str, 2)`.
mstore8(add(str, 1), mload(and(temp, 15)))
mstore8(str, mload(and(shr(4, temp), 15)))
temp := shr(8, temp)
if iszero(xor(str, start)) { break }
}
if temp {
mstore(0x00, 0x2194895a) // `HexLengthInsufficient()`.
revert(0x1c, 0x04)
}
// Compute the string's length.
let strLength := sub(end, str)
// Move the pointer and write the length.
str := sub(str, 0x20)
mstore(str, strLength)
}
}
/// @dev Returns the hexadecimal representation of `value`.
/// The output is prefixed with "0x" and encoded using 2 hexadecimal digits per byte.
/// As address are 20 bytes long, the output will left-padded to have
/// a length of `20 * 2 + 2` bytes.
function toHexString(uint256 value) internal pure returns (string memory str) {
str = toHexStringNoPrefix(value);
/// @solidity memory-safe-assembly
assembly {
let strLength := add(mload(str), 2) // Compute the length.
mstore(str, 0x3078) // Write the "0x" prefix.
str := sub(str, 2) // Move the pointer.
mstore(str, strLength) // Write the length.
}
}
/// @dev Returns the hexadecimal representation of `value`.
/// The output is prefixed with "0x".
/// The output excludes leading "0" from the `toHexString` output.
/// `0x00: "0x0", 0x01: "0x1", 0x12: "0x12", 0x123: "0x123"`.
function toMinimalHexString(uint256 value) internal pure returns (string memory str) {
str = toHexStringNoPrefix(value);
/// @solidity memory-safe-assembly
assembly {
let o := eq(byte(0, mload(add(str, 0x20))), 0x30) // Whether leading zero is present.
let strLength := add(mload(str), 2) // Compute the length.
mstore(add(str, o), 0x3078) // Write the "0x" prefix, accounting for leading zero.
str := sub(add(str, o), 2) // Move the pointer, accounting for leading zero.
mstore(str, sub(strLength, o)) // Write the length, accounting for leading zero.
}
}
/// @dev Returns the hexadecimal representation of `value`.
/// The output excludes leading "0" from the `toHexStringNoPrefix` output.
/// `0x00: "0", 0x01: "1", 0x12: "12", 0x123: "123"`.
function toMinimalHexStringNoPrefix(uint256 value) internal pure returns (string memory str) {
str = toHexStringNoPrefix(value);
/// @solidity memory-safe-assembly
assembly {
let o := eq(byte(0, mload(add(str, 0x20))), 0x30) // Whether leading zero is present.
let strLength := mload(str) // Get the length.
str := add(str, o) // Move the pointer, accounting for leading zero.
mstore(str, sub(strLength, o)) // Write the length, accounting for leading zero.
}
}
/// @dev Returns the hexadecimal representation of `value`.
/// The output is encoded using 2 hexadecimal digits per byte.
/// As address are 20 bytes long, the output will left-padded to have
/// a length of `20 * 2` bytes.
function toHexStringNoPrefix(uint256 value) internal pure returns (string memory str) {
/// @solidity memory-safe-assembly
assembly {
// We need 0x20 bytes for the trailing zeros padding, 0x20 bytes for the length,
// 0x02 bytes for the prefix, and 0x40 bytes for the digits.
// The next multiple of 0x20 above (0x20 + 0x20 + 0x02 + 0x40) is 0xa0.
str := add(mload(0x40), 0x80)
// Allocate the memory.
mstore(0x40, add(str, 0x20))
// Zeroize the slot after the string.
mstore(str, 0)
// Cache the end to calculate the length later.
let end := str
// Store "0123456789abcdef" in scratch space.
mstore(0x0f, 0x30313233343536373839616263646566)
let w := not(1) // Tsk.
// We write the string from rightmost digit to leftmost digit.
// The following is essentially a do-while loop that also handles the zero case.
for { let temp := value } 1 {} {
str := add(str, w) // `sub(str, 2)`.
mstore8(add(str, 1), mload(and(temp, 15)))
mstore8(str, mload(and(shr(4, temp), 15)))
temp := shr(8, temp)
if iszero(temp) { break }
}
// Compute the string's length.
let strLength := sub(end, str)
// Move the pointer and write the length.
str := sub(str, 0x20)
mstore(str, strLength)
}
}
/// @dev Returns the hexadecimal representation of `value`.
/// The output is prefixed with "0x", encoded using 2 hexadecimal digits per byte,
/// and the alphabets are capitalized conditionally according to
/// https://eips.ethereum.org/EIPS/eip-55
function toHexStringChecksummed(address value) internal pure returns (string memory str) {
str = toHexString(value);
/// @solidity memory-safe-assembly
assembly {
let mask := shl(6, div(not(0), 255)) // `0b010000000100000000 ...`
let o := add(str, 0x22)
let hashed := and(keccak256(o, 40), mul(34, mask)) // `0b10001000 ... `
let t := shl(240, 136) // `0b10001000 << 240`
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)))))
}
}
/// @dev Returns the hexadecimal representation of `value`.
/// The output is prefixed with "0x" and encoded using 2 hexadecimal digits per byte.
function toHexString(address value) internal pure returns (string memory str) {
str = toHexStringNoPrefix(value);
/// @solidity memory-safe-assembly
assembly {
let strLength := add(mload(str), 2) // Compute the length.
mstore(str, 0x3078) // Write the "0x" prefix.
str := sub(str, 2) // Move the pointer.
mstore(str, strLength) // Write the length.
}
}
/// @dev Returns the hexadecimal representation of `value`.
/// The output is encoded using 2 hexadecimal digits per byte.
function toHexStringNoPrefix(address value) internal pure returns (string memory str) {
/// @solidity memory-safe-assembly
assembly {
str := mload(0x40)
// Allocate the memory.
// We need 0x20 bytes for the trailing zeros padding, 0x20 bytes for the length,
// 0x02 bytes for the prefix, and 0x28 bytes for the digits.
// The next multiple of 0x20 above (0x20 + 0x20 + 0x02 + 0x28) is 0x80.
mstore(0x40, add(str, 0x80))
// Store "0123456789abcdef" in scratch space.
mstore(0x0f, 0x30313233343536373839616263646566)
str := add(str, 2)
mstore(str, 40)
let o := add(str, 0x20)
mstore(add(o, 40), 0)
value := shl(96, value)
// We write the string from rightmost digit to leftmost digit.
// The following is essentially a do-while loop that also handles the zero case.
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 }
}
}
}
/// @dev Returns the hex encoded string from the raw bytes.
/// The output is encoded using 2 hexadecimal digits per byte.
function toHexString(bytes memory raw) internal pure returns (string memory str) {
str = toHexStringNoPrefix(raw);
/// @solidity memory-safe-assembly
assembly {
let strLength := add(mload(str), 2) // Compute the length.
mstore(str, 0x3078) // Write the "0x" prefix.
str := sub(str, 2) // Move the pointer.
mstore(str, strLength) // Write the length.
}
}
/// @dev Returns the hex encoded string from the raw bytes.
/// The output is encoded using 2 hexadecimal digits per byte.
function toHexStringNoPrefix(bytes memory raw) internal pure returns (string memory str) {
/// @solidity memory-safe-assembly
assembly {
let length := mload(raw)
str := add(mload(0x40), 2) // Skip 2 bytes for the optional prefix.
mstore(str, add(length, length)) // Store the length of the output.
// Store "0123456789abcdef" in scratch space.
mstore(0x0f, 0x30313233343536373839616263646566)
let o := add(str, 0x20)
let end := add(raw, length)
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) // Zeroize the slot after the string.
mstore(0x40, add(o, 0x20)) // Allocate the memory.
}
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* RUNE STRING OPERATIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @dev Returns the number of UTF characters in the string.
function runeCount(string memory s) internal pure returns (uint256 result) {
/// @solidity memory-safe-assembly
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 }
}
}
}
}
/// @dev Returns if this string is a 7-bit ASCII string.
/// (i.e. all characters codes are in [0..127])
function is7BitASCII(string memory s) internal pure returns (bool result) {
/// @solidity memory-safe-assembly
assembly {
let mask := shl(7, div(not(0), 255))
result := 1
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)
}
}
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* BYTE STRING OPERATIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
// For performance and bytecode compactness, byte string operations are restricted
// to 7-bit ASCII strings. All offsets are byte offsets, not UTF character offsets.
// Usage of byte string operations on charsets with runes spanning two or more bytes
// can lead to undefined behavior.
/// @dev Returns `subject` all occurrences of `search` replaced with `replacement`.
function replace(string memory subject, string memory search, string memory replacement)
internal
pure
returns (string memory result)
{
/// @solidity memory-safe-assembly
assembly {
let subjectLength := mload(subject)
let searchLength := mload(search)
let replacementLength := mload(replacement)
subject := add(subject, 0x20)
search := add(search, 0x20)
replacement := add(replacement, 0x20)
result := add(mload(0x40), 0x20)
let subjectEnd := add(subject, subjectLength)
if iszero(gt(searchLength, subjectLength)) {
let subjectSearchEnd := add(sub(subjectEnd, searchLength), 1)
let h := 0
if iszero(lt(searchLength, 0x20)) { h := keccak256(search, searchLength) }
let m := shl(3, sub(0x20, and(searchLength, 0x1f)))
let s := mload(search)
for {} 1 {} {
let t := mload(subject)
// Whether the first `searchLength % 32` bytes of
// `subject` and `search` matches.
if iszero(shr(m, xor(t, s))) {
if h {
if iszero(eq(keccak256(subject, searchLength), h)) {
mstore(result, t)
result := add(result, 1)
subject := add(subject, 1)
if iszero(lt(subject, subjectSearchEnd)) { break }
continue
}
}
// Copy the `replacement` one word at a time.
for { let o := 0 } 1 {} {
mstore(add(result, o), mload(add(replacement, o)))
o := add(o, 0x20)
if iszero(lt(o, replacementLength)) { break }
}
result := add(result, replacementLength)
subject := add(subject, searchLength)
if searchLength {
if iszero(lt(subject, subjectSearchEnd)) { break }
continue
}
}
mstore(result, t)
result := add(result, 1)
subject := add(subject, 1)
if iszero(lt(subject, subjectSearchEnd)) { break }
}
}
let resultRemainder := result
result := add(mload(0x40), 0x20)
let k := add(sub(resultRemainder, result), sub(subjectEnd, subject))
// Copy the rest of the string one word at a time.
for {} lt(subject, subjectEnd) {} {
mstore(resultRemainder, mload(subject))
resultRemainder := add(resultRemainder, 0x20)
subject := add(subject, 0x20)
}
result := sub(result, 0x20)
let last := add(add(result, 0x20), k) // Zeroize the slot after the string.
mstore(last, 0)
mstore(0x40, add(last, 0x20)) // Allocate the memory.
mstore(result, k) // Store the length.
}
}
/// @dev Returns the byte index of the first location of `search` in `subject`,
/// searching from left to right, starting from `from`.
/// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `search` is not found.
function indexOf(string memory subject, string memory search, uint256 from)
internal
pure
returns (uint256 result)
{
/// @solidity memory-safe-assembly
assembly {
for { let subjectLength := mload(subject) } 1 {} {
if iszero(mload(search)) {
if iszero(gt(from, subjectLength)) {
result := from
break
}
result := subjectLength
break
}
let searchLength := mload(search)
let subjectStart := add(subject, 0x20)
result := not(0) // Initialize to `NOT_FOUND`.
subject := add(subjectStart, from)
let end := add(sub(add(subjectStart, subjectLength), searchLength), 1)
let m := shl(3, sub(0x20, and(searchLength, 0x1f)))
let s := mload(add(search, 0x20))
if iszero(and(lt(subject, end), lt(from, subjectLength))) { break }
if iszero(lt(searchLength, 0x20)) {
for { let h := keccak256(add(search, 0x20), searchLength) } 1 {} {
if iszero(shr(m, xor(mload(subject), s))) {
if eq(keccak256(subject, searchLength), 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
}
}
}
/// @dev Returns the byte index of the first location of `search` in `subject`,
/// searching from left to right.
/// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `search` is not found.
function indexOf(string memory subject, string memory search)
internal
pure
returns (uint256 result)
{
result = indexOf(subject, search, 0);
}
/// @dev Returns the byte index of the first location of `search` in `subject`,
/// searching from right to left, starting from `from`.
/// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `search` is not found.
function lastIndexOf(string memory subject, string memory search, uint256 from)
internal
pure
returns (uint256 result)
{
/// @solidity memory-safe-assembly
assembly {
for {} 1 {} {
result := not(0) // Initialize to `NOT_FOUND`.
let searchLength := mload(search)
if gt(searchLength, mload(subject)) { break }
let w := result
let fromMax := sub(mload(subject), searchLength)
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 }
// As this function is not too often used,
// we shall simply use keccak256 for smaller bytecode size.
for { let h := keccak256(add(search, 0x20), searchLength) } 1 {} {
if eq(keccak256(subject, searchLength), h) {
result := sub(subject, add(end, 1))
break
}
subject := add(subject, w) // `sub(subject, 1)`.
if iszero(gt(subject, end)) { break }
}
break
}
}
}
/// @dev Returns the byte index of the first location of `search` in `subject`,
/// searching from right to left.
/// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `search` is not found.
function lastIndexOf(string memory subject, string memory search)
internal
pure
returns (uint256 result)
{
result = lastIndexOf(subject, search, uint256(int256(-1)));
}
/// @dev Returns true if `search` is found in `subject`, false otherwise.
function contains(string memory subject, string memory search) internal pure returns (bool) {
return indexOf(subject, search) != NOT_FOUND;
}
/// @dev Returns whether `subject` starts with `search`.
function startsWith(string memory subject, string memory search)
internal
pure
returns (bool result)
{
/// @solidity memory-safe-assembly
assembly {
let searchLength := mload(search)
// Just using keccak256 directly is actually cheaper.
// forgefmt: disable-next-item
result := and(
iszero(gt(searchLength, mload(subject))),
eq(
keccak256(add(subject, 0x20), searchLength),
keccak256(add(search, 0x20), searchLength)
)
)
}
}
/// @dev Returns whether `subject` ends with `search`.
function endsWith(string memory subject, string memory search)
internal
pure
returns (bool result)
{
/// @solidity memory-safe-assembly
assembly {
let searchLength := mload(search)
let subjectLength := mload(subject)
// Whether `search` is not longer than `subject`.
let withinRange := iszero(gt(searchLength, subjectLength))
// Just using keccak256 directly is actually cheaper.
// forgefmt: disable-next-item
result := and(
withinRange,
eq(
keccak256(
// `subject + 0x20 + max(subjectLength - searchLength, 0)`.
add(add(subject, 0x20), mul(withinRange, sub(subjectLength, searchLength))),
searchLength
),
keccak256(add(search, 0x20), searchLength)
)
)
}
}
/// @dev Returns `subject` repeated `times`.
function repeat(string memory subject, uint256 times)
internal
pure
returns (string memory result)
{
/// @solidity memory-safe-assembly
assembly {
let subjectLength := mload(subject)
if iszero(or(iszero(times), iszero(subjectLength))) {
subject := add(subject, 0x20)
result := mload(0x40)
let output := add(result, 0x20)
for {} 1 {} {
// Copy the `subject` one word at a time.
for { let o := 0 } 1 {} {
mstore(add(output, o), mload(add(subject, o)))
o := add(o, 0x20)
if iszero(lt(o, subjectLength)) { break }
}
output := add(output, subjectLength)
times := sub(times, 1)
if iszero(times) { break }
}
mstore(output, 0) // Zeroize the slot after the string.
let resultLength := sub(output, add(result, 0x20))
mstore(result, resultLength) // Store the length.
// Allocate the memory.
mstore(0x40, add(result, add(resultLength, 0x20)))
}
}
}
/// @dev Returns a copy of `subject` sliced from `start` to `end` (exclusive).
/// `start` and `end` are byte offsets.
function slice(string memory subject, uint256 start, uint256 end)
internal
pure
returns (string memory result)
{
/// @solidity memory-safe-assembly
assembly {
let subjectLength := mload(subject)
if iszero(gt(subjectLength, end)) { end := subjectLength }
if iszero(gt(subjectLength, start)) { start := subjectLength }
if lt(start, end) {
result := mload(0x40)
let resultLength := sub(end, start)
mstore(result, resultLength)
subject := add(subject, start)
let w := not(0x1f)
// Copy the `subject` one word at a time, backwards.
for { let o := and(add(resultLength, 0x1f), w) } 1 {} {
mstore(add(result, o), mload(add(subject, o)))
o := add(o, w) // `sub(o, 0x20)`.
if iszero(o) { break }
}
// Zeroize the slot after the string.
mstore(add(add(result, 0x20), resultLength), 0)
// Allocate memory for the length and the bytes,
// rounded up to a multiple of 32.
mstore(0x40, add(result, and(add(resultLength, 0x3f), w)))
}
}
}
/// @dev Returns a copy of `subject` sliced from `start` to the end of the string.
/// `start` is a byte offset.
function slice(string memory subject, uint256 start)
internal
pure
returns (string memory result)
{
result = slice(subject, start, uint256(int256(-1)));
}
/// @dev Returns all the indices of `search` in `subject`.
/// The indices are byte offsets.
function indicesOf(string memory subject, string memory search)
internal
pure
returns (uint256[] memory result)
{
/// @solidity memory-safe-assembly
assembly {
let subjectLength := mload(subject)
let searchLength := mload(search)
if iszero(gt(searchLength, subjectLength)) {
subject := add(subject, 0x20)
search := add(search, 0x20)
result := add(mload(0x40), 0x20)
let subjectStart := subject
let subjectSearchEnd := add(sub(add(subject, subjectLength), searchLength), 1)
let h := 0
if iszero(lt(searchLength, 0x20)) { h := keccak256(search, searchLength) }
let m := shl(3, sub(0x20, and(searchLength, 0x1f)))
let s := mload(search)
for {} 1 {} {
let t := mload(subject)
// Whether the first `searchLength % 32` bytes of
// `subject` and `search` matches.
if iszero(shr(m, xor(t, s))) {
if h {
if iszero(eq(keccak256(subject, searchLength), h)) {
subject := add(subject, 1)
if iszero(lt(subject, subjectSearchEnd)) { break }
continue
}
}
// Append to `result`.
mstore(result, sub(subject, subjectStart))
result := add(result, 0x20)
// Advance `subject` by `searchLength`.
subject := add(subject, searchLength)
if searchLength {
if iszero(lt(subject, subjectSearchEnd)) { break }
continue
}
}
subject := add(subject, 1)
if iszero(lt(subject, subjectSearchEnd)) { break }
}
let resultEnd := result
// Assign `result` to the free memory pointer.
result := mload(0x40)
// Store the length of `result`.
mstore(result, shr(5, sub(resultEnd, add(result, 0x20))))
// Allocate memory for result.
// We allocate one more word, so this array can be recycled for {split}.
mstore(0x40, add(resultEnd, 0x20))
}
}
}
/// @dev Returns a arrays of strings based on the `delimiter` inside of the `subject` string.
function split(string memory subject, string memory delimiter)
internal
pure
returns (string[] memory result)
{
uint256[] memory indices = indicesOf(subject, delimiter);
/// @solidity memory-safe-assembly
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))
let prevIndex := 0
for {} 1 {} {
let index := mload(indexPtr)
mstore(indexPtr, 0x60)
if iszero(eq(index, prevIndex)) {
let element := mload(0x40)
let elementLength := sub(index, prevIndex)
mstore(element, elementLength)
// Copy the `subject` one word at a time, backwards.
for { let o := and(add(elementLength, 0x1f), w) } 1 {} {
mstore(add(element, o), mload(add(add(subject, prevIndex), o)))
o := add(o, w) // `sub(o, 0x20)`.
if iszero(o) { break }
}
// Zeroize the slot after the string.
mstore(add(add(element, 0x20), elementLength), 0)
// Allocate memory for the length and the bytes,
// rounded up to a multiple of 32.
mstore(0x40, add(element, and(add(elementLength, 0x3f), w)))
// Store the `element` into the array.
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))
}
}
}
/// @dev Returns a concatenated string of `a` and `b`.
/// Cheaper than `string.concat()` and does not de-align the free memory pointer.
function concat(string memory a, string memory b)
internal
pure
returns (string memory result)
{
/// @solidity memory-safe-assembly
assembly {
let w := not(0x1f)
result := mload(0x40)
let aLength := mload(a)
// Copy `a` one word at a time, backwards.
for { let o := and(add(aLength, 0x20), w) } 1 {} {
mstore(add(result, o), mload(add(a, o)))
o := add(o, w) // `sub(o, 0x20)`.
if iszero(o) { break }
}
let bLength := mload(b)
let output := add(result, aLength)
// Copy `b` one word at a time, backwards.
for { let o := and(add(bLength, 0x20), w) } 1 {} {
mstore(add(output, o), mload(add(b, o)))
o := add(o, w) // `sub(o, 0x20)`.
if iszero(o) { break }
}
let totalLength := add(aLength, bLength)
let last := add(add(result, 0x20), totalLength)
// Zeroize the slot after the string.
mstore(last, 0)
// Stores the length.
mstore(result, totalLength)
// Allocate memory for the length and the bytes,
// rounded up to a multiple of 32.
mstore(0x40, and(add(last, 0x1f), w))
}
}
/// @dev Returns a copy of the string in either lowercase or UPPERCASE.
/// WARNING! This function is only compatible with 7-bit ASCII strings.
function toCase(string memory subject, bool toUpper)
internal
pure
returns (string memory result)
{
/// @solidity memory-safe-assembly
assembly {
let length := mload(subject)
if length {
result := add(mload(0x40), 0x20)
subject := add(subject, 1)
let flags := shl(add(70, shl(5, toUpper)), 0x3ffffff)
let w := not(0)
for { let o := length } 1 {} {
o := add(o, w)
let b := and(0xff, mload(add(subject, o)))
mstore8(add(result, o), xor(b, and(shr(b, flags), 0x20)))
if iszero(o) { break }
}
result := mload(0x40)
mstore(result, length) // Store the length.
let last := add(add(result, 0x20), length)
mstore(last, 0) // Zeroize the slot after the string.
mstore(0x40, add(last, 0x20)) // Allocate the memory.
}
}
}
/// @dev Returns a string from a small bytes32 string.
/// `s` must be null-terminated, or behavior will be undefined.
function fromSmallString(bytes32 s) internal pure returns (string memory result) {
/// @solidity memory-safe-assembly
assembly {
result := mload(0x40)
let n := 0
for {} byte(n, s) { n := add(n, 1) } {} // Scan for '\0'.
mstore(result, n)
let o := add(result, 0x20)
mstore(o, s)
mstore(add(o, n), 0)
mstore(0x40, add(result, 0x40))
}
}
/// @dev Returns the small string, with all bytes after the first null byte zeroized.
function normalizeSmallString(bytes32 s) internal pure returns (bytes32 result) {
/// @solidity memory-safe-assembly
assembly {
for {} byte(result, s) { result := add(result, 1) } {} // Scan for '\0'.
mstore(0x00, s)
mstore(result, 0x00)
result := mload(0x00)
}
}
/// @dev Returns the string as a normalized null-terminated small string.
function toSmallString(string memory s) internal pure returns (bytes32 result) {
/// @solidity memory-safe-assembly
assembly {
result := mload(s)
if iszero(lt(result, 33)) {
mstore(0x00, 0xec92f9a3) // `TooBigForSmallString()`.
revert(0x1c, 0x04)
}
result := shl(shl(3, sub(32, result)), mload(add(s, result)))
}
}
/// @dev Returns a lowercased copy of the string.
/// WARNING! This function is only compatible with 7-bit ASCII strings.
function lower(string memory subject) internal pure returns (string memory result) {
result = toCase(subject, false);
}
/// @dev Returns an UPPERCASED copy of the string.
/// WARNING! This function is only compatible with 7-bit ASCII strings.
function upper(string memory subject) internal pure returns (string memory result) {
result = toCase(subject, true);
}
/// @dev Escapes the string to be used within HTML tags.
function escapeHTML(string memory s) internal pure returns (string memory result) {
/// @solidity memory-safe-assembly
assembly {
let end := add(s, mload(s))
result := add(mload(0x40), 0x20)
// Store the bytes of the packed offsets and strides into the scratch space.
// `packed = (stride << 5) | offset`. Max offset is 20. Max stride is 6.
mstore(0x1f, 0x900094)
mstore(0x08, 0xc0000000a6ab)
// Store ""&'<>" into the scratch space.
mstore(0x00, shl(64, 0x2671756f743b26616d703b262333393b266c743b2667743b))
for {} iszero(eq(s, end)) {} {
s := add(s, 1)
let c := and(mload(s), 0xff)
// Not in `["\"","'","&","<",">"]`.
if iszero(and(shl(c, 1), 0x500000c400000000)) {
mstore8(result, c)
result := add(result, 1)
continue
}
let t := shr(248, mload(c))
mstore(result, mload(and(t, 0x1f)))
result := add(result, shr(5, t))
}
let last := result
mstore(last, 0) // Zeroize the slot after the string.
result := mload(0x40)
mstore(result, sub(last, add(result, 0x20))) // Store the length.
mstore(0x40, add(last, 0x20)) // Allocate the memory.
}
}
/// @dev Escapes the string to be used within double-quotes in a JSON.
/// If `addDoubleQuotes` is true, the result will be enclosed in double-quotes.
function escapeJSON(string memory s, bool addDoubleQuotes)
internal
pure
returns (string memory result)
{
/// @solidity memory-safe-assembly
assembly {
let end := add(s, mload(s))
result := add(mload(0x40), 0x20)
if addDoubleQuotes {
mstore8(result, 34)
result := add(1, result)
}
// Store "\\u0000" in scratch space.
// Store "0123456789abcdef" in scratch space.
// Also, store `{0x08:"b", 0x09:"t", 0x0a:"n", 0x0c:"f", 0x0d:"r"}`.
// into the scratch space.
mstore(0x15, 0x5c75303030303031323334353637383961626364656662746e006672)
// Bitmask for detecting `["\"","\\"]`.
let e := or(shl(0x22, 1), shl(0x5c, 1))
for {} 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)) {
// Not in `["\"","\\"]`.
mstore8(result, c)
result := add(result, 1)
continue
}
mstore8(result, 0x5c) // "\\".
mstore8(add(result, 1), c)
result := add(result, 2)
continue
}
if iszero(and(shl(c, 1), 0x3700)) {
// Not in `["\b","\t","\n","\f","\d"]`.
mstore8(0x1d, mload(shr(4, c))) // Hex value.
mstore8(0x1e, mload(and(c, 15))) // Hex value.
mstore(result, mload(0x19)) // "\\u00XX".
result := add(result, 6)
continue
}
mstore8(result, 0x5c) // "\\".
mstore8(add(result, 1), mload(add(c, 8)))
result := add(result, 2)
}
if addDoubleQuotes {
mstore8(result, 34)
result := add(1, result)
}
let last := result
mstore(last, 0) // Zeroize the slot after the string.
result := mload(0x40)
mstore(result, sub(last, add(result, 0x20))) // Store the length.
mstore(0x40, add(last, 0x20)) // Allocate the memory.
}
}
/// @dev Escapes the string to be used within double-quotes in a JSON.
function escapeJSON(string memory s) internal pure returns (string memory result) {
result = escapeJSON(s, false);
}
/// @dev Returns whether `a` equals `b`.
function eq(string memory a, string memory b) internal pure returns (bool result) {
/// @solidity memory-safe-assembly
assembly {
result := eq(keccak256(add(a, 0x20), mload(a)), keccak256(add(b, 0x20), mload(b)))
}
}
/// @dev Returns whether `a` equals `b`, where `b` is a null-terminated small string.
function eqs(string memory a, bytes32 b) internal pure returns (bool result) {
/// @solidity memory-safe-assembly
assembly {
// These should be evaluated on compile time, as far as possible.
let m := not(shl(7, div(not(iszero(b)), 255))) // `0x7f7f ...`.
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))))
// forgefmt: disable-next-item
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)))))
}
}
/// @dev Packs a single string with its length into a single word.
/// Returns `bytes32(0)` if the length is zero or greater than 31.
function packOne(string memory a) internal pure returns (bytes32 result) {
/// @solidity memory-safe-assembly
assembly {
// We don't need to zero right pad the string,
// since this is our own custom non-standard packing scheme.
result :=
mul(
// Load the length and the bytes.
mload(add(a, 0x1f)),
// `length != 0 && length < 32`. Abuses underflow.
// Assumes that the length is valid and within the block gas limit.
lt(sub(mload(a), 1), 0x1f)
)
}
}
/// @dev Unpacks a string packed using {packOne}.
/// Returns the empty string if `packed` is `bytes32(0)`.
/// If `packed` is not an output of {packOne}, the output behavior is undefined.
function unpackOne(bytes32 packed) internal pure returns (string memory result) {
/// @solidity memory-safe-assembly
assembly {
// Grab the free memory pointer.
result := mload(0x40)
// Allocate 2 words (1 for the length, 1 for the bytes).
mstore(0x40, add(result, 0x40))
// Zeroize the length slot.
mstore(result, 0)
// Store the length and bytes.
mstore(add(result, 0x1f), packed)
// Right pad with zeroes.
mstore(add(add(result, 0x20), mload(result)), 0)
}
}
/// @dev Packs two strings with their lengths into a single word.
/// Returns `bytes32(0)` if combined length is zero or greater than 30.
function packTwo(string memory a, string memory b) internal pure returns (bytes32 result) {
/// @solidity memory-safe-assembly
assembly {
let aLength := mload(a)
// We don't need to zero right pad the strings,
// since this is our own custom non-standard packing scheme.
result :=
mul(
// Load the length and the bytes of `a` and `b`.
or(
shl(shl(3, sub(0x1f, aLength)), mload(add(a, aLength))),
mload(sub(add(b, 0x1e), aLength))
),
// `totalLength != 0 && totalLength < 31`. Abuses underflow.
// Assumes that the lengths are valid and within the block gas limit.
lt(sub(add(aLength, mload(b)), 1), 0x1e)
)
}
}
/// @dev Unpacks strings packed using {packTwo}.
/// Returns the empty strings if `packed` is `bytes32(0)`.
/// If `packed` is not an output of {packTwo}, the output behavior is undefined.
function unpackTwo(bytes32 packed)
internal
pure
returns (string memory resultA, string memory resultB)
{
/// @solidity memory-safe-assembly
assembly {
// Grab the free memory pointer.
resultA := mload(0x40)
resultB := add(resultA, 0x40)
// Allocate 2 words for each string (1 for the length, 1 for the byte). Total 4 words.
mstore(0x40, add(resultB, 0x40))
// Zeroize the length slots.
mstore(resultA, 0)
mstore(resultB, 0)
// Store the lengths and bytes.
mstore(add(resultA, 0x1f), packed)
mstore(add(resultB, 0x1f), mload(add(add(resultA, 0x20), mload(resultA))))
// Right pad with zeroes.
mstore(add(add(resultA, 0x20), mload(resultA)), 0)
mstore(add(add(resultB, 0x20), mload(resultB)), 0)
}
}
/// @dev Directly returns `a` without copying.
function directReturn(string memory a) internal pure {
assembly {
// Assumes that the string does not start from the scratch space.
let retStart := sub(a, 0x20)
let retSize := add(mload(a), 0x40)
// Right pad with zeroes. Just in case the string is produced
// by a method that doesn't zero right pad.
mstore(add(retStart, retSize), 0)
// Store the return offset.
mstore(retStart, 0x20)
// End the transaction, returning the string.
return(retStart, retSize)
}
}
}
// File: https://github.com/Vectorized/solady/blob/main/src/auth/Ownable.sol
pragma solidity ^0.8.4;
/// @notice Simple single owner authorization mixin.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/auth/Ownable.sol)
///
/// @dev Note:
/// This implementation does NOT auto-initialize the owner to `msg.sender`.
/// You MUST call the `_initializeOwner` in the constructor / initializer.
///
/// While the ownable portion follows
/// [EIP-173](https://eips.ethereum.org/EIPS/eip-173) for compatibility,
/// the nomenclature for the 2-step ownership handover may be unique to this codebase.
abstract contract Ownable {
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* CUSTOM ERRORS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @dev The caller is not authorized to call the function.
error Unauthorized();
/// @dev The `newOwner` cannot be the zero address.
error NewOwnerIsZeroAddress();
/// @dev The `pendingOwner` does not have a valid handover request.
error NoHandoverRequest();
/// @dev Cannot double-initialize.
error AlreadyInitialized();
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* EVENTS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @dev The ownership is transferred from `oldOwner` to `newOwner`.
/// This event is intentionally kept the same as OpenZeppelin's Ownable to be
/// compatible with indexers and [EIP-173](https://eips.ethereum.org/EIPS/eip-173),
/// despite it not being as lightweight as a single argument event.
event OwnershipTransferred(address indexed oldOwner, address indexed newOwner);
/// @dev An ownership handover to `pendingOwner` has been requested.
event OwnershipHandoverRequested(address indexed pendingOwner);
/// @dev The ownership handover to `pendingOwner` has been canceled.
event OwnershipHandoverCanceled(address indexed pendingOwner);
/// @dev `keccak256(bytes("OwnershipTransferred(address,address)"))`.
uint256 private constant _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE =
0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0;
/// @dev `keccak256(bytes("OwnershipHandoverRequested(address)"))`.
uint256 private constant _OWNERSHIP_HANDOVER_REQUESTED_EVENT_SIGNATURE =
0xdbf36a107da19e49527a7176a1babf963b4b0ff8cde35ee35d6cd8f1f9ac7e1d;
/// @dev `keccak256(bytes("OwnershipHandoverCanceled(address)"))`.
uint256 private constant _OWNERSHIP_HANDOVER_CANCELED_EVENT_SIGNATURE =
0xfa7b8eab7da67f412cc9575ed43464468f9bfbae89d1675917346ca6d8fe3c92;
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* STORAGE */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @dev The owner slot is given by:
/// `bytes32(~uint256(uint32(bytes4(keccak256("_OWNER_SLOT_NOT")))))`.
/// It is intentionally chosen to be a high value
/// to avoid collision with lower slots.
/// The choice of manual storage layout is to enable compatibility
/// with both regular and upgradeable contracts.
bytes32 internal constant _OWNER_SLOT =
0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927;
/// The ownership handover slot of `newOwner` is given by:
/// ```
/// mstore(0x00, or(shl(96, user), _HANDOVER_SLOT_SEED))
/// let handoverSlot := keccak256(0x00, 0x20)
/// ```
/// It stores the expiry timestamp of the two-step ownership handover.
uint256 private constant _HANDOVER_SLOT_SEED = 0x389a75e1;
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* INTERNAL FUNCTIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @dev Override to return true to make `_initializeOwner` prevent double-initialization.
function _guardInitializeOwner() internal pure virtual returns (bool guard) {}
/// @dev Initializes the owner directly without authorization guard.
/// This function must be called upon initialization,
/// regardless of whether the contract is upgradeable or not.
/// This is to enable generalization to both regular and upgradeable contracts,
/// and to save gas in case the initial owner is not the caller.
/// For performance reasons, this function will not check if there
/// is an existing owner.
function _initializeOwner(address newOwner) internal virtual {
if (_guardInitializeOwner()) {
/// @solidity memory-safe-assembly
assembly {
let ownerSlot := _OWNER_SLOT
if sload(ownerSlot) {
mstore(0x00, 0x0dc149f0) // `AlreadyInitialized()`.
revert(0x1c, 0x04)
}
// Clean the upper 96 bits.
newOwner := shr(96, shl(96, newOwner))
// Store the new value.
sstore(ownerSlot, or(newOwner, shl(255, iszero(newOwner))))
// Emit the {OwnershipTransferred} event.
log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, 0, newOwner)
}
} else {
/// @solidity memory-safe-assembly
assembly {
// Clean the upper 96 bits.
newOwner := shr(96, shl(96, newOwner))
// Store the new value.
sstore(_OWNER_SLOT, newOwner)
// Emit the {OwnershipTransferred} event.
log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, 0, newOwner)
}
}
}
/// @dev Sets the owner directly without authorization guard.
function _setOwner(address newOwner) internal virtual {
if (_guardInitializeOwner()) {
/// @solidity memory-safe-assembly
assembly {
let ownerSlot := _OWNER_SLOT
// Clean the upper 96 bits.
newOwner := shr(96, shl(96, newOwner))
// Emit the {OwnershipTransferred} event.
log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, sload(ownerSlot), newOwner)
// Store the new value.
sstore(ownerSlot, or(newOwner, shl(255, iszero(newOwner))))
}
} else {
/// @solidity memory-safe-assembly
assembly {
let ownerSlot := _OWNER_SLOT
// Clean the upper 96 bits.
newOwner := shr(96, shl(96, newOwner))
// Emit the {OwnershipTransferred} event.
log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, sload(ownerSlot), newOwner)
// Store the new value.
sstore(ownerSlot, newOwner)
}
}
}
/// @dev Throws if the sender is not the owner.
function _checkOwner() internal view virtual {
/// @solidity memory-safe-assembly
assembly {
// If the caller is not the stored owner, revert.
if iszero(eq(caller(), sload(_OWNER_SLOT))) {
mstore(0x00, 0x82b42900) // `Unauthorized()`.
revert(0x1c, 0x04)
}
}
}
/// @dev Returns how long a two-step ownership handover is valid for in seconds.
/// Override to return a different value if needed.
/// Made internal to conserve bytecode. Wrap it in a public function if needed.
function _ownershipHandoverValidFor() internal view virtual returns (uint64) {
return 48 * 3600;
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* PUBLIC UPDATE FUNCTIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @dev Allows the owner to transfer the ownership to `newOwner`.
function transferOwnership(address newOwner) public payable virtual onlyOwner {
/// @solidity memory-safe-assembly
assembly {
if iszero(shl(96, newOwner)) {
mstore(0x00, 0x7448fbae) // `NewOwnerIsZeroAddress()`.
revert(0x1c, 0x04)
}
}
_setOwner(newOwner);
}
/// @dev Allows the owner to renounce their ownership.
function renounceOwnership() public payable virtual onlyOwner {
_setOwner(address(0));
}
/// @dev Request a two-step ownership handover to the caller.
/// The request will automatically expire in 48 hours (172800 seconds) by default.
function requestOwnershipHandover() public payable virtual {
unchecked {
uint256 expires = block.timestamp + _ownershipHandoverValidFor();
/// @solidity memory-safe-assembly
assembly {
// Compute and set the handover slot to `expires`.
mstore(0x0c, _HANDOVER_SLOT_SEED)
mstore(0x00, caller())
sstore(keccak256(0x0c, 0x20), expires)
// Emit the {OwnershipHandoverRequested} event.
log2(0, 0, _OWNERSHIP_HANDOVER_REQUESTED_EVENT_SIGNATURE, caller())
}
}
}
/// @dev Cancels the two-step ownership handover to the caller, if any.
function cancelOwnershipHandover() public payable virtual {
/// @solidity memory-safe-assembly
assembly {
// Compute and set the handover slot to 0.
mstore(0x0c, _HANDOVER_SLOT_SEED)
mstore(0x00, caller())
sstore(keccak256(0x0c, 0x20), 0)
// Emit the {OwnershipHandoverCanceled} event.
log2(0, 0, _OWNERSHIP_HANDOVER_CANCELED_EVENT_SIGNATURE, caller())
}
}
/// @dev Allows the owner to complete the two-step ownership handover to `pendingOwner`.
/// Reverts if there is no existing ownership handover requested by `pendingOwner`.
function completeOwnershipHandover(address pendingOwner) public payable virtual onlyOwner {
/// @solidity memory-safe-assembly
assembly {
// Compute and set the handover slot to 0.
mstore(0x0c, _HANDOVER_SLOT_SEED)
mstore(0x00, pendingOwner)
let handoverSlot := keccak256(0x0c, 0x20)
// If the handover does not exist, or has expired.
if gt(timestamp(), sload(handoverSlot)) {
mstore(0x00, 0x6f5e8818) // `NoHandoverRequest()`.
revert(0x1c, 0x04)
}
// Set the handover slot to 0.
sstore(handoverSlot, 0)
}
_setOwner(pendingOwner);
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* PUBLIC READ FUNCTIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @dev Returns the owner of the contract.
function owner() public view virtual returns (address result) {
/// @solidity memory-safe-assembly
assembly {
result := sload(_OWNER_SLOT)
}
}
/// @dev Returns the expiry timestamp for the two-step ownership handover to `pendingOwner`.
function ownershipHandoverExpiresAt(address pendingOwner)
public
view
virtual
returns (uint256 result)
{
/// @solidity memory-safe-assembly
assembly {
// Compute the handover slot.
mstore(0x0c, _HANDOVER_SLOT_SEED)
mstore(0x00, pendingOwner)
// Load the handover slot.
result := sload(keccak256(0x0c, 0x20))
}
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* MODIFIERS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @dev Marks a function as only callable by the owner.
modifier onlyOwner() virtual {
_checkOwner();
_;
}
}
// File: src/DN404Mirror.sol
pragma solidity ^0.8.4;
/// @title DN404Mirror
/// @notice DN404Mirror provides an interface for interacting with the
/// NFT tokens in a DN404 implementation.
///
/// @author vectorized.eth (@optimizoor)
/// @author Quit (@0xQuit)
/// @author Michael Amadi (@AmadiMichaels)
/// @author cygaar (@0xCygaar)
/// @author Thomas (@0xjustadev)
/// @author Harrison (@PopPunkOnChain)
///
/// @dev Note:
/// - The ERC721 data is stored in the base DN404 contract.
contract DN404Mirror {
/*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
/* EVENTS */
/*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/
/// @dev Emitted when token `id` is transferred from `from` to `to`.
event Transfer(address indexed from, address indexed to, uint256 indexed id);
/// @dev Emitted when `owner` enables `account` to manage the `id` token.
event Approval(address indexed owner, address indexed account, uint256 indexed id);
/// @dev Emitted when `owner` enables or disables `operator` to manage all of their tokens.
event ApprovalForAll(address indexed owner, address indexed operator, bool isApproved);
/// @dev `keccak256(bytes("Transfer(address,address,uint256)"))`.
uint256 private constant _TRANSFER_EVENT_SIGNATURE =
0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef;
/// @dev `keccak256(bytes("Approval(address,address,uint256)"))`.
uint256 private constant _APPROVAL_EVENT_SIGNATURE =
0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925;
/// @dev `keccak256(bytes("ApprovalForAll(address,address,bool)"))`.
uint256 private constant _APPROVAL_FOR_ALL_EVENT_SIGNATURE =
0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31;
/*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
/* CUSTOM ERRORS */
/*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/
/// @dev Thrown when a call for an NFT function did not originate
/// from the base DN404 contract.
error SenderNotBase();
/// @dev Thrown when a call for an NFT function did not originate from the deployer.
error SenderNotDeployer();
/// @dev Thrown when transferring an NFT to a contract address that
/// does not implement ERC721Receiver.
error TransferToNonERC721ReceiverImplementer();
/// @dev Thrown when linking to the DN404 base contract and the
/// DN404 supportsInterface check fails or the call reverts.
error CannotLink();
/// @dev Thrown when a linkMirrorContract call is received and the
/// NFT mirror contract has already been linked to a DN404 base contract.
error AlreadyLinked();
/// @dev Thrown when retrieving the base DN404 address when a link has not
/// been established.
error NotLinked();
/*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
/* STORAGE */
/*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/
/// @dev Struct contain the NFT mirror contract storage.
struct DN404NFTStorage {
address baseERC20;
address deployer;
}
/// @dev Returns a storage pointer for DN404NFTStorage.
function _getDN404NFTStorage() internal pure virtual returns (DN404NFTStorage storage $) {
/// @solidity memory-safe-assembly
assembly {
// `uint72(bytes9(keccak256("DN404_MIRROR_STORAGE")))`.
$.slot := 0x3602298b8c10b01230 // Truncate to 9 bytes to reduce bytecode size.
}
}
/*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
/* CONSTRUCTOR */
/*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/
constructor(address deployer) {
// For non-proxies, we will store the deployer so that only the deployer can
// link the base contract.
_getDN404NFTStorage().deployer = deployer;
}
/*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
/* ERC721 OPERATIONS */
/*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/
/// @dev Returns the token collection name from the base DN404 contract.
function name() public view virtual returns (string memory result) {
address base = baseERC20();
/// @solidity memory-safe-assembly
assembly {
result := mload(0x40)
mstore(0x00, 0x06fdde03) // `name()`.
if iszero(staticcall(gas(), base, 0x1c, 0x04, 0x00, 0x00)) {
returndatacopy(result, 0x00, returndatasize())
revert(result, returndatasize())
}
returndatacopy(0x00, 0x00, 0x20)
returndatacopy(result, mload(0x00), 0x20)
returndatacopy(add(result, 0x20), add(mload(0x00), 0x20), mload(result))
mstore(0x40, add(add(result, 0x20), mload(result)))
}
}
/// @dev Returns the token collection symbol from the base DN404 contract.
function symbol() public view virtual returns (string memory result) {
address base = baseERC20();
/// @solidity memory-safe-assembly
assembly {
result := mload(0x40)
mstore(0x00, 0x95d89b41) // `symbol()`.
if iszero(staticcall(gas(), base, 0x1c, 0x04, 0x00, 0x00)) {
returndatacopy(result, 0x00, returndatasize())
revert(result, returndatasize())
}
returndatacopy(0x00, 0x00, 0x20)
returndatacopy(result, mload(0x00), 0x20)
returndatacopy(add(result, 0x20), add(mload(0x00), 0x20), mload(result))
mstore(0x40, add(add(result, 0x20), mload(result)))
}
}
/// @dev Returns the Uniform Resource Identifier (URI) for token `id` from
/// the base DN404 contract.
function tokenURI(uint256 id) public view virtual returns (string memory result) {
address base = baseERC20();
/// @solidity memory-safe-assembly
assembly {
result := mload(0x40)
mstore(0x20, id)
mstore(0x00, 0xc87b56dd) // `tokenURI()`.
if iszero(staticcall(gas(), base, 0x1c, 0x24, 0x00, 0x00)) {
returndatacopy(result, 0x00, returndatasize())
revert(result, returndatasize())
}
returndatacopy(0x00, 0x00, 0x20)
returndatacopy(result, mload(0x00), 0x20)
returndatacopy(add(result, 0x20), add(mload(0x00), 0x20), mload(result))
mstore(0x40, add(add(result, 0x20), mload(result)))
}
}
/// @dev Returns the total NFT supply from the base DN404 contract.
function totalSupply() public view virtual returns (uint256 result) {
address base = baseERC20();
/// @solidity memory-safe-assembly
assembly {
mstore(0x00, 0xe2c79281) // `totalNFTSupply()`.
if iszero(
and(gt(returndatasize(), 0x1f), staticcall(gas(), base, 0x1c, 0x04, 0x00, 0x20))
) {
returndatacopy(mload(0x40), 0x00, returndatasize())
revert(mload(0x40), returndatasize())
}
result := mload(0x00)
}
}
/// @dev Returns the number of NFT tokens owned by `owner` from the base DN404 contract.
///
/// Requirements:
/// - `owner` must not be the zero address.
function balanceOf(address owner) public view virtual returns (uint256 result) {
address base = baseERC20();
/// @solidity memory-safe-assembly
assembly {
mstore(0x20, shr(96, shl(96, owner)))
mstore(0x00, 0xf5b100ea) // `balanceOfNFT(address)`.
if iszero(
and(gt(returndatasize(), 0x1f), staticcall(gas(), base, 0x1c, 0x24, 0x00, 0x20))
) {
returndatacopy(mload(0x40), 0x00, returndatasize())
revert(mload(0x40), returndatasize())
}
result := mload(0x00)
}
}
/// @dev Returns the owner of token `id` from the base DN404 contract.
///
/// Requirements:
/// - Token `id` must exist.
function ownerOf(uint256 id) public view virtual returns (address result) {
address base = baseERC20();
/// @solidity memory-safe-assembly
assembly {
mstore(0x00, 0x6352211e) // `ownerOf(uint256)`.
mstore(0x20, id)
if iszero(
and(gt(returndatasize(), 0x1f), staticcall(gas(), base, 0x1c, 0x24, 0x00, 0x20))
) {
returndatacopy(mload(0x40), 0x00, returndatasize())
revert(mload(0x40), returndatasize())
}
result := shr(96, mload(0x0c))
}
}
/// @dev Sets `spender` as the approved account to manage token `id` in
/// the base DN404 contract.
///
/// Requirements:
/// - Token `id` must exist.
/// - The caller must be the owner of the token,
/// or an approved operator for the token owner.
///
/// Emits an {Approval} event.
function approve(address spender, uint256 id) public virtual {
address base = baseERC20();
/// @solidity memory-safe-assembly
assembly {
spender := shr(96, shl(96, spender))
let m := mload(0x40)
mstore(0x00, 0xd10b6e0c) // `approveNFT(address,uint256,address)`.
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) // Restore the free memory pointer.
mstore(0x60, 0) // Restore the zero pointer.
// Emit the {Approval} event.
log4(codesize(), 0x00, _APPROVAL_EVENT_SIGNATURE, shr(96, mload(0x0c)), spender, id)
}
}
/// @dev Returns the account approved to manage token `id` from
/// the base DN404 contract.
///
/// Requirements:
/// - Token `id` must exist.
function getApproved(uint256 id) public view virtual returns (address result) {
address base = baseERC20();
/// @solidity memory-safe-assembly
assembly {
mstore(0x00, 0x081812fc) // `getApproved(uint256)`.
mstore(0x20, id)
if iszero(
and(gt(returndatasize(), 0x1f), staticcall(gas(), base, 0x1c, 0x24, 0x00, 0x20))
) {
returndatacopy(mload(0x40), 0x00, returndatasize())
revert(mload(0x40), returndatasize())
}
result := shr(96, mload(0x0c))
}
}
/// @dev Sets whether `operator` is approved to manage the tokens of the caller in
/// the base DN404 contract.
///
/// Emits an {ApprovalForAll} event.
function setApprovalForAll(address operator, bool approved) public virtual {
address base = baseERC20();
/// @solidity memory-safe-assembly
assembly {
operator := shr(96, shl(96, operator))
let m := mload(0x40)
mstore(0x00, 0x813500fc) // `setApprovalForAll(address,bool,address)`.
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())
}
// Emit the {ApprovalForAll} event.
log3(0x40, 0x20, _APPROVAL_FOR_ALL_EVENT_SIGNATURE, caller(), operator)
mstore(0x40, m) // Restore the free memory pointer.
mstore(0x60, 0) // Restore the zero pointer.
}
}
/// @dev Returns whether `operator` is approved to manage the tokens of `owner` from
/// the base DN404 contract.
function isApprovedForAll(address owner, address operator)
public
view
virtual
returns (bool result)
{
address base = baseERC20();
/// @solidity memory-safe-assembly
assembly {
let m := mload(0x40)
mstore(0x40, operator)
mstore(0x2c, shl(96, owner))
mstore(0x0c, 0xe985e9c5000000000000000000000000) // `isApprovedForAll(address,address)`.
if iszero(
and(gt(returndatasize(), 0x1f), staticcall(gas(), base, 0x1c, 0x44, 0x00, 0x20))
) {
returndatacopy(m, 0x00, returndatasize())
revert(m, returndatasize())
}
mstore(0x40, m) // Restore the free memory pointer.
result := iszero(iszero(mload(0x00)))
}
}
/// @dev Transfers token `id` from `from` to `to`.
///
/// Requirements:
///
/// - Token `id` must exist.
/// - `from` must be the owner of the token.
/// - `to` cannot be the zero address.
/// - The caller must be the owner of the token, or be approved to manage the token.
///
/// Emits a {Transfer} event.
function transferFrom(address from, address to, uint256 id) public virtual {
address base = baseERC20();
/// @solidity memory-safe-assembly
assembly {
from := shr(96, shl(96, from))
to := shr(96, shl(96, to))
let m := mload(0x40)
mstore(m, 0xe5eb36c8) // `transferFromNFT(address,address,uint256,address)`.
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())
}
// Emit the {Transfer} event.
log4(codesize(), 0x00, _TRANSFER_EVENT_SIGNATURE, from, to, id)
}
}
/// @dev Equivalent to `safeTransferFrom(from, to, id, "")`.
function safeTransferFrom(address from, address to, uint256 id) public payable virtual {
transferFrom(from, to, id);
if (_hasCode(to)) _checkOnERC721Received(from, to, id, "");
}
/// @dev Transfers token `id` from `from` to `to`.
///
/// Requirements:
///
/// - Token `id` must exist.
/// - `from` must be the owner of the token.
/// - `to` cannot be the zero address.
/// - The caller must be the owner of the token, or be approved to manage the token.
/// - If `to` refers to a smart contract, it must implement
/// {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
///
/// Emits a {Transfer} event.
function safeTransferFrom(address from, address to, uint256 id, bytes calldata data)
public
virtual
{
transferFrom(from, to, id);
if (_hasCode(to)) _checkOnERC721Received(from, to, id, data);
}
/// @dev Returns true if this contract implements the interface defined by `interfaceId`.
/// See: https://eips.ethereum.org/EIPS/eip-165
/// This function call must use less than 30000 gas.
function supportsInterface(bytes4 interfaceId) public view virtual returns (bool result) {
/// @solidity memory-safe-assembly
assembly {
let s := shr(224, interfaceId)
// ERC165: 0x01ffc9a7, ERC721: 0x80ac58cd, ERC721Metadata: 0x5b5e139f.
result := or(or(eq(s, 0x01ffc9a7), eq(s, 0x80ac58cd)), eq(s, 0x5b5e139f))
}
}
/*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
/* MIRROR OPERATIONS */
/*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/
/// @dev Returns the address of the base DN404 contract.
function baseERC20() public view virtual returns (address base) {
base = _getDN404NFTStorage().baseERC20;
if (base == address(0)) revert NotLinked();
}
/// @dev Fallback modifier to execute calls from the base DN404 contract.
modifier dn404NFTFallback() virtual {
DN404NFTStorage storage $ = _getDN404NFTStorage();
uint256 fnSelector = _calldataload(0x00) >> 224;
// `logTransfer(uint256[])`.
if (fnSelector == 0x263c69d6) {
if (msg.sender != $.baseERC20) revert SenderNotBase();
/// @solidity memory-safe-assembly
assembly {
// When returndatacopy copies 1 or more out-of-bounds bytes, it reverts.
returndatacopy(0x00, returndatasize(), lt(calldatasize(), 0x20))
let o := add(0x24, calldataload(0x04)) // Packed logs offset.
returndatacopy(0x00, returndatasize(), lt(calldatasize(), o))
let end := add(o, shl(5, calldataload(sub(o, 0x20))))
returndatacopy(0x00, returndatasize(), lt(calldatasize(), end))
for {} iszero(eq(o, end)) { o := add(0x20, o) } {
let d := calldataload(o) // Entry in the packed logs.
let a := shr(96, d) // The address.
let b := and(1, d) // Whether it is a burn.
log4(
codesize(),
0x00,
_TRANSFER_EVENT_SIGNATURE,
mul(a, b),
mul(a, iszero(b)),
shr(168, shl(160, d))
)
}
mstore(0x00, 0x01)
return(0x00, 0x20)
}
}
// `linkMirrorContract(address)`.
if (fnSelector == 0x0f4599e5) {
if ($.deployer != address(0)) {
if (address(uint160(_calldataload(0x04))) != $.deployer) {
revert SenderNotDeployer();
}
}
if ($.baseERC20 != address(0)) revert AlreadyLinked();
$.baseERC20 = msg.sender;
/// @solidity memory-safe-assembly
assembly {
mstore(0x00, 0x01)
return(0x00, 0x20)
}
}
_;
}
/// @dev Fallback function for calls from base DN404 contract.
fallback() external payable virtual dn404NFTFallback {}
receive() external payable virtual {}
/*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
/* PRIVATE HELPERS */
/*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/
/// @dev Returns the calldata value at `offset`.
function _calldataload(uint256 offset) private pure returns (uint256 value) {
/// @solidity memory-safe-assembly
assembly {
value := calldataload(offset)
}
}
/// @dev Returns if `a` has bytecode of non-zero length.
function _hasCode(address a) private view returns (bool result) {
/// @solidity memory-safe-assembly
assembly {
result := extcodesize(a) // Can handle dirty upper bits.
}
}
/// @dev Perform a call to invoke {IERC721Receiver-onERC721Received} on `to`.
/// Reverts if the target does not support the function correctly.
function _checkOnERC721Received(address from, address to, uint256 id, bytes memory data)
private
{
/// @solidity memory-safe-assembly
assembly {
// Prepare the calldata.
let m := mload(0x40)
let onERC721ReceivedSelector := 0x150b7a02
mstore(m, onERC721ReceivedSelector)
mstore(add(m, 0x20), caller()) // The `operator`, which is always `msg.sender`.
mstore(add(m, 0x40), shr(96, shl(96, from)))
mstore(add(m, 0x60), id)
mstore(add(m, 0x80), 0x80)
let n := mload(data)
mstore(add(m, 0xa0), n)
if n { pop(staticcall(gas(), 4, add(data, 0x20), n, add(m, 0xc0), n)) }
// Revert if the call reverts.
if iszero(call(gas(), to, 0, add(m, 0x1c), add(n, 0xa4), m, 0x20)) {
if returndatasize() {
// Bubble up the revert if the call reverts.
returndatacopy(m, 0x00, returndatasize())
revert(m, returndatasize())
}
}
// Load the returndata and compare it.
if iszero(eq(mload(m), shl(224, onERC721ReceivedSelector))) {
mstore(0x00, 0xd1a57ed6) // `TransferToNonERC721ReceiverImplementer()`.
revert(0x1c, 0x04)
}
}
}
}
// File: src/DN404.sol
pragma solidity ^0.8.4;
/// @title DN404
/// @notice DN404 is a hybrid ERC20 and ERC721 implementation that mints
/// and burns NFTs based on an account's ERC20 token balance.
///
/// @author vectorized.eth (@optimizoor)
/// @author Quit (@0xQuit)
/// @author Michael Amadi (@AmadiMichaels)
/// @author cygaar (@0xCygaar)
/// @author Thomas (@0xjustadev)
/// @author Harrison (@PopPunkOnChain)
///
/// @dev Note:
/// - The ERC721 data is stored in this base DN404 contract, however a
/// DN404Mirror contract ***MUST*** be deployed and linked during
/// initialization.
abstract contract DN404 {
/*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
/* EVENTS */
/*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/
/// @dev Emitted when `amount` tokens is transferred from `from` to `to`.
event Transfer(address indexed from, address indexed to, uint256 amount);
/// @dev Emitted when `amount` tokens is approved by `owner` to be used by `spender`.
event Approval(address indexed owner, address indexed spender, uint256 amount);
/// @dev Emitted when `target` sets their skipNFT flag to `status`.
event SkipNFTSet(address indexed target, bool status);
/*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
/* CUSTOM ERRORS */
/*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/
/// @dev Thrown when attempting to double-initialize the contract.
error DNAlreadyInitialized();
/// @dev Thrown when attempting to transfer or burn more tokens than sender's balance.
error InsufficientBalance();
/// @dev Thrown when a spender attempts to transfer tokens with an insufficient allowance.
error InsufficientAllowance();
/// @dev Thrown when minting an amount of tokens that would overflow the max tokens.
error TotalSupplyOverflow();
/// @dev Thrown when the caller for a fallback NFT function is not the mirror contract.
error SenderNotMirror();
/// @dev Thrown when attempting to transfer tokens to the zero address.
error TransferToZeroAddress();
/// @dev Thrown when the mirror address provided for initialization is the zero address.
error MirrorAddressIsZero();
/// @dev Thrown when the link call to the mirror contract reverts.
error LinkMirrorContractFailed();
/// @dev Thrown when setting an NFT token approval
/// and the caller is not the owner or an approved operator.
error ApprovalCallerNotOwnerNorApproved();
/// @dev Thrown when transferring an NFT
/// and the caller is not the owner or an approved operator.
error TransferCallerNotOwnerNorApproved();
/// @dev Thrown when transferring an NFT and the from address is not the current owner.
error TransferFromIncorrectOwner();
/// @dev Thrown when checking the owner or approved address for an non-existent NFT.
error TokenDoesNotExist();
/*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
/* CONSTANTS */
/*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/
/// @dev Amount of token balance that is equal to one NFT.
uint256 internal constant _WAD = 10 ** 18;
/// @dev The maximum token ID allowed for an NFT.
uint256 internal constant _MAX_TOKEN_ID = 0xffffffff;
/// @dev The maximum possible token supply.
uint256 internal constant _MAX_SUPPLY = 10 ** 18 * 0xffffffff - 1;
/// @dev The flag to denote that the address data is initialized.
uint8 internal constant _ADDRESS_DATA_INITIALIZED_FLAG = 1 << 0;
/// @dev The flag to denote that the address should skip NFTs.
uint8 internal constant _ADDRESS_DATA_SKIP_NFT_FLAG = 1 << 1;
/*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
/* STORAGE */
/*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/
/// @dev Struct containing an address's token data and settings.
struct AddressData {
// Auxiliary data.
uint88 aux;
// Flags for `initialized` and `skipNFT`.
uint8 flags;
// The alias for the address. Zero means absence of an alias.
uint32 addressAlias;
// The number of NFT tokens.
uint32 ownedLength;
// The token balance in wei.
uint96 balance;
}
/// @dev A uint32 map in storage.
struct Uint32Map {
mapping(uint256 => uint256) map;
}
/// @dev Struct containing the base token contract storage.
struct DN404Storage {
// Current number of address aliases assigned.
uint32 numAliases;
// Next token ID to assign for an NFT mint.
uint32 nextTokenId;
// Total supply of minted NFTs.
uint32 totalNFTSupply;
// Total supply of tokens.
uint96 totalSupply;
// Address of the NFT mirror contract.
address mirrorERC721;
// Mapping of a user alias number to their address.
mapping(uint32 => address) aliasToAddress;
// Mapping of user operator approvals for NFTs.
mapping(address => mapping(address => bool)) operatorApprovals;
// Mapping of NFT token approvals to approved operators.
mapping(uint256 => address) tokenApprovals;
// Mapping of user allowances for token spenders.
mapping(address => mapping(address => uint256)) allowance;
// Mapping of NFT token IDs owned by an address.
mapping(address => Uint32Map) owned;
// Even indices: owner aliases. Odd indices: owned indices.
Uint32Map oo;
// Mapping of user account AddressData
mapping(address => AddressData) addressData;
}
/// @dev Returns a storage pointer for DN404Storage.
function _getDN404Storage() internal pure virtual returns (DN404Storage storage $) {
/// @solidity memory-safe-assembly
assembly {
// `uint72(bytes9(keccak256("DN404_STORAGE")))`.
$.slot := 0xa20d6e21d0e5255308 // Truncate to 9 bytes to reduce bytecode size.
}
}
/*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
/* INITIALIZER */
/*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/
/// @dev Initializes the DN404 contract with an
/// `initialTokenSupply`, `initialTokenOwner` and `mirror` NFT contract address.
function _initializeDN404(
uint256 initialTokenSupply,
address initialSupplyOwner,
address mirror
) internal virtual {
DN404Storage storage $ = _getDN404Storage();
if ($.nextTokenId != 0) revert DNAlreadyInitialized();
if (mirror == address(0)) revert MirrorAddressIsZero();
_linkMirrorContract(mirror);
$.nextTokenId = 1;
$.mirrorERC721 = mirror;
if (initialTokenSupply > 0) {
if (initialSupplyOwner == address(0)) revert TransferToZeroAddress();
if (initialTokenSupply > _MAX_SUPPLY) revert TotalSupplyOverflow();
$.totalSupply = uint96(initialTokenSupply);
AddressData storage initialOwnerAddressData = _addressData(initialSupplyOwner);
initialOwnerAddressData.balance = uint96(initialTokenSupply);
emit Transfer(address(0), initialSupplyOwner, initialTokenSupply);
_setSkipNFT(initialSupplyOwner, true);
}
}
/*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
/* METADATA FUNCTIONS TO OVERRIDE */
/*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/
/// @dev Returns the name of the token.
function name() public view virtual returns (string memory);
/// @dev Returns the symbol of the token.
function symbol() public view virtual returns (string memory);
/// @dev Returns the Uniform Resource Identifier (URI) for token `id`.
function tokenURI(uint256 id) public view virtual returns (string memory);
/*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
/* ERC20 OPERATIONS */
/*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/
/// @dev Returns the decimals places of the token. Always 18.
function decimals() public pure returns (uint8) {
return 18;
}
/// @dev Returns the amount of tokens in existence.
function totalSupply() public view virtual returns (uint256) {
return uint256(_getDN404Storage().totalSupply);
}
/// @dev Returns the amount of tokens owned by `owner`.
function balanceOf(address owner) public view virtual returns (uint256) {
return _getDN404Storage().addressData[owner].balance;
}
/// @dev Returns the amount of tokens that `spender` can spend on behalf of `owner`.
function allowance(address owner, address spender) public view returns (uint256) {
return _getDN404Storage().allowance[owner][spender];
}
/// @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
///
/// Emits a {Approval} event.
function approve(address spender, uint256 amount) public virtual returns (bool) {
DN404Storage storage $ = _getDN404Storage();
$.allowance[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
/// @dev Transfer `amount` tokens from the caller to `to`.
///
/// Will burn sender NFTs if balance after transfer is less than
/// the amount required to support the current NFT balance.
///
/// Will mint NFTs to `to` if the recipient's new balance supports
/// additional NFTs ***AND*** the `to` address's skipNFT flag is
/// set to false.
///
/// Requirements:
/// - `from` must at least have `amount`.
///
/// Emits a {Transfer} event.
function transfer(address to, uint256 amount) public virtual returns (bool) {
_transfer(msg.sender, to, amount);
return true;
}
/// @dev Transfers `amount` tokens from `from` to `to`.
///
/// Note: Does not update the allowance if it is the maximum uint256 value.
///
/// Will burn sender NFTs if balance after transfer is less than
/// the amount required to support the current NFT balance.
///
/// Will mint NFTs to `to` if the recipient's new balance supports
/// additional NFTs ***AND*** the `to` address's skipNFT flag is
/// set to false.
///
/// Requirements:
/// - `from` must at least have `amount`.
/// - The caller must have at least `amount` of allowance to transfer the tokens of `from`.
///
/// Emits a {Transfer} event.
function transferFrom(address from, address to, uint256 amount) public virtual returns (bool) {
DN404Storage storage $ = _getDN404Storage();
uint256 allowed = $.allowance[from][msg.sender];
if (allowed != type(uint256).max) {
if (amount > allowed) revert InsufficientAllowance();
unchecked {
$.allowance[from][msg.sender] = allowed - amount;
}
}
_transfer(from, to, amount);
return true;
}
/*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
/* INTERNAL MINT FUNCTIONS */
/*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/
/// @dev Mints `amount` tokens to `to`, increasing the total supply.
///
/// Will mint NFTs to `to` if the recipient's new balance supports
/// additional NFTs ***AND*** the `to` address's skipNFT flag is
/// set to false.
///
/// Emits a {Transfer} event.
function _mint(address to, uint256 amount) internal virtual {
if (to == address(0)) revert TransferToZeroAddress();
DN404Storage storage $ = _getDN404Storage();
AddressData storage toAddressData = _addressData(to);
unchecked {
uint256 currentTokenSupply = uint256($.totalSupply) + amount;
if (amount > _MAX_SUPPLY || currentTokenSupply > _MAX_SUPPLY) {
revert TotalSupplyOverflow();
}
$.totalSupply = uint96(currentTokenSupply);
uint256 toBalance = toAddressData.balance + amount;
toAddressData.balance = uint96(toBalance);
if (toAddressData.flags & _ADDRESS_DATA_SKIP_NFT_FLAG == 0) {
Uint32Map storage toOwned = $.owned[to];
uint256 toIndex = toAddressData.ownedLength;
uint256 toEnd = toBalance / _WAD;
_PackedLogs memory packedLogs = _packedLogsMalloc(_zeroFloorSub(toEnd, toIndex));
if (packedLogs.logs.length != 0) {
uint256 maxNFTId = $.totalSupply / _WAD;
uint32 toAlias = _registerAndResolveAlias(toAddressData, to);
uint256 id = $.nextTokenId;
$.totalNFTSupply += uint32(packedLogs.logs.length);
toAddressData.ownedLength = uint32(toEnd);
// Mint loop.
do {
while (_get($.oo, _ownershipIndex(id)) != 0) {
if (++id > maxNFTId) id = 1;
}
_set(toOwned, toIndex, uint32(id));
_setOwnerAliasAndOwnedIndex($.oo, id, toAlias, uint32(toIndex++));
_packedLogsAppend(packedLogs, to, id, 0);
if (++id > maxNFTId) id = 1;
} while (toIndex != toEnd);
$.nextTokenId = uint32(id);
_packedLogsSend(packedLogs, $.mirrorERC721);
}
}
}
emit Transfer(address(0), to, amount);
}
/*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
/* INTERNAL BURN FUNCTIONS */
/*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/
/// @dev Burns `amount` tokens from `from`, reducing the total supply.
///
/// Will burn sender NFTs if balance after transfer is less than
/// the amount required to support the current NFT balance.
///
/// Emits a {Transfer} event.
function _burn(address from, uint256 amount) internal virtual {
DN404Storage storage $ = _getDN404Storage();
AddressData storage fromAddressData = _addressData(from);
uint256 fromBalance = fromAddressData.balance;
if (amount > fromBalance) revert InsufficientBalance();
uint256 currentTokenSupply = $.totalSupply;
unchecked {
fromBalance -= amount;
fromAddressData.balance = uint96(fromBalance);
currentTokenSupply -= amount;
$.totalSupply = uint96(currentTokenSupply);
Uint32Map storage fromOwned = $.owned[from];
uint256 fromIndex = fromAddressData.ownedLength;
uint256 nftAmountToBurn = _zeroFloorSub(fromIndex, fromBalance / _WAD);
if (nftAmountToBurn != 0) {
$.totalNFTSupply -= uint32(nftAmountToBurn);
_PackedLogs memory packedLogs = _packedLogsMalloc(nftAmountToBurn);
uint256 fromEnd = fromIndex - nftAmountToBurn;
// Burn loop.
do {
uint256 id = _get(fromOwned, --fromIndex);
_setOwnerAliasAndOwnedIndex($.oo, id, 0, 0);
delete $.tokenApprovals[id];
_packedLogsAppend(packedLogs, from, id, 1);
} while (fromIndex != fromEnd);
fromAddressData.ownedLength = uint32(fromIndex);
_packedLogsSend(packedLogs, $.mirrorERC721);
}
}
emit Transfer(from, address(0), amount);
}
/*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
/* INTERNAL TRANSFER FUNCTIONS */
/*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/
/// @dev Moves `amount` of tokens from `from` to `to`.
///
/// Will burn sender NFTs if balance after transfer is less than
/// the amount required to support the current NFT balance.
///
/// Will mint NFTs to `to` if the recipient's new balance supports
/// additional NFTs ***AND*** the `to` address's skipNFT flag is
/// set to false.
///
/// Emits a {Transfer} event.
function _transfer(address from, address to, uint256 amount) internal virtual {
if (to == address(0)) revert TransferToZeroAddress();
DN404Storage storage $ = _getDN404Storage();
AddressData storage fromAddressData = _addressData(from);
AddressData storage toAddressData = _addressData(to);
_TransferTemps memory t;
t.fromOwnedLength = fromAddressData.ownedLength;
t.toOwnedLength = toAddressData.ownedLength;
t.fromBalance = fromAddressData.balance;
if (amount > t.fromBalance) revert InsufficientBalance();
unchecked {
t.fromBalance -= amount;
fromAddressData.balance = uint96(t.fromBalance);
toAddressData.balance = uint96(t.toBalance = toAddressData.balance + amount);
t.nftAmountToBurn = _zeroFloorSub(t.fromOwnedLength, t.fromBalance / _WAD);
if (toAddressData.flags & _ADDRESS_DATA_SKIP_NFT_FLAG == 0) {
if (from == to) t.toOwnedLength = t.fromOwnedLength - t.nftAmountToBurn;
t.nftAmountToMint = _zeroFloorSub(t.toBalance / _WAD, t.toOwnedLength);
}
_PackedLogs memory packedLogs = _packedLogsMalloc(t.nftAmountToBurn + t.nftAmountToMint);
if (t.nftAmountToBurn != 0) {
Uint32Map storage fromOwned = $.owned[from];
uint256 fromIndex = t.fromOwnedLength;
uint256 fromEnd = fromIndex - t.nftAmountToBurn;
$.totalNFTSupply -= uint32(t.nftAmountToBurn);
fromAddressData.ownedLength = uint32(fromEnd);
// Burn loop.
do {
uint256 id = _get(fromOwned, --fromIndex);
_setOwnerAliasAndOwnedIndex($.oo, id, 0, 0);
delete $.tokenApprovals[id];
_packedLogsAppend(packedLogs, from, id, 1);
} while (fromIndex != fromEnd);
}
if (t.nftAmountToMint != 0) {
Uint32Map storage toOwned = $.owned[to];
uint256 toIndex = t.toOwnedLength;
uint256 toEnd = toIndex + t.nftAmountToMint;
uint32 toAlias = _registerAndResolveAlias(toAddressData, to);
uint256 maxNFTId = $.totalSupply / _WAD;
uint256 id = $.nextTokenId;
$.totalNFTSupply += uint32(t.nftAmountToMint);
toAddressData.ownedLength = uint32(toEnd);
// Mint loop.
do {
while (_get($.oo, _ownershipIndex(id)) != 0) {
if (++id > maxNFTId) id = 1;
}
_set(toOwned, toIndex, uint32(id));
_setOwnerAliasAndOwnedIndex($.oo, id, toAlias, uint32(toIndex++));
_packedLogsAppend(packedLogs, to, id, 0);
if (++id > maxNFTId) id = 1;
} while (toIndex != toEnd);
$.nextTokenId = uint32(id);
}
if (packedLogs.logs.length != 0) {
_packedLogsSend(packedLogs, $.mirrorERC721);
}
}
emit Transfer(from, to, amount);
}
/// @dev Transfers token `id` from `from` to `to`.
///
/// Requirements:
///
/// - Call must originate from the mirror contract.
/// - Token `id` must exist.
/// - `from` must be the owner of the token.
/// - `to` cannot be the zero address.
/// `msgSender` must be the owner of the token, or be approved to manage the token.
///
/// Emits a {Transfer} event.
function _transferFromNFT(address from, address to, uint256 id, address msgSender)
internal
virtual
{
DN404Storage storage $ = _getDN404Storage();
if (to == address(0)) revert TransferToZeroAddress();
address owner = $.aliasToAddress[_get($.oo, _ownershipIndex(id))];
if (from != owner) revert TransferFromIncorrectOwner();
if (msgSender != from) {
if (!$.operatorApprovals[from][msgSender]) {
if (msgSender != $.tokenApprovals[id]) {
revert TransferCallerNotOwnerNorApproved();
}
}
}
AddressData storage fromAddressData = _addressData(from);
AddressData storage toAddressData = _addressData(to);
fromAddressData.balance -= uint96(_WAD);
unchecked {
toAddressData.balance += uint96(_WAD);
_set($.oo, _ownershipIndex(id), _registerAndResolveAlias(toAddressData, to));
delete $.tokenApprovals[id];
uint256 updatedId = _get($.owned[from], --fromAddressData.ownedLength);
_set($.owned[from], _get($.oo, _ownedIndex(id)), uint32(updatedId));
uint256 n = toAddressData.ownedLength++;
_set($.oo, _ownedIndex(updatedId), _get($.oo, _ownedIndex(id)));
_set($.owned[to], n, uint32(id));
_set($.oo, _ownedIndex(id), uint32(n));
}
emit Transfer(from, to, _WAD);
}
/*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
/* DATA HITCHHIKING FUNCTIONS */
/*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/
/// @dev Returns the auxiliary data for `owner`.
/// Minting, transferring, burning the tokens of `owner` will not change the auxiliary data.
/// Auxiliary data can be set for any address, even if it does not have any tokens.
function _getAux(address owner) internal view virtual returns (uint88) {
return _getDN404Storage().addressData[owner].aux;
}
/// @dev Set the auxiliary data for `owner` to `value`.
/// Minting, transferring, burning the tokens of `owner` will not change the auxiliary data.
/// Auxiliary data can be set for any address, even if it does not have any tokens.
function _setAux(address owner, uint88 value) internal virtual {
_getDN404Storage().addressData[owner].aux = value;
}
/*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
/* SKIP NFT FUNCTIONS */
/*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/
/// @dev Returns true if account `a` will skip NFT minting on token mints and transfers.
/// Returns false if account `a` will mint NFTs on token mints and transfers.
function getSkipNFT(address a) public view virtual returns (bool) {
AddressData storage d = _getDN404Storage().addressData[a];
if (d.flags & _ADDRESS_DATA_INITIALIZED_FLAG == 0) return _hasCode(a);
return d.flags & _ADDRESS_DATA_SKIP_NFT_FLAG != 0;
}
/// @dev Sets the caller's skipNFT flag to `skipNFT`
///
/// Emits a {SkipNFTSet} event.
function setSkipNFT(bool skipNFT) public virtual {
_setSkipNFT(msg.sender, skipNFT);
}
/// @dev Internal function to set account `a` skipNFT flag to `state`
///
/// Initializes account `a` AddressData if it is not currently initialized.
///
/// Emits a {SkipNFTSet} event.
function _setSkipNFT(address a, bool state) internal virtual {
AddressData storage d = _addressData(a);
if ((d.flags & _ADDRESS_DATA_SKIP_NFT_FLAG != 0) != state) {
d.flags ^= _ADDRESS_DATA_SKIP_NFT_FLAG;
}
emit SkipNFTSet(a, state);
}
/// @dev Returns a storage data pointer for account `a` AddressData
///
/// Initializes account `a` AddressData if it is not currently initialized.
function _addressData(address a) internal virtual returns (AddressData storage d) {
DN404Storage storage $ = _getDN404Storage();
d = $.addressData[a];
if (d.flags & _ADDRESS_DATA_INITIALIZED_FLAG == 0) {
uint8 flags = _ADDRESS_DATA_INITIALIZED_FLAG;
if (_hasCode(a)) flags |= _ADDRESS_DATA_SKIP_NFT_FLAG;
d.flags = flags;
}
}
/// @dev Returns the `addressAlias` of account `to`.
///
/// Assigns and registers the next alias if `to` alias was not previously registered.
function _registerAndResolveAlias(AddressData storage toAddressData, address to)
internal
virtual
returns (uint32 addressAlias)
{
DN404Storage storage $ = _getDN404Storage();
addressAlias = toAddressData.addressAlias;
if (addressAlias == 0) {
addressAlias = ++$.numAliases;
toAddressData.addressAlias = addressAlias;
$.aliasToAddress[addressAlias] = to;
}
}
/*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
/* MIRROR OPERATIONS */
/*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/
/// @dev Returns the address of the mirror NFT contract.
function mirrorERC721() public view virtual returns (address) {
return _getDN404Storage().mirrorERC721;
}
/// @dev Returns the total NFT supply.
function _totalNFTSupply() internal view virtual returns (uint256) {
return _getDN404Storage().totalNFTSupply;
}
/// @dev Returns `owner` NFT balance.
function _balanceOfNFT(address owner) internal view virtual returns (uint256) {
return _getDN404Storage().addressData[owner].ownedLength;
}
/// @dev Returns the owner of token `id`.
/// Returns the zero address instead of reverting if the token does not exist.
function _ownerAt(uint256 id) internal view virtual returns (address) {
DN404Storage storage $ = _getDN404Storage();
return $.aliasToAddress[_get($.oo, _ownershipIndex(id))];
}
/// @dev Returns the owner of token `id`.
///
/// Requirements:
/// - Token `id` must exist.
function _ownerOf(uint256 id) internal view virtual returns (address) {
if (!_exists(id)) revert TokenDoesNotExist();
return _ownerAt(id);
}
/// @dev Returns if token `id` exists.
function _exists(uint256 id) internal view virtual returns (bool) {
return _ownerAt(id) != address(0);
}
/// @dev Returns the account approved to manage token `id`.
///
/// Requirements:
/// - Token `id` must exist.
function _getApproved(uint256 id) internal view virtual returns (address) {
if (!_exists(id)) revert TokenDoesNotExist();
return _getDN404Storage().tokenApprovals[id];
}
/// @dev Sets `spender` as the approved account to manage token `id`, using `msgSender`.
///
/// Requirements:
/// - `msgSender` must be the owner or an approved operator for the token owner.
function _approveNFT(address spender, uint256 id, address msgSender)
internal
virtual
returns (address)
{
DN404Storage storage $ = _getDN404Storage();
address owner = $.aliasToAddress[_get($.oo, _ownershipIndex(id))];
if (msgSender != owner) {
if (!$.operatorApprovals[owner][msgSender]) {
revert ApprovalCallerNotOwnerNorApproved();
}
}
$.tokenApprovals[id] = spender;
return owner;
}
/// @dev Approve or remove the `operator` as an operator for `msgSender`,
/// without authorization checks.
function _setApprovalForAll(address operator, bool approved, address msgSender)
internal
virtual
{
_getDN404Storage().operatorApprovals[msgSender][operator] = approved;
}
/// @dev Calls the mirror contract to link it to this contract.
///
/// Reverts if the call to the mirror contract reverts.
function _linkMirrorContract(address mirror) internal virtual {
/// @solidity memory-safe-assembly
assembly {
mstore(0x00, 0x0f4599e5) // `linkMirrorContract(address)`.
mstore(0x20, caller())
if iszero(and(eq(mload(0x00), 1), call(gas(), mirror, 0, 0x1c, 0x24, 0x00, 0x20))) {
mstore(0x00, 0xd125259c) // `LinkMirrorContractFailed()`.
revert(0x1c, 0x04)
}
}
}
/// @dev Fallback modifier to dispatch calls from the mirror NFT contract
/// to internal functions in this contract.
modifier dn404Fallback() virtual {
DN404Storage storage $ = _getDN404Storage();
uint256 fnSelector = _calldataload(0x00) >> 224;
// `isApprovedForAll(address,address)`.
if (fnSelector == 0xe985e9c5) {
if (msg.sender != $.mirrorERC721) revert SenderNotMirror();
if (msg.data.length < 0x44) revert();
address owner = address(uint160(_calldataload(0x04)));
address operator = address(uint160(_calldataload(0x24)));
_return($.operatorApprovals[owner][operator] ? 1 : 0);
}
// `ownerOf(uint256)`.
if (fnSelector == 0x6352211e) {
if (msg.sender != $.mirrorERC721) revert SenderNotMirror();
if (msg.data.length < 0x24) revert();
uint256 id = _calldataload(0x04);
_return(uint160(_ownerOf(id)));
}
// `transferFromNFT(address,address,uint256,address)`.
if (fnSelector == 0xe5eb36c8) {
if (msg.sender != $.mirrorERC721) revert SenderNotMirror();
if (msg.data.length < 0x84) revert();
address from = address(uint160(_calldataload(0x04)));
address to = address(uint160(_calldataload(0x24)));
uint256 id = _calldataload(0x44);
address msgSender = address(uint160(_calldataload(0x64)));
_transferFromNFT(from, to, id, msgSender);
_return(1);
}
// `setApprovalForAll(address,bool,address)`.
if (fnSelector == 0x813500fc) {
if (msg.sender != $.mirrorERC721) revert SenderNotMirror();
if (msg.data.length < 0x64) revert();
address spender = address(uint160(_calldataload(0x04)));
bool status = _calldataload(0x24) != 0;
address msgSender = address(uint160(_calldataload(0x44)));
_setApprovalForAll(spender, status, msgSender);
_return(1);
}
// `approveNFT(address,uint256,address)`.
if (fnSelector == 0xd10b6e0c) {
if (msg.sender != $.mirrorERC721) revert SenderNotMirror();
if (msg.data.length < 0x64) revert();
address spender = address(uint160(_calldataload(0x04)));
uint256 id = _calldataload(0x24);
address msgSender = address(uint160(_calldataload(0x44)));
_return(uint160(_approveNFT(spender, id, msgSender)));
}
// `getApproved(uint256)`.
if (fnSelector == 0x081812fc) {
if (msg.sender != $.mirrorERC721) revert SenderNotMirror();
if (msg.data.length < 0x24) revert();
uint256 id = _calldataload(0x04);
_return(uint160(_getApproved(id)));
}
// `balanceOfNFT(address)`.
if (fnSelector == 0xf5b100ea) {
if (msg.sender != $.mirrorERC721) revert SenderNotMirror();
if (msg.data.length < 0x24) revert();
address owner = address(uint160(_calldataload(0x04)));
_return(_balanceOfNFT(owner));
}
// `totalNFTSupply()`.
if (fnSelector == 0xe2c79281) {
if (msg.sender != $.mirrorERC721) revert SenderNotMirror();
if (msg.data.length < 0x04) revert();
_return(_totalNFTSupply());
}
// `implementsDN404()`.
if (fnSelector == 0xb7a94eb8) {
_return(1);
}
_;
}
/// @dev Fallback function for calls from mirror NFT contract.
fallback() external payable virtual dn404Fallback {}
receive() external payable virtual {}
/*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
/* PRIVATE HELPERS */
/*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/
/// @dev Struct containing packed log data for `Transfer` events to be
/// emitted by the mirror NFT contract.
struct _PackedLogs {
uint256[] logs;
uint256 offset;
}
/// @dev Initiates memory allocation for packed logs with `n` log items.
function _packedLogsMalloc(uint256 n) private pure returns (_PackedLogs memory p) {
/// @solidity memory-safe-assembly
assembly {
let logs := add(mload(0x40), 0x40) // Offset by 2 words for `_packedLogsSend`.
mstore(logs, n)
let offset := add(0x20, logs)
mstore(0x40, add(offset, shl(5, n)))
mstore(p, logs)
mstore(add(0x20, p), offset)
}
}
/// @dev Adds a packed log item to `p` with address `a`, token `id` and burn flag `burnBit`.
function _packedLogsAppend(_PackedLogs memory p, address a, uint256 id, uint256 burnBit)
private
pure
{
/// @solidity memory-safe-assembly
assembly {
let offset := mload(add(0x20, p))
mstore(offset, or(or(shl(96, a), shl(8, id)), burnBit))
mstore(add(0x20, p), add(offset, 0x20))
}
}
/// @dev Calls the `mirror` NFT contract to emit Transfer events for packed logs `p`.
function _packedLogsSend(_PackedLogs memory p, address mirror) private {
/// @solidity memory-safe-assembly
assembly {
let logs := mload(p)
let o := sub(logs, 0x40) // Start of calldata to send.
mstore(o, 0x263c69d6) // `logTransfer(uint256[])`.
mstore(add(o, 0x20), 0x20) // Offset of `logs` in the calldata to send.
let n := add(0x44, shl(5, mload(logs))) // Length of calldata to send.
if iszero(and(eq(mload(o), 1), call(gas(), mirror, 0, add(o, 0x1c), n, o, 0x20))) {
revert(o, 0x00)
}
}
}
/// @dev Struct of temporary variables for transfers.
struct _TransferTemps {
uint256 nftAmountToBurn;
uint256 nftAmountToMint;
uint256 fromBalance;
uint256 toBalance;
uint256 fromOwnedLength;
uint256 toOwnedLength;
}
/// @dev Returns if `a` has bytecode of non-zero length.
function _hasCode(address a) private view returns (bool result) {
/// @solidity memory-safe-assembly
assembly {
result := extcodesize(a) // Can handle dirty upper bits.
}
}
/// @dev Returns the calldata value at `offset`.
function _calldataload(uint256 offset) private pure returns (uint256 value) {
/// @solidity memory-safe-assembly
assembly {
value := calldataload(offset)
}
}
/// @dev Executes a return opcode to return `x` and end the current call frame.
function _return(uint256 x) private pure {
/// @solidity memory-safe-assembly
assembly {
mstore(0x00, x)
return(0x00, 0x20)
}
}
/// @dev Returns `max(0, x - y)`.
function _zeroFloorSub(uint256 x, uint256 y) private pure returns (uint256 z) {
/// @solidity memory-safe-assembly
assembly {
z := mul(gt(x, y), sub(x, y))
}
}
/// @dev Returns `i << 1`.
function _ownershipIndex(uint256 i) private pure returns (uint256) {
return i << 1;
}
/// @dev Returns `(i << 1) + 1`.
function _ownedIndex(uint256 i) private pure returns (uint256) {
unchecked {
return (i << 1) + 1;
}
}
/// @dev Returns the uint32 value at `index` in `map`.
function _get(Uint32Map storage map, uint256 index) private view returns (uint32 result) {
result = uint32(map.map[index >> 3] >> ((index & 7) << 5));
}
/// @dev Updates the uint32 value at `index` in `map`.
function _set(Uint32Map storage map, uint256 index, uint32 value) private {
/// @solidity memory-safe-assembly
assembly {
mstore(0x20, map.slot)
mstore(0x00, shr(3, index))
let s := keccak256(0x00, 0x40) // Storage slot.
let o := shl(5, and(index, 7)) // Storage slot offset (bits).
let v := sload(s) // Storage slot value.
let m := 0xffffffff // Value mask.
sstore(s, xor(v, shl(o, and(m, xor(shr(o, v), value)))))
}
}
/// @dev Sets the owner alias and the owned index together.
function _setOwnerAliasAndOwnedIndex(
Uint32Map storage map,
uint256 id,
uint32 ownership,
uint32 ownedIndex
) private {
/// @solidity memory-safe-assembly
assembly {
let value := or(shl(32, ownedIndex), and(0xffffffff, ownership))
mstore(0x20, map.slot)
mstore(0x00, shr(2, id))
let s := keccak256(0x00, 0x40) // Storage slot.
let o := shl(6, and(id, 3)) // Storage slot offset (bits).
let v := sload(s) // Storage slot value.
let m := 0xffffffffffffffff // Value mask.
sstore(s, xor(v, shl(o, and(m, xor(shr(o, v), value)))))
}
}
}
// File: src/example/SimpleDN404.sol
pragma solidity ^0.8.4;
contract GEN404 is DN404, Ownable {
string private _name;
string private _symbol;
string private _baseURI;
constructor(
string memory name_,
string memory symbol_,
uint96 initialTokenSupply,
address initialSupplyOwner
) {
_initializeOwner(msg.sender);
_name = name_;
_symbol = symbol_;
address mirror = address(new DN404Mirror(msg.sender));
_initializeDN404(initialTokenSupply, initialSupplyOwner, mirror);
}
function name() public view override returns (string memory) {
return _name;
}
function symbol() public view override returns (string memory) {
return _symbol;
}
function tokenURI(uint256 tokenId) public view override returns (string memory) {
// Check if _baseURI is set
if (bytes(_baseURI).length != 0) {
// Construct the token URI with the .json extension and return it
return string(abi.encodePacked(_baseURI, LibString.toString(tokenId), ".json"));
}
return string(abi.encodePacked("https://bafybeifxyzd6jud3skqin7ymogxhumiqe5hgkuqljhre3jfisbug46lcg4.ipfs.nftstorage.link/", LibString.toString(tokenId), ".json"));
}
function setBaseURI(string calldata baseURI_) public onlyOwner {
_baseURI = baseURI_;
}
function withdraw() public onlyOwner {
SafeTransferLib.safeTransferAllETH(msg.sender);
}
}Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"string","name":"name_","type":"string"},{"internalType":"string","name":"symbol_","type":"string"},{"internalType":"uint96","name":"initialTokenSupply","type":"uint96"},{"internalType":"address","name":"initialSupplyOwner","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AlreadyInitialized","type":"error"},{"inputs":[],"name":"ApprovalCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"DNAlreadyInitialized","type":"error"},{"inputs":[],"name":"InsufficientAllowance","type":"error"},{"inputs":[],"name":"InsufficientBalance","type":"error"},{"inputs":[],"name":"LinkMirrorContractFailed","type":"error"},{"inputs":[],"name":"MirrorAddressIsZero","type":"error"},{"inputs":[],"name":"NewOwnerIsZeroAddress","type":"error"},{"inputs":[],"name":"NoHandoverRequest","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"},{"inputs":[],"name":"Unauthorized","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":"pendingOwner","type":"address"}],"name":"OwnershipHandoverCanceled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"pendingOwner","type":"address"}],"name":"OwnershipHandoverRequested","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"target","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"},{"stateMutability":"payable","type":"fallback"},{"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":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cancelOwnershipHandover","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"pendingOwner","type":"address"}],"name":"completeOwnershipHandover","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"a","type":"address"}],"name":"getSkipNFT","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"result","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pendingOwner","type":"address"}],"name":"ownershipHandoverExpiresAt","outputs":[{"internalType":"uint256","name":"result","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"requestOwnershipHandover","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"string","name":"baseURI_","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"skipNFT","type":"bool"}],"name":"setSkipNFT","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"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":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000003627e8f712373c0000000000000000000000000000d58eb740e0648510ae5326cf59671e778e914280000000000000000000000000000000000000000000000000000000000000000647454e3430340000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000347454e0000000000000000000000000000000000000000000000000000000000
-----Decoded View---------------
Arg [0] : name_ (string): GEN404
Arg [1] : symbol_ (string): GEN
Arg [2] : initialTokenSupply (uint96): 999000000000000000000
Arg [3] : initialSupplyOwner (address): 0xD58Eb740e0648510Ae5326cf59671e778E914280
-----Encoded View---------------
8 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [2] : 00000000000000000000000000000000000000000000003627e8f712373c0000
Arg [3] : 000000000000000000000000d58eb740e0648510ae5326cf59671e778e914280
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000006
Arg [5] : 47454e3430340000000000000000000000000000000000000000000000000000
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000003
Arg [7] : 47454e0000000000000000000000000000000000000000000000000000000000
Deployed Bytecode Sourcemap
147387:1469:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;138135:22;138160:18;:16;:18::i;:::-;138135:43;;138191:18;138235:3;138212:19;138226:4;138212:13;:19::i;:::-;:26;;138191:47;;138318:10;138304;:24;138300:377;;138363:1;:14;;;;;;;;;;;;138349:28;;:10;:28;;;138345:58;;138386:17;;;;;;;;;;;;;;138345:58;138440:4;138422:8;;:15;;:22;138418:36;;;138446:8;;;138418:36;138471:13;138503:19;138517:4;138503:13;:19::i;:::-;138471:53;;138539:16;138574:19;138588:4;138574:13;:19::i;:::-;138539:56;;138612:53;138620:1;:19;;:26;138640:5;138620:26;;;;;;;;;;;;;;;:36;138647:8;138620:36;;;;;;;;;;;;;;;;;;;;;;;;;:44;;138663:1;138620:44;;;138659:1;138620:44;138612:53;;:7;:53::i;:::-;138330:347;;138300:377;138737:10;138723;:24;138719:262;;138782:1;:14;;;;;;;;;;;;138768:28;;:10;:28;;;138764:58;;138805:17;;;;;;;;;;;;;;138764:58;138859:4;138841:8;;:15;;:22;138837:36;;;138865:8;;;138837:36;138890:10;138903:19;138917:4;138903:13;:19::i;:::-;138890:32;;138939:30;138955:12;138964:2;138955:8;:12::i;:::-;138939:30;;:7;:30::i;:::-;138749:232;138719:262;139073:10;139059;:24;139055:502;;139118:1;:14;;;;;;;;;;;;139104:28;;:10;:28;;;139100:58;;139141:17;;;;;;;;;;;;;;139100:58;139195:4;139177:8;;:15;;:22;139173:36;;;139201:8;;;139173:36;139226:12;139257:19;139271:4;139257:13;:19::i;:::-;139226:52;;139293:10;139322:19;139336:4;139322:13;:19::i;:::-;139293:50;;139358:10;139371:19;139385:4;139371:13;:19::i;:::-;139358:32;;139405:17;139441:19;139455:4;139441:13;:19::i;:::-;139405:57;;139479:41;139496:4;139502:2;139506;139510:9;139479:16;:41::i;:::-;139535:10;139543:1;139535:7;:10::i;:::-;139085:472;;;;139055:502;139640:10;139626;:24;139622:451;;139685:1;:14;;;;;;;;;;;;139671:28;;:10;:28;;;139667:58;;139708:17;;;;;;;;;;;;;;139667:58;139762:4;139744:8;;:15;;:22;139740:36;;;139768:8;;;139740:36;139793:15;139827:19;139841:4;139827:13;:19::i;:::-;139793:55;;139863:11;139900:1;139877:19;139891:4;139877:13;:19::i;:::-;:24;;139863:38;;139916:17;139952:19;139966:4;139952:13;:19::i;:::-;139916:57;;139990:46;140009:7;140018:6;140026:9;139990:18;:46::i;:::-;140051:10;140059:1;140051:7;:10::i;:::-;139652:421;;;139622:451;140152:10;140138;:24;140134:427;;140197:1;:14;;;;;;;;;;;;140183:28;;:10;:28;;;140179:58;;140220:17;;;;;;;;;;;;;;140179:58;140274:4;140256:8;;:15;;:22;140252:36;;;140280:8;;;140252:36;140305:15;140339:19;140353:4;140339:13;:19::i;:::-;140305:55;;140375:10;140388:19;140402:4;140388:13;:19::i;:::-;140375:32;;140422:17;140458:19;140472:4;140458:13;:19::i;:::-;140422:57;;140496:53;140512:35;140524:7;140533:2;140537:9;140512:11;:35::i;:::-;140496:53;;:7;:53::i;:::-;140164:397;;;140134:427;140625:10;140611;:24;140607:266;;140670:1;:14;;;;;;;;;;;;140656:28;;:10;:28;;;140652:58;;140693:17;;;;;;;;;;;;;;140652:58;140747:4;140729:8;;:15;;:22;140725:36;;;140753:8;;;140725:36;140778:10;140791:19;140805:4;140791:13;:19::i;:::-;140778:32;;140827:34;140843:16;140856:2;140843:12;:16::i;:::-;140827:34;;:7;:34::i;:::-;140637:236;140607:266;140938:10;140924;:24;140920:282;;140983:1;:14;;;;;;;;;;;;140969:28;;:10;:28;;;140965:58;;141006:17;;;;;;;;;;;;;;140965:58;141060:4;141042:8;;:15;;:22;141038:36;;;141066:8;;;141038:36;141091:13;141123:19;141137:4;141123:13;:19::i;:::-;141091:53;;141161:29;141169:20;141183:5;141169:13;:20::i;:::-;141161:7;:29::i;:::-;140950:252;140920:282;141262:10;141248;:24;141244:209;;141307:1;:14;;;;;;;;;;;;141293:28;;:10;:28;;;141289:58;;141330:17;;;;;;;;;;;;;;141289:58;141384:4;141366:8;;:15;;:22;141362:36;;;141390:8;;;141362:36;141415:26;141423:17;:15;:17::i;:::-;141415:7;:26::i;:::-;141244:209;141514:10;141500;:24;141496:67;;141541:10;141549:1;141541:7;:10::i;:::-;141496:67;138124:3458;147920:92;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;117644:275;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;116921:126;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;119279:512;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;82018:630;;;:::i;:::-;;132070:282;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;132464:100;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;116780:76;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;148751:102;;;;;;;;;;;;;:::i;:::-;;134627:119;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;82733:466;;;:::i;:::-;;148642:101;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;117116:143;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;81753:102;;;:::i;:::-;;84458:187;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;148020:96;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;118432:150;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;148124:504;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;117357:151;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;83390:724;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;81327:358;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;84751:449;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;114009:320;114068:22;114243:20;114233:30;;114009:320;:::o;144623:202::-;144684:13;144800:6;144787:20;144778:29;;144623:202;;;:::o;144918:185::-;145051:1;145045:4;145038:15;145080:4;145074;145067:18;135587:163;135648:7;135673:11;135681:2;135673:7;:11::i;:::-;135668:44;;135693:19;;;;;;;;;;;;;;135668:44;135730:12;135739:2;135730:8;:12::i;:::-;135723:19;;135587:163;;;:::o;129060:1507::-;129194:22;129219:18;:16;:18::i;:::-;129194:43;;129268:1;129254:16;;:2;:16;;;129250:52;;129279:23;;;;;;;;;;;;;;129250:52;129315:13;129331:1;:16;;:49;129348:31;129353:1;:4;;129359:19;129375:2;129359:15;:19::i;:::-;129348:4;:31::i;:::-;129331:49;;;;;;;;;;;;;;;;;;;;;;;;;129315:65;;129405:5;129397:13;;:4;:13;;;129393:54;;129419:28;;;;;;;;;;;;;;129393:54;129477:4;129464:17;;:9;:17;;;129460:250;;129503:1;:19;;:25;129523:4;129503:25;;;;;;;;;;;;;;;:36;129529:9;129503:36;;;;;;;;;;;;;;;;;;;;;;;;;129498:201;;129577:1;:16;;:20;129594:2;129577:20;;;;;;;;;;;;;;;;;;;;;129564:33;;:9;:33;;;129560:124;;129629:35;;;;;;;;;;;;;;129560:124;129498:201;129460:250;129722:35;129760:18;129773:4;129760:12;:18::i;:::-;129722:56;;129789:33;129825:16;129838:2;129825:12;:16::i;:::-;129789:52;;111300:8;129854:15;:23;;;:39;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;111300:8;129931:13;:21;;;:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;129985:76;129990:1;:4;;129996:19;130012:2;129996:15;:19::i;:::-;130017:43;130042:13;130057:2;130017:24;:43::i;:::-;129985:4;:76::i;:::-;130083:1;:16;;:20;130100:2;130083:20;;;;;;;;;;;;130076:27;;;;;;;;;;;130120:17;130140:50;130145:1;:7;;:13;130153:4;130145:13;;;;;;;;;;;;;;;130162:15;:27;;;130160:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;130140:50;;:4;:50::i;:::-;130120:70;;;;130205:67;130210:1;:7;;:13;130218:4;130210:13;;;;;;;;;;;;;;;130225:27;130230:1;:4;;130236:15;130248:2;130236:11;:15::i;:::-;130225:4;:27::i;:::-;130205:67;;130261:9;130205:4;:67::i;:::-;130289:9;130301:13;:25;;;:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;130289:39;;;;130343:63;130348:1;:4;;130354:22;130366:9;130354:11;:22::i;:::-;130378:27;130383:1;:4;;130389:15;130401:2;130389:11;:15::i;:::-;130378:4;:27::i;:::-;130343:4;:63::i;:::-;130421:32;130426:1;:7;;:11;130434:2;130426:11;;;;;;;;;;;;;;;130439:1;130449:2;130421:4;:32::i;:::-;130468:38;130473:1;:4;;130479:15;130491:2;130479:11;:15::i;:::-;130503:1;130468:4;:38::i;:::-;129906:612;;130550:2;130535:24;;130544:4;130535:24;;;111300:8;130535:24;;;;;;:::i;:::-;;;;;;;;129183:1384;;;;129060:1507;;;;:::o;137124:207::-;137315:8;137255:18;:16;:18::i;:::-;:36;;:47;137292:9;137255:47;;;;;;;;;;;;;;;:57;137303:8;137255:57;;;;;;;;;;;;;;;;:68;;;;;;;;;;;;;;;;;;137124:207;;;:::o;136471:527::-;136593:7;136618:22;136643:18;:16;:18::i;:::-;136618:43;;136674:13;136690:1;:16;;:49;136707:31;136712:1;:4;;136718:19;136734:2;136718:15;:19::i;:::-;136707:4;:31::i;:::-;136690:49;;;;;;;;;;;;;;;;;;;;;;;;;136674:65;;136769:5;136756:18;;:9;:18;;;136752:171;;136796:1;:19;;:26;136816:5;136796:26;;;;;;;;;;;;;;;:37;136823:9;136796:37;;;;;;;;;;;;;;;;;;;;;;;;;136791:121;;136861:35;;;;;;;;;;;;;;136791:121;136752:171;136958:7;136935:1;:16;;:20;136952:2;136935:20;;;;;;;;;;;;:30;;;;;;;;;;;;;;;;;;136985:5;136978:12;;;;136471:527;;;;;:::o;136059:192::-;136124:7;136149:11;136157:2;136149:7;:11::i;:::-;136144:44;;136169:19;;;;;;;;;;;;;;136144:44;136206:18;:16;:18::i;:::-;:33;;:37;136240:2;136206:37;;;;;;;;;;;;;;;;;;;;;136199:44;;136059:192;;;:::o;134975:153::-;135044:7;135071:18;:16;:18::i;:::-;:30;;:37;135102:5;135071:37;;;;;;;;;;;;;;;:49;;;;;;;;;;;;135064:56;;;;134975:153;;;:::o;134798:126::-;134856:7;134883:18;:16;:18::i;:::-;:33;;;;;;;;;;;;134876:40;;;;134798:126;:::o;147920:92::-;147966:13;147999:5;147992:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;147920:92;:::o;117644:275::-;117718:4;117735:22;117760:18;:16;:18::i;:::-;117735:43;;117826:6;117791:1;:11;;:23;117803:10;117791:23;;;;;;;;;;;;;;;:32;117815:7;117791:32;;;;;;;;;;;;;;;:41;;;;117871:7;117850:37;;117859:10;117850:37;;;117880:6;117850:37;;;;;;:::i;:::-;;;;;;;;117907:4;117900:11;;;117644:275;;;;:::o;116921:126::-;116973:7;117008:18;:16;:18::i;:::-;:30;;;;;;;;;;;;117000:39;;116993:46;;116921:126;:::o;119279:512::-;119367:4;119384:22;119409:18;:16;:18::i;:::-;119384:43;;119440:15;119458:1;:11;;:17;119470:4;119458:17;;;;;;;;;;;;;;;:29;119476:10;119458:29;;;;;;;;;;;;;;;;119440:47;;119515:17;119504:7;:28;119500:220;;119562:7;119553:6;:16;119549:52;;;119578:23;;;;;;;;;;;;;;119549:52;119687:6;119677:7;:16;119645:1;:11;;:17;119657:4;119645:17;;;;;;;;;;;;;;;:29;119663:10;119645:29;;;;;;;;;;;;;;;:48;;;;119500:220;119732:27;119742:4;119748:2;119752:6;119732:9;:27::i;:::-;119779:4;119772:11;;;;119279:512;;;;;:::o;82018:630::-;82113:15;82149:28;:26;:28::i;:::-;82131:46;;:15;:46;82113:64;;82349:19;82343:4;82336:33;82400:8;82394:4;82387:22;82457:7;82450:4;82444;82434:21;82427:38;82606:8;82559:45;82556:1;82553;82548:67;82249:381;82018:630::o;132070:282::-;132130:4;132147:21;132171:18;:16;:18::i;:::-;:30;;:33;132202:1;132171:33;;;;;;;;;;;;;;;132147:57;;132263:1;111684:6;132219:1;:7;;;;;;;;;;;;:40;:45;;;132215:69;;132273:11;132282:1;132273:8;:11::i;:::-;132266:18;;;;;132215:69;132343:1;111821:6;132302:1;:7;;;;;;;;;;;;:37;:42;;;;132295:49;;;132070:282;;;;:::o;132464:100::-;132524:32;132536:10;132548:7;132524:11;:32::i;:::-;132464:100;:::o;116780:76::-;116821:5;116846:2;116839:9;;116780:76;:::o;148751:102::-;85597:13;:11;:13::i;:::-;148799:46:::1;148834:10;148799:34;:46::i;:::-;148751:102::o:0;134627:119::-;134680:7;134707:18;:16;:18::i;:::-;:31;;;;;;;;;;;;134700:38;;134627:119;:::o;82733:466::-;82939:19;82933:4;82926:33;82986:8;82980:4;82973:22;83039:1;83032:4;83026;83016:21;83009:32;83172:8;83126:44;83123:1;83120;83115:66;82733:466::o;148642:101::-;85597:13;:11;:13::i;:::-;148727:8:::1;;148716;:19;;;;;;;:::i;:::-;;148642:101:::0;;:::o;117116:143::-;117179:7;117206:18;:16;:18::i;:::-;:30;;:37;117237:5;117206:37;;;;;;;;;;;;;;;:45;;;;;;;;;;;;117199:52;;;;117116:143;;;:::o;81753:102::-;85597:13;:11;:13::i;:::-;81826:21:::1;81844:1;81826:9;:21::i;:::-;81753:102::o:0;84458:187::-;84504:14;84615:11;84609:18;84599:28;;84458:187;:::o;148020:96::-;148068:13;148101:7;148094:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;148020:96;:::o;118432:150::-;118502:4;118519:33;118529:10;118541:2;118545:6;118519:9;:33::i;:::-;118570:4;118563:11;;118432:150;;;;:::o;148124:504::-;148189:13;148274:1;148254:8;148248:22;;;;;:::i;:::-;;;:27;148244:206;;148394:8;148404:27;148423:7;148404:18;:27::i;:::-;148377:64;;;;;;;;;:::i;:::-;;;;;;;;;;;;;148363:79;;;;148244:206;148586:27;148605:7;148586:18;:27::i;:::-;148476:147;;;;;;;;:::i;:::-;;;;;;;;;;;;;148462:162;;148124:504;;;;:::o;117357:151::-;117429:7;117456:18;:16;:18::i;:::-;:28;;:35;117485:5;117456:35;;;;;;;;;;;;;;;:44;117492:7;117456:44;;;;;;;;;;;;;;;;117449:51;;117357:151;;;;:::o;83390:724::-;85597:13;:11;:13::i;:::-;83628:19:::1;83622:4;83615:33;83675:12;83669:4;83662:26;83738:4;83732;83722:21;83846:12;83840:19;83827:11;83824:36;83821:160;;;83893:10;83887:4;83880:24;83961:4;83955;83948:18;83821:160;84060:1;84046:12;84039:23;83544:529;84083:23;84093:12;84083:9;:23::i;:::-;83390:724:::0;:::o;81327:358::-;85597:13;:11;:13::i;:::-;81502:8:::1;81498:2;81494:17;81484:153;;81545:10;81539:4;81532:24;81617:4;81611;81604:18;81484:153;81658:19;81668:8;81658:9;:19::i;:::-;81327:358:::0;:::o;84751:449::-;84874:14;85030:19;85024:4;85017:33;85077:12;85071:4;85064:26;85176:4;85170;85160:21;85154:28;85144:38;;84751:449;;;:::o;135802:118::-;135862:4;135910:1;135886:26;;:12;135895:2;135886:8;:12::i;:::-;:26;;;;135879:33;;135802:118;;;:::o;135267:199::-;135328:7;135348:22;135373:18;:16;:18::i;:::-;135348:43;;135409:1;:16;;:49;135426:31;135431:1;:4;;135437:19;135453:2;135437:15;:19::i;:::-;135426:4;:31::i;:::-;135409:49;;;;;;;;;;;;;;;;;;;;;;;;;135402:56;;;135267:199;;;:::o;145394:99::-;145452:7;145484:1;145479;:6;;145472:13;;145394:99;;;:::o;145744:166::-;145818:13;145899:1;145893;145885:5;:9;145884:16;;145860:3;:7;;:19;145877:1;145868:5;:10;;145860:19;;;;;;;;;;;;:41;;145844:58;;145744:166;;;;:::o;133243:407::-;133302:21;133336:22;133361:18;:16;:18::i;:::-;133336:43;;133394:1;:13;;:16;133408:1;133394:16;;;;;;;;;;;;;;;133390:20;;133471:1;111684:6;133427:1;:7;;;;;;;;;;;;:40;:45;;;133423:220;;133489:11;111684:6;133489:44;;133552:11;133561:1;133552:8;:11::i;:::-;133548:53;;;111821:6;133565:36;;;;133548:53;133626:5;133616:1;:7;;;:15;;;;;;;;;;;;;;;;;;133474:169;133423:220;133325:325;133243:407;;;:::o;133816:469::-;133950:19;133987:22;134012:18;:16;:18::i;:::-;133987:43;;134056:13;:26;;;;;;;;;;;;134041:41;;134113:1;134097:12;:17;;;134093:185;;134148:1;:12;;;134146:14;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;134131:29;;134204:12;134175:13;:26;;;:41;;;;;;;;;;;;;;;;;;134264:2;134231:1;:16;;:30;134248:12;134231:30;;;;;;;;;;;;;;;;:35;;;;;;;;;;;;;;;;;;134093:185;133976:309;133816:469;;;;:::o;145978:542::-;146144:8;146138:4;146131:22;146187:5;146184:1;146180:13;146174:4;146167:27;146233:4;146227;146217:21;146296:1;146289:5;146285:13;146282:1;146278:21;146359:1;146353:8;146407:10;146492:5;146488:1;146485;146481:9;146477:21;146474:1;146470:29;146467:1;146463:37;146460:1;146456:45;146453:1;146446:56;146116:397;;;;145978:542;;;:::o;145539:137::-;145593:7;145656:1;145651;145646;:6;;145645:12;145638:19;;145539:137;;;:::o;125367:3268::-;125474:1;125460:16;;:2;:16;;;125456:52;;125485:23;;;;;;;;;;;;;;125456:52;125521:22;125546:18;:16;:18::i;:::-;125521:43;;125577:35;125615:18;125628:4;125615:12;:18::i;:::-;125577:56;;125644:33;125680:16;125693:2;125680:12;:16::i;:::-;125644:52;;125709:23;;:::i;:::-;125763:15;:27;;;;;;;;;;;;125743:47;;:1;:17;;:47;;;;;125819:13;:25;;;;;;;;;;;;125801:43;;:1;:15;;:43;;;;;125871:15;:23;;;;;;;;;;;;125855:39;;:1;:13;;:39;;;;;125920:1;:13;;;125911:6;:22;125907:56;;;125942:21;;;;;;;;;;;;;;125907:56;126018:6;126001:1;:13;;:23;;;;;;;;;;;126072:1;:13;;;126039:15;:23;;;:47;;;;;;;;;;;;;;;;;;126170:6;126146:13;:21;;;;;;;;;;;;:30;;;126132:1;:11;;:44;;;;126101:13;:21;;;:76;;;;;;;;;;;;;;;;;;126214:54;126228:1;:17;;;111300:8;126247:1;:13;;;:20;;;;;:::i;:::-;;;126214:13;:54::i;:::-;126194:1;:17;;:74;;;;;126342:1;111821:6;126289:13;:19;;;;;;;;;;;;:49;:54;;;126285:255;;126376:2;126368:10;;:4;:10;;;126364:71;;126418:1;:17;;;126398:1;:17;;;:37;126380:1;:15;;:55;;;;;126364:71;126474:50;111300:8;126488:1;:11;;;:18;;;;;:::i;:::-;;;126508:1;:15;;;126474:13;:50::i;:::-;126454:1;:17;;:70;;;;;126285:255;126556:29;126588:56;126626:1;:17;;;126606:1;:17;;;:37;126588:17;:56::i;:::-;126556:88;;126686:1;126665;:17;;;:22;126661:703;;126708:27;126738:1;:7;;:13;126746:4;126738:13;;;;;;;;;;;;;;;126708:43;;126770:17;126790:1;:17;;;126770:37;;126826:15;126856:1;:17;;;126844:9;:29;126826:47;;126919:1;:17;;;126892:1;:16;;;:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;126993:7;126956:15;:27;;;:45;;;;;;;;;;;;;;;;;;127051:298;127077:10;127090:28;127095:9;127106:11;;;;;;;127090:4;:28::i;:::-;127077:41;;;;127141:43;127169:1;:4;;127175:2;127179:1;127182;127141:27;:43::i;:::-;127214:1;:16;;:20;127231:2;127214:20;;;;;;;;;;;;127207:27;;;;;;;;;;;127257:42;127275:10;127287:4;127293:2;127297:1;127257:17;:42::i;:::-;127054:265;127340:7;127327:9;:20;127051:298;;126689:675;;;126661:703;127405:1;127384;:17;;;:22;127380:1068;;127427:25;127455:1;:7;;:11;127463:2;127455:11;;;;;;;;;;;;;;;127427:39;;127485:15;127503:1;:15;;;127485:33;;127537:13;127563:1;:17;;;127553:7;:27;127537:43;;127599:14;127616:43;127641:13;127656:2;127616:24;:43::i;:::-;127599:60;;127678:16;111300:8;127697:1;:13;;;;;;;;;;;;:20;;;;;;;:::i;:::-;;;127678:39;;127736:10;127749:1;:13;;;;;;;;;;;;127736:26;;;;127808:1;:17;;;127781:1;:16;;;:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;127880:5;127845:13;:25;;;:41;;;;;;;;;;;;;;;;;;127936:452;127962:123;128004:1;127969:31;127974:1;:4;;127980:19;127996:2;127980:15;:19::i;:::-;127969:4;:31::i;:::-;:36;;;127962:123;;128045:8;128038:4;;;;;;:15;128034:27;;;128060:1;128055:6;;128034:27;127962:123;;;128107:34;128112:7;128121;128137:2;128107:4;:34::i;:::-;128164:65;128192:1;:4;;128198:2;128202:7;128218:9;;;;;;128164:27;:65::i;:::-;128252:40;128270:10;128282:2;128286;128290:1;128252:17;:40::i;:::-;128326:8;128319:4;;;;;;:15;128315:27;;;128341:1;128336:6;;128315:27;128381:5;128370:7;:16;127936:452;;128429:2;128406:1;:13;;;:26;;;;;;;;;;;;;;;;;;127408:1040;;;;;;127380:1068;128494:1;128468:10;:15;;;:22;:27;128464:111;;128516:43;128532:10;128544:1;:14;;;;;;;;;;;;128516:15;:43::i;:::-;128464:111;125976:2610;128616:2;128601:26;;128610:4;128601:26;;;128620:6;128601:26;;;;;;:::i;:::-;;;;;;;;125445:3190;;;;125367:3268;;;:::o;80848:112::-;80917:6;80943:9;80936:16;;80848:112;:::o;144344:217::-;144395:11;144509:1;144497:14;144487:24;;144344:217;;;:::o;132783:289::-;132855:21;132879:15;132892:1;132879:12;:15::i;:::-;132855:39;;132957:5;132909:53;;132951:1;111821:6;132910:1;:7;;;;;;;;;;;;:37;:42;;;;132909:53;;;132905:124;;111821:6;132979:1;:7;;;:38;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;132905:124;133055:1;133044:20;;;133058:5;133044:20;;;;;;:::i;:::-;;;;;;;;132844:228;132783:289;;:::o;80248:364::-;80464:11;80458:18;80448:8;80445:32;80435:159;;80511:10;80505:4;80498:24;80574:4;80568;80561:18;80435:159;80248:364::o;4931:415::-;5201:4;5189:10;5183:4;5171:10;5156:13;5152:2;5145:5;5140:66;5130:198;;5240:10;5234:4;5227:24;5308:4;5302;5295:18;5130:198;4931:415;:::o;79074:1113::-;79143:23;:21;:23::i;:::-;79139:1041;;;79276:11;79378:8;79374:2;79370:17;79366:2;79362:26;79350:38;;79534:8;79522:9;79516:16;79476:38;79473:1;79470;79465:78;79649:8;79642:16;79637:3;79633:26;79623:8;79620:40;79609:9;79602:59;79240:436;79139:1041;;;79801:11;79903:8;79899:2;79895:17;79891:2;79887:26;79875:38;;80059:8;80047:9;80041:16;80001:38;79998:1;79995;79990:78;80145:8;80134:9;80127:27;79765:404;79139:1041;79074:1113;:::o;21602:1676::-;21658:17;22110:4;22103;22097:11;22093:22;22086:29;;22211:4;22206:3;22202:14;22196:4;22189:28;22294:1;22289:3;22282:14;22398:3;22430:1;22426:6;22642:5;22624:410;22650:1;22624:410;;;22690:1;22685:3;22681:11;22674:18;;22879:2;22873:4;22869:13;22865:2;22861:22;22856:3;22848:36;22973:2;22967:4;22963:13;22955:21;;23004:4;22624:410;22994:25;22624:410;22628:21;23073:3;23068;23064:13;23188:4;23183:3;23179:14;23172:21;;23253:6;23248:3;23241:19;21741:1530;;;21602:1676;;;:::o;145150:204::-;145217:9;145333:1;145330;145326:9;145322:1;145319;145316:8;145312:24;145307:29;;145150:204;;;;:::o;142319:450::-;142379:20;;:::i;:::-;142509:4;142502;142496:11;142492:22;142585:1;142579:4;142572:15;142625:4;142619;142615:15;142676:1;142673;142669:9;142661:6;142657:22;142651:4;142644:36;142704:4;142701:1;142694:15;142744:6;142740:1;142734:4;142730:12;142723:28;142465:297;;142319:450;;;:::o;146593:708::-;146885:9;146873:10;146869:26;146856:10;146852:2;146848:19;146845:51;146923:8;146917:4;146910:22;146966:2;146963:1;146959:10;146953:4;146946:24;147009:4;147003;146993:21;147069:1;147065:2;147061:10;147058:1;147054:18;147132:1;147126:8;147180:18;147273:5;147269:1;147266;147262:9;147258:21;147255:1;147251:29;147248:1;147244:37;147241:1;147237:45;147234:1;147227:56;146817:477;;;;;146593:708;;;;:::o;142875:377::-;143109:1;143103:4;143099:12;143093:19;143172:7;143166:2;143163:1;143159:10;143155:1;143151:2;143147:10;143144:26;143141:39;143133:6;143126:55;143228:4;143220:6;143216:17;143212:1;143206:4;143202:12;143195:39;143064:181;142875:377;;;;:::o;143351:634::-;143519:1;143513:8;143554:4;143548;143544:15;143613:10;143610:1;143603:21;143688:4;143681;143678:1;143674:12;143667:26;143784:4;143778:11;143775:1;143771:19;143765:4;143761:30;143910:4;143907:1;143904;143897:4;143894:1;143890:12;143887:1;143879:6;143872:5;143867:48;143863:1;143859;143853:8;143850:15;143846:70;143836:131;;143947:4;143944:1;143937:15;143836:131;143486:492;;;143351:634;;:::o;77238:78::-;77302:10;77238:78;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;:::o;7:99:1:-;59:6;93:5;87:12;77:22;;7:99;;;:::o;112:169::-;196:11;230:6;225:3;218:19;270:4;265:3;261:14;246:29;;112:169;;;;:::o;287:246::-;368:1;378:113;392:6;389:1;386:13;378:113;;;477:1;472:3;468:11;462:18;458:1;453:3;449:11;442:39;414:2;411:1;407:10;402:15;;378:113;;;525:1;516:6;511:3;507:16;500:27;349:184;287:246;;;:::o;539:102::-;580:6;631:2;627:7;622:2;615:5;611:14;607:28;597:38;;539:102;;;:::o;647:377::-;735:3;763:39;796:5;763:39;:::i;:::-;818:71;882:6;877:3;818:71;:::i;:::-;811:78;;898:65;956:6;951:3;944:4;937:5;933:16;898:65;:::i;:::-;988:29;1010:6;988:29;:::i;:::-;983:3;979:39;972:46;;739:285;647:377;;;;:::o;1030:313::-;1143:4;1181:2;1170:9;1166:18;1158:26;;1230:9;1224:4;1220:20;1216:1;1205:9;1201:17;1194:47;1258:78;1331:4;1322:6;1258:78;:::i;:::-;1250:86;;1030:313;;;;:::o;1430:117::-;1539:1;1536;1529:12;1553:117;1662:1;1659;1652:12;1676:126;1713:7;1753:42;1746:5;1742:54;1731:65;;1676:126;;;:::o;1808:96::-;1845:7;1874:24;1892:5;1874:24;:::i;:::-;1863:35;;1808:96;;;:::o;1910:122::-;1983:24;2001:5;1983:24;:::i;:::-;1976:5;1973:35;1963:63;;2022:1;2019;2012:12;1963:63;1910:122;:::o;2038:139::-;2084:5;2122:6;2109:20;2100:29;;2138:33;2165:5;2138:33;:::i;:::-;2038:139;;;;:::o;2183:77::-;2220:7;2249:5;2238:16;;2183:77;;;:::o;2266:122::-;2339:24;2357:5;2339:24;:::i;:::-;2332:5;2329:35;2319:63;;2378:1;2375;2368:12;2319:63;2266:122;:::o;2394:139::-;2440:5;2478:6;2465:20;2456:29;;2494:33;2521:5;2494:33;:::i;:::-;2394:139;;;;:::o;2539:474::-;2607:6;2615;2664:2;2652:9;2643:7;2639:23;2635:32;2632:119;;;2670:79;;:::i;:::-;2632:119;2790:1;2815:53;2860:7;2851:6;2840:9;2836:22;2815:53;:::i;:::-;2805:63;;2761:117;2917:2;2943:53;2988:7;2979:6;2968:9;2964:22;2943:53;:::i;:::-;2933:63;;2888:118;2539:474;;;;;:::o;3019:90::-;3053:7;3096:5;3089:13;3082:21;3071:32;;3019:90;;;:::o;3115:109::-;3196:21;3211:5;3196:21;:::i;:::-;3191:3;3184:34;3115:109;;:::o;3230:210::-;3317:4;3355:2;3344:9;3340:18;3332:26;;3368:65;3430:1;3419:9;3415:17;3406:6;3368:65;:::i;:::-;3230:210;;;;:::o;3446:118::-;3533:24;3551:5;3533:24;:::i;:::-;3528:3;3521:37;3446:118;;:::o;3570:222::-;3663:4;3701:2;3690:9;3686:18;3678:26;;3714:71;3782:1;3771:9;3767:17;3758:6;3714:71;:::i;:::-;3570:222;;;;:::o;3798:619::-;3875:6;3883;3891;3940:2;3928:9;3919:7;3915:23;3911:32;3908:119;;;3946:79;;:::i;:::-;3908:119;4066:1;4091:53;4136:7;4127:6;4116:9;4112:22;4091:53;:::i;:::-;4081:63;;4037:117;4193:2;4219:53;4264:7;4255:6;4244:9;4240:22;4219:53;:::i;:::-;4209:63;;4164:118;4321:2;4347:53;4392:7;4383:6;4372:9;4368:22;4347:53;:::i;:::-;4337:63;;4292:118;3798:619;;;;;:::o;4423:329::-;4482:6;4531:2;4519:9;4510:7;4506:23;4502:32;4499:119;;;4537:79;;:::i;:::-;4499:119;4657:1;4682:53;4727:7;4718:6;4707:9;4703:22;4682:53;:::i;:::-;4672:63;;4628:117;4423:329;;;;:::o;4758:116::-;4828:21;4843:5;4828:21;:::i;:::-;4821:5;4818:32;4808:60;;4864:1;4861;4854:12;4808:60;4758:116;:::o;4880:133::-;4923:5;4961:6;4948:20;4939:29;;4977:30;5001:5;4977:30;:::i;:::-;4880:133;;;;:::o;5019:323::-;5075:6;5124:2;5112:9;5103:7;5099:23;5095:32;5092:119;;;5130:79;;:::i;:::-;5092:119;5250:1;5275:50;5317:7;5308:6;5297:9;5293:22;5275:50;:::i;:::-;5265:60;;5221:114;5019:323;;;;:::o;5348:86::-;5383:7;5423:4;5416:5;5412:16;5401:27;;5348:86;;;:::o;5440:112::-;5523:22;5539:5;5523:22;:::i;:::-;5518:3;5511:35;5440:112;;:::o;5558:214::-;5647:4;5685:2;5674:9;5670:18;5662:26;;5698:67;5762:1;5751:9;5747:17;5738:6;5698:67;:::i;:::-;5558:214;;;;:::o;5778:118::-;5865:24;5883:5;5865:24;:::i;:::-;5860:3;5853:37;5778:118;;:::o;5902:222::-;5995:4;6033:2;6022:9;6018:18;6010:26;;6046:71;6114:1;6103:9;6099:17;6090:6;6046:71;:::i;:::-;5902:222;;;;:::o;6130:117::-;6239:1;6236;6229:12;6253:117;6362:1;6359;6352:12;6376:117;6485:1;6482;6475:12;6513:553;6571:8;6581:6;6631:3;6624:4;6616:6;6612:17;6608:27;6598:122;;6639:79;;:::i;:::-;6598:122;6752:6;6739:20;6729:30;;6782:18;6774:6;6771:30;6768:117;;;6804:79;;:::i;:::-;6768:117;6918:4;6910:6;6906:17;6894:29;;6972:3;6964:4;6956:6;6952:17;6942:8;6938:32;6935:41;6932:128;;;6979:79;;:::i;:::-;6932:128;6513:553;;;;;:::o;7072:529::-;7143:6;7151;7200:2;7188:9;7179:7;7175:23;7171:32;7168:119;;;7206:79;;:::i;:::-;7168:119;7354:1;7343:9;7339:17;7326:31;7384:18;7376:6;7373:30;7370:117;;;7406:79;;:::i;:::-;7370:117;7519:65;7576:7;7567:6;7556:9;7552:22;7519:65;:::i;:::-;7501:83;;;;7297:297;7072:529;;;;;:::o;7607:329::-;7666:6;7715:2;7703:9;7694:7;7690:23;7686:32;7683:119;;;7721:79;;:::i;:::-;7683:119;7841:1;7866:53;7911:7;7902:6;7891:9;7887:22;7866:53;:::i;:::-;7856:63;;7812:117;7607:329;;;;:::o;7942:474::-;8010:6;8018;8067:2;8055:9;8046:7;8042:23;8038:32;8035:119;;;8073:79;;:::i;:::-;8035:119;8193:1;8218:53;8263:7;8254:6;8243:9;8239:22;8218:53;:::i;:::-;8208:63;;8164:117;8320:2;8346:53;8391:7;8382:6;8371:9;8367:22;8346:53;:::i;:::-;8336:63;;8291:118;7942:474;;;;;:::o;8422:109::-;8458:7;8498:26;8491:5;8487:38;8476:49;;8422:109;;;:::o;8537:180::-;8585:77;8582:1;8575:88;8682:4;8679:1;8672:15;8706:4;8703:1;8696:15;8723:216;8762:4;8782:19;8799:1;8782:19;:::i;:::-;8777:24;;8815:19;8832:1;8815:19;:::i;:::-;8810:24;;8858:1;8855;8851:9;8843:17;;8882:26;8876:4;8873:36;8870:62;;;8912:18;;:::i;:::-;8870:62;8723:216;;;;:::o;8945:180::-;8993:77;8990:1;8983:88;9090:4;9087:1;9080:15;9114:4;9111:1;9104:15;9131:320;9175:6;9212:1;9206:4;9202:12;9192:22;;9259:1;9253:4;9249:12;9280:18;9270:81;;9336:4;9328:6;9324:17;9314:27;;9270:81;9398:2;9390:6;9387:14;9367:18;9364:38;9361:84;;9417:18;;:::i;:::-;9361:84;9182:269;9131:320;;;:::o;9457:97::-;9516:6;9544:3;9534:13;;9457:97;;;;:::o;9560:180::-;9608:77;9605:1;9598:88;9705:4;9702:1;9695:15;9729:4;9726:1;9719:15;9746:141;9795:4;9818:3;9810:11;;9841:3;9838:1;9831:14;9875:4;9872:1;9862:18;9854:26;;9746:141;;;:::o;9893:93::-;9930:6;9977:2;9972;9965:5;9961:14;9957:23;9947:33;;9893:93;;;:::o;9992:107::-;10036:8;10086:5;10080:4;10076:16;10055:37;;9992:107;;;;:::o;10105:393::-;10174:6;10224:1;10212:10;10208:18;10247:97;10277:66;10266:9;10247:97;:::i;:::-;10365:39;10395:8;10384:9;10365:39;:::i;:::-;10353:51;;10437:4;10433:9;10426:5;10422:21;10413:30;;10486:4;10476:8;10472:19;10465:5;10462:30;10452:40;;10181:317;;10105:393;;;;;:::o;10504:60::-;10532:3;10553:5;10546:12;;10504:60;;;:::o;10570:142::-;10620:9;10653:53;10671:34;10680:24;10698:5;10680:24;:::i;:::-;10671:34;:::i;:::-;10653:53;:::i;:::-;10640:66;;10570:142;;;:::o;10718:75::-;10761:3;10782:5;10775:12;;10718:75;;;:::o;10799:269::-;10909:39;10940:7;10909:39;:::i;:::-;10970:91;11019:41;11043:16;11019:41;:::i;:::-;11011:6;11004:4;10998:11;10970:91;:::i;:::-;10964:4;10957:105;10875:193;10799:269;;;:::o;11074:73::-;11119:3;11074:73;:::o;11153:189::-;11230:32;;:::i;:::-;11271:65;11329:6;11321;11315:4;11271:65;:::i;:::-;11206:136;11153:189;;:::o;11348:186::-;11408:120;11425:3;11418:5;11415:14;11408:120;;;11479:39;11516:1;11509:5;11479:39;:::i;:::-;11452:1;11445:5;11441:13;11432:22;;11408:120;;;11348:186;;:::o;11540:543::-;11641:2;11636:3;11633:11;11630:446;;;11675:38;11707:5;11675:38;:::i;:::-;11759:29;11777:10;11759:29;:::i;:::-;11749:8;11745:44;11942:2;11930:10;11927:18;11924:49;;;11963:8;11948:23;;11924:49;11986:80;12042:22;12060:3;12042:22;:::i;:::-;12032:8;12028:37;12015:11;11986:80;:::i;:::-;11645:431;;11630:446;11540:543;;;:::o;12089:117::-;12143:8;12193:5;12187:4;12183:16;12162:37;;12089:117;;;;:::o;12212:169::-;12256:6;12289:51;12337:1;12333:6;12325:5;12322:1;12318:13;12289:51;:::i;:::-;12285:56;12370:4;12364;12360:15;12350:25;;12263:118;12212:169;;;;:::o;12386:295::-;12462:4;12608:29;12633:3;12627:4;12608:29;:::i;:::-;12600:37;;12670:3;12667:1;12663:11;12657:4;12654:21;12646:29;;12386:295;;;;:::o;12686:1403::-;12810:44;12850:3;12845;12810:44;:::i;:::-;12919:18;12911:6;12908:30;12905:56;;;12941:18;;:::i;:::-;12905:56;12985:38;13017:4;13011:11;12985:38;:::i;:::-;13070:67;13130:6;13122;13116:4;13070:67;:::i;:::-;13164:1;13193:2;13185:6;13182:14;13210:1;13205:632;;;;13881:1;13898:6;13895:84;;;13954:9;13949:3;13945:19;13932:33;13923:42;;13895:84;14005:67;14065:6;14058:5;14005:67;:::i;:::-;13999:4;13992:81;13854:229;13175:908;;13205:632;13257:4;13253:9;13245:6;13241:22;13291:37;13323:4;13291:37;:::i;:::-;13350:1;13364:215;13378:7;13375:1;13372:14;13364:215;;;13464:9;13459:3;13455:19;13442:33;13434:6;13427:49;13515:1;13507:6;13503:14;13493:24;;13562:2;13551:9;13547:18;13534:31;;13401:4;13398:1;13394:12;13389:17;;13364:215;;;13607:6;13598:7;13595:19;13592:186;;;13672:9;13667:3;13663:19;13650:33;13715:48;13757:4;13749:6;13745:17;13734:9;13715:48;:::i;:::-;13707:6;13700:64;13615:163;13592:186;13824:1;13820;13812:6;13808:14;13804:22;13798:4;13791:36;13212:625;;;13175:908;;12785:1304;;;12686:1403;;;:::o;14095:148::-;14197:11;14234:3;14219:18;;14095:148;;;;:::o;14273:874::-;14376:3;14413:5;14407:12;14442:36;14468:9;14442:36;:::i;:::-;14494:89;14576:6;14571:3;14494:89;:::i;:::-;14487:96;;14614:1;14603:9;14599:17;14630:1;14625:166;;;;14805:1;14800:341;;;;14592:549;;14625:166;14709:4;14705:9;14694;14690:25;14685:3;14678:38;14771:6;14764:14;14757:22;14749:6;14745:35;14740:3;14736:45;14729:52;;14625:166;;14800:341;14867:38;14899:5;14867:38;:::i;:::-;14927:1;14941:154;14955:6;14952:1;14949:13;14941:154;;;15029:7;15023:14;15019:1;15014:3;15010:11;15003:35;15079:1;15070:7;15066:15;15055:26;;14977:4;14974:1;14970:12;14965:17;;14941:154;;;15124:6;15119:3;15115:16;15108:23;;14807:334;;14592:549;;14380:767;;14273:874;;;;:::o;15153:390::-;15259:3;15287:39;15320:5;15287:39;:::i;:::-;15342:89;15424:6;15419:3;15342:89;:::i;:::-;15335:96;;15440:65;15498:6;15493:3;15486:4;15479:5;15475:16;15440:65;:::i;:::-;15530:6;15525:3;15521:16;15514:23;;15263:280;15153:390;;;;:::o;15549:155::-;15689:7;15685:1;15677:6;15673:14;15666:31;15549:155;:::o;15710:400::-;15870:3;15891:84;15973:1;15968:3;15891:84;:::i;:::-;15884:91;;15984:93;16073:3;15984:93;:::i;:::-;16102:1;16097:3;16093:11;16086:18;;15710:400;;;:::o;16116:695::-;16394:3;16416:92;16504:3;16495:6;16416:92;:::i;:::-;16409:99;;16525:95;16616:3;16607:6;16525:95;:::i;:::-;16518:102;;16637:148;16781:3;16637:148;:::i;:::-;16630:155;;16802:3;16795:10;;16116:695;;;;;:::o;16817:325::-;16957:34;16953:1;16945:6;16941:14;16934:58;17030:34;17025:2;17017:6;17013:15;17006:59;17103:27;17098:2;17090:6;17086:15;17079:52;16817:325;:::o;17152:418::-;17312:3;17337:85;17419:2;17414:3;17337:85;:::i;:::-;17330:92;;17435:93;17524:3;17435:93;:::i;:::-;17557:2;17552:3;17548:12;17541:19;;17152:418;;;:::o;17580:827::-;17914:3;17940:148;18084:3;17940:148;:::i;:::-;17933:155;;18109:95;18200:3;18191:6;18109:95;:::i;:::-;18102:102;;18225:148;18369:3;18225:148;:::i;:::-;18218:155;;18394:3;18387:10;;17580:827;;;;:::o;18417:101::-;18453:7;18497:10;18490:5;18486:22;18475:33;;18417:101;;;:::o;18528:191::-;18566:3;18593:23;18610:5;18593:23;:::i;:::-;18584:32;;18642:10;18635:5;18632:21;18629:47;;18656:18;;:::i;:::-;18629:47;18707:1;18700:5;18696:13;18689:20;;18528:191;;;:::o;18729:196::-;18781:77;18778:1;18771:88;18882:4;18879:1;18872:15;18910:4;18907:1;18900:15
Swarm Source
ipfs://9be16f4b6e7a751fbf019836c3d73f1e66a6fa7ab3e2b94a626824b87a86b877
Loading...
Loading
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.