¡El código fuente de este contrato está verificado!
Metadatos del Contrato
Compilador
0.8.20+commit.a1b79de6
Idioma
Solidity
Código Fuente del Contrato
Archivo 1 de 5: ECDSA.sol
// SPDX-License-Identifier: MITpragmasolidity ^0.8.4;/// @notice Gas optimized ECDSA wrapper./// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/ECDSA.sol)/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/ECDSA.sol)/// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/cryptography/ECDSA.sol)////// @dev Note:/// - The recovery functions use the ecrecover precompile (0x1).////// WARNING! Do NOT use signatures as unique identifiers./// Please use EIP712 with a nonce included in the digest to prevent replay attacks./// This implementation does NOT check if a signature is non-malleable.libraryECDSA{
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* CUSTOM ERRORS *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev The signature is invalid.errorInvalidSignature();
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* RECOVERY OPERATIONS *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/// Note: as of Solady version 0.0.68, these functions will// revert upon recovery failure for more safety by default./// @dev Recovers the signer's address from a message digest `hash`,/// and the `signature`.////// This function does NOT accept EIP-2098 short form signatures./// Use `recover(bytes32 hash, bytes32 r, bytes32 vs)` for EIP-2098/// short form signatures instead.functionrecover(bytes32 hash, bytesmemory signature) internalviewreturns (address result) {
/// @solidity memory-safe-assemblyassembly {
let m :=mload(0x40) // Cache the free memory pointer.let signatureLength :=mload(signature)
mstore(0x00, hash)
mstore(0x20, byte(0, mload(add(signature, 0x60)))) // `v`.mstore(0x40, mload(add(signature, 0x20))) // `r`.mstore(0x60, mload(add(signature, 0x40))) // `s`.
result :=mload(
staticcall(
gas(), // Amount of gas left for the transaction.eq(signatureLength, 65), // Address of `ecrecover`.0x00, // Start of input.0x80, // Size of input.0x01, // Start of output.0x20// Size of output.
)
)
// `returndatasize()` will be `0x20` upon success, and `0x00` otherwise.ifiszero(returndatasize()) {
mstore(0x00, 0x8baa579f) // `InvalidSignature()`.revert(0x1c, 0x04)
}
mstore(0x60, 0) // Restore the zero slot.mstore(0x40, m) // Restore the free memory pointer.
}
}
/// @dev Recovers the signer's address from a message digest `hash`,/// and the `signature`.////// This function does NOT accept EIP-2098 short form signatures./// Use `recover(bytes32 hash, bytes32 r, bytes32 vs)` for EIP-2098/// short form signatures instead.functionrecoverCalldata(bytes32 hash, bytescalldata signature)
internalviewreturns (address result)
{
/// @solidity memory-safe-assemblyassembly {
let m :=mload(0x40) // Cache the free memory pointer.mstore(0x00, hash)
mstore(0x20, byte(0, calldataload(add(signature.offset, 0x40)))) // `v`.calldatacopy(0x40, signature.offset, 0x40) // Copy `r` and `s`.
result :=mload(
staticcall(
gas(), // Amount of gas left for the transaction.eq(signature.length, 65), // Address of `ecrecover`.0x00, // Start of input.0x80, // Size of input.0x01, // Start of output.0x20// Size of output.
)
)
// `returndatasize()` will be `0x20` upon success, and `0x00` otherwise.ifiszero(returndatasize()) {
mstore(0x00, 0x8baa579f) // `InvalidSignature()`.revert(0x1c, 0x04)
}
mstore(0x60, 0) // Restore the zero slot.mstore(0x40, m) // Restore the free memory pointer.
}
}
/// @dev Recovers the signer's address from a message digest `hash`,/// and the EIP-2098 short form signature defined by `r` and `vs`.////// This function only accepts EIP-2098 short form signatures./// See: https://eips.ethereum.org/EIPS/eip-2098functionrecover(bytes32 hash, bytes32 r, bytes32 vs) internalviewreturns (address result) {
/// @solidity memory-safe-assemblyassembly {
let m :=mload(0x40) // Cache the free memory pointer.mstore(0x00, hash)
mstore(0x20, add(shr(255, vs), 27)) // `v`.mstore(0x40, r)
mstore(0x60, shr(1, shl(1, vs))) // `s`.
result :=mload(
staticcall(
gas(), // Amount of gas left for the transaction.1, // Address of `ecrecover`.0x00, // Start of input.0x80, // Size of input.0x01, // Start of output.0x20// Size of output.
)
)
// `returndatasize()` will be `0x20` upon success, and `0x00` otherwise.ifiszero(returndatasize()) {
mstore(0x00, 0x8baa579f) // `InvalidSignature()`.revert(0x1c, 0x04)
}
mstore(0x60, 0) // Restore the zero slot.mstore(0x40, m) // Restore the free memory pointer.
}
}
/// @dev Recovers the signer's address from a message digest `hash`,/// and the signature defined by `v`, `r`, `s`.functionrecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s)
internalviewreturns (address result)
{
/// @solidity memory-safe-assemblyassembly {
let m :=mload(0x40) // Cache the free memory pointer.mstore(0x00, hash)
mstore(0x20, and(v, 0xff))
mstore(0x40, r)
mstore(0x60, s)
result :=mload(
staticcall(
gas(), // Amount of gas left for the transaction.1, // Address of `ecrecover`.0x00, // Start of input.0x80, // Size of input.0x01, // Start of output.0x20// Size of output.
)
)
// `returndatasize()` will be `0x20` upon success, and `0x00` otherwise.ifiszero(returndatasize()) {
mstore(0x00, 0x8baa579f) // `InvalidSignature()`.revert(0x1c, 0x04)
}
mstore(0x60, 0) // Restore the zero slot.mstore(0x40, m) // Restore the free memory pointer.
}
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* TRY-RECOVER OPERATIONS *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/// WARNING!// These functions will NOT revert upon recovery failure.// Instead, they will return the zero address upon recovery failure.// It is critical that the returned address is NEVER compared against// a zero address (e.g. an uninitialized address variable)./// @dev Recovers the signer's address from a message digest `hash`,/// and the `signature`.////// This function does NOT accept EIP-2098 short form signatures./// Use `recover(bytes32 hash, bytes32 r, bytes32 vs)` for EIP-2098/// short form signatures instead.functiontryRecover(bytes32 hash, bytesmemory signature)
internalviewreturns (address result)
{
/// @solidity memory-safe-assemblyassembly {
let m :=mload(0x40) // Cache the free memory pointer.let signatureLength :=mload(signature)
mstore(0x00, hash)
mstore(0x20, byte(0, mload(add(signature, 0x60)))) // `v`.mstore(0x40, mload(add(signature, 0x20))) // `r`.mstore(0x60, mload(add(signature, 0x40))) // `s`.pop(
staticcall(
gas(), // Amount of gas left for the transaction.eq(signatureLength, 65), // Address of `ecrecover`.0x00, // Start of input.0x80, // Size of input.0x40, // Start of output.0x20// Size of output.
)
)
mstore(0x60, 0) // Restore the zero slot.// `returndatasize()` will be `0x20` upon success, and `0x00` otherwise.
result :=mload(xor(0x60, returndatasize()))
mstore(0x40, m) // Restore the free memory pointer.
}
}
/// @dev Recovers the signer's address from a message digest `hash`,/// and the `signature`.////// This function does NOT accept EIP-2098 short form signatures./// Use `recover(bytes32 hash, bytes32 r, bytes32 vs)` for EIP-2098/// short form signatures instead.functiontryRecoverCalldata(bytes32 hash, bytescalldata signature)
internalviewreturns (address result)
{
/// @solidity memory-safe-assemblyassembly {
let m :=mload(0x40) // Cache the free memory pointer.mstore(0x00, hash)
mstore(0x20, byte(0, calldataload(add(signature.offset, 0x40)))) // `v`.calldatacopy(0x40, signature.offset, 0x40) // Copy `r` and `s`.pop(
staticcall(
gas(), // Amount of gas left for the transaction.eq(signature.length, 65), // Address of `ecrecover`.0x00, // Start of input.0x80, // Size of input.0x40, // Start of output.0x20// Size of output.
)
)
mstore(0x60, 0) // Restore the zero slot.// `returndatasize()` will be `0x20` upon success, and `0x00` otherwise.
result :=mload(xor(0x60, returndatasize()))
mstore(0x40, m) // Restore the free memory pointer.
}
}
/// @dev Recovers the signer's address from a message digest `hash`,/// and the EIP-2098 short form signature defined by `r` and `vs`.////// This function only accepts EIP-2098 short form signatures./// See: https://eips.ethereum.org/EIPS/eip-2098functiontryRecover(bytes32 hash, bytes32 r, bytes32 vs)
internalviewreturns (address result)
{
/// @solidity memory-safe-assemblyassembly {
let m :=mload(0x40) // Cache the free memory pointer.mstore(0x00, hash)
mstore(0x20, add(shr(255, vs), 27)) // `v`.mstore(0x40, r)
mstore(0x60, shr(1, shl(1, vs))) // `s`.pop(
staticcall(
gas(), // Amount of gas left for the transaction.1, // Address of `ecrecover`.0x00, // Start of input.0x80, // Size of input.0x40, // Start of output.0x20// Size of output.
)
)
mstore(0x60, 0) // Restore the zero slot.// `returndatasize()` will be `0x20` upon success, and `0x00` otherwise.
result :=mload(xor(0x60, returndatasize()))
mstore(0x40, m) // Restore the free memory pointer.
}
}
/// @dev Recovers the signer's address from a message digest `hash`,/// and the signature defined by `v`, `r`, `s`.functiontryRecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s)
internalviewreturns (address result)
{
/// @solidity memory-safe-assemblyassembly {
let m :=mload(0x40) // Cache the free memory pointer.mstore(0x00, hash)
mstore(0x20, and(v, 0xff))
mstore(0x40, r)
mstore(0x60, s)
pop(
staticcall(
gas(), // Amount of gas left for the transaction.1, // Address of `ecrecover`.0x00, // Start of input.0x80, // Size of input.0x40, // Start of output.0x20// Size of output.
)
)
mstore(0x60, 0) // Restore the zero slot.// `returndatasize()` will be `0x20` upon success, and `0x00` otherwise.
result :=mload(xor(0x60, returndatasize()))
mstore(0x40, m) // Restore the free memory pointer.
}
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* HASHING OPERATIONS *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev Returns an Ethereum Signed Message, created from a `hash`./// This produces a hash corresponding to the one signed with the/// [`eth_sign`](https://eth.wiki/json-rpc/API#eth_sign)/// JSON-RPC method as part of EIP-191.functiontoEthSignedMessageHash(bytes32 hash) internalpurereturns (bytes32 result) {
/// @solidity memory-safe-assemblyassembly {
mstore(0x20, hash) // Store into scratch space for keccak256.mstore(0x00, "\x00\x00\x00\x00\x19Ethereum Signed Message:\n32") // 28 bytes.
result :=keccak256(0x04, 0x3c) // `32 * 2 - (32 - 28) = 60 = 0x3c`.
}
}
/// @dev Returns an Ethereum Signed Message, created from `s`./// This produces a hash corresponding to the one signed with the/// [`eth_sign`](https://eth.wiki/json-rpc/API#eth_sign)/// JSON-RPC method as part of EIP-191./// Note: Supports lengths of `s` up to 999999 bytes.functiontoEthSignedMessageHash(bytesmemory s) internalpurereturns (bytes32 result) {
/// @solidity memory-safe-assemblyassembly {
let sLength :=mload(s)
let o :=0x20mstore(o, "\x19Ethereum Signed Message:\n") // 26 bytes, zero-right-padded.mstore(0x00, 0x00)
// Convert the `s.length` to ASCII decimal representation: `base10(s.length)`.for { let temp := sLength } 1 {} {
o :=sub(o, 1)
mstore8(o, add(48, mod(temp, 10)))
temp :=div(temp, 10)
ifiszero(temp) { break }
}
let n :=sub(0x3a, o) // Header length: `26 + 32 - o`.// Throw an out-of-offset error (consumes all gas) if the header exceeds 32 bytes.returndatacopy(returndatasize(), returndatasize(), gt(n, 0x20))
mstore(s, or(mload(0x00), mload(n))) // Temporarily store the header.
result :=keccak256(add(s, sub(0x20, n)), add(n, sLength))
mstore(s, sLength) // Restore the length.
}
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* EMPTY CALLDATA HELPERS *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev Returns an empty calldata bytes.functionemptySignature() internalpurereturns (bytescalldata signature) {
/// @solidity memory-safe-assemblyassembly {
signature.length:=0
}
}
}
Código Fuente del Contrato
Archivo 2 de 5: ERC721.sol
// SPDX-License-Identifier: MITpragmasolidity ^0.8.4;/// @notice Simple ERC721 implementation with storage hitchhiking./// @author Solady (https://github.com/vectorized/solady/blob/main/src/tokens/ERC721.sol)/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC721.sol)/// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/tree/master/contracts/token/ERC721/ERC721.sol)////// @dev Note:/// - The ERC721 standard allows for self-approvals./// For performance, this implementation WILL NOT revert for such actions./// Please add any checks with overrides if desired./// - For performance, methods are made payable where permitted by the ERC721 standard./// - The `safeTransfer` functions use the identity precompile (0x4)/// to copy memory internally.////// If you are overriding:/// - NEVER violate the ERC721 invariant:/// the balance of an owner MUST be always be equal to their number of ownership slots./// The transfer functions do not have an underflow guard for user token balances./// - Make sure all variables written to storage are properly cleaned// (e.g. the bool value for `isApprovedForAll` MUST be either 1 or 0 under the hood)./// - Check that the overridden function is actually used in the function you want to/// change the behavior of. Much of the code has been manually inlined for performance.abstractcontractERC721{
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* CONSTANTS *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev An account can hold up to 4294967295 tokens.uint256internalconstant _MAX_ACCOUNT_BALANCE =0xffffffff;
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* CUSTOM ERRORS *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev Only the token owner or an approved account can manage the token.errorNotOwnerNorApproved();
/// @dev The token does not exist.errorTokenDoesNotExist();
/// @dev The token already exists.errorTokenAlreadyExists();
/// @dev Cannot query the balance for the zero address.errorBalanceQueryForZeroAddress();
/// @dev Cannot mint or transfer to the zero address.errorTransferToZeroAddress();
/// @dev The token must be owned by `from`.errorTransferFromIncorrectOwner();
/// @dev The recipient's balance has overflowed.errorAccountBalanceOverflow();
/// @dev Cannot safely transfer to a contract that does not implement/// the ERC721Receiver interface.errorTransferToNonERC721ReceiverImplementer();
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* EVENTS *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev Emitted when token `id` is transferred from `from` to `to`.eventTransfer(addressindexedfrom, addressindexed to, uint256indexed id);
/// @dev Emitted when `owner` enables `account` to manage the `id` token.eventApproval(addressindexed owner, addressindexed account, uint256indexed id);
/// @dev Emitted when `owner` enables or disables `operator` to manage all of their tokens.eventApprovalForAll(addressindexed owner, addressindexed operator, bool isApproved);
/// @dev `keccak256(bytes("Transfer(address,address,uint256)"))`.uint256privateconstant _TRANSFER_EVENT_SIGNATURE =0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef;
/// @dev `keccak256(bytes("Approval(address,address,uint256)"))`.uint256privateconstant _APPROVAL_EVENT_SIGNATURE =0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925;
/// @dev `keccak256(bytes("ApprovalForAll(address,address,bool)"))`.uint256privateconstant _APPROVAL_FOR_ALL_EVENT_SIGNATURE =0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31;
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* STORAGE *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev The ownership data slot of `id` is given by:/// ```/// mstore(0x00, id)/// mstore(0x1c, _ERC721_MASTER_SLOT_SEED)/// let ownershipSlot := add(id, add(id, keccak256(0x00, 0x20)))/// ```/// Bits Layout:/// - [0..159] `addr`/// - [160..255] `extraData`////// The approved address slot is given by: `add(1, ownershipSlot)`.////// See: https://notes.ethereum.org/%40vbuterin/verkle_tree_eip////// The balance slot of `owner` is given by:/// ```/// mstore(0x1c, _ERC721_MASTER_SLOT_SEED)/// mstore(0x00, owner)/// let balanceSlot := keccak256(0x0c, 0x1c)/// ```/// Bits Layout:/// - [0..31] `balance`/// - [32..255] `aux`////// The `operator` approval slot of `owner` is given by:/// ```/// mstore(0x1c, or(_ERC721_MASTER_SLOT_SEED, operator))/// mstore(0x00, owner)/// let operatorApprovalSlot := keccak256(0x0c, 0x30)/// ```uint256privateconstant _ERC721_MASTER_SLOT_SEED =0x7d8825530a5a2e7a<<192;
/// @dev Pre-shifted and pre-masked constant.uint256privateconstant _ERC721_MASTER_SLOT_SEED_MASKED =0x0a5a2e7a00000000;
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* ERC721 METADATA *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev Returns the token collection name.functionname() publicviewvirtualreturns (stringmemory);
/// @dev Returns the token collection symbol.functionsymbol() publicviewvirtualreturns (stringmemory);
/// @dev Returns the Uniform Resource Identifier (URI) for token `id`.functiontokenURI(uint256 id) publicviewvirtualreturns (stringmemory);
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* ERC721 *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev Returns the owner of token `id`.////// Requirements:/// - Token `id` must exist.functionownerOf(uint256 id) publicviewvirtualreturns (address result) {
result = _ownerOf(id);
/// @solidity memory-safe-assemblyassembly {
ifiszero(result) {
mstore(0x00, 0xceea21b6) // `TokenDoesNotExist()`.revert(0x1c, 0x04)
}
}
}
/// @dev Returns the number of tokens owned by `owner`.////// Requirements:/// - `owner` must not be the zero address.functionbalanceOf(address owner) publicviewvirtualreturns (uint256 result) {
/// @solidity memory-safe-assemblyassembly {
// Revert if the `owner` is the zero address.ifiszero(owner) {
mstore(0x00, 0x8f4eb604) // `BalanceQueryForZeroAddress()`.revert(0x1c, 0x04)
}
mstore(0x1c, _ERC721_MASTER_SLOT_SEED)
mstore(0x00, owner)
result :=and(sload(keccak256(0x0c, 0x1c)), _MAX_ACCOUNT_BALANCE)
}
}
/// @dev Returns the account approved to manage token `id`.////// Requirements:/// - Token `id` must exist.functiongetApproved(uint256 id) publicviewvirtualreturns (address result) {
/// @solidity memory-safe-assemblyassembly {
mstore(0x00, id)
mstore(0x1c, _ERC721_MASTER_SLOT_SEED)
let ownershipSlot :=add(id, add(id, keccak256(0x00, 0x20)))
ifiszero(shl(96, sload(ownershipSlot))) {
mstore(0x00, 0xceea21b6) // `TokenDoesNotExist()`.revert(0x1c, 0x04)
}
result :=sload(add(1, ownershipSlot))
}
}
/// @dev Sets `account` as the approved account to manage token `id`.////// Requirements:/// - Token `id` must exist./// - The caller must be the owner of the token,/// or an approved operator for the token owner.////// Emits an {Approval} event.functionapprove(address account, uint256 id) publicpayablevirtual{
_approve(msg.sender, account, id);
}
/// @dev Returns whether `operator` is approved to manage the tokens of `owner`.functionisApprovedForAll(address owner, address operator)
publicviewvirtualreturns (bool result)
{
/// @solidity memory-safe-assemblyassembly {
mstore(0x1c, operator)
mstore(0x08, _ERC721_MASTER_SLOT_SEED_MASKED)
mstore(0x00, owner)
result :=sload(keccak256(0x0c, 0x30))
}
}
/// @dev Sets whether `operator` is approved to manage the tokens of the caller.////// Emits an {ApprovalForAll} event.functionsetApprovalForAll(address operator, bool isApproved) publicvirtual{
/// @solidity memory-safe-assemblyassembly {
// Convert to 0 or 1.
isApproved :=iszero(iszero(isApproved))
// Update the `isApproved` for (`msg.sender`, `operator`).mstore(0x1c, operator)
mstore(0x08, _ERC721_MASTER_SLOT_SEED_MASKED)
mstore(0x00, caller())
sstore(keccak256(0x0c, 0x30), isApproved)
// Emit the {ApprovalForAll} event.mstore(0x00, isApproved)
log3(
0x00, 0x20, _APPROVAL_FOR_ALL_EVENT_SIGNATURE, caller(), shr(96, shl(96, operator))
)
}
}
/// @dev Transfers token `id` from `from` to `to`.////// Requirements:////// - Token `id` must exist./// - `from` must be the owner of the token./// - `to` cannot be the zero address./// - The caller must be the owner of the token, or be approved to manage the token.////// Emits a {Transfer} event.functiontransferFrom(addressfrom, address to, uint256 id) publicpayablevirtual{
_beforeTokenTransfer(from, to, id);
/// @solidity memory-safe-assemblyassembly {
// Clear the upper 96 bits.let bitmaskAddress :=shr(96, not(0))
from :=and(bitmaskAddress, from)
to :=and(bitmaskAddress, to)
// Load the ownership data.mstore(0x00, id)
mstore(0x1c, or(_ERC721_MASTER_SLOT_SEED, caller()))
let ownershipSlot :=add(id, add(id, keccak256(0x00, 0x20)))
let ownershipPacked :=sload(ownershipSlot)
let owner :=and(bitmaskAddress, ownershipPacked)
// Revert if `from` is not the owner, or does not exist.ifiszero(mul(owner, eq(owner, from))) {
ifiszero(owner) {
mstore(0x00, 0xceea21b6) // `TokenDoesNotExist()`.revert(0x1c, 0x04)
}
mstore(0x00, 0xa1148100) // `TransferFromIncorrectOwner()`.revert(0x1c, 0x04)
}
// Revert if `to` is the zero address.ifiszero(to) {
mstore(0x00, 0xea553b34) // `TransferToZeroAddress()`.revert(0x1c, 0x04)
}
// Load, check, and update the token approval.
{
mstore(0x00, from)
let approvedAddress :=sload(add(1, ownershipSlot))
// Revert if the caller is not the owner, nor approved.ifiszero(or(eq(caller(), from), eq(caller(), approvedAddress))) {
ifiszero(sload(keccak256(0x0c, 0x30))) {
mstore(0x00, 0x4b6e7f18) // `NotOwnerNorApproved()`.revert(0x1c, 0x04)
}
}
// Delete the approved address if any.if approvedAddress { sstore(add(1, ownershipSlot), 0) }
}
// Update with the new owner.sstore(ownershipSlot, xor(ownershipPacked, xor(from, to)))
// Decrement the balance of `from`.
{
let fromBalanceSlot :=keccak256(0x0c, 0x1c)
sstore(fromBalanceSlot, sub(sload(fromBalanceSlot), 1))
}
// Increment the balance of `to`.
{
mstore(0x00, to)
let toBalanceSlot :=keccak256(0x0c, 0x1c)
let toBalanceSlotPacked :=add(sload(toBalanceSlot), 1)
ifiszero(and(toBalanceSlotPacked, _MAX_ACCOUNT_BALANCE)) {
mstore(0x00, 0x01336cea) // `AccountBalanceOverflow()`.revert(0x1c, 0x04)
}
sstore(toBalanceSlot, toBalanceSlotPacked)
}
// Emit the {Transfer} event.log4(0x00, 0x00, _TRANSFER_EVENT_SIGNATURE, from, to, id)
}
_afterTokenTransfer(from, to, id);
}
/// @dev Equivalent to `safeTransferFrom(from, to, id, "")`.functionsafeTransferFrom(addressfrom, address to, uint256 id) publicpayablevirtual{
transferFrom(from, to, id);
if (_hasCode(to)) _checkOnERC721Received(from, to, id, "");
}
/// @dev Transfers token `id` from `from` to `to`.////// Requirements:////// - Token `id` must exist./// - `from` must be the owner of the token./// - `to` cannot be the zero address./// - The caller must be the owner of the token, or be approved to manage the token./// - If `to` refers to a smart contract, it must implement/// {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.////// Emits a {Transfer} event.functionsafeTransferFrom(addressfrom, address to, uint256 id, bytescalldata data)
publicpayablevirtual{
transferFrom(from, to, id);
if (_hasCode(to)) _checkOnERC721Received(from, to, id, data);
}
/// @dev Returns true if this contract implements the interface defined by `interfaceId`./// See: https://eips.ethereum.org/EIPS/eip-165/// This function call must use less than 30000 gas.functionsupportsInterface(bytes4 interfaceId) publicviewvirtualreturns (bool result) {
/// @solidity memory-safe-assemblyassembly {
let s :=shr(224, interfaceId)
// ERC165: 0x01ffc9a7, ERC721: 0x80ac58cd, ERC721Metadata: 0x5b5e139f.
result :=or(or(eq(s, 0x01ffc9a7), eq(s, 0x80ac58cd)), eq(s, 0x5b5e139f))
}
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* INTERNAL QUERY FUNCTIONS *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev Returns if token `id` exists.function_exists(uint256 id) internalviewvirtualreturns (bool result) {
/// @solidity memory-safe-assemblyassembly {
mstore(0x00, id)
mstore(0x1c, _ERC721_MASTER_SLOT_SEED)
result :=iszero(iszero(shl(96, sload(add(id, add(id, keccak256(0x00, 0x20)))))))
}
}
/// @dev Returns the owner of token `id`./// Returns the zero address instead of reverting if the token does not exist.function_ownerOf(uint256 id) internalviewvirtualreturns (address result) {
/// @solidity memory-safe-assemblyassembly {
mstore(0x00, id)
mstore(0x1c, _ERC721_MASTER_SLOT_SEED)
result :=shr(96, shl(96, sload(add(id, add(id, keccak256(0x00, 0x20))))))
}
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* INTERNAL DATA HITCHHIKING FUNCTIONS *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/// For performance, no events are emitted for the hitchhiking setters.// Please emit your own events if required./// @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) internalviewvirtualreturns (uint224 result) {
/// @solidity memory-safe-assemblyassembly {
mstore(0x1c, _ERC721_MASTER_SLOT_SEED)
mstore(0x00, owner)
result :=shr(32, sload(keccak256(0x0c, 0x1c)))
}
}
/// @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, uint224 value) internalvirtual{
/// @solidity memory-safe-assemblyassembly {
mstore(0x1c, _ERC721_MASTER_SLOT_SEED)
mstore(0x00, owner)
let balanceSlot :=keccak256(0x0c, 0x1c)
let packed :=sload(balanceSlot)
sstore(balanceSlot, xor(packed, shl(32, xor(value, shr(32, packed)))))
}
}
/// @dev Returns the extra data for token `id`./// Minting, transferring, burning a token will not change the extra data./// The extra data can be set on a non-existent token.function_getExtraData(uint256 id) internalviewvirtualreturns (uint96 result) {
/// @solidity memory-safe-assemblyassembly {
mstore(0x00, id)
mstore(0x1c, _ERC721_MASTER_SLOT_SEED)
result :=shr(160, sload(add(id, add(id, keccak256(0x00, 0x20)))))
}
}
/// @dev Sets the extra data for token `id` to `value`./// Minting, transferring, burning a token will not change the extra data./// The extra data can be set on a non-existent token.function_setExtraData(uint256 id, uint96 value) internalvirtual{
/// @solidity memory-safe-assemblyassembly {
mstore(0x00, id)
mstore(0x1c, _ERC721_MASTER_SLOT_SEED)
let ownershipSlot :=add(id, add(id, keccak256(0x00, 0x20)))
let packed :=sload(ownershipSlot)
sstore(ownershipSlot, xor(packed, shl(160, xor(value, shr(160, packed)))))
}
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* INTERNAL MINT FUNCTIONS *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev Mints token `id` to `to`.////// Requirements:////// - Token `id` must not exist./// - `to` cannot be the zero address.////// Emits a {Transfer} event.function_mint(address to, uint256 id) internalvirtual{
_beforeTokenTransfer(address(0), to, id);
/// @solidity memory-safe-assemblyassembly {
// Clear the upper 96 bits.
to :=shr(96, shl(96, to))
// Revert if `to` is the zero address.ifiszero(to) {
mstore(0x00, 0xea553b34) // `TransferToZeroAddress()`.revert(0x1c, 0x04)
}
// Load the ownership data.mstore(0x00, id)
mstore(0x1c, _ERC721_MASTER_SLOT_SEED)
let ownershipSlot :=add(id, add(id, keccak256(0x00, 0x20)))
let ownershipPacked :=sload(ownershipSlot)
// Revert if the token already exists.ifshl(96, ownershipPacked) {
mstore(0x00, 0xc991cbb1) // `TokenAlreadyExists()`.revert(0x1c, 0x04)
}
// Update with the owner.sstore(ownershipSlot, or(ownershipPacked, to))
// Increment the balance of the owner.
{
mstore(0x00, to)
let balanceSlot :=keccak256(0x0c, 0x1c)
let balanceSlotPacked :=add(sload(balanceSlot), 1)
ifiszero(and(balanceSlotPacked, _MAX_ACCOUNT_BALANCE)) {
mstore(0x00, 0x01336cea) // `AccountBalanceOverflow()`.revert(0x1c, 0x04)
}
sstore(balanceSlot, balanceSlotPacked)
}
// Emit the {Transfer} event.log4(0x00, 0x00, _TRANSFER_EVENT_SIGNATURE, 0, to, id)
}
_afterTokenTransfer(address(0), to, id);
}
/// @dev Equivalent to `_safeMint(to, id, "")`.function_safeMint(address to, uint256 id) internalvirtual{
_safeMint(to, id, "");
}
/// @dev Mints token `id` to `to`.////// Requirements:////// - Token `id` must not exist./// - `to` cannot be the zero address./// - If `to` refers to a smart contract, it must implement/// {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.////// Emits a {Transfer} event.function_safeMint(address to, uint256 id, bytesmemory data) internalvirtual{
_mint(to, id);
if (_hasCode(to)) _checkOnERC721Received(address(0), to, id, data);
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* INTERNAL BURN FUNCTIONS *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev Equivalent to `_burn(address(0), id)`.function_burn(uint256 id) internalvirtual{
_burn(address(0), id);
}
/// @dev Destroys token `id`, using `by`.////// Requirements:////// - Token `id` must exist./// - If `by` is not the zero address,/// it must be the owner of the token, or be approved to manage the token.////// Emits a {Transfer} event.function_burn(address by, uint256 id) internalvirtual{
address owner = ownerOf(id);
_beforeTokenTransfer(owner, address(0), id);
/// @solidity memory-safe-assemblyassembly {
// Clear the upper 96 bits.
by :=shr(96, shl(96, by))
// Load the ownership data.mstore(0x00, id)
mstore(0x1c, or(_ERC721_MASTER_SLOT_SEED, by))
let ownershipSlot :=add(id, add(id, keccak256(0x00, 0x20)))
let ownershipPacked :=sload(ownershipSlot)
// Reload the owner in case it is changed in `_beforeTokenTransfer`.
owner :=shr(96, shl(96, ownershipPacked))
// Revert if the token does not exist.ifiszero(owner) {
mstore(0x00, 0xceea21b6) // `TokenDoesNotExist()`.revert(0x1c, 0x04)
}
// Load and check the token approval.
{
mstore(0x00, owner)
let approvedAddress :=sload(add(1, ownershipSlot))
// If `by` is not the zero address, do the authorization check.// Revert if the `by` is not the owner, nor approved.ifiszero(or(iszero(by), or(eq(by, owner), eq(by, approvedAddress)))) {
ifiszero(sload(keccak256(0x0c, 0x30))) {
mstore(0x00, 0x4b6e7f18) // `NotOwnerNorApproved()`.revert(0x1c, 0x04)
}
}
// Delete the approved address if any.if approvedAddress { sstore(add(1, ownershipSlot), 0) }
}
// Clear the owner.sstore(ownershipSlot, xor(ownershipPacked, owner))
// Decrement the balance of `owner`.
{
let balanceSlot :=keccak256(0x0c, 0x1c)
sstore(balanceSlot, sub(sload(balanceSlot), 1))
}
// Emit the {Transfer} event.log4(0x00, 0x00, _TRANSFER_EVENT_SIGNATURE, owner, 0, id)
}
_afterTokenTransfer(owner, address(0), id);
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* INTERNAL APPROVAL FUNCTIONS *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev Returns whether `account` is the owner of token `id`, or is approved to manage it.////// Requirements:/// - Token `id` must exist.function_isApprovedOrOwner(address account, uint256 id)
internalviewvirtualreturns (bool result)
{
/// @solidity memory-safe-assemblyassembly {
result :=1// Clear the upper 96 bits.
account :=shr(96, shl(96, account))
// Load the ownership data.mstore(0x00, id)
mstore(0x1c, or(_ERC721_MASTER_SLOT_SEED, account))
let ownershipSlot :=add(id, add(id, keccak256(0x00, 0x20)))
let owner :=shr(96, shl(96, sload(ownershipSlot)))
// Revert if the token does not exist.ifiszero(owner) {
mstore(0x00, 0xceea21b6) // `TokenDoesNotExist()`.revert(0x1c, 0x04)
}
// Check if `account` is the `owner`.ifiszero(eq(account, owner)) {
mstore(0x00, owner)
// Check if `account` is approved to manage the token.ifiszero(sload(keccak256(0x0c, 0x30))) {
result :=eq(account, sload(add(1, ownershipSlot)))
}
}
}
}
/// @dev Returns the account approved to manage token `id`./// Returns the zero address instead of reverting if the token does not exist.function_getApproved(uint256 id) internalviewvirtualreturns (address result) {
/// @solidity memory-safe-assemblyassembly {
mstore(0x00, id)
mstore(0x1c, _ERC721_MASTER_SLOT_SEED)
result :=sload(add(1, add(id, add(id, keccak256(0x00, 0x20)))))
}
}
/// @dev Equivalent to `_approve(address(0), account, id)`.function_approve(address account, uint256 id) internalvirtual{
_approve(address(0), account, id);
}
/// @dev Sets `account` as the approved account to manage token `id`, using `by`.////// Requirements:/// - Token `id` must exist./// - If `by` is not the zero address, `by` must be the owner/// or an approved operator for the token owner.////// Emits a {Transfer} event.function_approve(address by, address account, uint256 id) internalvirtual{
assembly {
// Clear the upper 96 bits.let bitmaskAddress :=shr(96, not(0))
account :=and(bitmaskAddress, account)
by :=and(bitmaskAddress, by)
// Load the owner of the token.mstore(0x00, id)
mstore(0x1c, or(_ERC721_MASTER_SLOT_SEED, by))
let ownershipSlot :=add(id, add(id, keccak256(0x00, 0x20)))
let owner :=and(bitmaskAddress, sload(ownershipSlot))
// Revert if the token does not exist.ifiszero(owner) {
mstore(0x00, 0xceea21b6) // `TokenDoesNotExist()`.revert(0x1c, 0x04)
}
// If `by` is not the zero address, do the authorization check.// Revert if `by` is not the owner, nor approved.ifiszero(or(iszero(by), eq(by, owner))) {
mstore(0x00, owner)
ifiszero(sload(keccak256(0x0c, 0x30))) {
mstore(0x00, 0x4b6e7f18) // `NotOwnerNorApproved()`.revert(0x1c, 0x04)
}
}
// Sets `account` as the approved account to manage `id`.sstore(add(1, ownershipSlot), account)
// Emit the {Approval} event.log4(0x00, 0x00, _APPROVAL_EVENT_SIGNATURE, owner, account, id)
}
}
/// @dev Approve or remove the `operator` as an operator for `by`,/// without authorization checks.////// Emits an {ApprovalForAll} event.function_setApprovalForAll(address by, address operator, bool isApproved) internalvirtual{
/// @solidity memory-safe-assemblyassembly {
// Clear the upper 96 bits.
by :=shr(96, shl(96, by))
operator :=shr(96, shl(96, operator))
// Convert to 0 or 1.
isApproved :=iszero(iszero(isApproved))
// Update the `isApproved` for (`by`, `operator`).mstore(0x1c, or(_ERC721_MASTER_SLOT_SEED, operator))
mstore(0x00, by)
sstore(keccak256(0x0c, 0x30), isApproved)
// Emit the {ApprovalForAll} event.mstore(0x00, isApproved)
log3(0x00, 0x20, _APPROVAL_FOR_ALL_EVENT_SIGNATURE, by, operator)
}
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* INTERNAL TRANSFER FUNCTIONS *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev Equivalent to `_transfer(address(0), from, to, id)`.function_transfer(addressfrom, address to, uint256 id) internalvirtual{
_transfer(address(0), from, to, id);
}
/// @dev Transfers token `id` from `from` to `to`.////// Requirements:////// - Token `id` must exist./// - `from` must be the owner of the token./// - `to` cannot be the zero address./// - If `by` is not the zero address,/// it must be the owner of the token, or be approved to manage the token.////// Emits a {Transfer} event.function_transfer(address by, addressfrom, address to, uint256 id) internalvirtual{
_beforeTokenTransfer(from, to, id);
/// @solidity memory-safe-assemblyassembly {
// Clear the upper 96 bits.let bitmaskAddress :=shr(96, not(0))
from :=and(bitmaskAddress, from)
to :=and(bitmaskAddress, to)
by :=and(bitmaskAddress, by)
// Load the ownership data.mstore(0x00, id)
mstore(0x1c, or(_ERC721_MASTER_SLOT_SEED, by))
let ownershipSlot :=add(id, add(id, keccak256(0x00, 0x20)))
let ownershipPacked :=sload(ownershipSlot)
let owner :=and(bitmaskAddress, ownershipPacked)
// Revert if `from` is not the owner, or does not exist.ifiszero(mul(owner, eq(owner, from))) {
ifiszero(owner) {
mstore(0x00, 0xceea21b6) // `TokenDoesNotExist()`.revert(0x1c, 0x04)
}
mstore(0x00, 0xa1148100) // `TransferFromIncorrectOwner()`.revert(0x1c, 0x04)
}
// Revert if `to` is the zero address.ifiszero(to) {
mstore(0x00, 0xea553b34) // `TransferToZeroAddress()`.revert(0x1c, 0x04)
}
// Load, check, and update the token approval.
{
mstore(0x00, from)
let approvedAddress :=sload(add(1, ownershipSlot))
// If `by` is not the zero address, do the authorization check.// Revert if the `by` is not the owner, nor approved.ifiszero(or(iszero(by), or(eq(by, from), eq(by, approvedAddress)))) {
ifiszero(sload(keccak256(0x0c, 0x30))) {
mstore(0x00, 0x4b6e7f18) // `NotOwnerNorApproved()`.revert(0x1c, 0x04)
}
}
// Delete the approved address if any.if approvedAddress { sstore(add(1, ownershipSlot), 0) }
}
// Update with the new owner.sstore(ownershipSlot, xor(ownershipPacked, xor(from, to)))
// Decrement the balance of `from`.
{
let fromBalanceSlot :=keccak256(0x0c, 0x1c)
sstore(fromBalanceSlot, sub(sload(fromBalanceSlot), 1))
}
// Increment the balance of `to`.
{
mstore(0x00, to)
let toBalanceSlot :=keccak256(0x0c, 0x1c)
let toBalanceSlotPacked :=add(sload(toBalanceSlot), 1)
ifiszero(and(toBalanceSlotPacked, _MAX_ACCOUNT_BALANCE)) {
mstore(0x00, 0x01336cea) // `AccountBalanceOverflow()`.revert(0x1c, 0x04)
}
sstore(toBalanceSlot, toBalanceSlotPacked)
}
// Emit the {Transfer} event.log4(0x00, 0x00, _TRANSFER_EVENT_SIGNATURE, from, to, id)
}
_afterTokenTransfer(from, to, id);
}
/// @dev Equivalent to `_safeTransfer(from, to, id, "")`.function_safeTransfer(addressfrom, address to, uint256 id) internalvirtual{
_safeTransfer(from, to, id, "");
}
/// @dev Transfers token `id` from `from` to `to`.////// Requirements:////// - Token `id` must exist./// - `from` must be the owner of the token./// - `to` cannot be the zero address./// - The caller must be the owner of the token, or be approved to manage the token./// - If `to` refers to a smart contract, it must implement/// {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.////// Emits a {Transfer} event.function_safeTransfer(addressfrom, address to, uint256 id, bytesmemory data)
internalvirtual{
_transfer(address(0), from, to, id);
if (_hasCode(to)) _checkOnERC721Received(from, to, id, data);
}
/// @dev Equivalent to `_safeTransfer(by, from, to, id, "")`.function_safeTransfer(address by, addressfrom, address to, uint256 id) internalvirtual{
_safeTransfer(by, from, to, id, "");
}
/// @dev Transfers token `id` from `from` to `to`.////// Requirements:////// - Token `id` must exist./// - `from` must be the owner of the token./// - `to` cannot be the zero address./// - If `by` is not the zero address,/// it must be the owner of the token, or be approved to manage the token./// - If `to` refers to a smart contract, it must implement/// {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.////// Emits a {Transfer} event.function_safeTransfer(address by, addressfrom, address to, uint256 id, bytesmemory data)
internalvirtual{
_transfer(by, from, to, id);
if (_hasCode(to)) _checkOnERC721Received(from, to, id, data);
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* HOOKS FOR OVERRIDING *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev Hook that is called before any token transfers, including minting and burning.function_beforeTokenTransfer(addressfrom, address to, uint256 id) internalvirtual{}
/// @dev Hook that is called after any token transfers, including minting and burning.function_afterTokenTransfer(addressfrom, address to, uint256 id) internalvirtual{}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* PRIVATE HELPERS *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev Returns if `a` has bytecode of non-zero length.function_hasCode(address a) privateviewreturns (bool result) {
/// @solidity memory-safe-assemblyassembly {
result :=extcodesize(a) // Can handle dirty upper bits.
}
}
/// @dev Perform a call to invoke {IERC721Receiver-onERC721Received} on `to`./// Reverts if the target does not support the function correctly.function_checkOnERC721Received(addressfrom, address to, uint256 id, bytesmemory data)
private{
/// @solidity memory-safe-assemblyassembly {
// Prepare the calldata.let m :=mload(0x40)
let onERC721ReceivedSelector :=0x150b7a02mstore(m, onERC721ReceivedSelector)
mstore(add(m, 0x20), caller()) // The `operator`, which is always `msg.sender`.mstore(add(m, 0x40), shr(96, shl(96, from)))
mstore(add(m, 0x60), id)
mstore(add(m, 0x80), 0x80)
let n :=mload(data)
mstore(add(m, 0xa0), n)
if n { pop(staticcall(gas(), 4, add(data, 0x20), n, add(m, 0xc0), n)) }
// Revert if the call reverts.ifiszero(call(gas(), to, 0, add(m, 0x1c), add(n, 0xa4), m, 0x20)) {
ifreturndatasize() {
// Bubble up the revert if the call reverts.returndatacopy(0x00, 0x00, returndatasize())
revert(0x00, returndatasize())
}
}
// Load the returndata and compare it.ifiszero(eq(mload(m), shl(224, onERC721ReceivedSelector))) {
mstore(0x00, 0xd1a57ed6) // `TransferToNonERC721ReceiverImplementer()`.revert(0x1c, 0x04)
}
}
}
}
Código Fuente del Contrato
Archivo 3 de 5: LibString.sol
// SPDX-License-Identifier: MITpragmasolidity ^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)libraryLibString{
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* CUSTOM ERRORS *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev The `length` of the output is too small to contain all the hex digits.errorHexLengthInsufficient();
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* CONSTANTS *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev The constant returned when the `search` is not found in the string.uint256internalconstant NOT_FOUND =type(uint256).max;
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* DECIMAL OPERATIONS *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev Returns the base 10 decimal representation of `value`.functiontoString(uint256 value) internalpurereturns (stringmemory str) {
/// @solidity memory-safe-assemblyassembly {
// 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)
ifiszero(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`.functiontoString(int256 value) internalpurereturns (stringmemory str) {
if (value >=0) {
return toString(uint256(value));
}
unchecked {
str = toString(uint256(-value));
}
/// @solidity memory-safe-assemblyassembly {
// 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.functiontoHexString(uint256 value, uint256 length) internalpurereturns (stringmemory str) {
str = toHexStringNoPrefix(value, length);
/// @solidity memory-safe-assemblyassembly {
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.functiontoHexStringNoPrefix(uint256 value, uint256 length)
internalpurereturns (stringmemory str)
{
/// @solidity memory-safe-assemblyassembly {
// 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)
ifiszero(xor(str, start)) { break }
}
if temp {
// Store the function selector of `HexLengthInsufficient()`.mstore(0x00, 0x2194895a)
// Revert with (offset, size).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.functiontoHexString(uint256 value) internalpurereturns (stringmemory str) {
str = toHexStringNoPrefix(value);
/// @solidity memory-safe-assemblyassembly {
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"`.functiontoMinimalHexString(uint256 value) internalpurereturns (stringmemory str) {
str = toHexStringNoPrefix(value);
/// @solidity memory-safe-assemblyassembly {
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"`.functiontoMinimalHexStringNoPrefix(uint256 value) internalpurereturns (stringmemory str) {
str = toHexStringNoPrefix(value);
/// @solidity memory-safe-assemblyassembly {
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.functiontoHexStringNoPrefix(uint256 value) internalpurereturns (stringmemory str) {
/// @solidity memory-safe-assemblyassembly {
// 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)
ifiszero(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-55functiontoHexStringChecksummed(address value) internalpurereturns (stringmemory str) {
str = toHexString(value);
/// @solidity memory-safe-assemblyassembly {
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)
ifeq(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.functiontoHexString(address value) internalpurereturns (stringmemory str) {
str = toHexStringNoPrefix(value);
/// @solidity memory-safe-assemblyassembly {
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.functiontoHexStringNoPrefix(address value) internalpurereturns (stringmemory str) {
/// @solidity memory-safe-assemblyassembly {
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)
ifeq(i, 20) { break }
}
}
}
/// @dev Returns the hex encoded string from the raw bytes./// The output is encoded using 2 hexadecimal digits per byte.functiontoHexString(bytesmemory raw) internalpurereturns (stringmemory str) {
str = toHexStringNoPrefix(raw);
/// @solidity memory-safe-assemblyassembly {
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.functiontoHexStringNoPrefix(bytesmemory raw) internalpurereturns (stringmemory str) {
/// @solidity memory-safe-assemblyassembly {
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.functionruneCount(stringmemory s) internalpurereturns (uint256 result) {
/// @solidity memory-safe-assemblyassembly {
ifmload(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)))))
ifiszero(lt(o, end)) { break }
}
}
}
}
/// @dev Returns if this string is a 7-bit ASCII string./// (i.e. all characters codes are in [0..127])functionis7BitASCII(stringmemory s) internalpurereturns (bool result) {
/// @solidity memory-safe-assemblyassembly {
let mask :=shl(7, div(not(0), 255))
result :=1let n :=mload(s)
if n {
let o :=add(s, 0x20)
let end :=add(o, n)
let last :=mload(end)
mstore(end, 0)
for {} 1 {} {
ifand(mask, mload(o)) {
result :=0break
}
o :=add(o, 0x20)
ifiszero(lt(o, end)) { break }
}
mstore(end, last)
}
}
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* BYTE STRING OPERATIONS *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/// For performance and bytecode compactness, all indices of the following operations// are byte (ASCII) offsets, not UTF character offsets./// @dev Returns `subject` all occurrences of `search` replaced with `replacement`.functionreplace(stringmemory subject, stringmemory search, stringmemory replacement)
internalpurereturns (stringmemory result)
{
/// @solidity memory-safe-assemblyassembly {
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)
ifiszero(gt(searchLength, subjectLength)) {
let subjectSearchEnd :=add(sub(subjectEnd, searchLength), 1)
let h :=0ifiszero(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.ifiszero(shr(m, xor(t, s))) {
if h {
ifiszero(eq(keccak256(subject, searchLength), h)) {
mstore(result, t)
result :=add(result, 1)
subject :=add(subject, 1)
ifiszero(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)
ifiszero(lt(o, replacementLength)) { break }
}
result :=add(result, replacementLength)
subject :=add(subject, searchLength)
if searchLength {
ifiszero(lt(subject, subjectSearchEnd)) { break }
continue
}
}
mstore(result, t)
result :=add(result, 1)
subject :=add(subject, 1)
ifiszero(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.functionindexOf(stringmemory subject, stringmemory search, uint256from)
internalpurereturns (uint256 result)
{
/// @solidity memory-safe-assemblyassembly {
for { let subjectLength :=mload(subject) } 1 {} {
ifiszero(mload(search)) {
ifiszero(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))
ifiszero(and(lt(subject, end), lt(from, subjectLength))) { break }
ifiszero(lt(searchLength, 0x20)) {
for { let h :=keccak256(add(search, 0x20), searchLength) } 1 {} {
ifiszero(shr(m, xor(mload(subject), s))) {
ifeq(keccak256(subject, searchLength), h) {
result :=sub(subject, subjectStart)
break
}
}
subject :=add(subject, 1)
ifiszero(lt(subject, end)) { break }
}
break
}
for {} 1 {} {
ifiszero(shr(m, xor(mload(subject), s))) {
result :=sub(subject, subjectStart)
break
}
subject :=add(subject, 1)
ifiszero(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.functionindexOf(stringmemory subject, stringmemory search)
internalpurereturns (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.functionlastIndexOf(stringmemory subject, stringmemory search, uint256from)
internalpurereturns (uint256 result)
{
/// @solidity memory-safe-assemblyassembly {
for {} 1 {} {
result :=not(0) // Initialize to `NOT_FOUND`.let searchLength :=mload(search)
ifgt(searchLength, mload(subject)) { break }
let w := result
let fromMax :=sub(mload(subject), searchLength)
ifiszero(gt(fromMax, from)) { from := fromMax }
let end :=add(add(subject, 0x20), w)
subject :=add(add(subject, 0x20), from)
ifiszero(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 {} {
ifeq(keccak256(subject, searchLength), h) {
result :=sub(subject, add(end, 1))
break
}
subject :=add(subject, w) // `sub(subject, 1)`.ifiszero(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.functionlastIndexOf(stringmemory subject, stringmemory search)
internalpurereturns (uint256 result)
{
result = lastIndexOf(subject, search, uint256(int256(-1)));
}
/// @dev Returns whether `subject` starts with `search`.functionstartsWith(stringmemory subject, stringmemory search)
internalpurereturns (bool result)
{
/// @solidity memory-safe-assemblyassembly {
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`.functionendsWith(stringmemory subject, stringmemory search)
internalpurereturns (bool result)
{
/// @solidity memory-safe-assemblyassembly {
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`.functionrepeat(stringmemory subject, uint256 times)
internalpurereturns (stringmemory result)
{
/// @solidity memory-safe-assemblyassembly {
let subjectLength :=mload(subject)
ifiszero(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)
ifiszero(lt(o, subjectLength)) { break }
}
output :=add(output, subjectLength)
times :=sub(times, 1)
ifiszero(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.functionslice(stringmemory subject, uint256 start, uint256 end)
internalpurereturns (stringmemory result)
{
/// @solidity memory-safe-assemblyassembly {
let subjectLength :=mload(subject)
ifiszero(gt(subjectLength, end)) { end := subjectLength }
ifiszero(gt(subjectLength, start)) { start := subjectLength }
iflt(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)`.ifiszero(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.functionslice(stringmemory subject, uint256 start)
internalpurereturns (stringmemory result)
{
result = slice(subject, start, uint256(int256(-1)));
}
/// @dev Returns all the indices of `search` in `subject`./// The indices are byte offsets.functionindicesOf(stringmemory subject, stringmemory search)
internalpurereturns (uint256[] memory result)
{
/// @solidity memory-safe-assemblyassembly {
let subjectLength :=mload(subject)
let searchLength :=mload(search)
ifiszero(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 :=0ifiszero(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.ifiszero(shr(m, xor(t, s))) {
if h {
ifiszero(eq(keccak256(subject, searchLength), h)) {
subject :=add(subject, 1)
ifiszero(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 {
ifiszero(lt(subject, subjectSearchEnd)) { break }
continue
}
}
subject :=add(subject, 1)
ifiszero(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.functionsplit(stringmemory subject, stringmemory delimiter)
internalpurereturns (string[] memory result)
{
uint256[] memory indices = indicesOf(subject, delimiter);
/// @solidity memory-safe-assemblyassembly {
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 :=0for {} 1 {} {
let index :=mload(indexPtr)
mstore(indexPtr, 0x60)
ifiszero(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)`.ifiszero(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)
ifiszero(lt(indexPtr, indicesEnd)) { break }
}
result := indices
ifiszero(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.functionconcat(stringmemory a, stringmemory b)
internalpurereturns (stringmemory result)
{
/// @solidity memory-safe-assemblyassembly {
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)`.ifiszero(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)`.ifiszero(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.functiontoCase(stringmemory subject, bool toUpper)
internalpurereturns (stringmemory result)
{
/// @solidity memory-safe-assemblyassembly {
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)))
ifiszero(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 lowercased copy of the string./// WARNING! This function is only compatible with 7-bit ASCII strings.functionlower(stringmemory subject) internalpurereturns (stringmemory result) {
result = toCase(subject, false);
}
/// @dev Returns an UPPERCASED copy of the string./// WARNING! This function is only compatible with 7-bit ASCII strings.functionupper(stringmemory subject) internalpurereturns (stringmemory result) {
result = toCase(subject, true);
}
/// @dev Escapes the string to be used within HTML tags.functionescapeHTML(stringmemory s) internalpurereturns (stringmemory result) {
/// @solidity memory-safe-assemblyassembly {
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 `["\"","'","&","<",">"]`.ifiszero(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.functionescapeJSON(stringmemory s, bool addDoubleQuotes)
internalpurereturns (stringmemory result)
{
/// @solidity memory-safe-assemblyassembly {
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)
ifiszero(lt(c, 0x20)) {
ifiszero(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
}
ifiszero(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.functionescapeJSON(stringmemory s) internalpurereturns (stringmemory result) {
result = escapeJSON(s, false);
}
/// @dev Returns whether `a` equals `b`.functioneq(stringmemory a, stringmemory b) internalpurereturns (bool result) {
/// @solidity memory-safe-assemblyassembly {
result :=eq(keccak256(add(a, 0x20), mload(a)), keccak256(add(b, 0x20), mload(b)))
}
}
/// @dev Returns whether `a` equals `b`. For short strings up to 32 bytes.functioneqs(stringmemory a, bytes32 b) internalpurereturns (bool result) {
/// @solidity memory-safe-assemblyassembly {
// These should be evaluated on compile time, as far as possible.let x :=and(b, add(not(b), 1))
let r :=or(shl(8, iszero(b)), shl(7, iszero(iszero(shr(128, x)))))
r :=or(r, shl(6, iszero(iszero(shr(64, shr(r, x))))))
r :=or(r, shl(5, lt(0xffffffff, shr(r, x))))
r :=or(r, shl(4, lt(0xffff, shr(r, x))))
r :=or(r, shl(3, lt(0xff, shr(r, x))))
result :=gt(eq(mload(a), sub(32, shr(3, r))), shr(r, xor(b, 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.functionpackOne(stringmemory a) internalpurereturns (bytes32 result) {
/// @solidity memory-safe-assemblyassembly {
// 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 behaviour is undefined.functionunpackOne(bytes32 packed) internalpurereturns (stringmemory result) {
/// @solidity memory-safe-assemblyassembly {
// 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.functionpackTwo(stringmemory a, stringmemory b) internalpurereturns (bytes32 result) {
/// @solidity memory-safe-assemblyassembly {
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 behaviour is undefined.functionunpackTwo(bytes32 packed)
internalpurereturns (stringmemory resultA, stringmemory resultB)
{
/// @solidity memory-safe-assemblyassembly {
// 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.functiondirectReturn(stringmemory a) internalpure{
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)
}
}
}
Código Fuente del Contrato
Archivo 4 de 5: Ownable.sol
// SPDX-License-Identifier: MITpragmasolidity ^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.abstractcontractOwnable{
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* CUSTOM ERRORS *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev The caller is not authorized to call the function.errorUnauthorized();
/// @dev The `newOwner` cannot be the zero address.errorNewOwnerIsZeroAddress();
/// @dev The `pendingOwner` does not have a valid handover request.errorNoHandoverRequest();
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* EVENTS *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev The ownership is transferred from `oldOwner` to `newOwner`./// This event is intentionally kept the same as OpenZeppelin's Ownable to be/// compatible with indexers and [EIP-173](https://eips.ethereum.org/EIPS/eip-173),/// despite it not being as lightweight as a single argument event.eventOwnershipTransferred(addressindexed oldOwner, addressindexed newOwner);
/// @dev An ownership handover to `pendingOwner` has been requested.eventOwnershipHandoverRequested(addressindexed pendingOwner);
/// @dev The ownership handover to `pendingOwner` has been canceled.eventOwnershipHandoverCanceled(addressindexed pendingOwner);
/// @dev `keccak256(bytes("OwnershipTransferred(address,address)"))`.uint256privateconstant _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE =0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0;
/// @dev `keccak256(bytes("OwnershipHandoverRequested(address)"))`.uint256privateconstant _OWNERSHIP_HANDOVER_REQUESTED_EVENT_SIGNATURE =0xdbf36a107da19e49527a7176a1babf963b4b0ff8cde35ee35d6cd8f1f9ac7e1d;
/// @dev `keccak256(bytes("OwnershipHandoverCanceled(address)"))`.uint256privateconstant _OWNERSHIP_HANDOVER_CANCELED_EVENT_SIGNATURE =0xfa7b8eab7da67f412cc9575ed43464468f9bfbae89d1675917346ca6d8fe3c92;
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* STORAGE *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev The owner slot is given by: `not(_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.uint256privateconstant _OWNER_SLOT_NOT =0x8b78c6d8;
/// 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.uint256privateconstant _HANDOVER_SLOT_SEED =0x389a75e1;
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* INTERNAL FUNCTIONS *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @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) internalvirtual{
/// @solidity memory-safe-assemblyassembly {
// Clean the upper 96 bits.
newOwner :=shr(96, shl(96, newOwner))
// Store the new value.sstore(not(_OWNER_SLOT_NOT), 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) internalvirtual{
/// @solidity memory-safe-assemblyassembly {
let ownerSlot :=not(_OWNER_SLOT_NOT)
// 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() internalviewvirtual{
/// @solidity memory-safe-assemblyassembly {
// If the caller is not the stored owner, revert.ifiszero(eq(caller(), sload(not(_OWNER_SLOT_NOT)))) {
mstore(0x00, 0x82b42900) // `Unauthorized()`.revert(0x1c, 0x04)
}
}
}
/// @dev Returns how long a two-step ownership handover is valid for in seconds./// Override to return a different value if needed./// Made internal to conserve bytecode. Wrap it in a public function if needed.function_ownershipHandoverValidFor() internalviewvirtualreturns (uint64) {
return48*3600;
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* PUBLIC UPDATE FUNCTIONS *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev Allows the owner to transfer the ownership to `newOwner`.functiontransferOwnership(address newOwner) publicpayablevirtualonlyOwner{
/// @solidity memory-safe-assemblyassembly {
ifiszero(shl(96, newOwner)) {
mstore(0x00, 0x7448fbae) // `NewOwnerIsZeroAddress()`.revert(0x1c, 0x04)
}
}
_setOwner(newOwner);
}
/// @dev Allows the owner to renounce their ownership.functionrenounceOwnership() publicpayablevirtualonlyOwner{
_setOwner(address(0));
}
/// @dev Request a two-step ownership handover to the caller./// The request will automatically expire in 48 hours (172800 seconds) by default.functionrequestOwnershipHandover() publicpayablevirtual{
unchecked {
uint256 expires =block.timestamp+ _ownershipHandoverValidFor();
/// @solidity memory-safe-assemblyassembly {
// Compute and set the handover slot to `expires`.mstore(0x0c, _HANDOVER_SLOT_SEED)
mstore(0x00, caller())
sstore(keccak256(0x0c, 0x20), expires)
// Emit the {OwnershipHandoverRequested} event.log2(0, 0, _OWNERSHIP_HANDOVER_REQUESTED_EVENT_SIGNATURE, caller())
}
}
}
/// @dev Cancels the two-step ownership handover to the caller, if any.functioncancelOwnershipHandover() publicpayablevirtual{
/// @solidity memory-safe-assemblyassembly {
// Compute and set the handover slot to 0.mstore(0x0c, _HANDOVER_SLOT_SEED)
mstore(0x00, caller())
sstore(keccak256(0x0c, 0x20), 0)
// Emit the {OwnershipHandoverCanceled} event.log2(0, 0, _OWNERSHIP_HANDOVER_CANCELED_EVENT_SIGNATURE, caller())
}
}
/// @dev Allows the owner to complete the two-step ownership handover to `pendingOwner`./// Reverts if there is no existing ownership handover requested by `pendingOwner`.functioncompleteOwnershipHandover(address pendingOwner) publicpayablevirtualonlyOwner{
/// @solidity memory-safe-assemblyassembly {
// Compute and set the handover slot to 0.mstore(0x0c, _HANDOVER_SLOT_SEED)
mstore(0x00, pendingOwner)
let handoverSlot :=keccak256(0x0c, 0x20)
// If the handover does not exist, or has expired.ifgt(timestamp(), sload(handoverSlot)) {
mstore(0x00, 0x6f5e8818) // `NoHandoverRequest()`.revert(0x1c, 0x04)
}
// Set the handover slot to 0.sstore(handoverSlot, 0)
}
_setOwner(pendingOwner);
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* PUBLIC READ FUNCTIONS *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev Returns the owner of the contract.functionowner() publicviewvirtualreturns (address result) {
/// @solidity memory-safe-assemblyassembly {
result :=sload(not(_OWNER_SLOT_NOT))
}
}
/// @dev Returns the expiry timestamp for the two-step ownership handover to `pendingOwner`.functionownershipHandoverExpiresAt(address pendingOwner)
publicviewvirtualreturns (uint256 result)
{
/// @solidity memory-safe-assemblyassembly {
// Compute the handover slot.mstore(0x0c, _HANDOVER_SLOT_SEED)
mstore(0x00, pendingOwner)
// Load the handover slot.
result :=sload(keccak256(0x0c, 0x20))
}
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*//* MODIFIERS *//*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*//// @dev Marks a function as only callable by the owner.modifieronlyOwner() virtual{
_checkOwner();
_;
}
}
Código Fuente del Contrato
Archivo 5 de 5: Prime.sol
// SPDX-License-Identifier: UNLICENSEDpragmasolidity 0.8.20;import"solady/src/tokens/ERC721.sol";
import"solady/src/auth/Ownable.sol";
import"solady/src/utils/ECDSA.sol";
import"solady/src/utils/LibString.sol";
contractPrimeisERC721, Ownable{
usingECDSAforbytes;
errorInvalidValue();
errorMismatchLength(uint256 expecting);
errorNameUsed();
errorInvalidReferral();
errorFailedToSendFee();
errorNothingToClaim();
errorClaimsClosed();
errorContractDepleted();
errorQueryForNonexistantToken();
errorInvalidWhitelistClaim();
errorAlreadyClaimed();
errorInvalidDiscountValue();
errorMustUseSameRefCode(string code);
errorMintIsNotLive();
uint256public PRICE =0.018777*1ether;
uint256public DISCOUNT_PRICE =0.0169*1ether;
uint256public WHITELIST_PRICE =0.0142*1ether;
uint256public totalSupply =0;
uint256public totalRefClaims =0;
stringpublic baseURI ="https://app.sukuri.io/api/";
boolpublic IS_LIVE =false;
boolpublic CLAIMS_LIVE =false;
address signer;
mapping(uint256 tokenID =>string name) public namespace;
mapping(string name =>address owner) public nameOwner;
mapping(address referee =>string referral) public usedRefs;
mapping(address owner =>uint256 balance) refClaim;
mapping(address whitelistee =>uint256 claimed) public wlClaim;
constructor(address signer_) {
_initializeOwner(msg.sender);
signer = signer_;
}
functionwhitelistMint(stringcalldata _name,
stringmemory referral,
bytescalldata signature
) externalpayable{
if (!IS_LIVE) {
revert MintIsNotLive();
}
if (msg.value!= WHITELIST_PRICE) {
revert InvalidValue();
}
if (wlClaim[msg.sender] !=0) {
revert AlreadyClaimed();
}
bytes32 message =keccak256(abi.encode(msg.sender, _name, referral));
if (
ECDSA.recover(ECDSA.toEthSignedMessageHash(message), signature) !=
signer
) {
revert InvalidWhitelistClaim();
}
if (nameOwner[_name] !=address(0)) {
revert NameUsed();
}
_checkAndUpdateRefClaims(referral);
uint256 tokenId =++totalSupply;
namespace[tokenId] = _name;
nameOwner[_name] =msg.sender;
wlClaim[msg.sender]++;
_mint(msg.sender, tokenId);
}
functionmint(stringcalldata _name,
stringmemory referral
) externalpayable{
if (!IS_LIVE) {
revert MintIsNotLive();
}
bytesmemory refTmp =bytes(referral);
if (refTmp.length>0&&msg.value!= DISCOUNT_PRICE) {
revert InvalidDiscountValue();
} elseif (refTmp.length==0&&msg.value!= PRICE) {
revert InvalidValue();
}
if (nameOwner[_name] !=address(0)) {
revert NameUsed();
}
_checkAndUpdateRefClaims(referral);
uint256 tokenId =++totalSupply;
namespace[tokenId] = _name;
nameOwner[_name] =msg.sender;
_mint(msg.sender, tokenId);
}
function_afterTokenTransfer(addressfrom,
address to,
uint256 id
) internaloverride{
if (to ==address(0)) {
revert TransferToZeroAddress();
}
nameOwner[namespace[id]] = to;
}
functionclaimFees() external{
if (!CLAIMS_LIVE) {
revert ClaimsClosed();
}
uint256 claim = refClaim[msg.sender];
if (claim ==0) {
revert NothingToClaim();
}
if (address(this).balance< claim) {
revert ContractDepleted();
}
refClaim[msg.sender] =0;
totalRefClaims -= claim;
(bool success, ) =address(msg.sender).call{value: claim}("");
if (!success) {
revert FailedToSendFee();
}
}
functionadminMint(address[] calldata tos,
string[] calldata names
) externalonlyOwner{
if (tos.length!= names.length) {
revert MismatchLength({expecting: tos.length});
}
uint256 tokenId = totalSupply;
for (uint i; i < tos.length; ) {
tokenId++;
_mint(tos[i], tokenId);
namespace[tokenId] = names[i];
nameOwner[names[i]] = tos[i];
unchecked {
i++;
}
}
totalSupply += tos.length;
}
functionwithdraw() externalonlyOwner{
if (address(this).balance< totalRefClaims) {
revert ContractDepleted();
}
(bool success, ) =address(owner()).call{
value: address(this).balance- totalRefClaims
}("");
if (!success) {
revert FailedToSendFee();
}
}
// This should never be called unless nobody is claiming, the claim balances are extremely low// and we need to get the ETH out of the contract so it's not burned. Claim periods will be live// for a long time so this should not happen.functionforceWithdrawl() externalonlyOwner{
(bool success, ) =address(owner()).call{value: address(this).balance}(
""
);
if (!success) {
revert FailedToSendFee();
}
}
functionsetIsLive(bool status) externalonlyOwner{
IS_LIVE = status;
}
functionsetClaimLive(bool status) externalonlyOwner{
CLAIMS_LIVE = status;
}
functionsetSigner(address _signer) externalonlyOwner{
signer = _signer;
}
functionsetBaseURI(stringcalldata _baseURI) externalonlyOwner{
baseURI = _baseURI;
}
functionsetMintPrice(uint256 price) externalonlyOwner{
PRICE = price;
}
functioncheckClaim(address ref) publicviewreturns (uint256) {
return refClaim[ref];
}
functioncontractBalance() externalviewreturns (uint256) {
returnaddress(this).balance- totalRefClaims;
}
functionname() publicpureoverridereturns (stringmemory) {
return"Sukuri Prime";
}
functionsymbol() publicpureoverridereturns (stringmemory) {
return"PRIME";
}
functioncontractURI() publicviewreturns (stringmemory) {
return LibString.concat(baseURI, "contractURI");
}
functiontokenURI(uint256 id) publicviewoverridereturns (stringmemory) {
if (id > totalSupply || id ==0) {
revert QueryForNonexistantToken();
}
return
LibString.concat(
LibString.concat(baseURI, "tokenURI/"),
LibString.toString(id)
);
}
function_checkAndUpdateRefClaims(stringmemory referral) internal{
bytesmemory refTmp =bytes(referral);
if (refTmp.length>0) {
address ref = nameOwner[referral];
if (
LibString.packOne(usedRefs[msg.sender]) !=bytes32(0) &&!LibString.eq(usedRefs[msg.sender], referral)
) {
revert MustUseSameRefCode({code: usedRefs[msg.sender]});
}
if (ref ==address(0)) {
revert InvalidReferral();
}
usedRefs[msg.sender] = referral;
bool refHasRef = LibString.packOne(usedRefs[ref]) !=bytes32(0);
uint256 refFee = (msg.value*5) /100;
uint256 refRefFee = refHasRef ? (msg.value*5) /1000 : 0;
unchecked {
refClaim[nameOwner[usedRefs[ref]]] += refRefFee;
refClaim[ref] += refFee;
totalRefClaims += (refFee + refRefFee);
}
}
}
}
