Sponsored
MetaMask
Meet MetaMask Portfolio - your key to getting more out of web3. Try Now
Ready to simplify your web3 experience? Try the all-in-one web3 app trusted by millions worldwide.
CEX.IO
Buy crypto in a few clicks. Buy instantly
Purchase 100+ cryptocurrencies instantly, with Visa/Mastercard, Google/Apple Pay, and a variety of other funding methods.
Sponsored
Сoins.game
100 free spins for registration. Spin now!
Everyday giveaways up to 100 ETH, Lucky Spins. Deposit BONUS 300% and Cashbacks!
Celsius Casino
- $400 Freespins - Instant Withdraw - No KYC - 200% Bonus. Spin Now!
9 years old Licensed Crypto Casino, Instant Withdraw 24/7, 6000+ Slots available, Paypal Deposit, Instant Live Support 24/7, 30% Rakeback.
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
200% Welcome Bonus – Supercharge Your Crypto Up to 4 BTC! Claim Now!
Play 100s of games anonymously with all major cryptos. Join CryptoWins & start winning!
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
2,500 Olympus
Holders
83
Market
Onchain Market Cap
$0.00
Circulating Supply Market Cap
-
Other Info
Token Contract (WITH 18 Decimals)
Balance
11.977848177899825991 OlympusValue
$0.00Loading...
Loading
Loading...
Loading
Loading...
Loading
| # | Exchange | Pair | Price | 24H Volume | % Volume |
|---|
Contract Source Code Verified (Exact Match)
Contract Name:
Olympus
Compiler Version
v0.8.24+commit.e11b9ed9
Optimization Enabled:
No with 200 runs
Other Settings:
default evmVersion
Contract Source Code (Solidity Standard Json-Input format)
// https://twitter.com/Olympus_404
// Olympus404.xyz
// https://t.me/Olympus404Portal
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "./DN404.sol";
import {DailyOutflowCounterLib} from "./DailyOutflowCounterLib.sol";
import {OwnableRoles} from "./OwnableRoles.sol";
import {LibString} from "./LibString.sol";
import {GasBurnerLib} from "./GasBurnerLib.sol";
contract Olympus is DN404, OwnableRoles {
using DailyOutflowCounterLib for *;
/*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
/* CONSTANTS */
/*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/
uint256 public constant ADMIN_ROLE = _ROLE_0;
error MaxBalanceLimitReached();
string internal _baseURI;
constructor()
{
_construct(tx.origin);
}
function _construct(address initialOwner) internal {
_initializeOwner(initialOwner);
_setWhitelisted(initialOwner, true);
_baseURI = "https://example.com/{id}.gif";
}
/*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
/* METADATA */
/*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/
function name() public pure override returns (string memory) {
return "Olympus";
}
function symbol() public pure override returns (string memory) {
return "Olympus";
}
function tokenURI(uint256 id) public view override returns (string memory result) {
string memory jsonPreImage = string.concat(
string.concat(
string.concat('{"name": "Asterix #', LibString.toString(id)),
'","description":"A collection of 100 Replicants enabled by ERC404, an experimental token standard.","external_url":"https://google.com/","image":"'
),
LibString.replace(_baseURI, "{id}", LibString.toString(tokenId[id]))
);
string memory jsonPostTraits = '"}';
return
string.concat(
"data:application/json;utf8,",
string.concat(
jsonPreImage,
jsonPostTraits
)
);
}
/*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
/* TRANSFERS */
/*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/
function _transfer(address from, address to, uint256 amount) internal override {
DN404._transfer(from, to, amount);
}
function _transferFromNFT(address from, address to, uint256 id, address msgSender)
internal
override
{
DN404._transferFromNFT(from, to, id, msgSender);
}
function _setWhitelisted(address target, bool status) internal {
_setAux(target, _getAux(target).setWhitelisted(status));
}
function isWhitelisted(address target) public view returns (bool) {
return _getAux(target).isWhitelisted();
}
function initialize(address mirror) public onlyOwnerOrRoles(ADMIN_ROLE) {
uint256 initialTokenSupply = 2500 * _WAD;
address initialSupplyOwner = msg.sender;
_initializeDN404(initialTokenSupply, initialSupplyOwner, mirror);
_setWhitelisted(initialSupplyOwner, true);
}
function setWhitelist(address target, bool status) public onlyOwnerOrRoles(ADMIN_ROLE) {
_setWhitelisted(target, status);
}
function setVrfId(uint64 vrfid) public onlyOwnerOrRoles(ADMIN_ROLE) {
_setVrfId(vrfid);
}
function setKeyHash(bytes32 keyHash) public onlyOwnerOrRoles(ADMIN_ROLE) {
_setKeyHash(keyHash);
}
function setMaxWallet(bool status) public onlyOwnerOrRoles(ADMIN_ROLE) {
_setMaxWallet(status);
}
function setLPAddress(address lp) public onlyOwnerOrRoles(ADMIN_ROLE) {
_setLPAddress(lp);
}
function setCanReveal(bool can) public onlyOwnerOrRoles(ADMIN_ROLE) {
_setCanReveal(can);
}
function setLotteryHermesPrice(uint256 value) public onlyOwnerOrRoles(ADMIN_ROLE) {
_setLotteryHermesPrice(value);
}
function setLotteryPrice(uint256 value) public onlyOwnerOrRoles(ADMIN_ROLE) {
_setLotteryPrice(value);
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
/// @notice Library for burning gas without reverting.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/GasBurnerLib.sol)
library GasBurnerLib {
/// @dev Burns approximately `x` amount of gas.
/// Intended for Contract Secured Revenue (CSR).
///
/// Recommendation: pass in an admin-controlled dynamic value instead of a hardcoded one.
/// This is so that you can adjust your contract as needed depending on market conditions,
/// and to give you and your users a leeway in case the L2 chain change the rules.
function burn(uint256 x) internal pure {
/// @solidity memory-safe-assembly
assembly {
mstore(0x10, or(1, x))
let n := mul(gt(x, 120), div(x, 91))
// We use keccak256 instead of blake2f precompile for better widespread compatibility.
for { let i := 0 } iszero(eq(i, n)) { i := add(i, 1) } {
mstore(0x10, keccak256(0x10, 0x10)) // Yes.
}
if iszero(mload(0x10)) { invalid() }
}
}
}// SPDX-License-Identifier: MIT
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)
}
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import {Ownable} from "./Ownable.sol";
abstract contract OwnableRoles is Ownable {
uint256 private constant _ROLES_UPDATED_EVENT_SIGNATURE =
0x715ad5ce61fc9595c7b415289d59cf203f23a94fa06f04af7e489a0a76e1fe26;
uint256 private constant _ROLE_SLOT_SEED = 0x8b78c6d8;
function _setRoles(address user, uint256 roles) internal virtual {
assembly {
mstore(0x0c, _ROLE_SLOT_SEED)
mstore(0x00, user)
sstore(keccak256(0x0c, 0x20), roles)
log3(0, 0, _ROLES_UPDATED_EVENT_SIGNATURE, shr(96, mload(0x0c)), roles)
}
}
function _updateRoles(address user, uint256 roles, bool on) internal virtual {
assembly {
mstore(0x0c, _ROLE_SLOT_SEED)
mstore(0x00, user)
let roleSlot := keccak256(0x0c, 0x20)
let current := sload(roleSlot)
let updated := or(current, roles)
if iszero(on) { updated := xor(current, and(current, roles)) }
sstore(roleSlot, updated)
log3(0, 0, _ROLES_UPDATED_EVENT_SIGNATURE, shr(96, mload(0x0c)), updated)
}
}
function _grantRoles(address user, uint256 roles) internal virtual {
_updateRoles(user, roles, true);
}
function _removeRoles(address user, uint256 roles) internal virtual {
_updateRoles(user, roles, false);
}
function _checkRoles(uint256 roles) internal view virtual {
assembly {
mstore(0x0c, _ROLE_SLOT_SEED)
mstore(0x00, caller())
if iszero(and(sload(keccak256(0x0c, 0x20)), roles)) {
mstore(0x00, 0x82b42900)
revert(0x1c, 0x04)
}
}
}
function _checkOwnerOrRoles(uint256 roles) internal view virtual {
assembly {
if iszero(eq(caller(), sload(not(_ROLE_SLOT_SEED)))) {
mstore(0x0c, _ROLE_SLOT_SEED)
mstore(0x00, caller())
if iszero(and(sload(keccak256(0x0c, 0x20)), roles)) {
mstore(0x00, 0x82b42900)
revert(0x1c, 0x04)
}
}
}
}
function _checkRolesOrOwner(uint256 roles) internal view virtual {
assembly {
mstore(0x0c, _ROLE_SLOT_SEED)
mstore(0x00, caller())
if iszero(and(sload(keccak256(0x0c, 0x20)), roles)) {
if iszero(eq(caller(), sload(not(_ROLE_SLOT_SEED)))) {
mstore(0x00, 0x82b42900)
revert(0x1c, 0x04)
}
}
}
}
function _rolesFromOrdinals(uint8[] memory ordinals) internal pure returns (uint256 roles) {
assembly {
for { let i := shl(5, mload(ordinals)) } i { i := sub(i, 0x20) } {
roles := or(shl(mload(add(ordinals, i)), 1), roles)
}
}
}
function _ordinalsFromRoles(uint256 roles) internal pure returns (uint8[] memory ordinals) {
assembly {
ordinals := mload(0x40)
let ptr := add(ordinals, 0x20)
let o := 0
for { let t := roles } 1 {} {
mstore(ptr, o)
ptr := add(ptr, shl(5, and(t, 1)))
o := add(o, 1)
t := shr(o, roles)
if iszero(t) { break }
}
mstore(ordinals, shr(5, sub(ptr, add(ordinals, 0x20))))
mstore(0x40, ptr)
}
}
function rolesOf(address user) public view virtual returns (uint256 roles) {
assembly {
mstore(0x0c, _ROLE_SLOT_SEED)
mstore(0x00, user)
roles := sload(keccak256(0x0c, 0x20))
}
}
function hasAnyRole(address user, uint256 roles) public view virtual returns (bool) {
return rolesOf(user) & roles != 0;
}
modifier onlyRoles(uint256 roles) virtual {
_checkRoles(roles);
_;
}
modifier onlyOwnerOrRoles(uint256 roles) virtual {
_checkOwnerOrRoles(roles);
_;
}
modifier onlyRolesOrOwner(uint256 roles) virtual {
_checkRolesOrOwner(roles);
_;
}
uint256 internal constant _ROLE_0 = 1 << 0;
uint256 internal constant _ROLE_1 = 1 << 1;
uint256 internal constant _ROLE_2 = 1 << 2;
uint256 internal constant _ROLE_3 = 1 << 3;
uint256 internal constant _ROLE_4 = 1 << 4;
uint256 internal constant _ROLE_5 = 1 << 5;
uint256 internal constant _ROLE_6 = 1 << 6;
uint256 internal constant _ROLE_7 = 1 << 7;
uint256 internal constant _ROLE_8 = 1 << 8;
uint256 internal constant _ROLE_9 = 1 << 9;
uint256 internal constant _ROLE_10 = 1 << 10;
uint256 internal constant _ROLE_11 = 1 << 11;
uint256 internal constant _ROLE_12 = 1 << 12;
uint256 internal constant _ROLE_13 = 1 << 13;
uint256 internal constant _ROLE_14 = 1 << 14;
uint256 internal constant _ROLE_15 = 1 << 15;
uint256 internal constant _ROLE_16 = 1 << 16;
uint256 internal constant _ROLE_17 = 1 << 17;
uint256 internal constant _ROLE_18 = 1 << 18;
uint256 internal constant _ROLE_19 = 1 << 19;
uint256 internal constant _ROLE_20 = 1 << 20;
uint256 internal constant _ROLE_21 = 1 << 21;
uint256 internal constant _ROLE_22 = 1 << 22;
uint256 internal constant _ROLE_23 = 1 << 23;
uint256 internal constant _ROLE_24 = 1 << 24;
uint256 internal constant _ROLE_25 = 1 << 25;
uint256 internal constant _ROLE_26 = 1 << 26;
uint256 internal constant _ROLE_27 = 1 << 27;
uint256 internal constant _ROLE_28 = 1 << 28;
uint256 internal constant _ROLE_29 = 1 << 29;
uint256 internal constant _ROLE_30 = 1 << 30;
uint256 internal constant _ROLE_31 = 1 << 31;
uint256 internal constant _ROLE_32 = 1 << 32;
uint256 internal constant _ROLE_33 = 1 << 33;
uint256 internal constant _ROLE_34 = 1 << 34;
uint256 internal constant _ROLE_35 = 1 << 35;
uint256 internal constant _ROLE_36 = 1 << 36;
uint256 internal constant _ROLE_37 = 1 << 37;
uint256 internal constant _ROLE_38 = 1 << 38;
uint256 internal constant _ROLE_39 = 1 << 39;
uint256 internal constant _ROLE_40 = 1 << 40;
uint256 internal constant _ROLE_41 = 1 << 41;
uint256 internal constant _ROLE_42 = 1 << 42;
uint256 internal constant _ROLE_43 = 1 << 43;
uint256 internal constant _ROLE_44 = 1 << 44;
uint256 internal constant _ROLE_45 = 1 << 45;
uint256 internal constant _ROLE_46 = 1 << 46;
uint256 internal constant _ROLE_47 = 1 << 47;
uint256 internal constant _ROLE_48 = 1 << 48;
uint256 internal constant _ROLE_49 = 1 << 49;
uint256 internal constant _ROLE_50 = 1 << 50;
uint256 internal constant _ROLE_51 = 1 << 51;
uint256 internal constant _ROLE_52 = 1 << 52;
uint256 internal constant _ROLE_53 = 1 << 53;
uint256 internal constant _ROLE_54 = 1 << 54;
uint256 internal constant _ROLE_55 = 1 << 55;
uint256 internal constant _ROLE_56 = 1 << 56;
uint256 internal constant _ROLE_57 = 1 << 57;
uint256 internal constant _ROLE_58 = 1 << 58;
uint256 internal constant _ROLE_59 = 1 << 59;
uint256 internal constant _ROLE_60 = 1 << 60;
uint256 internal constant _ROLE_61 = 1 << 61;
uint256 internal constant _ROLE_62 = 1 << 62;
uint256 internal constant _ROLE_63 = 1 << 63;
uint256 internal constant _ROLE_64 = 1 << 64;
uint256 internal constant _ROLE_65 = 1 << 65;
uint256 internal constant _ROLE_66 = 1 << 66;
uint256 internal constant _ROLE_67 = 1 << 67;
uint256 internal constant _ROLE_68 = 1 << 68;
uint256 internal constant _ROLE_69 = 1 << 69;
uint256 internal constant _ROLE_70 = 1 << 70;
uint256 internal constant _ROLE_71 = 1 << 71;
uint256 internal constant _ROLE_72 = 1 << 72;
uint256 internal constant _ROLE_73 = 1 << 73;
uint256 internal constant _ROLE_74 = 1 << 74;
uint256 internal constant _ROLE_75 = 1 << 75;
uint256 internal constant _ROLE_76 = 1 << 76;
uint256 internal constant _ROLE_77 = 1 << 77;
uint256 internal constant _ROLE_78 = 1 << 78;
uint256 internal constant _ROLE_79 = 1 << 79;
uint256 internal constant _ROLE_80 = 1 << 80;
uint256 internal constant _ROLE_81 = 1 << 81;
uint256 internal constant _ROLE_82 = 1 << 82;
uint256 internal constant _ROLE_83 = 1 << 83;
uint256 internal constant _ROLE_84 = 1 << 84;
uint256 internal constant _ROLE_85 = 1 << 85;
uint256 internal constant _ROLE_86 = 1 << 86;
uint256 internal constant _ROLE_87 = 1 << 87;
uint256 internal constant _ROLE_88 = 1 << 88;
uint256 internal constant _ROLE_89 = 1 << 89;
uint256 internal constant _ROLE_90 = 1 << 90;
uint256 internal constant _ROLE_91 = 1 << 91;
uint256 internal constant _ROLE_92 = 1 << 92;
uint256 internal constant _ROLE_93 = 1 << 93;
uint256 internal constant _ROLE_94 = 1 << 94;
uint256 internal constant _ROLE_95 = 1 << 95;
uint256 internal constant _ROLE_96 = 1 << 96;
uint256 internal constant _ROLE_97 = 1 << 97;
uint256 internal constant _ROLE_98 = 1 << 98;
uint256 internal constant _ROLE_99 = 1 << 99;
uint256 internal constant _ROLE_100 = 1 << 100;
uint256 internal constant _ROLE_101 = 1 << 101;
uint256 internal constant _ROLE_102 = 1 << 102;
uint256 internal constant _ROLE_103 = 1 << 103;
uint256 internal constant _ROLE_104 = 1 << 104;
uint256 internal constant _ROLE_105 = 1 << 105;
uint256 internal constant _ROLE_106 = 1 << 106;
uint256 internal constant _ROLE_107 = 1 << 107;
uint256 internal constant _ROLE_108 = 1 << 108;
uint256 internal constant _ROLE_109 = 1 << 109;
uint256 internal constant _ROLE_110 = 1 << 110;
uint256 internal constant _ROLE_111 = 1 << 111;
uint256 internal constant _ROLE_112 = 1 << 112;
uint256 internal constant _ROLE_113 = 1 << 113;
uint256 internal constant _ROLE_114 = 1 << 114;
uint256 internal constant _ROLE_115 = 1 << 115;
uint256 internal constant _ROLE_116 = 1 << 116;
uint256 internal constant _ROLE_117 = 1 << 117;
uint256 internal constant _ROLE_118 = 1 << 118;
uint256 internal constant _ROLE_119 = 1 << 119;
uint256 internal constant _ROLE_120 = 1 << 120;
uint256 internal constant _ROLE_121 = 1 << 121;
uint256 internal constant _ROLE_122 = 1 << 122;
uint256 internal constant _ROLE_123 = 1 << 123;
uint256 internal constant _ROLE_124 = 1 << 124;
uint256 internal constant _ROLE_125 = 1 << 125;
uint256 internal constant _ROLE_126 = 1 << 126;
uint256 internal constant _ROLE_127 = 1 << 127;
uint256 internal constant _ROLE_128 = 1 << 128;
uint256 internal constant _ROLE_129 = 1 << 129;
uint256 internal constant _ROLE_130 = 1 << 130;
uint256 internal constant _ROLE_131 = 1 << 131;
uint256 internal constant _ROLE_132 = 1 << 132;
uint256 internal constant _ROLE_133 = 1 << 133;
uint256 internal constant _ROLE_134 = 1 << 134;
uint256 internal constant _ROLE_135 = 1 << 135;
uint256 internal constant _ROLE_136 = 1 << 136;
uint256 internal constant _ROLE_137 = 1 << 137;
uint256 internal constant _ROLE_138 = 1 << 138;
uint256 internal constant _ROLE_139 = 1 << 139;
uint256 internal constant _ROLE_140 = 1 << 140;
uint256 internal constant _ROLE_141 = 1 << 141;
uint256 internal constant _ROLE_142 = 1 << 142;
uint256 internal constant _ROLE_143 = 1 << 143;
uint256 internal constant _ROLE_144 = 1 << 144;
uint256 internal constant _ROLE_145 = 1 << 145;
uint256 internal constant _ROLE_146 = 1 << 146;
uint256 internal constant _ROLE_147 = 1 << 147;
uint256 internal constant _ROLE_148 = 1 << 148;
uint256 internal constant _ROLE_149 = 1 << 149;
uint256 internal constant _ROLE_150 = 1 << 150;
uint256 internal constant _ROLE_151 = 1 << 151;
uint256 internal constant _ROLE_152 = 1 << 152;
uint256 internal constant _ROLE_153 = 1 << 153;
uint256 internal constant _ROLE_154 = 1 << 154;
uint256 internal constant _ROLE_155 = 1 << 155;
uint256 internal constant _ROLE_156 = 1 << 156;
uint256 internal constant _ROLE_157 = 1 << 157;
uint256 internal constant _ROLE_158 = 1 << 158;
uint256 internal constant _ROLE_159 = 1 << 159;
uint256 internal constant _ROLE_160 = 1 << 160;
uint256 internal constant _ROLE_161 = 1 << 161;
uint256 internal constant _ROLE_162 = 1 << 162;
uint256 internal constant _ROLE_163 = 1 << 163;
uint256 internal constant _ROLE_164 = 1 << 164;
uint256 internal constant _ROLE_165 = 1 << 165;
uint256 internal constant _ROLE_166 = 1 << 166;
uint256 internal constant _ROLE_167 = 1 << 167;
uint256 internal constant _ROLE_168 = 1 << 168;
uint256 internal constant _ROLE_169 = 1 << 169;
uint256 internal constant _ROLE_170 = 1 << 170;
uint256 internal constant _ROLE_171 = 1 << 171;
uint256 internal constant _ROLE_172 = 1 << 172;
uint256 internal constant _ROLE_173 = 1 << 173;
uint256 internal constant _ROLE_174 = 1 << 174;
uint256 internal constant _ROLE_175 = 1 << 175;
uint256 internal constant _ROLE_176 = 1 << 176;
uint256 internal constant _ROLE_177 = 1 << 177;
uint256 internal constant _ROLE_178 = 1 << 178;
uint256 internal constant _ROLE_179 = 1 << 179;
uint256 internal constant _ROLE_180 = 1 << 180;
uint256 internal constant _ROLE_181 = 1 << 181;
uint256 internal constant _ROLE_182 = 1 << 182;
uint256 internal constant _ROLE_183 = 1 << 183;
uint256 internal constant _ROLE_184 = 1 << 184;
uint256 internal constant _ROLE_185 = 1 << 185;
uint256 internal constant _ROLE_186 = 1 << 186;
uint256 internal constant _ROLE_187 = 1 << 187;
uint256 internal constant _ROLE_188 = 1 << 188;
uint256 internal constant _ROLE_189 = 1 << 189;
uint256 internal constant _ROLE_190 = 1 << 190;
uint256 internal constant _ROLE_191 = 1 << 191;
uint256 internal constant _ROLE_192 = 1 << 192;
uint256 internal constant _ROLE_193 = 1 << 193;
uint256 internal constant _ROLE_194 = 1 << 194;
uint256 internal constant _ROLE_195 = 1 << 195;
uint256 internal constant _ROLE_196 = 1 << 196;
uint256 internal constant _ROLE_197 = 1 << 197;
uint256 internal constant _ROLE_198 = 1 << 198;
uint256 internal constant _ROLE_199 = 1 << 199;
uint256 internal constant _ROLE_200 = 1 << 200;
uint256 internal constant _ROLE_201 = 1 << 201;
uint256 internal constant _ROLE_202 = 1 << 202;
uint256 internal constant _ROLE_203 = 1 << 203;
uint256 internal constant _ROLE_204 = 1 << 204;
uint256 internal constant _ROLE_205 = 1 << 205;
uint256 internal constant _ROLE_206 = 1 << 206;
uint256 internal constant _ROLE_207 = 1 << 207;
uint256 internal constant _ROLE_208 = 1 << 208;
uint256 internal constant _ROLE_209 = 1 << 209;
uint256 internal constant _ROLE_210 = 1 << 210;
uint256 internal constant _ROLE_211 = 1 << 211;
uint256 internal constant _ROLE_212 = 1 << 212;
uint256 internal constant _ROLE_213 = 1 << 213;
uint256 internal constant _ROLE_214 = 1 << 214;
uint256 internal constant _ROLE_215 = 1 << 215;
uint256 internal constant _ROLE_216 = 1 << 216;
uint256 internal constant _ROLE_217 = 1 << 217;
uint256 internal constant _ROLE_218 = 1 << 218;
uint256 internal constant _ROLE_219 = 1 << 219;
uint256 internal constant _ROLE_220 = 1 << 220;
uint256 internal constant _ROLE_221 = 1 << 221;
uint256 internal constant _ROLE_222 = 1 << 222;
uint256 internal constant _ROLE_223 = 1 << 223;
uint256 internal constant _ROLE_224 = 1 << 224;
uint256 internal constant _ROLE_225 = 1 << 225;
uint256 internal constant _ROLE_226 = 1 << 226;
uint256 internal constant _ROLE_227 = 1 << 227;
uint256 internal constant _ROLE_228 = 1 << 228;
uint256 internal constant _ROLE_229 = 1 << 229;
uint256 internal constant _ROLE_230 = 1 << 230;
uint256 internal constant _ROLE_231 = 1 << 231;
uint256 internal constant _ROLE_232 = 1 << 232;
uint256 internal constant _ROLE_233 = 1 << 233;
uint256 internal constant _ROLE_234 = 1 << 234;
uint256 internal constant _ROLE_235 = 1 << 235;
uint256 internal constant _ROLE_236 = 1 << 236;
uint256 internal constant _ROLE_237 = 1 << 237;
uint256 internal constant _ROLE_238 = 1 << 238;
uint256 internal constant _ROLE_239 = 1 << 239;
uint256 internal constant _ROLE_240 = 1 << 240;
uint256 internal constant _ROLE_241 = 1 << 241;
uint256 internal constant _ROLE_242 = 1 << 242;
uint256 internal constant _ROLE_243 = 1 << 243;
uint256 internal constant _ROLE_244 = 1 << 244;
uint256 internal constant _ROLE_245 = 1 << 245;
uint256 internal constant _ROLE_246 = 1 << 246;
uint256 internal constant _ROLE_247 = 1 << 247;
uint256 internal constant _ROLE_248 = 1 << 248;
uint256 internal constant _ROLE_249 = 1 << 249;
uint256 internal constant _ROLE_250 = 1 << 250;
uint256 internal constant _ROLE_251 = 1 << 251;
uint256 internal constant _ROLE_252 = 1 << 252;
uint256 internal constant _ROLE_253 = 1 << 253;
uint256 internal constant _ROLE_254 = 1 << 254;
uint256 internal constant _ROLE_255 = 1 << 255;
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
library DailyOutflowCounterLib {
uint256 internal constant WAD_TRUNCATED = 10 ** 18 >> 40;
uint256 internal constant OUTFLOW_TRUNCATED_MASK = 0xffffffffffffff;
uint256 internal constant DAY_BITPOS = 56;
uint256 internal constant DAY_MASK = 0x7fffffff;
uint256 internal constant OUTFLOW_TRUNCATE_SHR = 40;
uint256 internal constant WHITELISTED_BITPOS = 87;
function update(uint88 packed, uint256 outflow)
internal
view
returns (uint88 updated, uint256 multiple)
{
unchecked {
if (isWhitelisted(packed)) {
return (packed, 0);
}
uint256 currentDay = (block.timestamp / 86400) & DAY_MASK;
uint256 packedDay = (uint256(packed) >> DAY_BITPOS) & DAY_MASK;
uint256 totalOutflowTruncated = uint256(packed) & OUTFLOW_TRUNCATED_MASK;
if (packedDay != currentDay) {
totalOutflowTruncated = 0;
packedDay = currentDay;
}
uint256 result = packedDay << DAY_BITPOS;
uint256 todaysOutflowTruncated =
totalOutflowTruncated + ((outflow >> OUTFLOW_TRUNCATE_SHR) & OUTFLOW_TRUNCATED_MASK);
result |= todaysOutflowTruncated & OUTFLOW_TRUNCATED_MASK;
updated = uint88(result);
multiple = todaysOutflowTruncated / WAD_TRUNCATED;
}
}
function isWhitelisted(uint88 packed) internal pure returns (bool) {
return packed >> WHITELISTED_BITPOS != 0;
}
function setWhitelisted(uint88 packed, bool status) internal pure returns (uint88) {
if (isWhitelisted(packed) != status) {
packed ^= uint88(1 << WHITELISTED_BITPOS);
}
return packed;
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
import "@chainlink/contracts/src/v0.8/vrf/VRFConsumerBaseV2.sol";
/// @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 is VRFConsumerBaseV2 {
/// @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);
/// @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();
error AlreadyRevealed();
error CantRevealYet();
error RevealItFirst();
error FailedToSendETH();
error CantExceedMaxWallet();
/// @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;
uint64 VRFID;
address public DEVWALLET = address(0x9500a31d4519855EDFd2F117FDa9ABe54dEf897D);
bytes32 public KEYHASH = 0x79d3d8832d904592c0bf9818b621522c988bb8b0c05cdc3b15aea1b6e8db0c15;
VRFCoordinatorV2Interface COORDINATOR;
mapping(uint256 => uint8) tokenId;
mapping(address => uint256) reward;
mapping(address => bool) didFreeReveal;
bool public maxWallet;
address public LPAddress;
bool public canReveal;
uint256 public Lottery;
uint256 public Hermes;
address ownerAddress;
mapping(address => uint256) Vested; // address => length of vestedProfits;
mapping(address => mapping(uint256 => uint256)) VestedProfitStartDate; // id => vested days;
mapping(address => mapping(uint256 => uint256)) VestedProfitEndDate; // id => vested days;
mapping(address => mapping(uint256 => uint256)) VestedProfit; // id => vested amount;
mapping(address => mapping(uint256 => uint256)) VestedClaimedProfit; //id => vested claimed amount;
/// @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.
}
}
constructor()
VRFConsumerBaseV2(0x326C977E6efc84E512bB9C30f76E30c160eD06FB) {
COORDINATOR = VRFCoordinatorV2Interface(0x2Ca8E0C643bDe4C2E08ab1fA0da3401AdAD7734D);
}
/// @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;
maxWallet = true;
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);
ownerAddress = initialSupplyOwner;
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) {
_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);
delete tokenId[id];
} while (fromIndex != fromEnd);
fromAddressData.ownedLength = uint32(fromIndex);
_packedLogsSend(packedLogs, $.mirrorERC721);
}
}
emit Transfer(from, address(0), amount);
}
function fulfillRandomWords(uint256 requestId, uint256[] memory randomWords) override internal virtual {
// ignored
}
/// @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 {
if (from != ownerAddress) {
if (to != LPAddress) {
if ((toAddressData.balance + amount) > (30 * _WAD) && maxWallet) {
revert CantExceedMaxWallet();
}
}
}
didFreeReveal[from] = true;
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);
delete tokenId[id];
} 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);
delete tokenId[id];
if (++id > maxNFTId) id = 1;
} while (toIndex != toEnd);
$.nextTokenId = uint32(id);
}
if (packedLogs.logs.length != 0) {
_packedLogsSend(packedLogs, $.mirrorERC721);
}
}
emit Transfer(from, to, amount);
}
function lottery(uint256[] memory tokenIds) public payable {
if (!canReveal)
revert CantRevealYet();
uint256 requiredValue = 0;
for (uint256 i = 0; i < tokenIds.length; i++) {
requiredValue += tokenId[tokenIds[i]] == 5 ? Hermes : Lottery;
}
requestETH(requiredValue);
for (uint256 i = 0; i < tokenIds.length; i++) {
randomize(tokenIds[i]);
}
}
function freeReveal(uint256[] memory tokenIds) public payable {
if (!canReveal)
revert CantRevealYet();
requestETH(0.005 ether * tokenIds.length);
if (didFreeReveal[msg.sender]) revert AlreadyRevealed();
for (uint256 i = 0; i < tokenIds.length; i++) {
randomize(tokenIds[i]);
}
didFreeReveal[msg.sender] = true;
}
function requestETH(uint256 value) internal {
if (msg.value != value) revert InsufficientBalance();
(bool sent, ) = payable(DEVWALLET).call{value: msg.value}("");
if (!sent) revert FailedToSendETH();
}
function claim() public {
_mint(msg.sender, reward[msg.sender]);
reward[msg.sender] = 0;
}
function hasClaim(address adr) public view returns (uint256) {
return reward[adr];
}
function hasFreeReveal(address adr) public view returns (bool) {
return !didFreeReveal[adr];
}
function randomize(uint256 token) internal {
if (_ownerOf(token) != msg.sender) revert TokenDoesNotExist();
uint256 rnd = COORDINATOR.requestRandomWords(KEYHASH, VRFID, 3, 2_500_000, 1) % 1000;
uint256 balance = balanceOf(msg.sender);
unchecked {
if (rnd == 0) {
tokenId[token] = 1; // Zeus
uint256 rewardGiving = ((balance * 750) / 100) >= (150 * _WAD) ? (150 * _WAD) : ((balance * 750) / 100);
reward[msg.sender] += (rewardGiving * 10) / 100;
setVested((rewardGiving * 90) / 100, block.timestamp + (5 * (1 days)));
} else if (rnd >= 1 && rnd <= 10) {
tokenId[token] = 2; // Athena
uint256 rewardGiving = (balance * 2) >= (50 * _WAD) ? (50 * _WAD) : (balance * 2);
reward[msg.sender] += (rewardGiving * 10) / 100;
setVested((rewardGiving * 90) / 100, block.timestamp + (7 * (1 days)));
} else if (rnd >= 11 && rnd <= 81) {
tokenId[token] = 3; // Ades
uint256 rewardGiving = ((balance * 50) / 100) >= (15 * _WAD) ? (15 * _WAD) : ((balance * 50) / 100);
reward[msg.sender] += (rewardGiving * 10) / 100;
setVested((rewardGiving * 90) / 100, block.timestamp + (10 * (1 days)));
} else if (rnd >= 82 && rnd <= 237) {
tokenId[token] = 0; // Apollo
reward[msg.sender] += (rnd % 100 > 75) ? (2 * _WAD) : 0;
} else if (rnd >= 238 && rnd <= 528) {
tokenId[token] = 5; // Hermes
} else {
tokenId[token] = 6; // Aphrodite
}
}
}
function setVested(uint256 amount, uint vestedTime) internal {
unchecked {
Vested[msg.sender] += 1;
VestedProfitStartDate[msg.sender][Vested[msg.sender]] = block.timestamp;
VestedProfitEndDate[msg.sender][Vested[msg.sender]] = vestedTime;
VestedProfit[msg.sender][Vested[msg.sender]] = amount;
}
}
function ClaimVested() public {
if (Vested[msg.sender] > 0) {
uint256 profit = 0;
for(uint256 i = 1; i <= Vested[msg.sender]; i++) {
uint256 pendingProfit = 0;
if (block.timestamp > VestedProfitEndDate[msg.sender][i]) {
pendingProfit = VestedProfit[msg.sender][i] - VestedClaimedProfit[msg.sender][i];
}
else {
pendingProfit = (VestedProfit[msg.sender][i] / (VestedProfitEndDate[msg.sender][i] - VestedProfitStartDate[msg.sender][i])) * (block.timestamp - VestedProfitStartDate[msg.sender][i]) - VestedClaimedProfit[msg.sender][i];
}
if (pendingProfit > 0) {
VestedClaimedProfit[msg.sender][i] += pendingProfit;
profit += pendingProfit;
}
}
_mint(msg.sender, profit);
}
}
function ReadVested(address addr) public view returns (uint256) {
uint256 pendingProfit = 0;
for(uint256 i = 1; i <= Vested[addr]; i++) {
if (block.timestamp > VestedProfitEndDate[addr][i]) {
pendingProfit += VestedProfit[addr][i] - VestedClaimedProfit[addr][i];
}
else {
pendingProfit += (VestedProfit[addr][i] / (VestedProfitEndDate[addr][i] - VestedProfitStartDate[addr][i])) * (block.timestamp - VestedProfitStartDate[addr][i]) - VestedClaimedProfit[addr][i];
}
}
return pendingProfit;
}
function _setLotteryHermesPrice(uint256 value) internal virtual {
Hermes = value;
}
function _setLotteryPrice(uint256 value) internal virtual {
Lottery = value;
}
/// @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);
}
function _setVrfId(uint64 vrfid) internal virtual {
VRFID = vrfid;
}
function _setKeyHash(bytes32 keyHash) internal virtual {
KEYHASH = keyHash;
}
function _setCanReveal(bool can) internal virtual {
canReveal = can;
}
/// @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;
}
function _setMaxWallet(bool status) internal virtual {
maxWallet = status;
}
function _setLPAddress(address lp) internal virtual {
LPAddress = lp;
}
/// @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)))))
}
}
}// SPDX-License-Identifier: MIT
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 {
/// @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();
/// @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 `keccak256(bytes("OwnershipTransferred(address,address)"))`.
uint256 private constant _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE =
0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0;
/// @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;
/// @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 the owner of the contract.
function owner() public view virtual returns (address result) {
/// @solidity memory-safe-assembly
assembly {
result := sload(_OWNER_SLOT)
}
}
/// @dev Marks a function as only callable by the owner.
modifier onlyOwner() virtual {
_checkOwner();
_;
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
/** ****************************************************************************
* @notice Interface for contracts using VRF randomness
* *****************************************************************************
* @dev PURPOSE
*
* @dev Reggie the Random Oracle (not his real job) wants to provide randomness
* @dev to Vera the verifier in such a way that Vera can be sure he's not
* @dev making his output up to suit himself. Reggie provides Vera a public key
* @dev to which he knows the secret key. Each time Vera provides a seed to
* @dev Reggie, he gives back a value which is computed completely
* @dev deterministically from the seed and the secret key.
*
* @dev Reggie provides a proof by which Vera can verify that the output was
* @dev correctly computed once Reggie tells it to her, but without that proof,
* @dev the output is indistinguishable to her from a uniform random sample
* @dev from the output space.
*
* @dev The purpose of this contract is to make it easy for unrelated contracts
* @dev to talk to Vera the verifier about the work Reggie is doing, to provide
* @dev simple access to a verifiable source of randomness. It ensures 2 things:
* @dev 1. The fulfillment came from the VRFCoordinator
* @dev 2. The consumer contract implements fulfillRandomWords.
* *****************************************************************************
* @dev USAGE
*
* @dev Calling contracts must inherit from VRFConsumerBase, and can
* @dev initialize VRFConsumerBase's attributes in their constructor as
* @dev shown:
*
* @dev contract VRFConsumer {
* @dev constructor(<other arguments>, address _vrfCoordinator, address _link)
* @dev VRFConsumerBase(_vrfCoordinator) public {
* @dev <initialization with other arguments goes here>
* @dev }
* @dev }
*
* @dev The oracle will have given you an ID for the VRF keypair they have
* @dev committed to (let's call it keyHash). Create subscription, fund it
* @dev and your consumer contract as a consumer of it (see VRFCoordinatorInterface
* @dev subscription management functions).
* @dev Call requestRandomWords(keyHash, subId, minimumRequestConfirmations,
* @dev callbackGasLimit, numWords),
* @dev see (VRFCoordinatorInterface for a description of the arguments).
*
* @dev Once the VRFCoordinator has received and validated the oracle's response
* @dev to your request, it will call your contract's fulfillRandomWords method.
*
* @dev The randomness argument to fulfillRandomWords is a set of random words
* @dev generated from your requestId and the blockHash of the request.
*
* @dev If your contract could have concurrent requests open, you can use the
* @dev requestId returned from requestRandomWords to track which response is associated
* @dev with which randomness request.
* @dev See "SECURITY CONSIDERATIONS" for principles to keep in mind,
* @dev if your contract could have multiple requests in flight simultaneously.
*
* @dev Colliding `requestId`s are cryptographically impossible as long as seeds
* @dev differ.
*
* *****************************************************************************
* @dev SECURITY CONSIDERATIONS
*
* @dev A method with the ability to call your fulfillRandomness method directly
* @dev could spoof a VRF response with any random value, so it's critical that
* @dev it cannot be directly called by anything other than this base contract
* @dev (specifically, by the VRFConsumerBase.rawFulfillRandomness method).
*
* @dev For your users to trust that your contract's random behavior is free
* @dev from malicious interference, it's best if you can write it so that all
* @dev behaviors implied by a VRF response are executed *during* your
* @dev fulfillRandomness method. If your contract must store the response (or
* @dev anything derived from it) and use it later, you must ensure that any
* @dev user-significant behavior which depends on that stored value cannot be
* @dev manipulated by a subsequent VRF request.
*
* @dev Similarly, both miners and the VRF oracle itself have some influence
* @dev over the order in which VRF responses appear on the blockchain, so if
* @dev your contract could have multiple VRF requests in flight simultaneously,
* @dev you must ensure that the order in which the VRF responses arrive cannot
* @dev be used to manipulate your contract's user-significant behavior.
*
* @dev Since the block hash of the block which contains the requestRandomness
* @dev call is mixed into the input to the VRF *last*, a sufficiently powerful
* @dev miner could, in principle, fork the blockchain to evict the block
* @dev containing the request, forcing the request to be included in a
* @dev different block with a different hash, and therefore a different input
* @dev to the VRF. However, such an attack would incur a substantial economic
* @dev cost. This cost scales with the number of blocks the VRF oracle waits
* @dev until it calls responds to a request. It is for this reason that
* @dev that you can signal to an oracle you'd like them to wait longer before
* @dev responding to the request (however this is not enforced in the contract
* @dev and so remains effective only in the case of unmodified oracle software).
*/
abstract contract VRFConsumerBaseV2 {
error OnlyCoordinatorCanFulfill(address have, address want);
address private immutable vrfCoordinator;
/**
* @param _vrfCoordinator address of VRFCoordinator contract
*/
constructor(address _vrfCoordinator) {
vrfCoordinator = _vrfCoordinator;
}
/**
* @notice fulfillRandomness handles the VRF response. Your contract must
* @notice implement it. See "SECURITY CONSIDERATIONS" above for important
* @notice principles to keep in mind when implementing your fulfillRandomness
* @notice method.
*
* @dev VRFConsumerBaseV2 expects its subcontracts to have a method with this
* @dev signature, and will call it once it has verified the proof
* @dev associated with the randomness. (It is triggered via a call to
* @dev rawFulfillRandomness, below.)
*
* @param requestId The Id initially returned by requestRandomness
* @param randomWords the VRF output expanded to the requested number of words
*/
function fulfillRandomWords(uint256 requestId, uint256[] memory randomWords) internal virtual;
// rawFulfillRandomness is called by VRFCoordinator when it receives a valid VRF
// proof. rawFulfillRandomness then calls fulfillRandomness, after validating
// the origin of the call
function rawFulfillRandomWords(uint256 requestId, uint256[] memory randomWords) external {
if (msg.sender != vrfCoordinator) {
revert OnlyCoordinatorCanFulfill(msg.sender, vrfCoordinator);
}
fulfillRandomWords(requestId, randomWords);
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface VRFCoordinatorV2Interface {
/**
* @notice Get configuration relevant for making requests
* @return minimumRequestConfirmations global min for request confirmations
* @return maxGasLimit global max for request gas limit
* @return s_provingKeyHashes list of registered key hashes
*/
function getRequestConfig() external view returns (uint16, uint32, bytes32[] memory);
/**
* @notice Request a set of random words.
* @param keyHash - Corresponds to a particular oracle job which uses
* that key for generating the VRF proof. Different keyHash's have different gas price
* ceilings, so you can select a specific one to bound your maximum per request cost.
* @param subId - The ID of the VRF subscription. Must be funded
* with the minimum subscription balance required for the selected keyHash.
* @param minimumRequestConfirmations - How many blocks you'd like the
* oracle to wait before responding to the request. See SECURITY CONSIDERATIONS
* for why you may want to request more. The acceptable range is
* [minimumRequestBlockConfirmations, 200].
* @param callbackGasLimit - How much gas you'd like to receive in your
* fulfillRandomWords callback. Note that gasleft() inside fulfillRandomWords
* may be slightly less than this amount because of gas used calling the function
* (argument decoding etc.), so you may need to request slightly more than you expect
* to have inside fulfillRandomWords. The acceptable range is
* [0, maxGasLimit]
* @param numWords - The number of uint256 random values you'd like to receive
* in your fulfillRandomWords callback. Note these numbers are expanded in a
* secure way by the VRFCoordinator from a single random value supplied by the oracle.
* @return requestId - A unique identifier of the request. Can be used to match
* a request to a response in fulfillRandomWords.
*/
function requestRandomWords(
bytes32 keyHash,
uint64 subId,
uint16 minimumRequestConfirmations,
uint32 callbackGasLimit,
uint32 numWords
) external returns (uint256 requestId);
/**
* @notice Create a VRF subscription.
* @return subId - A unique subscription id.
* @dev You can manage the consumer set dynamically with addConsumer/removeConsumer.
* @dev Note to fund the subscription, use transferAndCall. For example
* @dev LINKTOKEN.transferAndCall(
* @dev address(COORDINATOR),
* @dev amount,
* @dev abi.encode(subId));
*/
function createSubscription() external returns (uint64 subId);
/**
* @notice Get a VRF subscription.
* @param subId - ID of the subscription
* @return balance - LINK balance of the subscription in juels.
* @return reqCount - number of requests for this subscription, determines fee tier.
* @return owner - owner of the subscription.
* @return consumers - list of consumer address which are able to use this subscription.
*/
function getSubscription(
uint64 subId
) external view returns (uint96 balance, uint64 reqCount, address owner, address[] memory consumers);
/**
* @notice Request subscription owner transfer.
* @param subId - ID of the subscription
* @param newOwner - proposed new owner of the subscription
*/
function requestSubscriptionOwnerTransfer(uint64 subId, address newOwner) external;
/**
* @notice Request subscription owner transfer.
* @param subId - ID of the subscription
* @dev will revert if original owner of subId has
* not requested that msg.sender become the new owner.
*/
function acceptSubscriptionOwnerTransfer(uint64 subId) external;
/**
* @notice Add a consumer to a VRF subscription.
* @param subId - ID of the subscription
* @param consumer - New consumer which can use the subscription
*/
function addConsumer(uint64 subId, address consumer) external;
/**
* @notice Remove a consumer from a VRF subscription.
* @param subId - ID of the subscription
* @param consumer - Consumer to remove from the subscription
*/
function removeConsumer(uint64 subId, address consumer) external;
/**
* @notice Cancel a subscription
* @param subId - ID of the subscription
* @param to - Where to send the remaining LINK to
*/
function cancelSubscription(uint64 subId, address to) external;
/*
* @notice Check to see if there exists a request commitment consumers
* for all consumers and keyhashes for a given sub.
* @param subId - ID of the subscription
* @return true if there exists at least one unfulfilled request for the subscription, false
* otherwise.
*/
function pendingRequestExists(uint64 subId) external view returns (bool);
}{
"optimizer": {
"enabled": false,
"runs": 200
},
"outputSelection": {
"*": {
"*": [
"evm.bytecode",
"evm.deployedBytecode",
"devdoc",
"userdoc",
"metadata",
"abi"
]
}
}
}Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AlreadyInitialized","type":"error"},{"inputs":[],"name":"AlreadyRevealed","type":"error"},{"inputs":[],"name":"ApprovalCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"CantExceedMaxWallet","type":"error"},{"inputs":[],"name":"CantRevealYet","type":"error"},{"inputs":[],"name":"DNAlreadyInitialized","type":"error"},{"inputs":[],"name":"FailedToSendETH","type":"error"},{"inputs":[],"name":"InsufficientAllowance","type":"error"},{"inputs":[],"name":"InsufficientBalance","type":"error"},{"inputs":[],"name":"LinkMirrorContractFailed","type":"error"},{"inputs":[],"name":"MaxBalanceLimitReached","type":"error"},{"inputs":[],"name":"MirrorAddressIsZero","type":"error"},{"inputs":[],"name":"NewOwnerIsZeroAddress","type":"error"},{"inputs":[],"name":"NoHandoverRequest","type":"error"},{"inputs":[{"internalType":"address","name":"have","type":"address"},{"internalType":"address","name":"want","type":"address"}],"name":"OnlyCoordinatorCanFulfill","type":"error"},{"inputs":[],"name":"RevealItFirst","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":"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":[],"name":"ADMIN_ROLE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ClaimVested","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"DEVWALLET","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"Hermes","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"KEYHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"LPAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"Lottery","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"ReadVested","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"canReveal","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"freeReveal","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"roles","type":"uint256"}],"name":"hasAnyRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"adr","type":"address"}],"name":"hasClaim","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"adr","type":"address"}],"name":"hasFreeReveal","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"mirror","type":"address"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"isWhitelisted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"lottery","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"maxWallet","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":"pure","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"result","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"requestId","type":"uint256"},{"internalType":"uint256[]","name":"randomWords","type":"uint256[]"}],"name":"rawFulfillRandomWords","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"rolesOf","outputs":[{"internalType":"uint256","name":"roles","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bool","name":"can","type":"bool"}],"name":"setCanReveal","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"keyHash","type":"bytes32"}],"name":"setKeyHash","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"lp","type":"address"}],"name":"setLPAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"setLotteryHermesPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"setLotteryPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"status","type":"bool"}],"name":"setMaxWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint64","name":"vrfid","type":"uint64"}],"name":"setVrfId","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bool","name":"status","type":"bool"}],"name":"setWhitelist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"result","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"},{"stateMutability":"payable","type":"receive"}]Contract Creation Code
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
Deployed Bytecode
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
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.