// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)pragmasolidity ^0.8.20;/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/abstractcontractContext{
function_msgSender() internalviewvirtualreturns (address) {
returnmsg.sender;
}
function_msgData() internalviewvirtualreturns (bytescalldata) {
returnmsg.data;
}
function_contextSuffixLength() internalviewvirtualreturns (uint256) {
return0;
}
}
Contract Source Code
File 2 of 25: Create2.sol
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v5.0.0) (utils/Create2.sol)pragmasolidity ^0.8.20;/**
* @dev Helper to make usage of the `CREATE2` EVM opcode easier and safer.
* `CREATE2` can be used to compute in advance the address where a smart
* contract will be deployed, which allows for interesting new mechanisms known
* as 'counterfactual interactions'.
*
* See the https://eips.ethereum.org/EIPS/eip-1014#motivation[EIP] for more
* information.
*/libraryCreate2{
/**
* @dev Not enough balance for performing a CREATE2 deploy.
*/errorCreate2InsufficientBalance(uint256 balance, uint256 needed);
/**
* @dev There's no code to deploy.
*/errorCreate2EmptyBytecode();
/**
* @dev The deployment failed.
*/errorCreate2FailedDeployment();
/**
* @dev Deploys a contract using `CREATE2`. The address where the contract
* will be deployed can be known in advance via {computeAddress}.
*
* The bytecode for a contract can be obtained from Solidity with
* `type(contractName).creationCode`.
*
* Requirements:
*
* - `bytecode` must not be empty.
* - `salt` must have not been used for `bytecode` already.
* - the factory must have a balance of at least `amount`.
* - if `amount` is non-zero, `bytecode` must have a `payable` constructor.
*/functiondeploy(uint256 amount, bytes32 salt, bytesmemory bytecode) internalreturns (address addr) {
if (address(this).balance< amount) {
revert Create2InsufficientBalance(address(this).balance, amount);
}
if (bytecode.length==0) {
revert Create2EmptyBytecode();
}
/// @solidity memory-safe-assemblyassembly {
addr :=create2(amount, add(bytecode, 0x20), mload(bytecode), salt)
}
if (addr ==address(0)) {
revert Create2FailedDeployment();
}
}
/**
* @dev Returns the address where a contract will be stored if deployed via {deploy}. Any change in the
* `bytecodeHash` or `salt` will result in a new destination address.
*/functioncomputeAddress(bytes32 salt, bytes32 bytecodeHash) internalviewreturns (address) {
return computeAddress(salt, bytecodeHash, address(this));
}
/**
* @dev Returns the address where a contract will be stored if deployed via {deploy} from a contract located at
* `deployer`. If `deployer` is this contract's address, returns the same value as {computeAddress}.
*/functioncomputeAddress(bytes32 salt, bytes32 bytecodeHash, address deployer) internalpurereturns (address addr) {
/// @solidity memory-safe-assemblyassembly {
let ptr :=mload(0x40) // Get free memory pointer// | | ↓ ptr ... ↓ ptr + 0x0B (start) ... ↓ ptr + 0x20 ... ↓ ptr + 0x40 ... |// |-------------------|---------------------------------------------------------------------------|// | bytecodeHash | CCCCCCCCCCCCC...CC |// | salt | BBBBBBBBBBBBB...BB |// | deployer | 000000...0000AAAAAAAAAAAAAAAAAAA...AA |// | 0xFF | FF |// |-------------------|---------------------------------------------------------------------------|// | memory | 000000...00FFAAAAAAAAAAAAAAAAAAA...AABBBBBBBBBBBBB...BBCCCCCCCCCCCCC...CC |// | keccak(start, 85) | ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ |mstore(add(ptr, 0x40), bytecodeHash)
mstore(add(ptr, 0x20), salt)
mstore(ptr, deployer) // Right-aligned with 12 preceding garbage byteslet start :=add(ptr, 0x0b) // The hashed data starts at the final garbage byte which we will set to 0xffmstore8(start, 0xff)
addr :=keccak256(start, 85)
}
}
}
Contract Source Code
File 3 of 25: ECDSA.sol
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/ECDSA.sol)pragmasolidity ^0.8.20;/**
* @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
*
* These functions can be used to verify that a message was signed by the holder
* of the private keys of a given address.
*/libraryECDSA{
enumRecoverError {
NoError,
InvalidSignature,
InvalidSignatureLength,
InvalidSignatureS
}
/**
* @dev The signature derives the `address(0)`.
*/errorECDSAInvalidSignature();
/**
* @dev The signature has an invalid length.
*/errorECDSAInvalidSignatureLength(uint256 length);
/**
* @dev The signature has an S value that is in the upper half order.
*/errorECDSAInvalidSignatureS(bytes32 s);
/**
* @dev Returns the address that signed a hashed message (`hash`) with `signature` or an error. This will not
* return address(0) without also returning an error description. Errors are documented using an enum (error type)
* and a bytes32 providing additional information about the error.
*
* If no error is returned, then the address can be used for verification purposes.
*
* The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:
* this function rejects them by requiring the `s` value to be in the lower
* half order, and the `v` value to be either 27 or 28.
*
* IMPORTANT: `hash` _must_ be the result of a hash operation for the
* verification to be secure: it is possible to craft signatures that
* recover to arbitrary addresses for non-hashed data. A safe way to ensure
* this is by receiving a hash of the original message (which may otherwise
* be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.
*
* Documentation for signature generation:
* - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
* - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
*/functiontryRecover(bytes32 hash, bytesmemory signature) internalpurereturns (address, RecoverError, bytes32) {
if (signature.length==65) {
bytes32 r;
bytes32 s;
uint8 v;
// ecrecover takes the signature parameters, and the only way to get them// currently is to use assembly./// @solidity memory-safe-assemblyassembly {
r :=mload(add(signature, 0x20))
s :=mload(add(signature, 0x40))
v :=byte(0, mload(add(signature, 0x60)))
}
return tryRecover(hash, v, r, s);
} else {
return (address(0), RecoverError.InvalidSignatureLength, bytes32(signature.length));
}
}
/**
* @dev Returns the address that signed a hashed message (`hash`) with
* `signature`. This address can then be used for verification purposes.
*
* The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:
* this function rejects them by requiring the `s` value to be in the lower
* half order, and the `v` value to be either 27 or 28.
*
* IMPORTANT: `hash` _must_ be the result of a hash operation for the
* verification to be secure: it is possible to craft signatures that
* recover to arbitrary addresses for non-hashed data. A safe way to ensure
* this is by receiving a hash of the original message (which may otherwise
* be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.
*/functionrecover(bytes32 hash, bytesmemory signature) internalpurereturns (address) {
(address recovered, RecoverError error, bytes32errorArg) = tryRecover(hash, signature);
_throwError(error, errorArg);
return recovered;
}
/**
* @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
*
* See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
*/functiontryRecover(bytes32 hash, bytes32 r, bytes32 vs) internalpurereturns (address, RecoverError, bytes32) {
unchecked {
bytes32 s = vs &bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
// We do not check for an overflow here since the shift operation results in 0 or 1.uint8 v =uint8((uint256(vs) >>255) +27);
return tryRecover(hash, v, r, s);
}
}
/**
* @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
*/functionrecover(bytes32 hash, bytes32 r, bytes32 vs) internalpurereturns (address) {
(address recovered, RecoverError error, bytes32errorArg) = tryRecover(hash, r, vs);
_throwError(error, errorArg);
return recovered;
}
/**
* @dev Overload of {ECDSA-tryRecover} that receives the `v`,
* `r` and `s` signature fields separately.
*/functiontryRecover(bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s
) internalpurereturns (address, RecoverError, bytes32) {
// EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature// unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines// the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most// signatures from current libraries generate a unique signature with an s-value in the lower half order.//// If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value// with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or// vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept// these malleable signatures as well.if (uint256(s) >0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
return (address(0), RecoverError.InvalidSignatureS, s);
}
// If the signature is valid (and not malleable), return the signer addressaddress signer =ecrecover(hash, v, r, s);
if (signer ==address(0)) {
return (address(0), RecoverError.InvalidSignature, bytes32(0));
}
return (signer, RecoverError.NoError, bytes32(0));
}
/**
* @dev Overload of {ECDSA-recover} that receives the `v`,
* `r` and `s` signature fields separately.
*/functionrecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internalpurereturns (address) {
(address recovered, RecoverError error, bytes32errorArg) = tryRecover(hash, v, r, s);
_throwError(error, errorArg);
return recovered;
}
/**
* @dev Optionally reverts with the corresponding custom error according to the `error` argument provided.
*/function_throwError(RecoverError error, bytes32 errorArg) privatepure{
if (error == RecoverError.NoError) {
return; // no error: do nothing
} elseif (error == RecoverError.InvalidSignature) {
revert ECDSAInvalidSignature();
} elseif (error == RecoverError.InvalidSignatureLength) {
revert ECDSAInvalidSignatureLength(uint256(errorArg));
} elseif (error == RecoverError.InvalidSignatureS) {
revert ECDSAInvalidSignatureS(errorArg);
}
}
}
pragmasolidity ^0.8.26;// SPDX-License-Identifier: MITimport {IERC404} from"../interfaces/IERC404.sol";
import {PackedDoubleEndedQueue} from"./PackedDoubleEndedQueue.sol";
import {ERC6551Account} from"./ERC6551Account.sol";
import {ERC6551Registry} from"./ERC6551Registry.sol";
import {ERC721Events} from"./ERC721Events.sol";
import {ERC20Events} from"./ERC20Events.sol";
import {IERC721Receiver} from"@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import {IERC165} from"@openzeppelin/contracts/interfaces/IERC165.sol";
abstractcontractERC4DisIERC404{
usingPackedDoubleEndedQueueforPackedDoubleEndedQueue.Uint16Deque;
/// @dev The queue of ERC-721 tokens stored in the contract.
PackedDoubleEndedQueue.Uint16Deque private _storedERC721Ids;
/// @dev Token namestringpublic name;
/// @dev Token symbolstringpublic symbol;
/// @dev Decimals for ERC-20 representationuint8publicimmutable decimals;
/// @dev Units for ERC-20 representationuint256publicimmutable units;
/// @dev Total supply in ERC-20 representationuint256public totalSupply;
/// @dev Current mint counter which also represents the highest/// minted id, monotonically increasing to ensure accurate ownershipuint256public minted;
/// @dev Initial chain id for EIP-2612 supportuint256internalimmutable _INITIAL_CHAIN_ID;
/// @dev Initial domain separator for EIP-2612 supportbytes32internalimmutable _INITIAL_DOMAIN_SEPARATOR;
/// @dev Balance of user in ERC-20 representationmapping(address=>uint256) public balanceOf;
/// @dev Allowance of user in ERC-20 representationmapping(address=>mapping(address=>uint256)) public allowance;
/// @dev Approval in ERC-721 representaionmapping(uint256=>address) public getApproved;
/// @dev Approval for all in ERC-721 representationmapping(address=>mapping(address=>bool)) public isApprovedForAll;
/// @dev Packed representation of ownerOf and owned indicesmapping(uint256=>uint256) internal _ownedData;
/// @dev Array of owned ids in ERC-721 representationmapping(address=>uint16[]) internal _owned;
/// @dev Addresses that are exempt from ERC-721 transfer, typically for gas savings (pairs, routers, etc)mapping(address=>bool) internal _erc721TransferExempt;
/// @dev EIP-2612 noncesmapping(address=>uint256) public nonces;
/// @dev Address bitmask for packed ownership datauint256privateconstant _BITMASK_ADDRESS = (1<<160) -1;
/// @dev Owned index bitmask for packed ownership datauint256privateconstant _BITMASK_OWNED_INDEX = ((1<<96) -1) <<160;
/// @dev Constant for token id encodinguint256publicconstant ID_ENCODING_PREFIX =1<<255;
/// @dev struct for changeable 6551 setupsstructdddd_setup {
ERC6551Account implementation;
ERC6551Registry registry;
bytes32 salt;
}
/// @dev storage for each 6551 setup
dddd_setup[] public setup;
/// @dev 6551 setup set for each NFTmapping(uint256=>uint256) public nft_setup_set;
constructor(stringmemory name_, stringmemory symbol_, uint8 decimals_) {
name = name_;
symbol = symbol_;
if (decimals_ <18) {
revert DecimalsTooLow();
}
decimals = decimals_;
units =10** decimals;
// EIP-2612 initialization
_INITIAL_CHAIN_ID =block.chainid;
_INITIAL_DOMAIN_SEPARATOR = _computeDomainSeparator();
}
functionaccount(uint256 id_) publicviewreturns (address) {
dddd_setup memory s = setup[nft_setup_set[id_]];
return s.registry.account(address(s.implementation), s.salt, block.chainid, address(this), id_);
}
functionexecute(uint256 id_, address to, uint256 value, bytescalldata data, uint8 operation)
externalpayablereturns (bytesmemory result)
{
return ERC6551Account(payable(account(id_))).execute(to, value, data, operation);
}
/// @notice Function to find owner of a given ERC-721 tokenfunctionownerOf(uint256 id_) publicviewvirtualreturns (address erc721Owner) {
id_ += ID_ENCODING_PREFIX;
erc721Owner = _getOwnerOf(id_);
if (!_isValidTokenId(id_)) {
revert InvalidTokenId();
}
if (erc721Owner ==address(0)) {
revert NotFound();
}
}
functionowned(address owner_) publicviewvirtualreturns (uint256[] memory) {
uint256[] memory ownedAsU256 =newuint256[](_owned[owner_].length);
for (uint256 i =0; i < _owned[owner_].length;) {
ownedAsU256[i] = _owned[owner_][i];
unchecked {
++i;
}
}
return ownedAsU256;
}
functionerc721BalanceOf(address owner_) publicviewvirtualreturns (uint256) {
return _owned[owner_].length;
}
functionerc20BalanceOf(address owner_) publicviewvirtualreturns (uint256) {
return balanceOf[owner_];
}
functionerc20TotalSupply() publicviewvirtualreturns (uint256) {
return totalSupply;
}
functionerc721TotalSupply() publicviewvirtualreturns (uint256) {
return minted;
}
functiongetERC721QueueLength() publicviewvirtualreturns (uint256) {
return _storedERC721Ids.length();
}
functiongetERC721TokensInQueue(uint256 start_, uint256 count_) publicviewvirtualreturns (uint256[] memory) {
uint256[] memory tokensInQueue =newuint256[](count_);
for (uint256 i = start_; i < start_ + count_;) {
tokensInQueue[i - start_] = _storedERC721Ids.at(i);
unchecked {
++i;
}
}
return tokensInQueue;
}
/// @notice tokenURI must be implemented by child contractfunctiontokenURI(uint256 id_) publicviewvirtualreturns (stringmemory);
/// @notice Function for token approvals/// @dev This function assumes the operator is attempting to approve an ERC-721/// if valueOrId is less than the minted count. Unlike setApprovalForAll,/// spender_ must be allowed to be 0x0 so that approval can be revoked.functionapprove(address spender_, uint256 valueOrId_) publicvirtualreturns (bool) {
// The ERC-721 tokens are 1-indexed, so 0 is not a valid id and indicates that// operator is attempting to set the ERC-20 allowance to 0.if (valueOrId_ >= ID_ENCODING_PREFIX) {
return erc20Approve(spender_, valueOrId_);
}
if (_isValidTokenId(valueOrId_ + ID_ENCODING_PREFIX)) {
bool auth = erc721Approve(spender_, valueOrId_);
// If ERC-721 exists but sender is not authorised then default to ERC-20if (!auth) return erc20Approve(spender_, valueOrId_);
} else {
return erc20Approve(spender_, valueOrId_);
}
returntrue;
}
functionerc721Approve(address spender_, uint256 id_) publicvirtualreturns (bool) {
// Intention is to approve as ERC-721 token (id).
id_ += ID_ENCODING_PREFIX;
address erc721Owner = _getOwnerOf(id_);
if (msg.sender!= erc721Owner &&!isApprovedForAll[erc721Owner][msg.sender]) {
returnfalse;
}
getApproved[id_] = spender_;
emit ERC721Events.Approval(erc721Owner, spender_, id_ - ID_ENCODING_PREFIX);
returntrue;
}
/// @dev Providing type(uint256).max for approval value results in an/// unlimited approval that is not deducted from on transfers.functionerc20Approve(address spender_, uint256 value_) publicvirtualreturns (bool) {
// Prevent granting 0x0 an ERC-20 allowance.if (spender_ ==address(0)) {
revert InvalidSpender();
}
// Intention is to approve as ERC-20 token (value).
allowance[msg.sender][spender_] = value_;
emit ERC20Events.Approval(msg.sender, spender_, value_);
returntrue;
}
/// @notice Function for ERC-721 approvalsfunctionsetApprovalForAll(address operator_, bool approved_) publicvirtual{
// Prevent approvals to 0x0.if (operator_ ==address(0)) {
revert InvalidOperator();
}
isApprovedForAll[msg.sender][operator_] = approved_;
emit ERC721Events.ApprovalForAll(msg.sender, operator_, approved_);
}
/// @notice Function for mixed transfers from an operator that may be different than 'from'./// @dev This function assumes the operator is attempting to transfer an ERC-721/// if valueOrId is less than or equal to current max id.functiontransferFrom(address from_, address to_, uint256 valueOrId_) publicvirtualreturns (bool) {
if (_isValidTokenId(valueOrId_ + ID_ENCODING_PREFIX)) {
if (from_ != _getOwnerOf(valueOrId_ + ID_ENCODING_PREFIX)) {
return erc20TransferFrom(from_, to_, valueOrId_);
} else {
erc721TransferFrom(from_, to_, valueOrId_);
}
} else {
// Intention is to transfer as ERC-20 token (value).return erc20TransferFrom(from_, to_, valueOrId_);
}
returntrue;
}
/// @notice Function for ERC-721 transfers from./// @dev This function is recommended for ERC721 transfersfunctionerc721TransferFrom(address from_, address to_, uint256 id_) publicvirtual{
id_ += ID_ENCODING_PREFIX;
// Prevent transferring tokens from 0x0.if (from_ ==address(0)) {
revert InvalidSender();
}
// Prevent burning tokens to 0x0.if (to_ ==address(0)) {
revert InvalidRecipient();
}
if (from_ != _getOwnerOf(id_)) {
revert Unauthorized();
}
// Check that the operator is either the sender or approved for the transfer.if (msg.sender!= from_ &&!isApprovedForAll[from_][msg.sender] &&msg.sender!= getApproved[id_]) {
revert Unauthorized();
}
if (erc721TransferExempt(to_)) {
revert RecipientIsERC721TransferExempt();
}
// Transfer 1 * units ERC-20 and 1 ERC-721 token.// ERC-721 transfer exemptions handled above. Can't make it to this point if either is transfer exempt.
_transferERC20(from_, to_, units);
_transferERC721(from_, to_, id_);
}
/// @notice Function for ERC-20 transfers from./// @dev This function is recommended for ERC20 transfersfunctionerc20TransferFrom(address from_, address to_, uint256 value_) publicvirtualreturns (bool) {
// Prevent transferring tokens from 0x0.if (from_ ==address(0)) {
revert InvalidSender();
}
// Prevent burning tokens to 0x0.if (to_ ==address(0)) {
revert InvalidRecipient();
}
// Intention is to transfer as ERC-20 token (value).uint256 allowed = allowance[from_][msg.sender];
// Check that the operator has sufficient allowance.if (allowed !=type(uint256).max) {
allowance[from_][msg.sender] = allowed - value_;
}
// Transferring ERC-20s directly requires the _transfer function.// Handles ERC-721 exemptions internally.return _transferERC20WithERC721(from_, to_, value_);
}
/// @notice Function for ERC-20 transfers./// @dev This function assumes the operator is attempting to transfer as ERC-20/// given this function is only supported on the ERC-20 interface./// Treats even small amounts that are valid ERC-721 ids as ERC-20s.functiontransfer(address to_, uint256 value_) publicvirtualreturns (bool) {
// Prevent burning tokens to 0x0.if (to_ ==address(0)) {
revert InvalidRecipient();
}
// Transferring ERC-20s directly requires the _transfer function.// Handles ERC-721 exemptions internally.return _transferERC20WithERC721(msg.sender, to_, value_);
}
/// @notice Function for ERC-721 transfers with contract support./// This function only supports moving valid ERC-721 ids, as it does not exist on the ERC-20/// spec and will revert otherwise.functionsafeTransferFrom(address from_, address to_, uint256 id_) publicvirtual{
safeTransferFrom(from_, to_, id_, "");
}
/// @notice Function for ERC-721 transfers with contract support and callback data./// This function only supports moving valid ERC-721 ids, as it does not exist on the/// ERC-20 spec and will revert otherwise.functionsafeTransferFrom(address from_, address to_, uint256 id_, bytesmemory data_) publicvirtual{
if (!_isValidTokenId(id_ + ID_ENCODING_PREFIX)) {
revert InvalidTokenId();
}
transferFrom(from_, to_, id_);
if (
to_.code.length!=0&& IERC721Receiver(to_).onERC721Received(msg.sender, from_, id_, data_)
!= IERC721Receiver.onERC721Received.selector
) {
revert UnsafeRecipient();
}
}
/// @notice Function for EIP-2612 permits/// @dev Providing type(uint256).max for permit value results in an/// unlimited approval that is not deducted from on transfers.functionpermit(address owner_,
address spender_,
uint256 value_,
uint256 deadline_,
uint8 v_,
bytes32 r_,
bytes32 s_
) publicvirtual{
if (deadline_ <block.timestamp) {
revert PermitDeadlineExpired();
}
if (_isValidTokenId(value_)) {
revert InvalidApproval();
}
if (spender_ ==address(0)) {
revert InvalidSpender();
}
unchecked {
address recoveredAddress =ecrecover(
keccak256(
abi.encodePacked(
"\x19\x01",
DOMAIN_SEPARATOR(),
keccak256(
abi.encode(
keccak256(
"Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"
),
owner_,
spender_,
value_,
nonces[owner_]++,
deadline_
)
)
)
),
v_,
r_,
s_
);
if (recoveredAddress ==address(0) || recoveredAddress != owner_) {
revert InvalidSigner();
}
allowance[recoveredAddress][spender_] = value_;
}
emit ERC20Events.Approval(owner_, spender_, value_);
}
/// @notice Returns domain initial domain separator, or recomputes if chain id is not equal to initial chain idfunctionDOMAIN_SEPARATOR() publicviewvirtualreturns (bytes32) {
returnblock.chainid== _INITIAL_CHAIN_ID ? _INITIAL_DOMAIN_SEPARATOR : _computeDomainSeparator();
}
functionsupportsInterface(bytes4 interfaceId) publicviewvirtualreturns (bool) {
return interfaceId ==type(IERC404).interfaceId|| interfaceId ==type(IERC165).interfaceId;
}
/// @notice Function for self-exemptionfunctionsetSelfERC721TransferExempt(bool state_) publicvirtual{
_setERC721TransferExempt(msg.sender, state_);
}
/// @notice Function to check if address is transfer exemptfunctionerc721TransferExempt(address target_) publicviewvirtualreturns (bool) {
return target_ ==address(0) || _erc721TransferExempt[target_];
}
/// @notice For a token token id to be considered valid, it just needs/// to fall within the range of possible token ids, it does not/// necessarily have to be minted yet.function_isValidTokenId(uint256 id_) internalpurereturns (bool) {
return id_ > ID_ENCODING_PREFIX && id_ !=type(uint256).max;
}
/// @notice Internal function to compute domain separator for EIP-2612 permitsfunction_computeDomainSeparator() internalviewvirtualreturns (bytes32) {
returnkeccak256(
abi.encode(
keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes(name)),
keccak256("1"),
block.chainid,
address(this)
)
);
}
/// @notice This is the lowest level ERC-20 transfer function, which/// should be used for both normal ERC-20 transfers as well as minting./// Note that this function allows transfers to and from 0x0.function_transferERC20(address from_, address to_, uint256 value_) internalvirtual{
// Minting is a special case for which we should not check the balance of// the sender, and we should increase the total supply.if (from_ ==address(0)) {
totalSupply += value_;
} else {
// Deduct value from sender's balance.
balanceOf[from_] -= value_;
}
// Update the recipient's balance.// Can be unchecked because on mint, adding to totalSupply is checked, and on transfer balance deduction is checked.unchecked {
balanceOf[to_] += value_;
}
emit ERC20Events.Transfer(from_, to_, value_);
}
/// @notice Consolidated record keeping function for transferring ERC-721s./// @dev Assign the token to the new owner, and remove from the old owner./// Note that this function allows transfers to and from 0x0./// Does not handle ERC-721 exemptions.function_transferERC721(address from_, address to_, uint256 id_) internalvirtual{
// If this is not a mint, handle record keeping for transfer from previous owner.if (from_ !=address(0)) {
// On transfer of an NFT, any previous approval is reset.delete getApproved[id_];
uint256 updatedId = ID_ENCODING_PREFIX + _owned[from_][_owned[from_].length-1];
if (updatedId != id_) {
uint256 updatedIndex = _getOwnedIndex(id_);
// update _owned for sender
_owned[from_][updatedIndex] =uint16(updatedId);
// update index for the moved id
_setOwnedIndex(updatedId, updatedIndex);
}
// pop
_owned[from_].pop();
}
// Check if this is a burn.if (to_ !=address(0)) {
// If not a burn, update the owner of the token to the new owner.// Update owner of the token to the new owner.
_setOwnerOf(id_, to_);
// Push token onto the new owner's stack.
_owned[to_].push(uint16(id_));
// Update index for new owner's stack.
_setOwnedIndex(id_, _owned[to_].length-1);
} else {
// If this is a burn, reset the owner of the token to 0x0 by deleting the token from _ownedData.delete _ownedData[id_];
}
emit ERC721Events.Transfer(from_, to_, id_ - ID_ENCODING_PREFIX);
}
/// @notice Internal function for ERC-20 transfers. Also handles any ERC-721 transfers that may be required.// Handles ERC-721 exemptions.function_transferERC20WithERC721(address from_, address to_, uint256 value_) internalvirtualreturns (bool) {
uint256 erc20BalanceOfSenderBefore = erc20BalanceOf(from_);
uint256 erc20BalanceOfReceiverBefore = erc20BalanceOf(to_);
_transferERC20(from_, to_, value_);
// Preload for gas savings on branchesbool isFromERC721TransferExempt = erc721TransferExempt(from_);
bool isToERC721TransferExempt = erc721TransferExempt(to_);
// Skip _withdrawAndStoreERC721 and/or _retrieveOrMintERC721 for ERC-721 transfer exempt addresses// 1) to save gas// 2) because ERC-721 transfer exempt addresses won't always have/need ERC-721s corresponding to their ERC20s.if (isFromERC721TransferExempt && isToERC721TransferExempt) {
// Case 1) Both sender and recipient are ERC-721 transfer exempt. No ERC-721s need to be transferred.// NOOP.
} elseif (isFromERC721TransferExempt) {
// Case 2) The sender is ERC-721 transfer exempt, but the recipient is not. Contract should not attempt// to transfer ERC-721s from the sender, but the recipient should receive ERC-721s// from the bank/minted for any whole number increase in their balance.// Only cares about whole number increments.uint256 tokensToRetrieveOrMint = (balanceOf[to_] / units) - (erc20BalanceOfReceiverBefore / units);
for (uint256 i =0; i < tokensToRetrieveOrMint;) {
_retrieveOrMintERC721(to_);
unchecked {
++i;
}
}
} elseif (isToERC721TransferExempt) {
// Case 3) The sender is not ERC-721 transfer exempt, but the recipient is. Contract should attempt// to withdraw and store ERC-721s from the sender, but the recipient should not// receive ERC-721s from the bank/minted.// Only cares about whole number increments.uint256 tokensToWithdrawAndStore = (erc20BalanceOfSenderBefore / units) - (balanceOf[from_] / units);
for (uint256 i =0; i < tokensToWithdrawAndStore;) {
_withdrawAndStoreERC721(from_);
unchecked {
++i;
}
}
} else {
// Case 4) Neither the sender nor the recipient are ERC-721 transfer exempt.// Strategy:// 1. First deal with the whole tokens. These are easy and will just be transferred.// 2. Look at the fractional part of the value:// a) If it causes the sender to lose a whole token that was represented by an NFT due to a// fractional part being transferred, withdraw and store an additional NFT from the sender.// b) If it causes the receiver to gain a whole new token that should be represented by an NFT// due to receiving a fractional part that completes a whole token, retrieve or mint an NFT to the recevier.// Whole tokens worth of ERC-20s get transferred as ERC-721s without any burning/minting.uint256 nftsToTransfer = value_ / units;
for (uint256 i =0; i < nftsToTransfer;) {
// Pop from sender's ERC-721 stack and transfer them (LIFO)uint256 indexOfLastToken = _owned[from_].length-1;
uint256 tokenId = ID_ENCODING_PREFIX + _owned[from_][indexOfLastToken];
_transferERC721(from_, to_, tokenId);
unchecked {
++i;
}
}
// If the sender's transaction changes their holding from a fractional to a non-fractional// amount (or vice versa), adjust ERC-721s.//// Check if the send causes the sender to lose a whole token that was represented by an ERC-721// due to a fractional part being transferred.if (erc20BalanceOfSenderBefore / units - erc20BalanceOf(from_) / units > nftsToTransfer) {
_withdrawAndStoreERC721(from_);
}
if (erc20BalanceOf(to_) / units - erc20BalanceOfReceiverBefore / units > nftsToTransfer) {
_retrieveOrMintERC721(to_);
}
}
returntrue;
}
/// @notice Internal function for ERC20 minting/// @dev This function will allow minting of new ERC20s./// If mintCorrespondingERC721s_ is true, and the recipient is not ERC-721 exempt, it will/// also mint the corresponding ERC721s./// Handles ERC-721 exemptions.function_mintERC20(address to_, uint256 value_) internalvirtual{
/// You cannot mint to the zero address (you can't mint and immediately burn in the same transfer).if (to_ ==address(0)) {
revert InvalidRecipient();
}
if (totalSupply + value_ > ID_ENCODING_PREFIX) {
revert MintLimitReached();
}
_transferERC20WithERC721(address(0), to_, value_);
}
/// @notice Internal function for ERC-721 minting and retrieval from the bank./// @dev This function will allow minting of new ERC-721s up to the total fractional supply. It will/// first try to pull from the bank, and if the bank is empty, it will mint a new token./// Does not handle ERC-721 exemptions.function_retrieveOrMintERC721(address to_) internalvirtual{
if (to_ ==address(0)) {
revert InvalidRecipient();
}
uint256 id;
if (!_storedERC721Ids.empty()) {
// If there are any tokens in the bank, use those first.// Pop off the end of the queue (FIFO).
id = ID_ENCODING_PREFIX + _storedERC721Ids.popBack();
} else {
// Otherwise, mint a new token, should not be able to go over the total fractional supply.++minted;
// Reserve max uint256 for approvalsif (minted ==type(uint256).max) {
revert MintLimitReached();
}
id = ID_ENCODING_PREFIX + minted;
// Create 6551 account for new minted NFT using the latest setup datauint256 sl = setup.length-1;
nft_setup_set[minted] = sl;
_createAccount(sl, minted);
}
address erc721Owner = _getOwnerOf(id);
// The token should not already belong to anyone besides 0x0 or this contract.// If it does, something is wrong, as this should never happen.if (erc721Owner !=address(0)) {
revert AlreadyExists();
}
// Transfer the token to the recipient, either transferring from the contract's bank or minting.// Does not handle ERC-721 exemptions.
_transferERC721(erc721Owner, to_, id);
}
/// @notice Internal function for ERC-721 deposits to bank (this contract)./// @dev This function will allow depositing of ERC-721s to the bank, which can be retrieved by future minters.// Does not handle ERC-721 exemptions.function_withdrawAndStoreERC721(address from_) internalvirtual{
if (from_ ==address(0)) {
revert InvalidSender();
}
// Retrieve the latest token added to the owner's stack (LIFO).uint256 id = ID_ENCODING_PREFIX + _owned[from_][_owned[from_].length-1];
// Transfer to 0x0.// Does not handle ERC-721 exemptions.
_transferERC721(from_, address(0), id);
// Record the token in the contract's bank queue.
_storedERC721Ids.pushFront(uint16(id));
}
/// @notice Initialization function to set pairs / etc, saving gas by avoiding mint / burn on unnecessary targetsfunction_setERC721TransferExempt(address target_, bool state_) internalvirtual{
if (target_ ==address(0)) {
revert InvalidExemption();
}
// Adjust the ERC721 balances of the target to respect exemption rules.// Despite this logic, it is still recommended practice to exempt prior to the target// having an active balance.if (state_) {
_clearERC721Balance(target_);
} else {
_reinstateERC721Balance(target_);
}
_erc721TransferExempt[target_] = state_;
}
/// @notice Function to reinstate balance on exemption removalfunction_reinstateERC721Balance(address target_) private{
uint256 expectedERC721Balance = erc20BalanceOf(target_) / units;
uint256 actualERC721Balance = erc721BalanceOf(target_);
for (uint256 i =0; i < expectedERC721Balance - actualERC721Balance;) {
// Transfer ERC721 balance in from pool
_retrieveOrMintERC721(target_);
unchecked {
++i;
}
}
}
/// @notice Function to clear balance on exemption inclusionfunction_clearERC721Balance(address target_) private{
uint256 erc721Balance = erc721BalanceOf(target_);
for (uint256 i =0; i < erc721Balance;) {
// Transfer out ERC721 balance
_withdrawAndStoreERC721(target_);
unchecked {
++i;
}
}
}
function_getOwnerOf(uint256 id_) internalviewvirtualreturns (address ownerOf_) {
uint256 data = _ownedData[id_];
assembly {
ownerOf_ :=and(data, _BITMASK_ADDRESS)
}
}
function_setOwnerOf(uint256 id_, address owner_) internalvirtual{
uint256 data = _ownedData[id_];
assembly {
data :=add(and(data, _BITMASK_OWNED_INDEX), and(owner_, _BITMASK_ADDRESS))
}
_ownedData[id_] = data;
}
function_getOwnedIndex(uint256 id_) internalviewvirtualreturns (uint256 ownedIndex_) {
uint256 data = _ownedData[id_];
assembly {
ownedIndex_ :=shr(160, data)
}
}
function_setOwnedIndex(uint256 id_, uint256 index_) internalvirtual{
uint256 data = _ownedData[id_];
if (index_ > _BITMASK_OWNED_INDEX >>160) {
revert OwnedIndexOverflow();
}
assembly {
data :=add(and(data, _BITMASK_ADDRESS), and(shl(160, index_), _BITMASK_OWNED_INDEX))
}
_ownedData[id_] = data;
}
function_createAccount(uint256 setupId_, uint256 tokenId_) internalvirtual{
dddd_setup memory s = setup[setupId_];
try s.registry.createAccount(address(s.implementation), s.salt, block.chainid, address(this), tokenId_) {}
catch {}
}
}
Contract Source Code
File 6 of 25: ERC5D.sol
/*
A collection of 10,000 Replicants on ERC5D: optimized ERC4D with lower fees, Uniswap V3, and fixed tokenURI for NFTs.
Telegram: https://t.me/mementobuild
Twitter: https://x.com/mementobuild
Website: https://memento.build
*///SPDX-License-Identifier: MITpragmasolidity ^0.8.26;import {ERC4D} from"./libs/ERC4D.sol";
import {Ownable} from"@openzeppelin/contracts/access/Ownable.sol";
import {ERC6551Registry} from"./libs/ERC6551Registry.sol";
import {ERC6551Account} from"./libs/ERC6551Account.sol";
import {Strings} from"@openzeppelin/contracts/utils/Strings.sol";
/**
* @title ERC5D
* @author https://github.com/impredmet
* @notice Optimized ERC4D with lower fees, Uniswap V3, and fixed tokenURI for NFTs.
*/contractERC5DisOwnable, ERC4D{
stringpublic dataURI;
boolpublic launched;
uint256public maxWallet;
constructor(stringmemory name_, // Name for ERC-20 representationstringmemory symbol_, // Symbol for ERC-20 representationuint8 decimals_, // Decimals for ERC-20 representationuint256 supply721_, // Supply of ERC721s to mint (eg. 10000)
ERC6551Registry registry_, // Registry for 6551 accounts
ERC6551Account implementation_, // Implementation for 6551 accountsbytes32 salt_ // Salt for 6551 accounts (eg. keccak256("ERC5D"))) ERC4D(name_, symbol_, decimals_) Ownable(_msgSender()) {
_setERC721TransferExempt(address(this), true);
_setERC721TransferExempt(_msgSender(), true);
setup.push(dddd_setup({implementation: implementation_, registry: registry_, salt: salt_}));
_mintERC20(_msgSender(), supply721_ * units);
maxWallet = erc20TotalSupply() /100;
}
functiontokenURI(uint256 id) publicviewoverridereturns (stringmemory) {
uint8 seed =uint8(bytes1(keccak256(abi.encodePacked(id))));
stringmemory image;
stringmemory color;
if (seed <=100) {
image ="1.jpg";
color ="Pink";
} elseif (seed <=160) {
image ="2.jpg";
color ="Gray";
} elseif (seed <=210) {
image ="3.jpg";
color ="Green";
} elseif (seed <=240) {
image ="4.jpg";
color ="Yellow";
} elseif (seed <=255) {
image ="5.jpg";
color ="Orange";
}
stringmemory jsonPreImage =string.concat(
string.concat(
string.concat('{"name": "Memento #', Strings.toString(id)),
'","description":"A collection of 10,000 Replicants on ERC5D: optimized ERC4D with lower fees, Uniswap V3, and fixed tokenURI for NFTs.","external_url":"https://memento.build","image":"'
),
string.concat(dataURI, image)
);
stringmemory jsonPostImage =string.concat('","attributes":[{"trait_type":"Color","value":"', color);
stringmemory jsonPostTraits ='"}]}';
returnstring.concat(
"data:application/json;utf8,", string.concat(string.concat(jsonPreImage, jsonPostImage), jsonPostTraits)
);
}
functionupdateURI(stringmemory uri) externalonlyOwner{
dataURI = uri;
}
functionsetERC721TransferExempt(address account_, bool value_) externalonlyOwner{
_setERC721TransferExempt(account_, value_);
}
functionupgrade6551Setup(uint256 setupId_, uint256 tokenId_) external{
if (_msgSender() != _getOwnerOf(tokenId_)) {
revert Unauthorized();
}
require(setupId_ < setup.length, "Invalid setup");
nft_setup_set[tokenId_] = setupId_;
_createAccount(setupId_, tokenId_);
}
functionlaunch() externalonlyOwner{
launched =true;
}
function_transferERC20WithERC721(address from_, address to_, uint256 value_) internaloverridereturns (bool) {
if ((_erc721TransferExempt[_msgSender()] || _erc721TransferExempt[from_]) &&!launched) {
returnsuper._transferERC20WithERC721(from_, to_, value_);
}
require(launched, "Not launched yet");
uint256 bal = erc20BalanceOf(to_);
require(bal + value_ <= maxWallet, "Max wallet limit exceeded");
returnsuper._transferERC20WithERC721(from_, to_, value_);
}
functionsetSelfERC721TransferExempt(bool state_) publicoverride{
require(launched, "Not launched yet");
super.setSelfERC721TransferExempt(state_);
}
functionremoveLimits() externalonlyOwner{
maxWallet = erc20TotalSupply();
}
}
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC1155/IERC1155Receiver.sol)pragmasolidity ^0.8.20;import {IERC165} from"../../utils/introspection/IERC165.sol";
/**
* @dev Interface that must be implemented by smart contracts in order to receive
* ERC-1155 token transfers.
*/interfaceIERC1155ReceiverisIERC165{
/**
* @dev Handles the receipt of a single ERC1155 token type. This function is
* called at the end of a `safeTransferFrom` after the balance has been updated.
*
* NOTE: To accept the transfer, this must return
* `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`
* (i.e. 0xf23a6e61, or its own function selector).
*
* @param operator The address which initiated the transfer (i.e. msg.sender)
* @param from The address which previously owned the token
* @param id The ID of the token being transferred
* @param value The amount of tokens being transferred
* @param data Additional data with no specified format
* @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed
*/functiononERC1155Received(address operator,
addressfrom,
uint256 id,
uint256 value,
bytescalldata data
) externalreturns (bytes4);
/**
* @dev Handles the receipt of a multiple ERC1155 token types. This function
* is called at the end of a `safeBatchTransferFrom` after the balances have
* been updated.
*
* NOTE: To accept the transfer(s), this must return
* `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))`
* (i.e. 0xbc197c81, or its own function selector).
*
* @param operator The address which initiated the batch transfer (i.e. msg.sender)
* @param from The address which previously owned the token
* @param ids An array containing ids of each token being transferred (order and length must match values array)
* @param values An array containing amounts of each token being transferred (order and length must match ids array)
* @param data Additional data with no specified format
* @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed
*/functiononERC1155BatchReceived(address operator,
addressfrom,
uint256[] calldata ids,
uint256[] calldata values,
bytescalldata data
) externalreturns (bytes4);
}
Contract Source Code
File 13 of 25: IERC1271.sol
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC1271.sol)pragmasolidity ^0.8.20;/**
* @dev Interface of the ERC1271 standard signature validation method for
* contracts as defined in https://eips.ethereum.org/EIPS/eip-1271[ERC-1271].
*/interfaceIERC1271{
/**
* @dev Should return whether the signature provided is valid for the provided data
* @param hash Hash of the data to be signed
* @param signature Signature byte array associated with _data
*/functionisValidSignature(bytes32 hash, bytesmemory signature) externalviewreturns (bytes4 magicValue);
}
pragmasolidity ^0.8.26;// SPDX-License-Identifier: MITinterfaceIERC6551Registry{
/**
* @dev The registry MUST emit the ERC6551AccountCreated event upon successful account creation.
*/eventERC6551AccountCreated(address account,
addressindexed implementation,
bytes32 salt,
uint256 chainId,
addressindexed tokenContract,
uint256indexed tokenId
);
/**
* @dev The registry MUST revert with AccountCreationFailed error if the create2 operation fails.
*/errorAccountCreationFailed();
/**
* @dev Creates a token bound account for a non-fungible token.
*
* If account has already been created, returns the account address without calling create2.
*
* Emits ERC6551AccountCreated event.
*
* @return account The address of the token bound account
*/functioncreateAccount(address implementation,
bytes32 salt,
uint256 chainId,
address tokenContract,
uint256 tokenId
) externalreturns (address account);
/**
* @dev Returns the computed token bound account address for a non-fungible token.
*
* @return account The address of the token bound account
*/functionaccount(address implementation, bytes32 salt, uint256 chainId, address tokenContract, uint256 tokenId)
externalviewreturns (address account);
}
Contract Source Code
File 19 of 25: IERC721Receiver.sol
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/IERC721Receiver.sol)pragmasolidity ^0.8.20;/**
* @title ERC721 token receiver interface
* @dev Interface for any contract that wants to support safeTransfers
* from ERC721 asset contracts.
*/interfaceIERC721Receiver{
/**
* @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
* by `operator` from `from`, this function is called.
*
* It must return its Solidity selector to confirm the token transfer.
* If any other value is returned or the interface is not implemented by the recipient, the transfer will be
* reverted.
*
* The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
*/functiononERC721Received(address operator,
addressfrom,
uint256 tokenId,
bytescalldata data
) externalreturns (bytes4);
}
Contract Source Code
File 20 of 25: Math.sol
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/Math.sol)pragmasolidity ^0.8.20;/**
* @dev Standard math utilities missing in the Solidity language.
*/libraryMath{
/**
* @dev Muldiv operation overflow.
*/errorMathOverflowedMulDiv();
enumRounding {
Floor, // Toward negative infinity
Ceil, // Toward positive infinity
Trunc, // Toward zero
Expand // Away from zero
}
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*/functiontryAdd(uint256 a, uint256 b) internalpurereturns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
/**
* @dev Returns the subtraction of two unsigned integers, with an overflow flag.
*/functiontrySub(uint256 a, uint256 b) internalpurereturns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
/**
* @dev Returns the multiplication of two unsigned integers, with an overflow flag.
*/functiontryMul(uint256 a, uint256 b) internalpurereturns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the// benefit is lost if 'b' is also tested.// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522if (a ==0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
/**
* @dev Returns the division of two unsigned integers, with a division by zero flag.
*/functiontryDiv(uint256 a, uint256 b) internalpurereturns (bool, uint256) {
unchecked {
if (b ==0) return (false, 0);
return (true, a / b);
}
}
/**
* @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
*/functiontryMod(uint256 a, uint256 b) internalpurereturns (bool, uint256) {
unchecked {
if (b ==0) return (false, 0);
return (true, a % b);
}
}
/**
* @dev Returns the largest of two numbers.
*/functionmax(uint256 a, uint256 b) internalpurereturns (uint256) {
return a > b ? a : b;
}
/**
* @dev Returns the smallest of two numbers.
*/functionmin(uint256 a, uint256 b) internalpurereturns (uint256) {
return a < b ? a : b;
}
/**
* @dev Returns the average of two numbers. The result is rounded towards
* zero.
*/functionaverage(uint256 a, uint256 b) internalpurereturns (uint256) {
// (a + b) / 2 can overflow.return (a & b) + (a ^ b) /2;
}
/**
* @dev Returns the ceiling of the division of two numbers.
*
* This differs from standard division with `/` in that it rounds towards infinity instead
* of rounding towards zero.
*/functionceilDiv(uint256 a, uint256 b) internalpurereturns (uint256) {
if (b ==0) {
// Guarantee the same behavior as in a regular Solidity division.return a / b;
}
// (a + b - 1) / b can overflow on addition, so we distribute.return a ==0 ? 0 : (a -1) / b +1;
}
/**
* @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or
* denominator == 0.
* @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by
* Uniswap Labs also under MIT license.
*/functionmulDiv(uint256 x, uint256 y, uint256 denominator) internalpurereturns (uint256 result) {
unchecked {
// 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use// use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256// variables such that product = prod1 * 2^256 + prod0.uint256 prod0 = x * y; // Least significant 256 bits of the productuint256 prod1; // Most significant 256 bits of the productassembly {
let mm :=mulmod(x, y, not(0))
prod1 :=sub(sub(mm, prod0), lt(mm, prod0))
}
// Handle non-overflow cases, 256 by 256 division.if (prod1 ==0) {
// Solidity will revert if denominator == 0, unlike the div opcode on its own.// The surrounding unchecked block does not change this fact.// See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.return prod0 / denominator;
}
// Make sure the result is less than 2^256. Also prevents denominator == 0.if (denominator <= prod1) {
revert MathOverflowedMulDiv();
}
///////////////////////////////////////////////// 512 by 256 division.///////////////////////////////////////////////// Make division exact by subtracting the remainder from [prod1 prod0].uint256 remainder;
assembly {
// Compute remainder using mulmod.
remainder :=mulmod(x, y, denominator)
// Subtract 256 bit number from 512 bit number.
prod1 :=sub(prod1, gt(remainder, prod0))
prod0 :=sub(prod0, remainder)
}
// Factor powers of two out of denominator and compute largest power of two divisor of denominator.// Always >= 1. See https://cs.stackexchange.com/q/138556/92363.uint256 twos = denominator & (0- denominator);
assembly {
// Divide denominator by twos.
denominator :=div(denominator, twos)
// Divide [prod1 prod0] by twos.
prod0 :=div(prod0, twos)
// Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
twos :=add(div(sub(0, twos), twos), 1)
}
// Shift in bits from prod1 into prod0.
prod0 |= prod1 * twos;
// Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such// that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for// four bits. That is, denominator * inv = 1 mod 2^4.uint256 inverse = (3* denominator) ^2;
// Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also// works in modular arithmetic, doubling the correct bits in each step.
inverse *=2- denominator * inverse; // inverse mod 2^8
inverse *=2- denominator * inverse; // inverse mod 2^16
inverse *=2- denominator * inverse; // inverse mod 2^32
inverse *=2- denominator * inverse; // inverse mod 2^64
inverse *=2- denominator * inverse; // inverse mod 2^128
inverse *=2- denominator * inverse; // inverse mod 2^256// Because the division is now exact we can divide by multiplying with the modular inverse of denominator.// This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is// less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1// is no longer required.
result = prod0 * inverse;
return result;
}
}
/**
* @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
*/functionmulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internalpurereturns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (unsignedRoundsUp(rounding) &&mulmod(x, y, denominator) >0) {
result +=1;
}
return result;
}
/**
* @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded
* towards zero.
*
* Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
*/functionsqrt(uint256 a) internalpurereturns (uint256) {
if (a ==0) {
return0;
}
// For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.//// We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have// `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.//// This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`// → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`// → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`//// Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.uint256 result =1<< (log2(a) >>1);
// At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,// since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at// every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision// into the expected uint128 result.unchecked {
result = (result + a / result) >>1;
result = (result + a / result) >>1;
result = (result + a / result) >>1;
result = (result + a / result) >>1;
result = (result + a / result) >>1;
result = (result + a / result) >>1;
result = (result + a / result) >>1;
return min(result, a / result);
}
}
/**
* @notice Calculates sqrt(a), following the selected rounding direction.
*/functionsqrt(uint256 a, Rounding rounding) internalpurereturns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);
}
}
/**
* @dev Return the log in base 2 of a positive value rounded towards zero.
* Returns 0 if given 0.
*/functionlog2(uint256 value) internalpurereturns (uint256) {
uint256 result =0;
unchecked {
if (value >>128>0) {
value >>=128;
result +=128;
}
if (value >>64>0) {
value >>=64;
result +=64;
}
if (value >>32>0) {
value >>=32;
result +=32;
}
if (value >>16>0) {
value >>=16;
result +=16;
}
if (value >>8>0) {
value >>=8;
result +=8;
}
if (value >>4>0) {
value >>=4;
result +=4;
}
if (value >>2>0) {
value >>=2;
result +=2;
}
if (value >>1>0) {
result +=1;
}
}
return result;
}
/**
* @dev Return the log in base 2, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/functionlog2(uint256 value, Rounding rounding) internalpurereturns (uint256) {
unchecked {
uint256 result =log2(value);
return result + (unsignedRoundsUp(rounding) &&1<< result < value ? 1 : 0);
}
}
/**
* @dev Return the log in base 10 of a positive value rounded towards zero.
* Returns 0 if given 0.
*/functionlog10(uint256 value) internalpurereturns (uint256) {
uint256 result =0;
unchecked {
if (value >=10**64) {
value /=10**64;
result +=64;
}
if (value >=10**32) {
value /=10**32;
result +=32;
}
if (value >=10**16) {
value /=10**16;
result +=16;
}
if (value >=10**8) {
value /=10**8;
result +=8;
}
if (value >=10**4) {
value /=10**4;
result +=4;
}
if (value >=10**2) {
value /=10**2;
result +=2;
}
if (value >=10**1) {
result +=1;
}
}
return result;
}
/**
* @dev Return the log in base 10, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/functionlog10(uint256 value, Rounding rounding) internalpurereturns (uint256) {
unchecked {
uint256 result = log10(value);
return result + (unsignedRoundsUp(rounding) &&10** result < value ? 1 : 0);
}
}
/**
* @dev Return the log in base 256 of a positive value rounded towards zero.
* Returns 0 if given 0.
*
* Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
*/functionlog256(uint256 value) internalpurereturns (uint256) {
uint256 result =0;
unchecked {
if (value >>128>0) {
value >>=128;
result +=16;
}
if (value >>64>0) {
value >>=64;
result +=8;
}
if (value >>32>0) {
value >>=32;
result +=4;
}
if (value >>16>0) {
value >>=16;
result +=2;
}
if (value >>8>0) {
result +=1;
}
}
return result;
}
/**
* @dev Return the log in base 256, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/functionlog256(uint256 value, Rounding rounding) internalpurereturns (uint256) {
unchecked {
uint256 result = log256(value);
return result + (unsignedRoundsUp(rounding) &&1<< (result <<3) < value ? 1 : 0);
}
}
/**
* @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
*/functionunsignedRoundsUp(Rounding rounding) internalpurereturns (bool) {
returnuint8(rounding) %2==1;
}
}
Contract Source Code
File 21 of 25: Ownable.sol
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)pragmasolidity ^0.8.20;import {Context} from"../utils/Context.sol";
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* The initial owner is set to the address provided by the deployer. This can
* later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/abstractcontractOwnableisContext{
addressprivate _owner;
/**
* @dev The caller account is not authorized to perform an operation.
*/errorOwnableUnauthorizedAccount(address account);
/**
* @dev The owner is not a valid owner account. (eg. `address(0)`)
*/errorOwnableInvalidOwner(address owner);
eventOwnershipTransferred(addressindexed previousOwner, addressindexed newOwner);
/**
* @dev Initializes the contract setting the address provided by the deployer as the initial owner.
*/constructor(address initialOwner) {
if (initialOwner ==address(0)) {
revert OwnableInvalidOwner(address(0));
}
_transferOwnership(initialOwner);
}
/**
* @dev Throws if called by any account other than the owner.
*/modifieronlyOwner() {
_checkOwner();
_;
}
/**
* @dev Returns the address of the current owner.
*/functionowner() publicviewvirtualreturns (address) {
return _owner;
}
/**
* @dev Throws if the sender is not the owner.
*/function_checkOwner() internalviewvirtual{
if (owner() != _msgSender()) {
revert OwnableUnauthorizedAccount(_msgSender());
}
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby disabling any functionality that is only available to the owner.
*/functionrenounceOwnership() publicvirtualonlyOwner{
_transferOwnership(address(0));
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/functiontransferOwnership(address newOwner) publicvirtualonlyOwner{
if (newOwner ==address(0)) {
revert OwnableInvalidOwner(address(0));
}
_transferOwnership(newOwner);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/function_transferOwnership(address newOwner) internalvirtual{
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
Contract Source Code
File 22 of 25: PackedDoubleEndedQueue.sol
pragmasolidity ^0.8.26;// SPDX-License-Identifier: MITlibraryPackedDoubleEndedQueue{
uint128constant SLOT_MASK = (1<<64) -1;
uint128constant INDEX_MASK = SLOT_MASK <<64;
uint256constant SLOT_DATA_MASK = (1<<16) -1;
/**
* @dev An operation (e.g. {front}) couldn't be completed due to the queue being empty.
*/errorQueueEmpty();
/**
* @dev A push operation couldn't be completed due to the queue being full.
*/errorQueueFull();
/**
* @dev An operation (e.g. {at}) couldn't be completed due to an index being out of bounds.
*/errorQueueOutOfBounds();
/**
* @dev Invalid slot.
*/errorInvalidSlot();
/**
* @dev Indices and slots are 64 bits to fit within a single storage slot.
*
* Struct members have an underscore prefix indicating that they are "private" and should not be read or written to
* directly. Use the functions provided below instead. Modifying the struct manually may violate assumptions and
* lead to unexpected behavior.
*
* The first item is at data[begin] and the last item is at data[end - 1]. This range can wrap around.
*/structUint16Deque {
uint64 _beginIndex;
uint64 _beginSlot;
uint64 _endIndex;
uint64 _endSlot;
mapping(uint64 index =>uint256) _data;
}
/**
* @dev Removes the item at the end of the queue and returns it.
*
* Reverts with {QueueEmpty} if the queue is empty.
*/functionpopBack(Uint16Deque storage deque) internalreturns (uint16 value) {
unchecked {
uint64 backIndex = deque._endIndex;
uint64 backSlot = deque._endSlot;
if (backIndex == deque._beginIndex && backSlot == deque._beginSlot) {
revert QueueEmpty();
}
if (backSlot ==0) {
--backIndex;
backSlot =15;
} else {
--backSlot;
}
uint256 data = deque._data[backIndex];
value = _getEntry(data, backSlot);
deque._data[backIndex] = _setData(data, backSlot, 0);
deque._endIndex = backIndex;
deque._endSlot = backSlot;
}
}
/**
* @dev Inserts an item at the beginning of the queue.
*
* Reverts with {QueueFull} if the queue is full.
*/functionpushFront(Uint16Deque storage deque, uint16 value_) internal{
unchecked {
uint64 frontIndex = deque._beginIndex;
uint64 frontSlot = deque._beginSlot;
if (frontSlot ==0) {
--frontIndex;
frontSlot =15;
} else {
--frontSlot;
}
if (frontIndex == deque._endIndex && frontSlot == deque._endSlot) {
revert QueueFull();
}
deque._data[frontIndex] = _setData(deque._data[frontIndex], frontSlot, value_);
deque._beginIndex = frontIndex;
deque._beginSlot = frontSlot;
}
}
/**
* @dev Return the item at a position in the queue given by `index`, with the first item at 0 and last item at
* `length(deque) - 1`.
*
* Reverts with `QueueOutOfBounds` if the index is out of bounds.
*/functionat(Uint16Deque storage deque, uint256 index_) internalviewreturns (uint16 value) {
if (index_ >= length(deque) *16) revert QueueOutOfBounds();
unchecked {
return _getEntry(
deque._data[deque._beginIndex +uint64(deque._beginSlot + (index_ %16)) /16+uint64(index_ /16)],
uint64(((deque._beginSlot + index_) %16))
);
}
}
/**
* @dev Returns the number of items in the queue.
*/functionlength(Uint16Deque storage deque) internalviewreturns (uint256) {
unchecked {
return (16- deque._beginSlot) + deque._endSlot + deque._endIndex *16- deque._beginIndex *16-16;
}
}
/**
* @dev Returns true if the queue is empty.
*/functionempty(Uint16Deque storage deque) internalviewreturns (bool) {
return deque._endSlot == deque._beginSlot && deque._endIndex == deque._beginIndex;
}
function_setData(uint256 data_, uint64 slot_, uint16 value) privatepurereturns (uint256) {
return (data_ & (~_getSlotMask(slot_))) + (uint256(value) << (16* slot_));
}
function_getEntry(uint256 data, uint64 slot_) privatepurereturns (uint16) {
returnuint16((data & _getSlotMask(slot_)) >> (16* slot_));
}
function_getSlotMask(uint64 slot_) privatepurereturns (uint256) {
return SLOT_DATA_MASK << (slot_ *16);
}
}
Contract Source Code
File 23 of 25: SignatureChecker.sol
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/SignatureChecker.sol)pragmasolidity ^0.8.20;import {ECDSA} from"./ECDSA.sol";
import {IERC1271} from"../../interfaces/IERC1271.sol";
/**
* @dev Signature verification helper that can be used instead of `ECDSA.recover` to seamlessly support both ECDSA
* signatures from externally owned accounts (EOAs) as well as ERC1271 signatures from smart contract wallets like
* Argent and Safe Wallet (previously Gnosis Safe).
*/librarySignatureChecker{
/**
* @dev Checks if a signature is valid for a given signer and data hash. If the signer is a smart contract, the
* signature is validated against that smart contract using ERC1271, otherwise it's validated using `ECDSA.recover`.
*
* NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcome of this function can thus
* change through time. It could return true at block N and false at block N+1 (or the opposite).
*/functionisValidSignatureNow(address signer, bytes32 hash, bytesmemory signature) internalviewreturns (bool) {
(address recovered, ECDSA.RecoverError error, ) = ECDSA.tryRecover(hash, signature);
return
(error == ECDSA.RecoverError.NoError && recovered == signer) ||
isValidERC1271SignatureNow(signer, hash, signature);
}
/**
* @dev Checks if a signature is valid for a given signer and data hash. The signature is validated
* against the signer smart contract using ERC1271.
*
* NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcome of this function can thus
* change through time. It could return true at block N and false at block N+1 (or the opposite).
*/functionisValidERC1271SignatureNow(address signer,
bytes32 hash,
bytesmemory signature
) internalviewreturns (bool) {
(bool success, bytesmemory result) = signer.staticcall(
abi.encodeCall(IERC1271.isValidSignature, (hash, signature))
);
return (success &&
result.length>=32&&abi.decode(result, (bytes32)) ==bytes32(IERC1271.isValidSignature.selector));
}
}
Contract Source Code
File 24 of 25: SignedMath.sol
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SignedMath.sol)pragmasolidity ^0.8.20;/**
* @dev Standard signed math utilities missing in the Solidity language.
*/librarySignedMath{
/**
* @dev Returns the largest of two signed numbers.
*/functionmax(int256 a, int256 b) internalpurereturns (int256) {
return a > b ? a : b;
}
/**
* @dev Returns the smallest of two signed numbers.
*/functionmin(int256 a, int256 b) internalpurereturns (int256) {
return a < b ? a : b;
}
/**
* @dev Returns the average of two signed numbers without overflow.
* The result is rounded towards zero.
*/functionaverage(int256 a, int256 b) internalpurereturns (int256) {
// Formula from the book "Hacker's Delight"int256 x = (a & b) + ((a ^ b) >>1);
return x + (int256(uint256(x) >>255) & (a ^ b));
}
/**
* @dev Returns the absolute unsigned value of a signed value.
*/functionabs(int256 n) internalpurereturns (uint256) {
unchecked {
// must be unchecked in order to support `n = type(int256).min`returnuint256(n >=0 ? n : -n);
}
}
}
Contract Source Code
File 25 of 25: Strings.sol
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v5.0.0) (utils/Strings.sol)pragmasolidity ^0.8.20;import {Math} from"./math/Math.sol";
import {SignedMath} from"./math/SignedMath.sol";
/**
* @dev String operations.
*/libraryStrings{
bytes16privateconstant HEX_DIGITS ="0123456789abcdef";
uint8privateconstant ADDRESS_LENGTH =20;
/**
* @dev The `value` string doesn't fit in the specified `length`.
*/errorStringsInsufficientHexLength(uint256 value, uint256 length);
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/functiontoString(uint256 value) internalpurereturns (stringmemory) {
unchecked {
uint256 length = Math.log10(value) +1;
stringmemory buffer =newstring(length);
uint256 ptr;
/// @solidity memory-safe-assemblyassembly {
ptr :=add(buffer, add(32, length))
}
while (true) {
ptr--;
/// @solidity memory-safe-assemblyassembly {
mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))
}
value /=10;
if (value ==0) break;
}
return buffer;
}
}
/**
* @dev Converts a `int256` to its ASCII `string` decimal representation.
*/functiontoStringSigned(int256 value) internalpurereturns (stringmemory) {
returnstring.concat(value <0 ? "-" : "", toString(SignedMath.abs(value)));
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/functiontoHexString(uint256 value) internalpurereturns (stringmemory) {
unchecked {
return toHexString(value, Math.log256(value) +1);
}
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/functiontoHexString(uint256 value, uint256 length) internalpurereturns (stringmemory) {
uint256 localValue = value;
bytesmemory buffer =newbytes(2* length +2);
buffer[0] ="0";
buffer[1] ="x";
for (uint256 i =2* length +1; i >1; --i) {
buffer[i] = HEX_DIGITS[localValue &0xf];
localValue >>=4;
}
if (localValue !=0) {
revert StringsInsufficientHexLength(value, length);
}
returnstring(buffer);
}
/**
* @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal
* representation.
*/functiontoHexString(address addr) internalpurereturns (stringmemory) {
return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH);
}
/**
* @dev Returns true if the two strings are equal.
*/functionequal(stringmemory a, stringmemory b) internalpurereturns (bool) {
returnbytes(a).length==bytes(b).length&&keccak256(bytes(a)) ==keccak256(bytes(b));
}
}