Overview
APE Balance
0 APE
APE Value
$0.00More Info
Private Name Tags
ContractCreator
Loading...
Loading
This contract may be a proxy contract. Click on More Options and select Is this a proxy? to confirm and enable the "Read as Proxy" & "Write as Proxy" tabs.
Contract Source Code Verified (Exact Match)
Contract Name:
DragonsLair
Compiler Version
v0.8.28+commit.7893614a
Optimization Enabled:
Yes with 2000 runs
Other Settings:
paris EvmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: MIT pragma solidity 0.8.28; import "@openzeppelin/contracts/token/ERC721/IERC721.sol"; import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol"; import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol"; import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol"; import "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/ERC721EnumerableUpgradeable.sol"; import "@openzeppelin/contracts-upgradeable/utils/ReentrancyGuardUpgradeable.sol"; import "@openzeppelin/contracts-upgradeable/token/ERC721/utils/ERC721HolderUpgradeable.sol"; import "@openzeppelin/contracts/utils/Strings.sol"; import {IEntropyConsumer} from "@pythnetwork/entropy-sdk-solidity/IEntropyConsumer.sol"; import {IEntropy} from "@pythnetwork/entropy-sdk-solidity/IEntropy.sol"; interface IDerpyDragons { /// @notice Mints a new token to the specified address with the given token URI. /// @param to The address to receive the newly minted token. /// @param tokenUri The metadata URI for the minted token. function mint(address to, string memory tokenUri) external; } contract DragonsLair is IEntropyConsumer, Initializable, OwnableUpgradeable, UUPSUpgradeable, ReentrancyGuardUpgradeable, ERC721HolderUpgradeable { error NotOwnerOfToken(uint256 tokenId); error AlreadyStaked(); error StakingClosed(); error NotStakedOwner(); error InvalidTokenIndex(); error DirectTransferNotAllowed(); error InsufficientBalance(uint256 currentRewards, uint256 pointsRequired); error InsufficientFee(uint256 sent, uint256 required); error InvalidSender(); error InvalidProvider(); error InvalidEntropySender(address sender); error InvalidEntropyProvider(address provider); error RequestAlreadyCompleted(uint64 sequenceNumber); error RequestNotCompleted(uint64 sequenceNumber); error RequestAlreadyCancelled(uint64 sequenceNumber); error MintAlreadyCompleted(uint64 sequenceNumber); error MintRequestAlreadyCancelled(uint64 sequenceNumber); error MintRequestNotYetExpired(uint64 requestId, uint256 timeLeft); error InvalidRollType(); error InputMismatch(); error TooManyRollTypes(); error InvalidProbabilitySum(); error ConfigMismatch(); error RollsNotInitialized(); error NoMintsLeft(); event StakingModeUpdated(bool open); event Staked(address indexed user, uint256 tokenId); event PointsPerDayPerTokenUpdated(uint points); event Unstaked(address indexed user, uint256 tokenId); event TokenMinted(address indexed user, uint256 tokenId); event PointsRequiredUpdated(uint256 tokenType, uint256 points); event MintRequested(address indexed user, uint64 requestId); event MintFailed(address indexed user, uint64 requestId); event TokenReadyForMint(address indexed user, uint64 requestId); event RollTypesInitialized(); event RarityLevelsInitialized(); event ProviderUpdated(address provider); struct StakedTokens { address owner; uint256 checkInTimestamp; } struct MintRequest { address user; uint256 tokenId; uint256 randomNumber; uint256 timestamp; string uri; uint8 rollType; bool requestCompleted; bool cancelled; bool mintFinalized; } struct RarityLevel { uint256 minted; uint256 maxSupply; string tokenUri; } struct RollType { uint256 price; uint256[] probabilities; } bool public stakingOpen; uint public pointsPerHourPerToken; uint public pointsPerDayPerToken; uint public mintedDragonCount; uint public mintRequestId; bool internal stakingInProgress; address[] public allStakers; IERC721 public dragons; IDerpyDragons public derpyDragons; IEntropy public entropy; address public provider; bool public rolesInitialized; bool public rarityLevelsInitialized; uint public existingRolls; mapping(address user => uint256[] stakedTokens) public stakedTokenIds; mapping(uint256 tokenId => StakedTokens stakedTokens) public stakedTokenProps; mapping(address => bool) public hasStaked; mapping(uint256 => uint256) internal tokenIndexInArray; mapping(address => uint256) public owedRewards; mapping(uint64 => uint256) public requestIdToMintId; mapping(uint64 => MintRequest) public mintRequests; mapping(address => uint256[]) public mintRequestsByUser; mapping(uint8 => RollType) public rollTypes; mapping(uint8 => RarityLevel) public rarityLevels; /// @custom:oz-upgrades-unsafe-allow constructor constructor() { _disableInitializers(); } function initialize( address entropy_, uint256 pointsPerHourPerToken_, address dragonsAddress_, address derpyDragonsAddress_, address provider_ ) public initializer { __Ownable_init(msg.sender); __UUPSUpgradeable_init(); __ReentrancyGuard_init(); __ERC721Holder_init(); derpyDragons = IDerpyDragons(derpyDragonsAddress_); dragons = IERC721(dragonsAddress_); entropy = IEntropy(entropy_); provider = provider_; pointsPerHourPerToken = pointsPerHourPerToken_; pointsPerDayPerToken = pointsPerHourPerToken_ * 24; stakedTokenIds[address(0)].push(); } /** * @dev Initializes the rarity levels for the contract. * @param _rarityLevels The rarity levels to be initialized. */ function initializeRarityLevels( RarityLevel[] memory _rarityLevels ) external onlyOwner { if (!rolesInitialized) revert RollsNotInitialized(); if (_rarityLevels.length != existingRolls) revert ConfigMismatch(); for (uint8 i = 0; i < _rarityLevels.length; i++) { rarityLevels[i] = RarityLevel({ minted: 0, maxSupply: _rarityLevels[i].maxSupply, tokenUri: _rarityLevels[i].tokenUri }); } rarityLevelsInitialized = true; emit RarityLevelsInitialized(); } /** * @dev Initializes the roll types for the contract. * @param newRollTypes The roll types to be initialized. */ function initializeRollTypes( RollType[] memory newRollTypes ) external onlyOwner { for (uint8 i = 0; i < newRollTypes.length; i++) { uint256 totalProbability = 0; for (uint8 j = 0; j < newRollTypes[i].probabilities.length; j++) { totalProbability += newRollTypes[i].probabilities[j]; } if (totalProbability != 100) { revert InvalidProbabilitySum(); } rollTypes[i] = newRollTypes[i]; } rolesInitialized = true; existingRolls = newRollTypes.length; emit RollTypesInitialized(); } /** * @dev Allows the owner to update the staking mode. * @param open The new staking mode. */ function setStakingMode(bool open) external onlyOwner { stakingOpen = open; emit StakingModeUpdated(open); } /** * @dev Allows the owner to update the provider address. * @param provider_ The new provider address. */ function setProvider(address provider_) external onlyOwner { provider = provider_; emit ProviderUpdated(provider_); } /** * @dev Allows the owner to update the points. * @param pointsPerDay The new points required. */ function setPointsPerDayPerToken(uint256 pointsPerDay) external onlyOwner { pointsPerHourPerToken = pointsPerDay / 24; pointsPerDayPerToken = pointsPerDay; emit PointsPerDayPerTokenUpdated(pointsPerDay); } /** * @dev gets the entropy provider address */ function getEntropy() internal view override returns (address) { return address(entropy); // Return the stored entropy contract address } /** * @dev Returns a list of token IDs that are staked by a particular address. * @param addr The address to query staked tokens for. * @return An array of token IDs that the address has staked. */ function getTokensStaked( address addr ) external view returns (uint256[] memory) { return stakedTokenIds[addr]; } /** * @dev returns te mint requests by user * this can be used in fronted to display a history or unfinished requests */ function getmintRequestsByUser( address user ) external view returns (uint256[] memory) { return mintRequestsByUser[user]; } /** * @dev returns all the stakers of the contract * this can be used in fronted to display a leaderboard */ function getAllStakers() external view returns (address[] memory) { return allStakers; } /** * @dev helper functon for getting the rollType configuration * @param rollTypeId The ID of the roll type to be retrieved. */ function getRollTypeById( uint8 rollTypeId ) external view returns (RollType memory) { RollType storage rollType = rollTypes[rollTypeId]; return (rollType); } //-------------------------------------------------------------------------------- // Staking functions //-------------------------------------------------------------------------------- /** * @dev Allows a user to stake one or more tokens by transferring them to the contract. * Staking is only allowed when staking is open. * @param tokenIds An array of token IDs to be staked. */ function stake(uint256[] calldata tokenIds) external nonReentrant { if (!stakingOpen) revert StakingClosed(); stakingInProgress = true; for (uint256 i = 0; i < tokenIds.length; i++) { _stake(tokenIds[i]); } stakingInProgress = false; } /** * @dev Internal function to handle the logic of staking a single token. * Checks if the token is already staked and transfers the token to the contract. * @param tokenId The ID of the token to be staked. */ function _stake(uint256 tokenId) internal { if (stakedTokenProps[tokenId].owner != address(0)) revert AlreadyStaked(); if (dragons.ownerOf(tokenId) != msg.sender) revert NotOwnerOfToken(tokenId); stakedTokenProps[tokenId].owner = msg.sender; stakedTokenProps[tokenId].checkInTimestamp = block.timestamp; add(tokenId); if (!hasStaked[msg.sender]) { hasStaked[msg.sender] = true; allStakers.push(msg.sender); } dragons.safeTransferFrom(msg.sender, address(this), tokenId); emit Staked(msg.sender, tokenId); } /** * @dev Allows a user to unstake one or more tokens, transferring them back from the contract. * If the contract doesn't have enough TOKEN, the rewards are stored. * @param tokenIds An array of token IDs to be unstaked. */ function unstake(uint256[] calldata tokenIds) external nonReentrant { if (tokenIds.length == 0) revert InvalidTokenIndex(); ( uint256 totalClaimable, uint256[] memory tokenIdsToReset ) = _calculatePendingRewards(msg.sender); _resetCurrentStakedRewards(tokenIdsToReset); if (totalClaimable > 0) { owedRewards[msg.sender] += totalClaimable; } for (uint256 i = 0; i < tokenIds.length; i++) { _unstake(tokenIds[i]); } } /** * @dev Internal function to handle the logic of unstaking a single token. * Checks if the token is staked by the user and transfers the token back to the user. * @param tokenId The ID of the token to be unstaked. */ function _unstake(uint256 tokenId) internal { address owner = stakedTokenProps[tokenId].owner; if (owner != msg.sender) revert NotStakedOwner(); stakedTokenProps[tokenId].owner = address(0); stakedTokenProps[tokenId].checkInTimestamp = 0; remove(tokenId); dragons.safeTransferFrom(address(this), owner, tokenId); emit Unstaked(owner, tokenId); } /** * @dev Allows a user to view their earned rewards without modifying state. * @param user The address of the user to calculate rewards for. * @return totalClaimable The total rewards earned by the user. */ function pendingRewards( address user ) public view returns (uint256 totalClaimable) { uint256 owed = owedRewards[user]; (totalClaimable, ) = _calculatePendingRewards(user); totalClaimable = totalClaimable + owed; } /** * @dev Internal view function to calculate the total pending rewards for a user's staked tokens. * Does not modify state. * @param user The address of the user to calculate rewards for. * @return totalClaimable The total rewards earned by the user. * @return tokenIdsToReset The token IDs that need their timestamp reset. */ function _calculatePendingRewards( address user ) internal view returns (uint256 totalClaimable, uint256[] memory tokenIdsToReset) { uint256[] storage userStakedTokens = stakedTokenIds[user]; uint256 tokenCount = userStakedTokens.length; uint256[] memory tempTokenIdsToReset = new uint256[](tokenCount); uint256 resetIndex = 0; for (uint256 i = 0; i < tokenCount; i++) { uint256 tokenId = userStakedTokens[i]; StakedTokens storage staked = stakedTokenProps[tokenId]; uint256 startTime = staked.checkInTimestamp; if (block.timestamp > startTime) { uint256 stakingDuration = block.timestamp - startTime; uint256 earnedPoints = (stakingDuration * pointsPerHourPerToken) / (1 hours); totalClaimable += earnedPoints; if (earnedPoints > 0) { tempTokenIdsToReset[resetIndex] = tokenId; resetIndex++; } } } tokenIdsToReset = new uint256[](resetIndex); for (uint256 i = 0; i < resetIndex; i++) { tokenIdsToReset[i] = tempTokenIdsToReset[i]; } } /** * @dev Internal function to calculate the total rewards for a specific set of tokens. * Updates the check-in timestamp only for the specified tokens. * @param tokenIds The array of token IDs to calculate rewards for. */ function _resetCurrentStakedRewards(uint256[] memory tokenIds) internal { for (uint256 i = 0; i < tokenIds.length; i++) { uint256 tokenId = tokenIds[i]; StakedTokens storage staked = stakedTokenProps[tokenId]; staked.checkInTimestamp = block.timestamp; } } //-------------------------------------------------------------------------------- // Minting functions //-------------------------------------------------------------------------------- /** * @dev Allows a user to request a token mint. * The user must have enough points to request the token. * @param rollType The type of roll to be requested. */ function requestToken(uint8 rollType) external payable nonReentrant { if (rollType >= existingRolls) revert InvalidRollType(); RollType storage selectedRollType = rollTypes[rollType]; bool hasMintCapacity = false; for (uint8 i = 0; i < selectedRollType.probabilities.length; i++) { if (selectedRollType.probabilities[i] == 0) { continue; } if (rarityLevels[i].minted < rarityLevels[i].maxSupply) { hasMintCapacity = true; break; } } if (!hasMintCapacity) { revert NoMintsLeft(); } uint256 pointsRequired = rollTypes[rollType].price; ( uint256 totalClaimable, uint256[] memory tokenIdsToReset ) = _calculatePendingRewards(msg.sender); _resetCurrentStakedRewards(tokenIdsToReset); uint256 allRewards = totalClaimable + owedRewards[msg.sender]; if (allRewards < pointsRequired) { revert InsufficientBalance(allRewards, pointsRequired); } uint fee = entropy.getFee(provider); if (msg.value < fee) { revert InsufficientFee(msg.value, fee); } uint256 rewardsLeft = allRewards - pointsRequired; owedRewards[msg.sender] = rewardsLeft; mintRequestId += 1; uint64 sequenceNumber = entropy.requestWithCallback{value: fee}( provider, keccak256(abi.encodePacked(block.timestamp, msg.sender)) ); mintRequests[sequenceNumber] = MintRequest({ user: msg.sender, tokenId: 0, randomNumber: 0, timestamp: block.timestamp, uri: "", rollType: rollType, requestCompleted: false, cancelled: false, mintFinalized: false }); requestIdToMintId[sequenceNumber] = mintRequestId; mintRequestsByUser[msg.sender].push(sequenceNumber); emit MintRequested(msg.sender, sequenceNumber); } /** * @dev callback function leveraged by pyth giving the entropy * @param sequenceNumber The sequence number of the request. * @param randomNumber The random number generated by the entropy provider. */ function entropyCallback( uint64 sequenceNumber, address, bytes32 randomNumber ) internal override { MintRequest storage request = mintRequests[sequenceNumber]; if (request.requestCompleted) { revert RequestAlreadyCompleted(sequenceNumber); } if (request.cancelled) { revert RequestAlreadyCancelled(sequenceNumber); } request.randomNumber = uint256(randomNumber); request.requestCompleted = true; emit TokenReadyForMint(request.user, sequenceNumber); } /** * @dev Allows a user to cancel a mint request if it has not been completed by the provider. * @param sequenceNumber The sequence number of the mint request to be cancelled. */ function resolveExpiredMint(uint64 sequenceNumber) external { MintRequest storage request = mintRequests[sequenceNumber]; if (request.requestCompleted) { revert MintAlreadyCompleted(sequenceNumber); } if (request.cancelled) { revert MintRequestAlreadyCancelled(sequenceNumber); } if (block.timestamp <= request.timestamp + 1 days) { revert MintRequestNotYetExpired( sequenceNumber, (request.timestamp + 1 days) - block.timestamp ); } uint256 pointsRequired = rollTypes[request.rollType].price; owedRewards[request.user] += pointsRequired; request.cancelled = true; emit MintFailed(request.user, sequenceNumber); } /** * @dev Allows the provider to mint the token based on a calculated rarity. * @param sequenceNumber The sequence number of the mint request to be completed. */ function selectRarityAndMint(uint64 sequenceNumber) external { MintRequest storage request = mintRequests[sequenceNumber]; if (!request.requestCompleted) { revert RequestNotCompleted(sequenceNumber); } if (request.mintFinalized) { revert MintAlreadyCompleted(sequenceNumber); } uint8[] memory availableRarities = new uint8[](existingRolls); uint256 randomValue = request.randomNumber % 100; uint8 finalRarityIndex = 0; uint256 cumulativeProbability = 0; uint256 usedRandomness = 0; uint256 availableCount = 0; for (uint8 i = 0; i < existingRolls; i++) { if (rarityLevels[i].minted < rarityLevels[i].maxSupply) { availableRarities[availableCount] = i; availableCount++; } } for (uint8 attempt = 0; attempt < availableCount; attempt++) { uint256 effectiveRandomValue = (attempt == 0) ? randomValue : uint256( keccak256(abi.encode(request.randomNumber, usedRandomness)) ) % 100; for (uint8 j = 0; j < availableCount; j++) { uint8 rarityIndex = availableRarities[j]; uint256 probability = rollTypes[request.rollType].probabilities[ rarityIndex ]; cumulativeProbability += probability; if (effectiveRandomValue < cumulativeProbability) { finalRarityIndex = rarityIndex; break; } } if ( rarityLevels[finalRarityIndex].minted < rarityLevels[finalRarityIndex].maxSupply ) { break; } cumulativeProbability = 0; usedRandomness++; finalRarityIndex = 0; } if ( rarityLevels[finalRarityIndex].minted >= rarityLevels[finalRarityIndex].maxSupply ) { owedRewards[request.user] += rollTypes[request.rollType].price; request.cancelled = true; emit MintFailed(request.user, sequenceNumber); return; } rarityLevels[finalRarityIndex].minted += 1; mintedDragonCount += 1; request.tokenId = mintedDragonCount; string memory fullUri = string( abi.encodePacked( rarityLevels[finalRarityIndex].tokenUri, Strings.toString(mintedDragonCount), ".json" ) ); mintRequests[sequenceNumber].uri = fullUri; mintRequests[sequenceNumber].mintFinalized = true; derpyDragons.mint(request.user, fullUri); emit TokenMinted(request.user, mintedDragonCount); } // ------------------------------------------------------- // Utility functions // ------------------------------------------------------ /** * @dev Adds a token ID to the staked token array for a user. * @param tokenId The ID of the token to be added. */ function add(uint256 tokenId) internal { uint256[] storage tokenIds = stakedTokenIds[msg.sender]; tokenIndexInArray[tokenId] = tokenIds.length; tokenIds.push(tokenId); } /** * @dev Removes a token ID from the staked token array for a user. * @param tokenId The ID of the token to be removed. */ function remove(uint256 tokenId) internal { uint256[] storage tokenIds = stakedTokenIds[msg.sender]; uint256 index = tokenIndexInArray[tokenId]; if (index >= tokenIds.length) revert InvalidTokenIndex(); uint256 lastTokenId = tokenIds[tokenIds.length - 1]; tokenIds[index] = lastTokenId; tokenIndexInArray[lastTokenId] = index; tokenIds.pop(); delete tokenIndexInArray[tokenId]; } /** * @dev prevent direct transfers of tokens to the contract */ function onERC721Received( address, address, uint256, bytes memory ) public view override returns (bytes4) { if (!stakingInProgress) revert DirectTransferNotAllowed(); return this.onERC721Received.selector; } /** * @dev upgrading the contract */ function _authorizeUpgrade( address newImplementation ) internal override onlyOwner {} /** * @dev returns the version of the contract */ function version() public pure returns (string memory) { return "1.0"; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol) pragma solidity ^0.8.20; import {ContextUpgradeable} from "../utils/ContextUpgradeable.sol"; import {Initializable} from "../proxy/utils/Initializable.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. */ abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable { /// @custom:storage-location erc7201:openzeppelin.storage.Ownable struct OwnableStorage { address _owner; } // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Ownable")) - 1)) & ~bytes32(uint256(0xff)) bytes32 private constant OwnableStorageLocation = 0x9016d09d72d40fdae2fd8ceac6b6234c7706214fd39c1cd1e609a0528c199300; function _getOwnableStorage() private pure returns (OwnableStorage storage $) { assembly { $.slot := OwnableStorageLocation } } /** * @dev The caller account is not authorized to perform an operation. */ error OwnableUnauthorizedAccount(address account); /** * @dev The owner is not a valid owner account. (eg. `address(0)`) */ error OwnableInvalidOwner(address owner); event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the address provided by the deployer as the initial owner. */ function __Ownable_init(address initialOwner) internal onlyInitializing { __Ownable_init_unchained(initialOwner); } function __Ownable_init_unchained(address initialOwner) internal onlyInitializing { if (initialOwner == address(0)) { revert OwnableInvalidOwner(address(0)); } _transferOwnership(initialOwner); } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { _checkOwner(); _; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { OwnableStorage storage $ = _getOwnableStorage(); return $._owner; } /** * @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { 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. */ function renounceOwnership() public virtual onlyOwner { _transferOwnership(address(0)); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { 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) internal virtual { OwnableStorage storage $ = _getOwnableStorage(); address oldOwner = $._owner; $._owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (proxy/utils/Initializable.sol) pragma solidity ^0.8.20; /** * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect. * * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in * case an upgrade adds a module that needs to be initialized. * * For example: * * [.hljs-theme-light.nopadding] * ```solidity * contract MyToken is ERC20Upgradeable { * function initialize() initializer public { * __ERC20_init("MyToken", "MTK"); * } * } * * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable { * function initializeV2() reinitializer(2) public { * __ERC20Permit_init("MyToken"); * } * } * ``` * * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}. * * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity. * * [CAUTION] * ==== * Avoid leaving a contract uninitialized. * * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed: * * [.hljs-theme-light.nopadding] * ``` * /// @custom:oz-upgrades-unsafe-allow constructor * constructor() { * _disableInitializers(); * } * ``` * ==== */ abstract contract Initializable { /** * @dev Storage of the initializable contract. * * It's implemented on a custom ERC-7201 namespace to reduce the risk of storage collisions * when using with upgradeable contracts. * * @custom:storage-location erc7201:openzeppelin.storage.Initializable */ struct InitializableStorage { /** * @dev Indicates that the contract has been initialized. */ uint64 _initialized; /** * @dev Indicates that the contract is in the process of being initialized. */ bool _initializing; } // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Initializable")) - 1)) & ~bytes32(uint256(0xff)) bytes32 private constant INITIALIZABLE_STORAGE = 0xf0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a00; /** * @dev The contract is already initialized. */ error InvalidInitialization(); /** * @dev The contract is not initializing. */ error NotInitializing(); /** * @dev Triggered when the contract has been initialized or reinitialized. */ event Initialized(uint64 version); /** * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope, * `onlyInitializing` functions can be used to initialize parent contracts. * * Similar to `reinitializer(1)`, except that in the context of a constructor an `initializer` may be invoked any * number of times. This behavior in the constructor can be useful during testing and is not expected to be used in * production. * * Emits an {Initialized} event. */ modifier initializer() { // solhint-disable-next-line var-name-mixedcase InitializableStorage storage $ = _getInitializableStorage(); // Cache values to avoid duplicated sloads bool isTopLevelCall = !$._initializing; uint64 initialized = $._initialized; // Allowed calls: // - initialSetup: the contract is not in the initializing state and no previous version was // initialized // - construction: the contract is initialized at version 1 (no reininitialization) and the // current contract is just being deployed bool initialSetup = initialized == 0 && isTopLevelCall; bool construction = initialized == 1 && address(this).code.length == 0; if (!initialSetup && !construction) { revert InvalidInitialization(); } $._initialized = 1; if (isTopLevelCall) { $._initializing = true; } _; if (isTopLevelCall) { $._initializing = false; emit Initialized(1); } } /** * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be * used to initialize parent contracts. * * A reinitializer may be used after the original initialization step. This is essential to configure modules that * are added through upgrades and that require initialization. * * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer` * cannot be nested. If one is invoked in the context of another, execution will revert. * * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in * a contract, executing them in the right order is up to the developer or operator. * * WARNING: Setting the version to 2**64 - 1 will prevent any future reinitialization. * * Emits an {Initialized} event. */ modifier reinitializer(uint64 version) { // solhint-disable-next-line var-name-mixedcase InitializableStorage storage $ = _getInitializableStorage(); if ($._initializing || $._initialized >= version) { revert InvalidInitialization(); } $._initialized = version; $._initializing = true; _; $._initializing = false; emit Initialized(version); } /** * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the * {initializer} and {reinitializer} modifiers, directly or indirectly. */ modifier onlyInitializing() { _checkInitializing(); _; } /** * @dev Reverts if the contract is not in an initializing state. See {onlyInitializing}. */ function _checkInitializing() internal view virtual { if (!_isInitializing()) { revert NotInitializing(); } } /** * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call. * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized * to any version. It is recommended to use this to lock implementation contracts that are designed to be called * through proxies. * * Emits an {Initialized} event the first time it is successfully executed. */ function _disableInitializers() internal virtual { // solhint-disable-next-line var-name-mixedcase InitializableStorage storage $ = _getInitializableStorage(); if ($._initializing) { revert InvalidInitialization(); } if ($._initialized != type(uint64).max) { $._initialized = type(uint64).max; emit Initialized(type(uint64).max); } } /** * @dev Returns the highest version that has been initialized. See {reinitializer}. */ function _getInitializedVersion() internal view returns (uint64) { return _getInitializableStorage()._initialized; } /** * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}. */ function _isInitializing() internal view returns (bool) { return _getInitializableStorage()._initializing; } /** * @dev Returns a pointer to the storage namespace. */ // solhint-disable-next-line var-name-mixedcase function _getInitializableStorage() private pure returns (InitializableStorage storage $) { assembly { $.slot := INITIALIZABLE_STORAGE } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.1.0) (proxy/utils/UUPSUpgradeable.sol) pragma solidity ^0.8.20; import {IERC1822Proxiable} from "@openzeppelin/contracts/interfaces/draft-IERC1822.sol"; import {ERC1967Utils} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Utils.sol"; import {Initializable} from "./Initializable.sol"; /** * @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an * {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy. * * A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is * reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing * `UUPSUpgradeable` with a custom implementation of upgrades. * * The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism. */ abstract contract UUPSUpgradeable is Initializable, IERC1822Proxiable { /// @custom:oz-upgrades-unsafe-allow state-variable-immutable address private immutable __self = address(this); /** * @dev The version of the upgrade interface of the contract. If this getter is missing, both `upgradeTo(address)` * and `upgradeToAndCall(address,bytes)` are present, and `upgradeTo` must be used if no function should be called, * while `upgradeToAndCall` will invoke the `receive` function if the second argument is the empty byte string. * If the getter returns `"5.0.0"`, only `upgradeToAndCall(address,bytes)` is present, and the second argument must * be the empty byte string if no function should be called, making it impossible to invoke the `receive` function * during an upgrade. */ string public constant UPGRADE_INTERFACE_VERSION = "5.0.0"; /** * @dev The call is from an unauthorized context. */ error UUPSUnauthorizedCallContext(); /** * @dev The storage `slot` is unsupported as a UUID. */ error UUPSUnsupportedProxiableUUID(bytes32 slot); /** * @dev Check that the execution is being performed through a delegatecall call and that the execution context is * a proxy contract with an implementation (as defined in ERC-1967) pointing to self. This should only be the case * for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a * function through ERC-1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to * fail. */ modifier onlyProxy() { _checkProxy(); _; } /** * @dev Check that the execution is not being performed through a delegate call. This allows a function to be * callable on the implementing contract but not through proxies. */ modifier notDelegated() { _checkNotDelegated(); _; } function __UUPSUpgradeable_init() internal onlyInitializing { } function __UUPSUpgradeable_init_unchained() internal onlyInitializing { } /** * @dev Implementation of the ERC-1822 {proxiableUUID} function. This returns the storage slot used by the * implementation. It is used to validate the implementation's compatibility when performing an upgrade. * * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this * function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier. */ function proxiableUUID() external view virtual notDelegated returns (bytes32) { return ERC1967Utils.IMPLEMENTATION_SLOT; } /** * @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call * encoded in `data`. * * Calls {_authorizeUpgrade}. * * Emits an {Upgraded} event. * * @custom:oz-upgrades-unsafe-allow-reachable delegatecall */ function upgradeToAndCall(address newImplementation, bytes memory data) public payable virtual onlyProxy { _authorizeUpgrade(newImplementation); _upgradeToAndCallUUPS(newImplementation, data); } /** * @dev Reverts if the execution is not performed via delegatecall or the execution * context is not of a proxy with an ERC-1967 compliant implementation pointing to self. * See {_onlyProxy}. */ function _checkProxy() internal view virtual { if ( address(this) == __self || // Must be called through delegatecall ERC1967Utils.getImplementation() != __self // Must be called through an active proxy ) { revert UUPSUnauthorizedCallContext(); } } /** * @dev Reverts if the execution is performed via delegatecall. * See {notDelegated}. */ function _checkNotDelegated() internal view virtual { if (address(this) != __self) { // Must not be called through delegatecall revert UUPSUnauthorizedCallContext(); } } /** * @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by * {upgradeToAndCall}. * * Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}. * * ```solidity * function _authorizeUpgrade(address) internal onlyOwner {} * ``` */ function _authorizeUpgrade(address newImplementation) internal virtual; /** * @dev Performs an implementation upgrade with a security check for UUPS proxies, and additional setup call. * * As a security check, {proxiableUUID} is invoked in the new implementation, and the return value * is expected to be the implementation slot in ERC-1967. * * Emits an {IERC1967-Upgraded} event. */ function _upgradeToAndCallUUPS(address newImplementation, bytes memory data) private { try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) { if (slot != ERC1967Utils.IMPLEMENTATION_SLOT) { revert UUPSUnsupportedProxiableUUID(slot); } ERC1967Utils.upgradeToAndCall(newImplementation, data); } catch { // The implementation is not UUPS revert ERC1967Utils.ERC1967InvalidImplementation(newImplementation); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.1.0) (token/ERC721/ERC721.sol) pragma solidity ^0.8.20; import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol"; import {IERC721Metadata} from "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol"; import {ERC721Utils} from "@openzeppelin/contracts/token/ERC721/utils/ERC721Utils.sol"; import {ContextUpgradeable} from "../../utils/ContextUpgradeable.sol"; import {Strings} from "@openzeppelin/contracts/utils/Strings.sol"; import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol"; import {ERC165Upgradeable} from "../../utils/introspection/ERC165Upgradeable.sol"; import {IERC721Errors} from "@openzeppelin/contracts/interfaces/draft-IERC6093.sol"; import {Initializable} from "../../proxy/utils/Initializable.sol"; /** * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC-721] Non-Fungible Token Standard, including * the Metadata extension, but not including the Enumerable extension, which is available separately as * {ERC721Enumerable}. */ abstract contract ERC721Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC721, IERC721Metadata, IERC721Errors { using Strings for uint256; /// @custom:storage-location erc7201:openzeppelin.storage.ERC721 struct ERC721Storage { // Token name string _name; // Token symbol string _symbol; mapping(uint256 tokenId => address) _owners; mapping(address owner => uint256) _balances; mapping(uint256 tokenId => address) _tokenApprovals; mapping(address owner => mapping(address operator => bool)) _operatorApprovals; } // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.ERC721")) - 1)) & ~bytes32(uint256(0xff)) bytes32 private constant ERC721StorageLocation = 0x80bb2b638cc20bc4d0a60d66940f3ab4a00c1d7b313497ca82fb0b4ab0079300; function _getERC721Storage() private pure returns (ERC721Storage storage $) { assembly { $.slot := ERC721StorageLocation } } /** * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection. */ function __ERC721_init(string memory name_, string memory symbol_) internal onlyInitializing { __ERC721_init_unchained(name_, symbol_); } function __ERC721_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing { ERC721Storage storage $ = _getERC721Storage(); $._name = name_; $._symbol = symbol_; } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165) returns (bool) { return interfaceId == type(IERC721).interfaceId || interfaceId == type(IERC721Metadata).interfaceId || super.supportsInterface(interfaceId); } /** * @dev See {IERC721-balanceOf}. */ function balanceOf(address owner) public view virtual returns (uint256) { ERC721Storage storage $ = _getERC721Storage(); if (owner == address(0)) { revert ERC721InvalidOwner(address(0)); } return $._balances[owner]; } /** * @dev See {IERC721-ownerOf}. */ function ownerOf(uint256 tokenId) public view virtual returns (address) { return _requireOwned(tokenId); } /** * @dev See {IERC721Metadata-name}. */ function name() public view virtual returns (string memory) { ERC721Storage storage $ = _getERC721Storage(); return $._name; } /** * @dev See {IERC721Metadata-symbol}. */ function symbol() public view virtual returns (string memory) { ERC721Storage storage $ = _getERC721Storage(); return $._symbol; } /** * @dev See {IERC721Metadata-tokenURI}. */ function tokenURI(uint256 tokenId) public view virtual returns (string memory) { _requireOwned(tokenId); string memory baseURI = _baseURI(); return bytes(baseURI).length > 0 ? string.concat(baseURI, tokenId.toString()) : ""; } /** * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each * token will be the concatenation of the `baseURI` and the `tokenId`. Empty * by default, can be overridden in child contracts. */ function _baseURI() internal view virtual returns (string memory) { return ""; } /** * @dev See {IERC721-approve}. */ function approve(address to, uint256 tokenId) public virtual { _approve(to, tokenId, _msgSender()); } /** * @dev See {IERC721-getApproved}. */ function getApproved(uint256 tokenId) public view virtual returns (address) { _requireOwned(tokenId); return _getApproved(tokenId); } /** * @dev See {IERC721-setApprovalForAll}. */ function setApprovalForAll(address operator, bool approved) public virtual { _setApprovalForAll(_msgSender(), operator, approved); } /** * @dev See {IERC721-isApprovedForAll}. */ function isApprovedForAll(address owner, address operator) public view virtual returns (bool) { ERC721Storage storage $ = _getERC721Storage(); return $._operatorApprovals[owner][operator]; } /** * @dev See {IERC721-transferFrom}. */ function transferFrom(address from, address to, uint256 tokenId) public virtual { if (to == address(0)) { revert ERC721InvalidReceiver(address(0)); } // Setting an "auth" arguments enables the `_isAuthorized` check which verifies that the token exists // (from != 0). Therefore, it is not needed to verify that the return value is not 0 here. address previousOwner = _update(to, tokenId, _msgSender()); if (previousOwner != from) { revert ERC721IncorrectOwner(from, tokenId, previousOwner); } } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom(address from, address to, uint256 tokenId) public { safeTransferFrom(from, to, tokenId, ""); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public virtual { transferFrom(from, to, tokenId); ERC721Utils.checkOnERC721Received(_msgSender(), from, to, tokenId, data); } /** * @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist * * IMPORTANT: Any overrides to this function that add ownership of tokens not tracked by the * core ERC-721 logic MUST be matched with the use of {_increaseBalance} to keep balances * consistent with ownership. The invariant to preserve is that for any address `a` the value returned by * `balanceOf(a)` must be equal to the number of tokens such that `_ownerOf(tokenId)` is `a`. */ function _ownerOf(uint256 tokenId) internal view virtual returns (address) { ERC721Storage storage $ = _getERC721Storage(); return $._owners[tokenId]; } /** * @dev Returns the approved address for `tokenId`. Returns 0 if `tokenId` is not minted. */ function _getApproved(uint256 tokenId) internal view virtual returns (address) { ERC721Storage storage $ = _getERC721Storage(); return $._tokenApprovals[tokenId]; } /** * @dev Returns whether `spender` is allowed to manage `owner`'s tokens, or `tokenId` in * particular (ignoring whether it is owned by `owner`). * * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this * assumption. */ function _isAuthorized(address owner, address spender, uint256 tokenId) internal view virtual returns (bool) { return spender != address(0) && (owner == spender || isApprovedForAll(owner, spender) || _getApproved(tokenId) == spender); } /** * @dev Checks if `spender` can operate on `tokenId`, assuming the provided `owner` is the actual owner. * Reverts if: * - `spender` does not have approval from `owner` for `tokenId`. * - `spender` does not have approval to manage all of `owner`'s assets. * * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this * assumption. */ function _checkAuthorized(address owner, address spender, uint256 tokenId) internal view virtual { if (!_isAuthorized(owner, spender, tokenId)) { if (owner == address(0)) { revert ERC721NonexistentToken(tokenId); } else { revert ERC721InsufficientApproval(spender, tokenId); } } } /** * @dev Unsafe write access to the balances, used by extensions that "mint" tokens using an {ownerOf} override. * * NOTE: the value is limited to type(uint128).max. This protect against _balance overflow. It is unrealistic that * a uint256 would ever overflow from increments when these increments are bounded to uint128 values. * * WARNING: Increasing an account's balance using this function tends to be paired with an override of the * {_ownerOf} function to resolve the ownership of the corresponding tokens so that balances and ownership * remain consistent with one another. */ function _increaseBalance(address account, uint128 value) internal virtual { ERC721Storage storage $ = _getERC721Storage(); unchecked { $._balances[account] += value; } } /** * @dev Transfers `tokenId` from its current owner to `to`, or alternatively mints (or burns) if the current owner * (or `to`) is the zero address. Returns the owner of the `tokenId` before the update. * * The `auth` argument is optional. If the value passed is non 0, then this function will check that * `auth` is either the owner of the token, or approved to operate on the token (by the owner). * * Emits a {Transfer} event. * * NOTE: If overriding this function in a way that tracks balances, see also {_increaseBalance}. */ function _update(address to, uint256 tokenId, address auth) internal virtual returns (address) { ERC721Storage storage $ = _getERC721Storage(); address from = _ownerOf(tokenId); // Perform (optional) operator check if (auth != address(0)) { _checkAuthorized(from, auth, tokenId); } // Execute the update if (from != address(0)) { // Clear approval. No need to re-authorize or emit the Approval event _approve(address(0), tokenId, address(0), false); unchecked { $._balances[from] -= 1; } } if (to != address(0)) { unchecked { $._balances[to] += 1; } } $._owners[tokenId] = to; emit Transfer(from, to, tokenId); return from; } /** * @dev Mints `tokenId` and transfers it to `to`. * * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible * * Requirements: * * - `tokenId` must not exist. * - `to` cannot be the zero address. * * Emits a {Transfer} event. */ function _mint(address to, uint256 tokenId) internal { if (to == address(0)) { revert ERC721InvalidReceiver(address(0)); } address previousOwner = _update(to, tokenId, address(0)); if (previousOwner != address(0)) { revert ERC721InvalidSender(address(0)); } } /** * @dev Mints `tokenId`, transfers it to `to` and checks for `to` acceptance. * * Requirements: * * - `tokenId` must not exist. * - 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 tokenId) internal { _safeMint(to, tokenId, ""); } /** * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is * forwarded in {IERC721Receiver-onERC721Received} to contract recipients. */ function _safeMint(address to, uint256 tokenId, bytes memory data) internal virtual { _mint(to, tokenId); ERC721Utils.checkOnERC721Received(_msgSender(), address(0), to, tokenId, data); } /** * @dev Destroys `tokenId`. * The approval is cleared when the token is burned. * This is an internal function that does not check if the sender is authorized to operate on the token. * * Requirements: * * - `tokenId` must exist. * * Emits a {Transfer} event. */ function _burn(uint256 tokenId) internal { address previousOwner = _update(address(0), tokenId, address(0)); if (previousOwner == address(0)) { revert ERC721NonexistentToken(tokenId); } } /** * @dev Transfers `tokenId` from `from` to `to`. * As opposed to {transferFrom}, this imposes no restrictions on msg.sender. * * Requirements: * * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * * Emits a {Transfer} event. */ function _transfer(address from, address to, uint256 tokenId) internal { if (to == address(0)) { revert ERC721InvalidReceiver(address(0)); } address previousOwner = _update(to, tokenId, address(0)); if (previousOwner == address(0)) { revert ERC721NonexistentToken(tokenId); } else if (previousOwner != from) { revert ERC721IncorrectOwner(from, tokenId, previousOwner); } } /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking that contract recipients * are aware of the ERC-721 standard to prevent tokens from being forever locked. * * `data` is additional data, it has no specified format and it is sent in call to `to`. * * This internal function is like {safeTransferFrom} in the sense that it invokes * {IERC721Receiver-onERC721Received} on the receiver, and can be used to e.g. * implement alternative mechanisms to perform token transfer, such as signature-based. * * Requirements: * * - `tokenId` token must exist and be owned by `from`. * - `to` cannot be the zero address. * - `from` 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 _safeTransfer(address from, address to, uint256 tokenId) internal { _safeTransfer(from, to, tokenId, ""); } /** * @dev Same as {xref-ERC721-_safeTransfer-address-address-uint256-}[`_safeTransfer`], with an additional `data` parameter which is * forwarded in {IERC721Receiver-onERC721Received} to contract recipients. */ function _safeTransfer(address from, address to, uint256 tokenId, bytes memory data) internal virtual { _transfer(from, to, tokenId); ERC721Utils.checkOnERC721Received(_msgSender(), from, to, tokenId, data); } /** * @dev Approve `to` to operate on `tokenId` * * The `auth` argument is optional. If the value passed is non 0, then this function will check that `auth` is * either the owner of the token, or approved to operate on all tokens held by this owner. * * Emits an {Approval} event. * * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument. */ function _approve(address to, uint256 tokenId, address auth) internal { _approve(to, tokenId, auth, true); } /** * @dev Variant of `_approve` with an optional flag to enable or disable the {Approval} event. The event is not * emitted in the context of transfers. */ function _approve(address to, uint256 tokenId, address auth, bool emitEvent) internal virtual { ERC721Storage storage $ = _getERC721Storage(); // Avoid reading the owner unless necessary if (emitEvent || auth != address(0)) { address owner = _requireOwned(tokenId); // We do not use _isAuthorized because single-token approvals should not be able to call approve if (auth != address(0) && owner != auth && !isApprovedForAll(owner, auth)) { revert ERC721InvalidApprover(auth); } if (emitEvent) { emit Approval(owner, to, tokenId); } } $._tokenApprovals[tokenId] = to; } /** * @dev Approve `operator` to operate on all of `owner` tokens * * Requirements: * - operator can't be the address zero. * * Emits an {ApprovalForAll} event. */ function _setApprovalForAll(address owner, address operator, bool approved) internal virtual { ERC721Storage storage $ = _getERC721Storage(); if (operator == address(0)) { revert ERC721InvalidOperator(operator); } $._operatorApprovals[owner][operator] = approved; emit ApprovalForAll(owner, operator, approved); } /** * @dev Reverts if the `tokenId` doesn't have a current owner (it hasn't been minted, or it has been burned). * Returns the owner. * * Overrides to ownership logic should be done to {_ownerOf}. */ function _requireOwned(uint256 tokenId) internal view returns (address) { address owner = _ownerOf(tokenId); if (owner == address(0)) { revert ERC721NonexistentToken(tokenId); } return owner; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.1.0) (token/ERC721/extensions/ERC721Enumerable.sol) pragma solidity ^0.8.20; import {ERC721Upgradeable} from "../ERC721Upgradeable.sol"; import {IERC721Enumerable} from "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol"; import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol"; import {Initializable} from "../../../proxy/utils/Initializable.sol"; /** * @dev This implements an optional extension of {ERC721} defined in the ERC that adds enumerability * of all the token ids in the contract as well as all token ids owned by each account. * * CAUTION: {ERC721} extensions that implement custom `balanceOf` logic, such as {ERC721Consecutive}, * interfere with enumerability and should not be used together with {ERC721Enumerable}. */ abstract contract ERC721EnumerableUpgradeable is Initializable, ERC721Upgradeable, IERC721Enumerable { /// @custom:storage-location erc7201:openzeppelin.storage.ERC721Enumerable struct ERC721EnumerableStorage { mapping(address owner => mapping(uint256 index => uint256)) _ownedTokens; mapping(uint256 tokenId => uint256) _ownedTokensIndex; uint256[] _allTokens; mapping(uint256 tokenId => uint256) _allTokensIndex; } // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.ERC721Enumerable")) - 1)) & ~bytes32(uint256(0xff)) bytes32 private constant ERC721EnumerableStorageLocation = 0x645e039705490088daad89bae25049a34f4a9072d398537b1ab2425f24cbed00; function _getERC721EnumerableStorage() private pure returns (ERC721EnumerableStorage storage $) { assembly { $.slot := ERC721EnumerableStorageLocation } } /** * @dev An `owner`'s token query was out of bounds for `index`. * * NOTE: The owner being `address(0)` indicates a global out of bounds index. */ error ERC721OutOfBoundsIndex(address owner, uint256 index); /** * @dev Batch mint is not allowed. */ error ERC721EnumerableForbiddenBatchMint(); function __ERC721Enumerable_init() internal onlyInitializing { } function __ERC721Enumerable_init_unchained() internal onlyInitializing { } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721Upgradeable) returns (bool) { return interfaceId == type(IERC721Enumerable).interfaceId || super.supportsInterface(interfaceId); } /** * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}. */ function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual returns (uint256) { ERC721EnumerableStorage storage $ = _getERC721EnumerableStorage(); if (index >= balanceOf(owner)) { revert ERC721OutOfBoundsIndex(owner, index); } return $._ownedTokens[owner][index]; } /** * @dev See {IERC721Enumerable-totalSupply}. */ function totalSupply() public view virtual returns (uint256) { ERC721EnumerableStorage storage $ = _getERC721EnumerableStorage(); return $._allTokens.length; } /** * @dev See {IERC721Enumerable-tokenByIndex}. */ function tokenByIndex(uint256 index) public view virtual returns (uint256) { ERC721EnumerableStorage storage $ = _getERC721EnumerableStorage(); if (index >= totalSupply()) { revert ERC721OutOfBoundsIndex(address(0), index); } return $._allTokens[index]; } /** * @dev See {ERC721-_update}. */ function _update(address to, uint256 tokenId, address auth) internal virtual override returns (address) { address previousOwner = super._update(to, tokenId, auth); if (previousOwner == address(0)) { _addTokenToAllTokensEnumeration(tokenId); } else if (previousOwner != to) { _removeTokenFromOwnerEnumeration(previousOwner, tokenId); } if (to == address(0)) { _removeTokenFromAllTokensEnumeration(tokenId); } else if (previousOwner != to) { _addTokenToOwnerEnumeration(to, tokenId); } return previousOwner; } /** * @dev Private function to add a token to this extension's ownership-tracking data structures. * @param to address representing the new owner of the given token ID * @param tokenId uint256 ID of the token to be added to the tokens list of the given address */ function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private { ERC721EnumerableStorage storage $ = _getERC721EnumerableStorage(); uint256 length = balanceOf(to) - 1; $._ownedTokens[to][length] = tokenId; $._ownedTokensIndex[tokenId] = length; } /** * @dev Private function to add a token to this extension's token tracking data structures. * @param tokenId uint256 ID of the token to be added to the tokens list */ function _addTokenToAllTokensEnumeration(uint256 tokenId) private { ERC721EnumerableStorage storage $ = _getERC721EnumerableStorage(); $._allTokensIndex[tokenId] = $._allTokens.length; $._allTokens.push(tokenId); } /** * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for * gas optimizations e.g. when performing a transfer operation (avoiding double writes). * This has O(1) time complexity, but alters the order of the _ownedTokens array. * @param from address representing the previous owner of the given token ID * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address */ function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private { ERC721EnumerableStorage storage $ = _getERC721EnumerableStorage(); // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and // then delete the last slot (swap and pop). uint256 lastTokenIndex = balanceOf(from); uint256 tokenIndex = $._ownedTokensIndex[tokenId]; mapping(uint256 index => uint256) storage _ownedTokensByOwner = $._ownedTokens[from]; // When the token to delete is the last token, the swap operation is unnecessary if (tokenIndex != lastTokenIndex) { uint256 lastTokenId = _ownedTokensByOwner[lastTokenIndex]; _ownedTokensByOwner[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token $._ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index } // This also deletes the contents at the last position of the array delete $._ownedTokensIndex[tokenId]; delete _ownedTokensByOwner[lastTokenIndex]; } /** * @dev Private function to remove a token from this extension's token tracking data structures. * This has O(1) time complexity, but alters the order of the _allTokens array. * @param tokenId uint256 ID of the token to be removed from the tokens list */ function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private { ERC721EnumerableStorage storage $ = _getERC721EnumerableStorage(); // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and // then delete the last slot (swap and pop). uint256 lastTokenIndex = $._allTokens.length - 1; uint256 tokenIndex = $._allTokensIndex[tokenId]; // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding // an 'if' statement (like in _removeTokenFromOwnerEnumeration) uint256 lastTokenId = $._allTokens[lastTokenIndex]; $._allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token $._allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index // This also deletes the contents at the last position of the array delete $._allTokensIndex[tokenId]; $._allTokens.pop(); } /** * See {ERC721-_increaseBalance}. We need that to account tokens that were minted in batch */ function _increaseBalance(address account, uint128 amount) internal virtual override { if (amount > 0) { revert ERC721EnumerableForbiddenBatchMint(); } super._increaseBalance(account, amount); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/utils/ERC721Holder.sol) pragma solidity ^0.8.20; import {IERC721Receiver} from "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol"; import {Initializable} from "../../../proxy/utils/Initializable.sol"; /** * @dev Implementation of the {IERC721Receiver} interface. * * Accepts all token transfers. * Make sure the contract is able to use its token with {IERC721-safeTransferFrom}, {IERC721-approve} or * {IERC721-setApprovalForAll}. */ abstract contract ERC721HolderUpgradeable is Initializable, IERC721Receiver { function __ERC721Holder_init() internal onlyInitializing { } function __ERC721Holder_init_unchained() internal onlyInitializing { } /** * @dev See {IERC721Receiver-onERC721Received}. * * Always returns `IERC721Receiver.onERC721Received.selector`. */ function onERC721Received(address, address, uint256, bytes memory) public virtual returns (bytes4) { return this.onERC721Received.selector; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol) pragma solidity ^0.8.20; import {Initializable} from "../proxy/utils/Initializable.sol"; /** * @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. */ abstract contract ContextUpgradeable is Initializable { function __Context_init() internal onlyInitializing { } function __Context_init_unchained() internal onlyInitializing { } function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } function _contextSuffixLength() internal view virtual returns (uint256) { return 0; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/ERC165.sol) pragma solidity ^0.8.20; import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol"; import {Initializable} from "../../proxy/utils/Initializable.sol"; /** * @dev Implementation of the {IERC165} interface. * * Contracts that want to implement ERC-165 should inherit from this contract and override {supportsInterface} to check * for the additional interface id that will be supported. For example: * * ```solidity * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId); * } * ``` */ abstract contract ERC165Upgradeable is Initializable, IERC165 { function __ERC165_init() internal onlyInitializing { } function __ERC165_init_unchained() internal onlyInitializing { } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) { return interfaceId == type(IERC165).interfaceId; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.1.0) (utils/ReentrancyGuard.sol) pragma solidity ^0.8.20; import {Initializable} from "../proxy/utils/Initializable.sol"; /** * @dev Contract module that helps prevent reentrant calls to a function. * * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier * available, which can be applied to functions to make sure there are no nested * (reentrant) calls to them. * * Note that because there is a single `nonReentrant` guard, functions marked as * `nonReentrant` may not call one another. This can be worked around by making * those functions `private`, and then adding `external` `nonReentrant` entry * points to them. * * TIP: If EIP-1153 (transient storage) is available on the chain you're deploying at, * consider using {ReentrancyGuardTransient} instead. * * TIP: If you would like to learn more about reentrancy and alternative ways * to protect against it, check out our blog post * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul]. */ abstract contract ReentrancyGuardUpgradeable is Initializable { // Booleans are more expensive than uint256 or any type that takes up a full // word because each write operation emits an extra SLOAD to first read the // slot's contents, replace the bits taken up by the boolean, and then write // back. This is the compiler's defense against contract upgrades and // pointer aliasing, and it cannot be disabled. // The values being non-zero value makes deployment a bit more expensive, // but in exchange the refund on every call to nonReentrant will be lower in // amount. Since refunds are capped to a percentage of the total // transaction's gas, it is best to keep them low in cases like this one, to // increase the likelihood of the full refund coming into effect. uint256 private constant NOT_ENTERED = 1; uint256 private constant ENTERED = 2; /// @custom:storage-location erc7201:openzeppelin.storage.ReentrancyGuard struct ReentrancyGuardStorage { uint256 _status; } // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.ReentrancyGuard")) - 1)) & ~bytes32(uint256(0xff)) bytes32 private constant ReentrancyGuardStorageLocation = 0x9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00; function _getReentrancyGuardStorage() private pure returns (ReentrancyGuardStorage storage $) { assembly { $.slot := ReentrancyGuardStorageLocation } } /** * @dev Unauthorized reentrant call. */ error ReentrancyGuardReentrantCall(); function __ReentrancyGuard_init() internal onlyInitializing { __ReentrancyGuard_init_unchained(); } function __ReentrancyGuard_init_unchained() internal onlyInitializing { ReentrancyGuardStorage storage $ = _getReentrancyGuardStorage(); $._status = NOT_ENTERED; } /** * @dev Prevents a contract from calling itself, directly or indirectly. * Calling a `nonReentrant` function from another `nonReentrant` * function is not supported. It is possible to prevent this from happening * by making the `nonReentrant` function external, and making it call a * `private` function that does the actual work. */ modifier nonReentrant() { _nonReentrantBefore(); _; _nonReentrantAfter(); } function _nonReentrantBefore() private { ReentrancyGuardStorage storage $ = _getReentrancyGuardStorage(); // On the first call to nonReentrant, _status will be NOT_ENTERED if ($._status == ENTERED) { revert ReentrancyGuardReentrantCall(); } // Any calls to nonReentrant after this point will fail $._status = ENTERED; } function _nonReentrantAfter() private { ReentrancyGuardStorage storage $ = _getReentrancyGuardStorage(); // By storing the original value once again, a refund is triggered (see // https://eips.ethereum.org/EIPS/eip-2200) $._status = NOT_ENTERED; } /** * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a * `nonReentrant` function in the call stack. */ function _reentrancyGuardEntered() internal view returns (bool) { ReentrancyGuardStorage storage $ = _getReentrancyGuardStorage(); return $._status == ENTERED; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.1.0) (interfaces/draft-IERC1822.sol) pragma solidity ^0.8.20; /** * @dev ERC-1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified * proxy whose upgrades are fully controlled by the current implementation. */ interface IERC1822Proxiable { /** * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation * address. * * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this * function revert if invoked through a proxy. */ function proxiableUUID() external view returns (bytes32); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.1.0) (interfaces/draft-IERC6093.sol) pragma solidity ^0.8.20; /** * @dev Standard ERC-20 Errors * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-20 tokens. */ interface IERC20Errors { /** * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers. * @param sender Address whose tokens are being transferred. * @param balance Current balance for the interacting account. * @param needed Minimum amount required to perform a transfer. */ error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed); /** * @dev Indicates a failure with the token `sender`. Used in transfers. * @param sender Address whose tokens are being transferred. */ error ERC20InvalidSender(address sender); /** * @dev Indicates a failure with the token `receiver`. Used in transfers. * @param receiver Address to which tokens are being transferred. */ error ERC20InvalidReceiver(address receiver); /** * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers. * @param spender Address that may be allowed to operate on tokens without being their owner. * @param allowance Amount of tokens a `spender` is allowed to operate with. * @param needed Minimum amount required to perform a transfer. */ error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed); /** * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals. * @param approver Address initiating an approval operation. */ error ERC20InvalidApprover(address approver); /** * @dev Indicates a failure with the `spender` to be approved. Used in approvals. * @param spender Address that may be allowed to operate on tokens without being their owner. */ error ERC20InvalidSpender(address spender); } /** * @dev Standard ERC-721 Errors * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-721 tokens. */ interface IERC721Errors { /** * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-20. * Used in balance queries. * @param owner Address of the current owner of a token. */ error ERC721InvalidOwner(address owner); /** * @dev Indicates a `tokenId` whose `owner` is the zero address. * @param tokenId Identifier number of a token. */ error ERC721NonexistentToken(uint256 tokenId); /** * @dev Indicates an error related to the ownership over a particular token. Used in transfers. * @param sender Address whose tokens are being transferred. * @param tokenId Identifier number of a token. * @param owner Address of the current owner of a token. */ error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner); /** * @dev Indicates a failure with the token `sender`. Used in transfers. * @param sender Address whose tokens are being transferred. */ error ERC721InvalidSender(address sender); /** * @dev Indicates a failure with the token `receiver`. Used in transfers. * @param receiver Address to which tokens are being transferred. */ error ERC721InvalidReceiver(address receiver); /** * @dev Indicates a failure with the `operator`’s approval. Used in transfers. * @param operator Address that may be allowed to operate on tokens without being their owner. * @param tokenId Identifier number of a token. */ error ERC721InsufficientApproval(address operator, uint256 tokenId); /** * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals. * @param approver Address initiating an approval operation. */ error ERC721InvalidApprover(address approver); /** * @dev Indicates a failure with the `operator` to be approved. Used in approvals. * @param operator Address that may be allowed to operate on tokens without being their owner. */ error ERC721InvalidOperator(address operator); } /** * @dev Standard ERC-1155 Errors * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-1155 tokens. */ interface IERC1155Errors { /** * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers. * @param sender Address whose tokens are being transferred. * @param balance Current balance for the interacting account. * @param needed Minimum amount required to perform a transfer. * @param tokenId Identifier number of a token. */ error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId); /** * @dev Indicates a failure with the token `sender`. Used in transfers. * @param sender Address whose tokens are being transferred. */ error ERC1155InvalidSender(address sender); /** * @dev Indicates a failure with the token `receiver`. Used in transfers. * @param receiver Address to which tokens are being transferred. */ error ERC1155InvalidReceiver(address receiver); /** * @dev Indicates a failure with the `operator`’s approval. Used in transfers. * @param operator Address that may be allowed to operate on tokens without being their owner. * @param owner Address of the current owner of a token. */ error ERC1155MissingApprovalForAll(address operator, address owner); /** * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals. * @param approver Address initiating an approval operation. */ error ERC1155InvalidApprover(address approver); /** * @dev Indicates a failure with the `operator` to be approved. Used in approvals. * @param operator Address that may be allowed to operate on tokens without being their owner. */ error ERC1155InvalidOperator(address operator); /** * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation. * Used in batch transfers. * @param idsLength Length of the array of token identifiers * @param valuesLength Length of the array of token amounts */ error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC1967.sol) pragma solidity ^0.8.20; /** * @dev ERC-1967: Proxy Storage Slots. This interface contains the events defined in the ERC. */ interface IERC1967 { /** * @dev Emitted when the implementation is upgraded. */ event Upgraded(address indexed implementation); /** * @dev Emitted when the admin account has changed. */ event AdminChanged(address previousAdmin, address newAdmin); /** * @dev Emitted when the beacon is changed. */ event BeaconUpgraded(address indexed beacon); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (proxy/beacon/IBeacon.sol) pragma solidity ^0.8.20; /** * @dev This is the interface that {BeaconProxy} expects of its beacon. */ interface IBeacon { /** * @dev Must return an address that can be used as a delegate call target. * * {UpgradeableBeacon} will check that this address is a contract. */ function implementation() external view returns (address); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.1.0) (proxy/ERC1967/ERC1967Utils.sol) pragma solidity ^0.8.21; import {IBeacon} from "../beacon/IBeacon.sol"; import {IERC1967} from "../../interfaces/IERC1967.sol"; import {Address} from "../../utils/Address.sol"; import {StorageSlot} from "../../utils/StorageSlot.sol"; /** * @dev This library provides getters and event emitting update functions for * https://eips.ethereum.org/EIPS/eip-1967[ERC-1967] slots. */ library ERC1967Utils { /** * @dev Storage slot with the address of the current implementation. * This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1. */ // solhint-disable-next-line private-vars-leading-underscore bytes32 internal constant IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc; /** * @dev The `implementation` of the proxy is invalid. */ error ERC1967InvalidImplementation(address implementation); /** * @dev The `admin` of the proxy is invalid. */ error ERC1967InvalidAdmin(address admin); /** * @dev The `beacon` of the proxy is invalid. */ error ERC1967InvalidBeacon(address beacon); /** * @dev An upgrade function sees `msg.value > 0` that may be lost. */ error ERC1967NonPayable(); /** * @dev Returns the current implementation address. */ function getImplementation() internal view returns (address) { return StorageSlot.getAddressSlot(IMPLEMENTATION_SLOT).value; } /** * @dev Stores a new address in the ERC-1967 implementation slot. */ function _setImplementation(address newImplementation) private { if (newImplementation.code.length == 0) { revert ERC1967InvalidImplementation(newImplementation); } StorageSlot.getAddressSlot(IMPLEMENTATION_SLOT).value = newImplementation; } /** * @dev Performs implementation upgrade with additional setup call if data is nonempty. * This function is payable only if the setup call is performed, otherwise `msg.value` is rejected * to avoid stuck value in the contract. * * Emits an {IERC1967-Upgraded} event. */ function upgradeToAndCall(address newImplementation, bytes memory data) internal { _setImplementation(newImplementation); emit IERC1967.Upgraded(newImplementation); if (data.length > 0) { Address.functionDelegateCall(newImplementation, data); } else { _checkNonPayable(); } } /** * @dev Storage slot with the admin of the contract. * This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1. */ // solhint-disable-next-line private-vars-leading-underscore bytes32 internal constant ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103; /** * @dev Returns the current admin. * * TIP: To get this value clients can read directly from the storage slot shown below (specified by ERC-1967) using * the https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call. * `0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103` */ function getAdmin() internal view returns (address) { return StorageSlot.getAddressSlot(ADMIN_SLOT).value; } /** * @dev Stores a new address in the ERC-1967 admin slot. */ function _setAdmin(address newAdmin) private { if (newAdmin == address(0)) { revert ERC1967InvalidAdmin(address(0)); } StorageSlot.getAddressSlot(ADMIN_SLOT).value = newAdmin; } /** * @dev Changes the admin of the proxy. * * Emits an {IERC1967-AdminChanged} event. */ function changeAdmin(address newAdmin) internal { emit IERC1967.AdminChanged(getAdmin(), newAdmin); _setAdmin(newAdmin); } /** * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy. * This is the keccak-256 hash of "eip1967.proxy.beacon" subtracted by 1. */ // solhint-disable-next-line private-vars-leading-underscore bytes32 internal constant BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50; /** * @dev Returns the current beacon. */ function getBeacon() internal view returns (address) { return StorageSlot.getAddressSlot(BEACON_SLOT).value; } /** * @dev Stores a new beacon in the ERC-1967 beacon slot. */ function _setBeacon(address newBeacon) private { if (newBeacon.code.length == 0) { revert ERC1967InvalidBeacon(newBeacon); } StorageSlot.getAddressSlot(BEACON_SLOT).value = newBeacon; address beaconImplementation = IBeacon(newBeacon).implementation(); if (beaconImplementation.code.length == 0) { revert ERC1967InvalidImplementation(beaconImplementation); } } /** * @dev Change the beacon and trigger a setup call if data is nonempty. * This function is payable only if the setup call is performed, otherwise `msg.value` is rejected * to avoid stuck value in the contract. * * Emits an {IERC1967-BeaconUpgraded} event. * * CAUTION: Invoking this function has no effect on an instance of {BeaconProxy} since v5, since * it uses an immutable beacon without looking at the value of the ERC-1967 beacon slot for * efficiency. */ function upgradeBeaconToAndCall(address newBeacon, bytes memory data) internal { _setBeacon(newBeacon); emit IERC1967.BeaconUpgraded(newBeacon); if (data.length > 0) { Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data); } else { _checkNonPayable(); } } /** * @dev Reverts if `msg.value` is not zero. It can be used to avoid `msg.value` stuck in the contract * if an upgrade doesn't perform an initialization call. */ function _checkNonPayable() private { if (msg.value > 0) { revert ERC1967NonPayable(); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/extensions/IERC721Enumerable.sol) pragma solidity ^0.8.20; import {IERC721} from "../IERC721.sol"; /** * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension * @dev See https://eips.ethereum.org/EIPS/eip-721 */ interface IERC721Enumerable is IERC721 { /** * @dev Returns the total amount of tokens stored by the contract. */ function totalSupply() external view returns (uint256); /** * @dev Returns a token ID owned by `owner` at a given `index` of its token list. * Use along with {balanceOf} to enumerate all of ``owner``'s tokens. */ function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256); /** * @dev Returns a token ID at a given `index` of all the tokens stored by the contract. * Use along with {totalSupply} to enumerate all tokens. */ function tokenByIndex(uint256 index) external view returns (uint256); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/extensions/IERC721Metadata.sol) pragma solidity ^0.8.20; import {IERC721} from "../IERC721.sol"; /** * @title ERC-721 Non-Fungible Token Standard, optional metadata extension * @dev See https://eips.ethereum.org/EIPS/eip-721 */ interface IERC721Metadata is IERC721 { /** * @dev Returns the token collection name. */ function name() external view returns (string memory); /** * @dev Returns the token collection symbol. */ function symbol() external view returns (string memory); /** * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token. */ function tokenURI(uint256 tokenId) external view returns (string memory); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.1.0) (token/ERC721/IERC721.sol) pragma solidity ^0.8.20; import {IERC165} from "../../utils/introspection/IERC165.sol"; /** * @dev Required interface of an ERC-721 compliant contract. */ interface IERC721 is IERC165 { /** * @dev Emitted when `tokenId` token is transferred from `from` to `to`. */ event Transfer(address indexed from, address indexed to, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token. */ event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets. */ event ApprovalForAll(address indexed owner, address indexed operator, bool approved); /** * @dev Returns the number of tokens in ``owner``'s account. */ function balanceOf(address owner) external view returns (uint256 balance); /** * @dev Returns the owner of the `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function ownerOf(uint256 tokenId) external view returns (address owner); /** * @dev Safely transfers `tokenId` token from `from` to `to`. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon * a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external; /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients * are aware of the ERC-721 protocol to prevent tokens from being forever locked. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or * {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon * a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom(address from, address to, uint256 tokenId) external; /** * @dev Transfers `tokenId` token from `from` to `to`. * * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC-721 * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must * understand this adds an external call which potentially creates a reentrancy vulnerability. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * * Emits a {Transfer} event. */ function transferFrom(address from, address to, uint256 tokenId) external; /** * @dev Gives permission to `to` to transfer `tokenId` token to another account. * The approval is cleared when the token is transferred. * * Only a single account can be approved at a time, so approving the zero address clears previous approvals. * * Requirements: * * - The caller must own the token or be an approved operator. * - `tokenId` must exist. * * Emits an {Approval} event. */ function approve(address to, uint256 tokenId) external; /** * @dev Approve or remove `operator` as an operator for the caller. * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. * * Requirements: * * - The `operator` cannot be the address zero. * * Emits an {ApprovalForAll} event. */ function setApprovalForAll(address operator, bool approved) external; /** * @dev Returns the account approved for `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function getApproved(uint256 tokenId) external view returns (address operator); /** * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`. * * See {setApprovalForAll} */ function isApprovedForAll(address owner, address operator) external view returns (bool); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.1.0) (token/ERC721/IERC721Receiver.sol) pragma solidity ^0.8.20; /** * @title ERC-721 token receiver interface * @dev Interface for any contract that wants to support safeTransfers * from ERC-721 asset contracts. */ interface IERC721Receiver { /** * @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`. */ function onERC721Received( address operator, address from, uint256 tokenId, bytes calldata data ) external returns (bytes4); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.1.0) (token/ERC721/utils/ERC721Utils.sol) pragma solidity ^0.8.20; import {IERC721Receiver} from "../IERC721Receiver.sol"; import {IERC721Errors} from "../../../interfaces/draft-IERC6093.sol"; /** * @dev Library that provide common ERC-721 utility functions. * * See https://eips.ethereum.org/EIPS/eip-721[ERC-721]. * * _Available since v5.1._ */ library ERC721Utils { /** * @dev Performs an acceptance check for the provided `operator` by calling {IERC721-onERC721Received} * on the `to` address. The `operator` is generally the address that initiated the token transfer (i.e. `msg.sender`). * * The acceptance call is not executed and treated as a no-op if the target address doesn't contain code (i.e. an EOA). * Otherwise, the recipient must implement {IERC721Receiver-onERC721Received} and return the acceptance magic value to accept * the transfer. */ function checkOnERC721Received( address operator, address from, address to, uint256 tokenId, bytes memory data ) internal { if (to.code.length > 0) { try IERC721Receiver(to).onERC721Received(operator, from, tokenId, data) returns (bytes4 retval) { if (retval != IERC721Receiver.onERC721Received.selector) { // Token rejected revert IERC721Errors.ERC721InvalidReceiver(to); } } catch (bytes memory reason) { if (reason.length == 0) { // non-IERC721Receiver implementer revert IERC721Errors.ERC721InvalidReceiver(to); } else { assembly ("memory-safe") { revert(add(32, reason), mload(reason)) } } } } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.1.0) (utils/Address.sol) pragma solidity ^0.8.20; import {Errors} from "./Errors.sol"; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev There's no code at `target` (it is not a contract). */ error AddressEmptyCode(address target); /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { if (address(this).balance < amount) { revert Errors.InsufficientBalance(address(this).balance, amount); } (bool success, ) = recipient.call{value: amount}(""); if (!success) { revert Errors.FailedCall(); } } /** * @dev Performs a Solidity function call using a low level `call`. A * plain `call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason or custom error, it is bubbled * up by this function (like regular Solidity function calls). However, if * the call reverted with no returned reason, this function reverts with a * {Errors.FailedCall} error. * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCallWithValue(target, data, 0); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. */ function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { if (address(this).balance < value) { revert Errors.InsufficientBalance(address(this).balance, value); } (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResultFromTarget(target, success, returndata); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResultFromTarget(target, success, returndata); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResultFromTarget(target, success, returndata); } /** * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target * was not a contract or bubbling up the revert reason (falling back to {Errors.FailedCall}) in case * of an unsuccessful call. */ function verifyCallResultFromTarget( address target, bool success, bytes memory returndata ) internal view returns (bytes memory) { if (!success) { _revert(returndata); } else { // only check if target is a contract if the call was successful and the return data is empty // otherwise we already know that it was a contract if (returndata.length == 0 && target.code.length == 0) { revert AddressEmptyCode(target); } return returndata; } } /** * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the * revert reason or with a default {Errors.FailedCall} error. */ function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) { if (!success) { _revert(returndata); } else { return returndata; } } /** * @dev Reverts with returndata if present. Otherwise reverts with {Errors.FailedCall}. */ function _revert(bytes memory returndata) private pure { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly assembly ("memory-safe") { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert Errors.FailedCall(); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.1.0) (utils/Errors.sol) pragma solidity ^0.8.20; /** * @dev Collection of common custom errors used in multiple contracts * * IMPORTANT: Backwards compatibility is not guaranteed in future versions of the library. * It is recommended to avoid relying on the error API for critical functionality. * * _Available since v5.1._ */ library Errors { /** * @dev The ETH balance of the account is not enough to perform the operation. */ error InsufficientBalance(uint256 balance, uint256 needed); /** * @dev A call to an address target failed. The target may have reverted. */ error FailedCall(); /** * @dev The deployment failed. */ error FailedDeployment(); /** * @dev A necessary precompile is missing. */ error MissingPrecompile(address); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/IERC165.sol) pragma solidity ^0.8.20; /** * @dev Interface of the ERC-165 standard, as defined in the * https://eips.ethereum.org/EIPS/eip-165[ERC]. * * Implementers can declare support of contract interfaces, which can then be * queried by others ({ERC165Checker}). * * For an implementation, see {ERC165}. */ interface IERC165 { /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section] * to learn more about how these ids are created. * * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.1.0) (utils/math/Math.sol) pragma solidity ^0.8.20; import {Panic} from "../Panic.sol"; import {SafeCast} from "./SafeCast.sol"; /** * @dev Standard math utilities missing in the Solidity language. */ library Math { enum Rounding { 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 success flag (no overflow). */ function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) { unchecked { uint256 c = a + b; if (c < a) return (false, 0); return (true, c); } } /** * @dev Returns the subtraction of two unsigned integers, with an success flag (no overflow). */ function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) { unchecked { if (b > a) return (false, 0); return (true, a - b); } } /** * @dev Returns the multiplication of two unsigned integers, with an success flag (no overflow). */ function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) { 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/522 if (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 success flag (no division by zero). */ function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) { unchecked { if (b == 0) return (false, 0); return (true, a / b); } } /** * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero). */ function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) { unchecked { if (b == 0) return (false, 0); return (true, a % b); } } /** * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant. * * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone. * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute * one branch when needed, making this function more expensive. */ function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) { unchecked { // branchless ternary works because: // b ^ (a ^ b) == a // b ^ 0 == b return b ^ ((a ^ b) * SafeCast.toUint(condition)); } } /** * @dev Returns the largest of two numbers. */ function max(uint256 a, uint256 b) internal pure returns (uint256) { return ternary(a > b, a, b); } /** * @dev Returns the smallest of two numbers. */ function min(uint256 a, uint256 b) internal pure returns (uint256) { return ternary(a < b, a, b); } /** * @dev Returns the average of two numbers. The result is rounded towards * zero. */ function average(uint256 a, uint256 b) internal pure returns (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. */ function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) { if (b == 0) { // Guarantee the same behavior as in a regular Solidity division. Panic.panic(Panic.DIVISION_BY_ZERO); } // The following calculation ensures accurate ceiling division without overflow. // Since a is non-zero, (a - 1) / b will not overflow. // The largest possible result occurs when (a - 1) / b is type(uint256).max, // but the largest value we can obtain is type(uint256).max - 1, which happens // when a = type(uint256).max and b = 1. unchecked { return SafeCast.toUint(a > 0) * ((a - 1) / b + 1); } } /** * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or * denominator == 0. * * 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. */ function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) { unchecked { // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2²⁵⁶ and mod 2²⁵⁶ - 1, then use // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256 // variables such that product = prod1 * 2²⁵⁶ + prod0. uint256 prod0 = x * y; // Least significant 256 bits of the product uint256 prod1; // Most significant 256 bits of the product assembly { 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²⁵⁶. Also prevents denominator == 0. if (denominator <= prod1) { Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW)); } /////////////////////////////////////////////// // 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²⁵⁶ / 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²⁵⁶. Now that denominator is an odd number, it has an inverse modulo 2²⁵⁶ such // that denominator * inv ≡ 1 mod 2²⁵⁶. Compute the inverse by starting with a seed that is correct for // four bits. That is, denominator * inv ≡ 1 mod 2⁴. 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⁸ inverse *= 2 - denominator * inverse; // inverse mod 2¹⁶ inverse *= 2 - denominator * inverse; // inverse mod 2³² inverse *= 2 - denominator * inverse; // inverse mod 2⁶⁴ inverse *= 2 - denominator * inverse; // inverse mod 2¹²⁸ inverse *= 2 - denominator * inverse; // inverse mod 2²⁵⁶ // 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²⁵⁶. Since the preconditions guarantee that the outcome is // less than 2²⁵⁶, 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; } } /** * @dev Calculates x * y / denominator with full precision, following the selected rounding direction. */ function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) { return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0); } /** * @dev Calculate the modular multiplicative inverse of a number in Z/nZ. * * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0. * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible. * * If the input value is not inversible, 0 is returned. * * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}. */ function invMod(uint256 a, uint256 n) internal pure returns (uint256) { unchecked { if (n == 0) return 0; // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version) // Used to compute integers x and y such that: ax + ny = gcd(a, n). // When the gcd is 1, then the inverse of a modulo n exists and it's x. // ax + ny = 1 // ax = 1 + (-y)n // ax ≡ 1 (mod n) # x is the inverse of a modulo n // If the remainder is 0 the gcd is n right away. uint256 remainder = a % n; uint256 gcd = n; // Therefore the initial coefficients are: // ax + ny = gcd(a, n) = n // 0a + 1n = n int256 x = 0; int256 y = 1; while (remainder != 0) { uint256 quotient = gcd / remainder; (gcd, remainder) = ( // The old remainder is the next gcd to try. remainder, // Compute the next remainder. // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd // where gcd is at most n (capped to type(uint256).max) gcd - remainder * quotient ); (x, y) = ( // Increment the coefficient of a. y, // Decrement the coefficient of n. // Can overflow, but the result is casted to uint256 so that the // next value of y is "wrapped around" to a value between 0 and n - 1. x - y * int256(quotient) ); } if (gcd != 1) return 0; // No inverse exists. return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative. } } /** * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`. * * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is * prime, then `a**(p-1) ≡ 1 mod p`. As a consequence, we have `a * a**(p-2) ≡ 1 mod p`, which means that * `a**(p-2)` is the modular multiplicative inverse of a in Fp. * * NOTE: this function does NOT check that `p` is a prime greater than `2`. */ function invModPrime(uint256 a, uint256 p) internal view returns (uint256) { unchecked { return Math.modExp(a, p - 2, p); } } /** * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m) * * Requirements: * - modulus can't be zero * - underlying staticcall to precompile must succeed * * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make * sure the chain you're using it on supports the precompiled contract for modular exponentiation * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, * the underlying function will succeed given the lack of a revert, but the result may be incorrectly * interpreted as 0. */ function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) { (bool success, uint256 result) = tryModExp(b, e, m); if (!success) { Panic.panic(Panic.DIVISION_BY_ZERO); } return result; } /** * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m). * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying * to operate modulo 0 or if the underlying precompile reverted. * * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack * of a revert, but the result may be incorrectly interpreted as 0. */ function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) { if (m == 0) return (false, 0); assembly ("memory-safe") { let ptr := mload(0x40) // | Offset | Content | Content (Hex) | // |-----------|------------|--------------------------------------------------------------------| // | 0x00:0x1f | size of b | 0x0000000000000000000000000000000000000000000000000000000000000020 | // | 0x20:0x3f | size of e | 0x0000000000000000000000000000000000000000000000000000000000000020 | // | 0x40:0x5f | size of m | 0x0000000000000000000000000000000000000000000000000000000000000020 | // | 0x60:0x7f | value of b | 0x<.............................................................b> | // | 0x80:0x9f | value of e | 0x<.............................................................e> | // | 0xa0:0xbf | value of m | 0x<.............................................................m> | mstore(ptr, 0x20) mstore(add(ptr, 0x20), 0x20) mstore(add(ptr, 0x40), 0x20) mstore(add(ptr, 0x60), b) mstore(add(ptr, 0x80), e) mstore(add(ptr, 0xa0), m) // Given the result < m, it's guaranteed to fit in 32 bytes, // so we can use the memory scratch space located at offset 0. success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20) result := mload(0x00) } } /** * @dev Variant of {modExp} that supports inputs of arbitrary length. */ function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) { (bool success, bytes memory result) = tryModExp(b, e, m); if (!success) { Panic.panic(Panic.DIVISION_BY_ZERO); } return result; } /** * @dev Variant of {tryModExp} that supports inputs of arbitrary length. */ function tryModExp( bytes memory b, bytes memory e, bytes memory m ) internal view returns (bool success, bytes memory result) { if (_zeroBytes(m)) return (false, new bytes(0)); uint256 mLen = m.length; // Encode call args in result and move the free memory pointer result = abi.encodePacked(b.length, e.length, mLen, b, e, m); assembly ("memory-safe") { let dataPtr := add(result, 0x20) // Write result on top of args to avoid allocating extra memory. success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen) // Overwrite the length. // result.length > returndatasize() is guaranteed because returndatasize() == m.length mstore(result, mLen) // Set the memory pointer after the returned data. mstore(0x40, add(dataPtr, mLen)) } } /** * @dev Returns whether the provided byte array is zero. */ function _zeroBytes(bytes memory byteArray) private pure returns (bool) { for (uint256 i = 0; i < byteArray.length; ++i) { if (byteArray[i] != 0) { return false; } } return true; } /** * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded * towards zero. * * This method is based on Newton's method for computing square roots; the algorithm is restricted to only * using integer operations. */ function sqrt(uint256 a) internal pure returns (uint256) { unchecked { // Take care of easy edge cases when a == 0 or a == 1 if (a <= 1) { return a; } // In this function, we use Newton's method to get a root of `f(x) := x² - a`. It involves building a // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between // the current value as `ε_n = | x_n - sqrt(a) |`. // // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root // of the target. (i.e. `2**(e-1) ≤ sqrt(a) < 2**e`). We know that `e ≤ 128` because `(2¹²⁸)² = 2²⁵⁶` is // bigger than any uint256. // // By noticing that // `2**(e-1) ≤ sqrt(a) < 2**e → (2**(e-1))² ≤ a < (2**e)² → 2**(2*e-2) ≤ a < 2**(2*e)` // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar // to the msb function. uint256 aa = a; uint256 xn = 1; if (aa >= (1 << 128)) { aa >>= 128; xn <<= 64; } if (aa >= (1 << 64)) { aa >>= 64; xn <<= 32; } if (aa >= (1 << 32)) { aa >>= 32; xn <<= 16; } if (aa >= (1 << 16)) { aa >>= 16; xn <<= 8; } if (aa >= (1 << 8)) { aa >>= 8; xn <<= 4; } if (aa >= (1 << 4)) { aa >>= 4; xn <<= 2; } if (aa >= (1 << 2)) { xn <<= 1; } // We now have x_n such that `x_n = 2**(e-1) ≤ sqrt(a) < 2**e = 2 * x_n`. This implies ε_n ≤ 2**(e-1). // // We can refine our estimation by noticing that the middle of that interval minimizes the error. // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to ε_n ≤ 2**(e-2). // This is going to be our x_0 (and ε_0) xn = (3 * xn) >> 1; // ε_0 := | x_0 - sqrt(a) | ≤ 2**(e-2) // From here, Newton's method give us: // x_{n+1} = (x_n + a / x_n) / 2 // // One should note that: // x_{n+1}² - a = ((x_n + a / x_n) / 2)² - a // = ((x_n² + a) / (2 * x_n))² - a // = (x_n⁴ + 2 * a * x_n² + a²) / (4 * x_n²) - a // = (x_n⁴ + 2 * a * x_n² + a² - 4 * a * x_n²) / (4 * x_n²) // = (x_n⁴ - 2 * a * x_n² + a²) / (4 * x_n²) // = (x_n² - a)² / (2 * x_n)² // = ((x_n² - a) / (2 * x_n))² // ≥ 0 // Which proves that for all n ≥ 1, sqrt(a) ≤ x_n // // This gives us the proof of quadratic convergence of the sequence: // ε_{n+1} = | x_{n+1} - sqrt(a) | // = | (x_n + a / x_n) / 2 - sqrt(a) | // = | (x_n² + a - 2*x_n*sqrt(a)) / (2 * x_n) | // = | (x_n - sqrt(a))² / (2 * x_n) | // = | ε_n² / (2 * x_n) | // = ε_n² / | (2 * x_n) | // // For the first iteration, we have a special case where x_0 is known: // ε_1 = ε_0² / | (2 * x_0) | // ≤ (2**(e-2))² / (2 * (2**(e-1) + 2**(e-2))) // ≤ 2**(2*e-4) / (3 * 2**(e-1)) // ≤ 2**(e-3) / 3 // ≤ 2**(e-3-log2(3)) // ≤ 2**(e-4.5) // // For the following iterations, we use the fact that, 2**(e-1) ≤ sqrt(a) ≤ x_n: // ε_{n+1} = ε_n² / | (2 * x_n) | // ≤ (2**(e-k))² / (2 * 2**(e-1)) // ≤ 2**(2*e-2*k) / 2**e // ≤ 2**(e-2*k) xn = (xn + a / xn) >> 1; // ε_1 := | x_1 - sqrt(a) | ≤ 2**(e-4.5) -- special case, see above xn = (xn + a / xn) >> 1; // ε_2 := | x_2 - sqrt(a) | ≤ 2**(e-9) -- general case with k = 4.5 xn = (xn + a / xn) >> 1; // ε_3 := | x_3 - sqrt(a) | ≤ 2**(e-18) -- general case with k = 9 xn = (xn + a / xn) >> 1; // ε_4 := | x_4 - sqrt(a) | ≤ 2**(e-36) -- general case with k = 18 xn = (xn + a / xn) >> 1; // ε_5 := | x_5 - sqrt(a) | ≤ 2**(e-72) -- general case with k = 36 xn = (xn + a / xn) >> 1; // ε_6 := | x_6 - sqrt(a) | ≤ 2**(e-144) -- general case with k = 72 // Because e ≤ 128 (as discussed during the first estimation phase), we know have reached a precision // ε_6 ≤ 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either // sqrt(a) or sqrt(a) + 1. return xn - SafeCast.toUint(xn > a / xn); } } /** * @dev Calculates sqrt(a), following the selected rounding direction. */ function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = sqrt(a); return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a); } } /** * @dev Return the log in base 2 of a positive value rounded towards zero. * Returns 0 if given 0. */ function log2(uint256 value) internal pure returns (uint256) { uint256 result = 0; uint256 exp; unchecked { exp = 128 * SafeCast.toUint(value > (1 << 128) - 1); value >>= exp; result += exp; exp = 64 * SafeCast.toUint(value > (1 << 64) - 1); value >>= exp; result += exp; exp = 32 * SafeCast.toUint(value > (1 << 32) - 1); value >>= exp; result += exp; exp = 16 * SafeCast.toUint(value > (1 << 16) - 1); value >>= exp; result += exp; exp = 8 * SafeCast.toUint(value > (1 << 8) - 1); value >>= exp; result += exp; exp = 4 * SafeCast.toUint(value > (1 << 4) - 1); value >>= exp; result += exp; exp = 2 * SafeCast.toUint(value > (1 << 2) - 1); value >>= exp; result += exp; result += SafeCast.toUint(value > 1); } return result; } /** * @dev Return the log in base 2, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log2(value); return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value); } } /** * @dev Return the log in base 10 of a positive value rounded towards zero. * Returns 0 if given 0. */ function log10(uint256 value) internal pure returns (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. */ function log10(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log10(value); return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value); } } /** * @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. */ function log256(uint256 value) internal pure returns (uint256) { uint256 result = 0; uint256 isGt; unchecked { isGt = SafeCast.toUint(value > (1 << 128) - 1); value >>= isGt * 128; result += isGt * 16; isGt = SafeCast.toUint(value > (1 << 64) - 1); value >>= isGt * 64; result += isGt * 8; isGt = SafeCast.toUint(value > (1 << 32) - 1); value >>= isGt * 32; result += isGt * 4; isGt = SafeCast.toUint(value > (1 << 16) - 1); value >>= isGt * 16; result += isGt * 2; result += SafeCast.toUint(value > (1 << 8) - 1); } return result; } /** * @dev Return the log in base 256, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log256(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log256(value); return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value); } } /** * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers. */ function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) { return uint8(rounding) % 2 == 1; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol) // This file was procedurally generated from scripts/generate/templates/SafeCast.js. pragma solidity ^0.8.20; /** * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow * checks. * * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can * easily result in undesired exploitation or bugs, since developers usually * assume that overflows raise errors. `SafeCast` restores this intuition by * reverting the transaction when such an operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. */ library SafeCast { /** * @dev Value doesn't fit in an uint of `bits` size. */ error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value); /** * @dev An int value doesn't fit in an uint of `bits` size. */ error SafeCastOverflowedIntToUint(int256 value); /** * @dev Value doesn't fit in an int of `bits` size. */ error SafeCastOverflowedIntDowncast(uint8 bits, int256 value); /** * @dev An uint value doesn't fit in an int of `bits` size. */ error SafeCastOverflowedUintToInt(uint256 value); /** * @dev Returns the downcasted uint248 from uint256, reverting on * overflow (when the input is greater than largest uint248). * * Counterpart to Solidity's `uint248` operator. * * Requirements: * * - input must fit into 248 bits */ function toUint248(uint256 value) internal pure returns (uint248) { if (value > type(uint248).max) { revert SafeCastOverflowedUintDowncast(248, value); } return uint248(value); } /** * @dev Returns the downcasted uint240 from uint256, reverting on * overflow (when the input is greater than largest uint240). * * Counterpart to Solidity's `uint240` operator. * * Requirements: * * - input must fit into 240 bits */ function toUint240(uint256 value) internal pure returns (uint240) { if (value > type(uint240).max) { revert SafeCastOverflowedUintDowncast(240, value); } return uint240(value); } /** * @dev Returns the downcasted uint232 from uint256, reverting on * overflow (when the input is greater than largest uint232). * * Counterpart to Solidity's `uint232` operator. * * Requirements: * * - input must fit into 232 bits */ function toUint232(uint256 value) internal pure returns (uint232) { if (value > type(uint232).max) { revert SafeCastOverflowedUintDowncast(232, value); } return uint232(value); } /** * @dev Returns the downcasted uint224 from uint256, reverting on * overflow (when the input is greater than largest uint224). * * Counterpart to Solidity's `uint224` operator. * * Requirements: * * - input must fit into 224 bits */ function toUint224(uint256 value) internal pure returns (uint224) { if (value > type(uint224).max) { revert SafeCastOverflowedUintDowncast(224, value); } return uint224(value); } /** * @dev Returns the downcasted uint216 from uint256, reverting on * overflow (when the input is greater than largest uint216). * * Counterpart to Solidity's `uint216` operator. * * Requirements: * * - input must fit into 216 bits */ function toUint216(uint256 value) internal pure returns (uint216) { if (value > type(uint216).max) { revert SafeCastOverflowedUintDowncast(216, value); } return uint216(value); } /** * @dev Returns the downcasted uint208 from uint256, reverting on * overflow (when the input is greater than largest uint208). * * Counterpart to Solidity's `uint208` operator. * * Requirements: * * - input must fit into 208 bits */ function toUint208(uint256 value) internal pure returns (uint208) { if (value > type(uint208).max) { revert SafeCastOverflowedUintDowncast(208, value); } return uint208(value); } /** * @dev Returns the downcasted uint200 from uint256, reverting on * overflow (when the input is greater than largest uint200). * * Counterpart to Solidity's `uint200` operator. * * Requirements: * * - input must fit into 200 bits */ function toUint200(uint256 value) internal pure returns (uint200) { if (value > type(uint200).max) { revert SafeCastOverflowedUintDowncast(200, value); } return uint200(value); } /** * @dev Returns the downcasted uint192 from uint256, reverting on * overflow (when the input is greater than largest uint192). * * Counterpart to Solidity's `uint192` operator. * * Requirements: * * - input must fit into 192 bits */ function toUint192(uint256 value) internal pure returns (uint192) { if (value > type(uint192).max) { revert SafeCastOverflowedUintDowncast(192, value); } return uint192(value); } /** * @dev Returns the downcasted uint184 from uint256, reverting on * overflow (when the input is greater than largest uint184). * * Counterpart to Solidity's `uint184` operator. * * Requirements: * * - input must fit into 184 bits */ function toUint184(uint256 value) internal pure returns (uint184) { if (value > type(uint184).max) { revert SafeCastOverflowedUintDowncast(184, value); } return uint184(value); } /** * @dev Returns the downcasted uint176 from uint256, reverting on * overflow (when the input is greater than largest uint176). * * Counterpart to Solidity's `uint176` operator. * * Requirements: * * - input must fit into 176 bits */ function toUint176(uint256 value) internal pure returns (uint176) { if (value > type(uint176).max) { revert SafeCastOverflowedUintDowncast(176, value); } return uint176(value); } /** * @dev Returns the downcasted uint168 from uint256, reverting on * overflow (when the input is greater than largest uint168). * * Counterpart to Solidity's `uint168` operator. * * Requirements: * * - input must fit into 168 bits */ function toUint168(uint256 value) internal pure returns (uint168) { if (value > type(uint168).max) { revert SafeCastOverflowedUintDowncast(168, value); } return uint168(value); } /** * @dev Returns the downcasted uint160 from uint256, reverting on * overflow (when the input is greater than largest uint160). * * Counterpart to Solidity's `uint160` operator. * * Requirements: * * - input must fit into 160 bits */ function toUint160(uint256 value) internal pure returns (uint160) { if (value > type(uint160).max) { revert SafeCastOverflowedUintDowncast(160, value); } return uint160(value); } /** * @dev Returns the downcasted uint152 from uint256, reverting on * overflow (when the input is greater than largest uint152). * * Counterpart to Solidity's `uint152` operator. * * Requirements: * * - input must fit into 152 bits */ function toUint152(uint256 value) internal pure returns (uint152) { if (value > type(uint152).max) { revert SafeCastOverflowedUintDowncast(152, value); } return uint152(value); } /** * @dev Returns the downcasted uint144 from uint256, reverting on * overflow (when the input is greater than largest uint144). * * Counterpart to Solidity's `uint144` operator. * * Requirements: * * - input must fit into 144 bits */ function toUint144(uint256 value) internal pure returns (uint144) { if (value > type(uint144).max) { revert SafeCastOverflowedUintDowncast(144, value); } return uint144(value); } /** * @dev Returns the downcasted uint136 from uint256, reverting on * overflow (when the input is greater than largest uint136). * * Counterpart to Solidity's `uint136` operator. * * Requirements: * * - input must fit into 136 bits */ function toUint136(uint256 value) internal pure returns (uint136) { if (value > type(uint136).max) { revert SafeCastOverflowedUintDowncast(136, value); } return uint136(value); } /** * @dev Returns the downcasted uint128 from uint256, reverting on * overflow (when the input is greater than largest uint128). * * Counterpart to Solidity's `uint128` operator. * * Requirements: * * - input must fit into 128 bits */ function toUint128(uint256 value) internal pure returns (uint128) { if (value > type(uint128).max) { revert SafeCastOverflowedUintDowncast(128, value); } return uint128(value); } /** * @dev Returns the downcasted uint120 from uint256, reverting on * overflow (when the input is greater than largest uint120). * * Counterpart to Solidity's `uint120` operator. * * Requirements: * * - input must fit into 120 bits */ function toUint120(uint256 value) internal pure returns (uint120) { if (value > type(uint120).max) { revert SafeCastOverflowedUintDowncast(120, value); } return uint120(value); } /** * @dev Returns the downcasted uint112 from uint256, reverting on * overflow (when the input is greater than largest uint112). * * Counterpart to Solidity's `uint112` operator. * * Requirements: * * - input must fit into 112 bits */ function toUint112(uint256 value) internal pure returns (uint112) { if (value > type(uint112).max) { revert SafeCastOverflowedUintDowncast(112, value); } return uint112(value); } /** * @dev Returns the downcasted uint104 from uint256, reverting on * overflow (when the input is greater than largest uint104). * * Counterpart to Solidity's `uint104` operator. * * Requirements: * * - input must fit into 104 bits */ function toUint104(uint256 value) internal pure returns (uint104) { if (value > type(uint104).max) { revert SafeCastOverflowedUintDowncast(104, value); } return uint104(value); } /** * @dev Returns the downcasted uint96 from uint256, reverting on * overflow (when the input is greater than largest uint96). * * Counterpart to Solidity's `uint96` operator. * * Requirements: * * - input must fit into 96 bits */ function toUint96(uint256 value) internal pure returns (uint96) { if (value > type(uint96).max) { revert SafeCastOverflowedUintDowncast(96, value); } return uint96(value); } /** * @dev Returns the downcasted uint88 from uint256, reverting on * overflow (when the input is greater than largest uint88). * * Counterpart to Solidity's `uint88` operator. * * Requirements: * * - input must fit into 88 bits */ function toUint88(uint256 value) internal pure returns (uint88) { if (value > type(uint88).max) { revert SafeCastOverflowedUintDowncast(88, value); } return uint88(value); } /** * @dev Returns the downcasted uint80 from uint256, reverting on * overflow (when the input is greater than largest uint80). * * Counterpart to Solidity's `uint80` operator. * * Requirements: * * - input must fit into 80 bits */ function toUint80(uint256 value) internal pure returns (uint80) { if (value > type(uint80).max) { revert SafeCastOverflowedUintDowncast(80, value); } return uint80(value); } /** * @dev Returns the downcasted uint72 from uint256, reverting on * overflow (when the input is greater than largest uint72). * * Counterpart to Solidity's `uint72` operator. * * Requirements: * * - input must fit into 72 bits */ function toUint72(uint256 value) internal pure returns (uint72) { if (value > type(uint72).max) { revert SafeCastOverflowedUintDowncast(72, value); } return uint72(value); } /** * @dev Returns the downcasted uint64 from uint256, reverting on * overflow (when the input is greater than largest uint64). * * Counterpart to Solidity's `uint64` operator. * * Requirements: * * - input must fit into 64 bits */ function toUint64(uint256 value) internal pure returns (uint64) { if (value > type(uint64).max) { revert SafeCastOverflowedUintDowncast(64, value); } return uint64(value); } /** * @dev Returns the downcasted uint56 from uint256, reverting on * overflow (when the input is greater than largest uint56). * * Counterpart to Solidity's `uint56` operator. * * Requirements: * * - input must fit into 56 bits */ function toUint56(uint256 value) internal pure returns (uint56) { if (value > type(uint56).max) { revert SafeCastOverflowedUintDowncast(56, value); } return uint56(value); } /** * @dev Returns the downcasted uint48 from uint256, reverting on * overflow (when the input is greater than largest uint48). * * Counterpart to Solidity's `uint48` operator. * * Requirements: * * - input must fit into 48 bits */ function toUint48(uint256 value) internal pure returns (uint48) { if (value > type(uint48).max) { revert SafeCastOverflowedUintDowncast(48, value); } return uint48(value); } /** * @dev Returns the downcasted uint40 from uint256, reverting on * overflow (when the input is greater than largest uint40). * * Counterpart to Solidity's `uint40` operator. * * Requirements: * * - input must fit into 40 bits */ function toUint40(uint256 value) internal pure returns (uint40) { if (value > type(uint40).max) { revert SafeCastOverflowedUintDowncast(40, value); } return uint40(value); } /** * @dev Returns the downcasted uint32 from uint256, reverting on * overflow (when the input is greater than largest uint32). * * Counterpart to Solidity's `uint32` operator. * * Requirements: * * - input must fit into 32 bits */ function toUint32(uint256 value) internal pure returns (uint32) { if (value > type(uint32).max) { revert SafeCastOverflowedUintDowncast(32, value); } return uint32(value); } /** * @dev Returns the downcasted uint24 from uint256, reverting on * overflow (when the input is greater than largest uint24). * * Counterpart to Solidity's `uint24` operator. * * Requirements: * * - input must fit into 24 bits */ function toUint24(uint256 value) internal pure returns (uint24) { if (value > type(uint24).max) { revert SafeCastOverflowedUintDowncast(24, value); } return uint24(value); } /** * @dev Returns the downcasted uint16 from uint256, reverting on * overflow (when the input is greater than largest uint16). * * Counterpart to Solidity's `uint16` operator. * * Requirements: * * - input must fit into 16 bits */ function toUint16(uint256 value) internal pure returns (uint16) { if (value > type(uint16).max) { revert SafeCastOverflowedUintDowncast(16, value); } return uint16(value); } /** * @dev Returns the downcasted uint8 from uint256, reverting on * overflow (when the input is greater than largest uint8). * * Counterpart to Solidity's `uint8` operator. * * Requirements: * * - input must fit into 8 bits */ function toUint8(uint256 value) internal pure returns (uint8) { if (value > type(uint8).max) { revert SafeCastOverflowedUintDowncast(8, value); } return uint8(value); } /** * @dev Converts a signed int256 into an unsigned uint256. * * Requirements: * * - input must be greater than or equal to 0. */ function toUint256(int256 value) internal pure returns (uint256) { if (value < 0) { revert SafeCastOverflowedIntToUint(value); } return uint256(value); } /** * @dev Returns the downcasted int248 from int256, reverting on * overflow (when the input is less than smallest int248 or * greater than largest int248). * * Counterpart to Solidity's `int248` operator. * * Requirements: * * - input must fit into 248 bits */ function toInt248(int256 value) internal pure returns (int248 downcasted) { downcasted = int248(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(248, value); } } /** * @dev Returns the downcasted int240 from int256, reverting on * overflow (when the input is less than smallest int240 or * greater than largest int240). * * Counterpart to Solidity's `int240` operator. * * Requirements: * * - input must fit into 240 bits */ function toInt240(int256 value) internal pure returns (int240 downcasted) { downcasted = int240(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(240, value); } } /** * @dev Returns the downcasted int232 from int256, reverting on * overflow (when the input is less than smallest int232 or * greater than largest int232). * * Counterpart to Solidity's `int232` operator. * * Requirements: * * - input must fit into 232 bits */ function toInt232(int256 value) internal pure returns (int232 downcasted) { downcasted = int232(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(232, value); } } /** * @dev Returns the downcasted int224 from int256, reverting on * overflow (when the input is less than smallest int224 or * greater than largest int224). * * Counterpart to Solidity's `int224` operator. * * Requirements: * * - input must fit into 224 bits */ function toInt224(int256 value) internal pure returns (int224 downcasted) { downcasted = int224(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(224, value); } } /** * @dev Returns the downcasted int216 from int256, reverting on * overflow (when the input is less than smallest int216 or * greater than largest int216). * * Counterpart to Solidity's `int216` operator. * * Requirements: * * - input must fit into 216 bits */ function toInt216(int256 value) internal pure returns (int216 downcasted) { downcasted = int216(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(216, value); } } /** * @dev Returns the downcasted int208 from int256, reverting on * overflow (when the input is less than smallest int208 or * greater than largest int208). * * Counterpart to Solidity's `int208` operator. * * Requirements: * * - input must fit into 208 bits */ function toInt208(int256 value) internal pure returns (int208 downcasted) { downcasted = int208(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(208, value); } } /** * @dev Returns the downcasted int200 from int256, reverting on * overflow (when the input is less than smallest int200 or * greater than largest int200). * * Counterpart to Solidity's `int200` operator. * * Requirements: * * - input must fit into 200 bits */ function toInt200(int256 value) internal pure returns (int200 downcasted) { downcasted = int200(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(200, value); } } /** * @dev Returns the downcasted int192 from int256, reverting on * overflow (when the input is less than smallest int192 or * greater than largest int192). * * Counterpart to Solidity's `int192` operator. * * Requirements: * * - input must fit into 192 bits */ function toInt192(int256 value) internal pure returns (int192 downcasted) { downcasted = int192(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(192, value); } } /** * @dev Returns the downcasted int184 from int256, reverting on * overflow (when the input is less than smallest int184 or * greater than largest int184). * * Counterpart to Solidity's `int184` operator. * * Requirements: * * - input must fit into 184 bits */ function toInt184(int256 value) internal pure returns (int184 downcasted) { downcasted = int184(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(184, value); } } /** * @dev Returns the downcasted int176 from int256, reverting on * overflow (when the input is less than smallest int176 or * greater than largest int176). * * Counterpart to Solidity's `int176` operator. * * Requirements: * * - input must fit into 176 bits */ function toInt176(int256 value) internal pure returns (int176 downcasted) { downcasted = int176(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(176, value); } } /** * @dev Returns the downcasted int168 from int256, reverting on * overflow (when the input is less than smallest int168 or * greater than largest int168). * * Counterpart to Solidity's `int168` operator. * * Requirements: * * - input must fit into 168 bits */ function toInt168(int256 value) internal pure returns (int168 downcasted) { downcasted = int168(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(168, value); } } /** * @dev Returns the downcasted int160 from int256, reverting on * overflow (when the input is less than smallest int160 or * greater than largest int160). * * Counterpart to Solidity's `int160` operator. * * Requirements: * * - input must fit into 160 bits */ function toInt160(int256 value) internal pure returns (int160 downcasted) { downcasted = int160(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(160, value); } } /** * @dev Returns the downcasted int152 from int256, reverting on * overflow (when the input is less than smallest int152 or * greater than largest int152). * * Counterpart to Solidity's `int152` operator. * * Requirements: * * - input must fit into 152 bits */ function toInt152(int256 value) internal pure returns (int152 downcasted) { downcasted = int152(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(152, value); } } /** * @dev Returns the downcasted int144 from int256, reverting on * overflow (when the input is less than smallest int144 or * greater than largest int144). * * Counterpart to Solidity's `int144` operator. * * Requirements: * * - input must fit into 144 bits */ function toInt144(int256 value) internal pure returns (int144 downcasted) { downcasted = int144(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(144, value); } } /** * @dev Returns the downcasted int136 from int256, reverting on * overflow (when the input is less than smallest int136 or * greater than largest int136). * * Counterpart to Solidity's `int136` operator. * * Requirements: * * - input must fit into 136 bits */ function toInt136(int256 value) internal pure returns (int136 downcasted) { downcasted = int136(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(136, value); } } /** * @dev Returns the downcasted int128 from int256, reverting on * overflow (when the input is less than smallest int128 or * greater than largest int128). * * Counterpart to Solidity's `int128` operator. * * Requirements: * * - input must fit into 128 bits */ function toInt128(int256 value) internal pure returns (int128 downcasted) { downcasted = int128(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(128, value); } } /** * @dev Returns the downcasted int120 from int256, reverting on * overflow (when the input is less than smallest int120 or * greater than largest int120). * * Counterpart to Solidity's `int120` operator. * * Requirements: * * - input must fit into 120 bits */ function toInt120(int256 value) internal pure returns (int120 downcasted) { downcasted = int120(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(120, value); } } /** * @dev Returns the downcasted int112 from int256, reverting on * overflow (when the input is less than smallest int112 or * greater than largest int112). * * Counterpart to Solidity's `int112` operator. * * Requirements: * * - input must fit into 112 bits */ function toInt112(int256 value) internal pure returns (int112 downcasted) { downcasted = int112(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(112, value); } } /** * @dev Returns the downcasted int104 from int256, reverting on * overflow (when the input is less than smallest int104 or * greater than largest int104). * * Counterpart to Solidity's `int104` operator. * * Requirements: * * - input must fit into 104 bits */ function toInt104(int256 value) internal pure returns (int104 downcasted) { downcasted = int104(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(104, value); } } /** * @dev Returns the downcasted int96 from int256, reverting on * overflow (when the input is less than smallest int96 or * greater than largest int96). * * Counterpart to Solidity's `int96` operator. * * Requirements: * * - input must fit into 96 bits */ function toInt96(int256 value) internal pure returns (int96 downcasted) { downcasted = int96(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(96, value); } } /** * @dev Returns the downcasted int88 from int256, reverting on * overflow (when the input is less than smallest int88 or * greater than largest int88). * * Counterpart to Solidity's `int88` operator. * * Requirements: * * - input must fit into 88 bits */ function toInt88(int256 value) internal pure returns (int88 downcasted) { downcasted = int88(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(88, value); } } /** * @dev Returns the downcasted int80 from int256, reverting on * overflow (when the input is less than smallest int80 or * greater than largest int80). * * Counterpart to Solidity's `int80` operator. * * Requirements: * * - input must fit into 80 bits */ function toInt80(int256 value) internal pure returns (int80 downcasted) { downcasted = int80(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(80, value); } } /** * @dev Returns the downcasted int72 from int256, reverting on * overflow (when the input is less than smallest int72 or * greater than largest int72). * * Counterpart to Solidity's `int72` operator. * * Requirements: * * - input must fit into 72 bits */ function toInt72(int256 value) internal pure returns (int72 downcasted) { downcasted = int72(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(72, value); } } /** * @dev Returns the downcasted int64 from int256, reverting on * overflow (when the input is less than smallest int64 or * greater than largest int64). * * Counterpart to Solidity's `int64` operator. * * Requirements: * * - input must fit into 64 bits */ function toInt64(int256 value) internal pure returns (int64 downcasted) { downcasted = int64(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(64, value); } } /** * @dev Returns the downcasted int56 from int256, reverting on * overflow (when the input is less than smallest int56 or * greater than largest int56). * * Counterpart to Solidity's `int56` operator. * * Requirements: * * - input must fit into 56 bits */ function toInt56(int256 value) internal pure returns (int56 downcasted) { downcasted = int56(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(56, value); } } /** * @dev Returns the downcasted int48 from int256, reverting on * overflow (when the input is less than smallest int48 or * greater than largest int48). * * Counterpart to Solidity's `int48` operator. * * Requirements: * * - input must fit into 48 bits */ function toInt48(int256 value) internal pure returns (int48 downcasted) { downcasted = int48(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(48, value); } } /** * @dev Returns the downcasted int40 from int256, reverting on * overflow (when the input is less than smallest int40 or * greater than largest int40). * * Counterpart to Solidity's `int40` operator. * * Requirements: * * - input must fit into 40 bits */ function toInt40(int256 value) internal pure returns (int40 downcasted) { downcasted = int40(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(40, value); } } /** * @dev Returns the downcasted int32 from int256, reverting on * overflow (when the input is less than smallest int32 or * greater than largest int32). * * Counterpart to Solidity's `int32` operator. * * Requirements: * * - input must fit into 32 bits */ function toInt32(int256 value) internal pure returns (int32 downcasted) { downcasted = int32(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(32, value); } } /** * @dev Returns the downcasted int24 from int256, reverting on * overflow (when the input is less than smallest int24 or * greater than largest int24). * * Counterpart to Solidity's `int24` operator. * * Requirements: * * - input must fit into 24 bits */ function toInt24(int256 value) internal pure returns (int24 downcasted) { downcasted = int24(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(24, value); } } /** * @dev Returns the downcasted int16 from int256, reverting on * overflow (when the input is less than smallest int16 or * greater than largest int16). * * Counterpart to Solidity's `int16` operator. * * Requirements: * * - input must fit into 16 bits */ function toInt16(int256 value) internal pure returns (int16 downcasted) { downcasted = int16(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(16, value); } } /** * @dev Returns the downcasted int8 from int256, reverting on * overflow (when the input is less than smallest int8 or * greater than largest int8). * * Counterpart to Solidity's `int8` operator. * * Requirements: * * - input must fit into 8 bits */ function toInt8(int256 value) internal pure returns (int8 downcasted) { downcasted = int8(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(8, value); } } /** * @dev Converts an unsigned uint256 into a signed int256. * * Requirements: * * - input must be less than or equal to maxInt256. */ function toInt256(uint256 value) internal pure returns (int256) { // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive if (value > uint256(type(int256).max)) { revert SafeCastOverflowedUintToInt(value); } return int256(value); } /** * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump. */ function toUint(bool b) internal pure returns (uint256 u) { assembly ("memory-safe") { u := iszero(iszero(b)) } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SignedMath.sol) pragma solidity ^0.8.20; import {SafeCast} from "./SafeCast.sol"; /** * @dev Standard signed math utilities missing in the Solidity language. */ library SignedMath { /** * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant. * * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone. * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute * one branch when needed, making this function more expensive. */ function ternary(bool condition, int256 a, int256 b) internal pure returns (int256) { unchecked { // branchless ternary works because: // b ^ (a ^ b) == a // b ^ 0 == b return b ^ ((a ^ b) * int256(SafeCast.toUint(condition))); } } /** * @dev Returns the largest of two signed numbers. */ function max(int256 a, int256 b) internal pure returns (int256) { return ternary(a > b, a, b); } /** * @dev Returns the smallest of two signed numbers. */ function min(int256 a, int256 b) internal pure returns (int256) { return ternary(a < b, a, b); } /** * @dev Returns the average of two signed numbers without overflow. * The result is rounded towards zero. */ function average(int256 a, int256 b) internal pure returns (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. */ function abs(int256 n) internal pure returns (uint256) { unchecked { // Formula from the "Bit Twiddling Hacks" by Sean Eron Anderson. // Since `n` is a signed integer, the generated bytecode will use the SAR opcode to perform the right shift, // taking advantage of the most significant (or "sign" bit) in two's complement representation. // This opcode adds new most significant bits set to the value of the previous most significant bit. As a result, // the mask will either be `bytes32(0)` (if n is positive) or `~bytes32(0)` (if n is negative). int256 mask = n >> 255; // A `bytes32(0)` mask leaves the input unchanged, while a `~bytes32(0)` mask complements it. return uint256((n + mask) ^ mask); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol) pragma solidity ^0.8.20; /** * @dev Helper library for emitting standardized panic codes. * * ```solidity * contract Example { * using Panic for uint256; * * // Use any of the declared internal constants * function foo() { Panic.GENERIC.panic(); } * * // Alternatively * function foo() { Panic.panic(Panic.GENERIC); } * } * ``` * * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil]. * * _Available since v5.1._ */ // slither-disable-next-line unused-state library Panic { /// @dev generic / unspecified error uint256 internal constant GENERIC = 0x00; /// @dev used by the assert() builtin uint256 internal constant ASSERT = 0x01; /// @dev arithmetic underflow or overflow uint256 internal constant UNDER_OVERFLOW = 0x11; /// @dev division or modulo by zero uint256 internal constant DIVISION_BY_ZERO = 0x12; /// @dev enum conversion error uint256 internal constant ENUM_CONVERSION_ERROR = 0x21; /// @dev invalid encoding in storage uint256 internal constant STORAGE_ENCODING_ERROR = 0x22; /// @dev empty array pop uint256 internal constant EMPTY_ARRAY_POP = 0x31; /// @dev array out of bounds access uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32; /// @dev resource error (too large allocation or too large array) uint256 internal constant RESOURCE_ERROR = 0x41; /// @dev calling invalid internal function uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51; /// @dev Reverts with a panic code. Recommended to use with /// the internal constants with predefined codes. function panic(uint256 code) internal pure { assembly ("memory-safe") { mstore(0x00, 0x4e487b71) mstore(0x20, code) revert(0x1c, 0x24) } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.1.0) (utils/StorageSlot.sol) // This file was procedurally generated from scripts/generate/templates/StorageSlot.js. pragma solidity ^0.8.20; /** * @dev Library for reading and writing primitive types to specific storage slots. * * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts. * This library helps with reading and writing to such slots without the need for inline assembly. * * The functions in this library return Slot structs that contain a `value` member that can be used to read or write. * * Example usage to set ERC-1967 implementation slot: * ```solidity * contract ERC1967 { * // Define the slot. Alternatively, use the SlotDerivation library to derive the slot. * bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc; * * function _getImplementation() internal view returns (address) { * return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value; * } * * function _setImplementation(address newImplementation) internal { * require(newImplementation.code.length > 0); * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation; * } * } * ``` * * TIP: Consider using this library along with {SlotDerivation}. */ library StorageSlot { struct AddressSlot { address value; } struct BooleanSlot { bool value; } struct Bytes32Slot { bytes32 value; } struct Uint256Slot { uint256 value; } struct Int256Slot { int256 value; } struct StringSlot { string value; } struct BytesSlot { bytes value; } /** * @dev Returns an `AddressSlot` with member `value` located at `slot`. */ function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) { assembly ("memory-safe") { r.slot := slot } } /** * @dev Returns a `BooleanSlot` with member `value` located at `slot`. */ function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) { assembly ("memory-safe") { r.slot := slot } } /** * @dev Returns a `Bytes32Slot` with member `value` located at `slot`. */ function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) { assembly ("memory-safe") { r.slot := slot } } /** * @dev Returns a `Uint256Slot` with member `value` located at `slot`. */ function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) { assembly ("memory-safe") { r.slot := slot } } /** * @dev Returns a `Int256Slot` with member `value` located at `slot`. */ function getInt256Slot(bytes32 slot) internal pure returns (Int256Slot storage r) { assembly ("memory-safe") { r.slot := slot } } /** * @dev Returns a `StringSlot` with member `value` located at `slot`. */ function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) { assembly ("memory-safe") { r.slot := slot } } /** * @dev Returns an `StringSlot` representation of the string storage pointer `store`. */ function getStringSlot(string storage store) internal pure returns (StringSlot storage r) { assembly ("memory-safe") { r.slot := store.slot } } /** * @dev Returns a `BytesSlot` with member `value` located at `slot`. */ function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) { assembly ("memory-safe") { r.slot := slot } } /** * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`. */ function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) { assembly ("memory-safe") { r.slot := store.slot } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.1.0) (utils/Strings.sol) pragma solidity ^0.8.20; import {Math} from "./math/Math.sol"; import {SignedMath} from "./math/SignedMath.sol"; /** * @dev String operations. */ library Strings { bytes16 private constant HEX_DIGITS = "0123456789abcdef"; uint8 private constant ADDRESS_LENGTH = 20; /** * @dev The `value` string doesn't fit in the specified `length`. */ error StringsInsufficientHexLength(uint256 value, uint256 length); /** * @dev Converts a `uint256` to its ASCII `string` decimal representation. */ function toString(uint256 value) internal pure returns (string memory) { unchecked { uint256 length = Math.log10(value) + 1; string memory buffer = new string(length); uint256 ptr; assembly ("memory-safe") { ptr := add(buffer, add(32, length)) } while (true) { ptr--; assembly ("memory-safe") { 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. */ function toStringSigned(int256 value) internal pure returns (string memory) { return string.concat(value < 0 ? "-" : "", toString(SignedMath.abs(value))); } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation. */ function toHexString(uint256 value) internal pure returns (string memory) { unchecked { return toHexString(value, Math.log256(value) + 1); } } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length. */ function toHexString(uint256 value, uint256 length) internal pure returns (string memory) { uint256 localValue = value; bytes memory buffer = new bytes(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); } return string(buffer); } /** * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal * representation. */ function toHexString(address addr) internal pure returns (string memory) { return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH); } /** * @dev Converts an `address` with fixed length of 20 bytes to its checksummed ASCII `string` hexadecimal * representation, according to EIP-55. */ function toChecksumHexString(address addr) internal pure returns (string memory) { bytes memory buffer = bytes(toHexString(addr)); // hash the hex part of buffer (skip length + 2 bytes, length 40) uint256 hashValue; assembly ("memory-safe") { hashValue := shr(96, keccak256(add(buffer, 0x22), 40)) } for (uint256 i = 41; i > 1; --i) { // possible values for buffer[i] are 48 (0) to 57 (9) and 97 (a) to 102 (f) if (hashValue & 0xf > 7 && uint8(buffer[i]) > 96) { // case shift by xoring with 0x20 buffer[i] ^= 0x20; } hashValue >>= 4; } return string(buffer); } /** * @dev Returns true if the two strings are equal. */ function equal(string memory a, string memory b) internal pure returns (bool) { return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b)); } }
// SPDX-License-Identifier: Apache-2.0 pragma solidity ^0.8.0; import "./EntropyStructs.sol"; interface EntropyEvents { event Registered(EntropyStructs.ProviderInfo provider); event Requested(EntropyStructs.Request request); event RequestedWithCallback( address indexed provider, address indexed requestor, uint64 indexed sequenceNumber, bytes32 userRandomNumber, EntropyStructs.Request request ); event Revealed( EntropyStructs.Request request, bytes32 userRevelation, bytes32 providerRevelation, bytes32 blockHash, bytes32 randomNumber ); event RevealedWithCallback( EntropyStructs.Request request, bytes32 userRandomNumber, bytes32 providerRevelation, bytes32 randomNumber ); event ProviderFeeUpdated(address provider, uint128 oldFee, uint128 newFee); event ProviderUriUpdated(address provider, bytes oldUri, bytes newUri); event ProviderFeeManagerUpdated( address provider, address oldFeeManager, address newFeeManager ); event Withdrawal( address provider, address recipient, uint128 withdrawnAmount ); }
// SPDX-License-Identifier: Apache 2 pragma solidity ^0.8.0; contract EntropyStructs { struct ProviderInfo { uint128 feeInWei; uint128 accruedFeesInWei; // The commitment that the provider posted to the blockchain, and the sequence number // where they committed to this. This value is not advanced after the provider commits, // and instead is stored to help providers track where they are in the hash chain. bytes32 originalCommitment; uint64 originalCommitmentSequenceNumber; // Metadata for the current commitment. Providers may optionally use this field to help // manage rotations (i.e., to pick the sequence number from the correct hash chain). bytes commitmentMetadata; // Optional URI where clients can retrieve revelations for the provider. // Client SDKs can use this field to automatically determine how to retrieve random values for each provider. // TODO: specify the API that must be implemented at this URI bytes uri; // The first sequence number that is *not* included in the current commitment (i.e., an exclusive end index). // The contract maintains the invariant that sequenceNumber <= endSequenceNumber. // If sequenceNumber == endSequenceNumber, the provider must rotate their commitment to add additional random values. uint64 endSequenceNumber; // The sequence number that will be assigned to the next inbound user request. uint64 sequenceNumber; // The current commitment represents an index/value in the provider's hash chain. // These values are used to verify requests for future sequence numbers. Note that // currentCommitmentSequenceNumber < sequenceNumber. // // The currentCommitment advances forward through the provider's hash chain as values // are revealed on-chain. bytes32 currentCommitment; uint64 currentCommitmentSequenceNumber; // An address that is authorized to set / withdraw fees on behalf of this provider. address feeManager; } struct Request { // Storage slot 1 // address provider; uint64 sequenceNumber; // The number of hashes required to verify the provider revelation. uint32 numHashes; // Storage slot 2 // // The commitment is keccak256(userCommitment, providerCommitment). Storing the hash instead of both saves 20k gas by // eliminating 1 store. bytes32 commitment; // Storage slot 3 // // The number of the block where this request was created. // Note that we're using a uint64 such that we have an additional space for an address and other fields in // this storage slot. Although block.number returns a uint256, 64 bits should be plenty to index all of the // blocks ever generated. uint64 blockNumber; // The address that requested this random number. address requester; // If true, incorporate the blockhash of blockNumber into the generated random value. bool useBlockhash; // If true, the requester will be called back with the generated random value. bool isRequestWithCallback; // There are 2 remaining bytes of free space in this slot. } }
// SPDX-License-Identifier: Apache 2 pragma solidity ^0.8.0; import "./EntropyEvents.sol"; interface IEntropy is EntropyEvents { // Register msg.sender as a randomness provider. The arguments are the provider's configuration parameters // and initial commitment. Re-registering the same provider rotates the provider's commitment (and updates // the feeInWei). // // chainLength is the number of values in the hash chain *including* the commitment, that is, chainLength >= 1. function register( uint128 feeInWei, bytes32 commitment, bytes calldata commitmentMetadata, uint64 chainLength, bytes calldata uri ) external; // Withdraw a portion of the accumulated fees for the provider msg.sender. // Calling this function will transfer `amount` wei to the caller (provided that they have accrued a sufficient // balance of fees in the contract). function withdraw(uint128 amount) external; // Withdraw a portion of the accumulated fees for provider. The msg.sender must be the fee manager for this provider. // Calling this function will transfer `amount` wei to the caller (provided that they have accrued a sufficient // balance of fees in the contract). function withdrawAsFeeManager(address provider, uint128 amount) external; // As a user, request a random number from `provider`. Prior to calling this method, the user should // generate a random number x and keep it secret. The user should then compute hash(x) and pass that // as the userCommitment argument. (You may call the constructUserCommitment method to compute the hash.) // // This method returns a sequence number. The user should pass this sequence number to // their chosen provider (the exact method for doing so will depend on the provider) to retrieve the provider's // number. The user should then call fulfillRequest to construct the final random number. // // This method will revert unless the caller provides a sufficient fee (at least getFee(provider)) as msg.value. // Note that excess value is *not* refunded to the caller. function request( address provider, bytes32 userCommitment, bool useBlockHash ) external payable returns (uint64 assignedSequenceNumber); // Request a random number. The method expects the provider address and a secret random number // in the arguments. It returns a sequence number. // // The address calling this function should be a contract that inherits from the IEntropyConsumer interface. // The `entropyCallback` method on that interface will receive a callback with the generated random number. // // This method will revert unless the caller provides a sufficient fee (at least getFee(provider)) as msg.value. // Note that excess value is *not* refunded to the caller. function requestWithCallback( address provider, bytes32 userRandomNumber ) external payable returns (uint64 assignedSequenceNumber); // Fulfill a request for a random number. This method validates the provided userRandomness and provider's proof // against the corresponding commitments in the in-flight request. If both values are validated, this function returns // the corresponding random number. // // Note that this function can only be called once per in-flight request. Calling this function deletes the stored // request information (so that the contract doesn't use a linear amount of storage in the number of requests). // If you need to use the returned random number more than once, you are responsible for storing it. function reveal( address provider, uint64 sequenceNumber, bytes32 userRevelation, bytes32 providerRevelation ) external returns (bytes32 randomNumber); // Fulfill a request for a random number. This method validates the provided userRandomness // and provider's revelation against the corresponding commitment in the in-flight request. If both values are validated // and the requestor address is a contract address, this function calls the requester's entropyCallback method with the // sequence number, provider address and the random number as arguments. Else if the requestor is an EOA, it won't call it. // // Note that this function can only be called once per in-flight request. Calling this function deletes the stored // request information (so that the contract doesn't use a linear amount of storage in the number of requests). // If you need to use the returned random number more than once, you are responsible for storing it. // // Anyone can call this method to fulfill a request, but the callback will only be made to the original requester. function revealWithCallback( address provider, uint64 sequenceNumber, bytes32 userRandomNumber, bytes32 providerRevelation ) external; function getProviderInfo( address provider ) external view returns (EntropyStructs.ProviderInfo memory info); function getDefaultProvider() external view returns (address provider); function getRequest( address provider, uint64 sequenceNumber ) external view returns (EntropyStructs.Request memory req); function getFee(address provider) external view returns (uint128 feeAmount); function getAccruedPythFees() external view returns (uint128 accruedPythFeesInWei); function setProviderFee(uint128 newFeeInWei) external; function setProviderFeeAsFeeManager( address provider, uint128 newFeeInWei ) external; function setProviderUri(bytes calldata newUri) external; // Set manager as the fee manager for the provider msg.sender. // After calling this function, manager will be able to set the provider's fees and withdraw them. // Only one address can be the fee manager for a provider at a time -- calling this function again with a new value // will override the previous value. Call this function with the all-zero address to disable the fee manager role. function setFeeManager(address manager) external; function constructUserCommitment( bytes32 userRandomness ) external pure returns (bytes32 userCommitment); function combineRandomValues( bytes32 userRandomness, bytes32 providerRandomness, bytes32 blockHash ) external pure returns (bytes32 combinedRandomness); }
// SPDX-License-Identifier: Apache 2 pragma solidity ^0.8.0; abstract contract IEntropyConsumer { // This method is called by Entropy to provide the random number to the consumer. // It asserts that the msg.sender is the Entropy contract. It is not meant to be // override by the consumer. function _entropyCallback( uint64 sequence, address provider, bytes32 randomNumber ) external { address entropy = getEntropy(); require(entropy != address(0), "Entropy address not set"); require(msg.sender == entropy, "Only Entropy can call this function"); entropyCallback(sequence, provider, randomNumber); } // getEntropy returns Entropy contract address. The method is being used to check that the // callback is indeed from Entropy contract. The consumer is expected to implement this method. // Entropy address can be found here - https://docs.pyth.network/entropy/contract-addresses function getEntropy() internal view virtual returns (address); // This method is expected to be implemented by the consumer to handle the random number. // It will be called by _entropyCallback after _entropyCallback ensures that the call is // indeed from Entropy contract. function entropyCallback( uint64 sequence, address provider, bytes32 randomNumber ) internal virtual; }
{ "optimizer": { "enabled": true, "runs": 2000 }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } }, "evmVersion": "paris", "libraries": {} }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"AddressEmptyCode","type":"error"},{"inputs":[],"name":"AlreadyStaked","type":"error"},{"inputs":[],"name":"ConfigMismatch","type":"error"},{"inputs":[],"name":"DirectTransferNotAllowed","type":"error"},{"inputs":[{"internalType":"address","name":"implementation","type":"address"}],"name":"ERC1967InvalidImplementation","type":"error"},{"inputs":[],"name":"ERC1967NonPayable","type":"error"},{"inputs":[],"name":"FailedCall","type":"error"},{"inputs":[],"name":"InputMismatch","type":"error"},{"inputs":[{"internalType":"uint256","name":"currentRewards","type":"uint256"},{"internalType":"uint256","name":"pointsRequired","type":"uint256"}],"name":"InsufficientBalance","type":"error"},{"inputs":[{"internalType":"uint256","name":"sent","type":"uint256"},{"internalType":"uint256","name":"required","type":"uint256"}],"name":"InsufficientFee","type":"error"},{"inputs":[{"internalType":"address","name":"provider","type":"address"}],"name":"InvalidEntropyProvider","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"InvalidEntropySender","type":"error"},{"inputs":[],"name":"InvalidInitialization","type":"error"},{"inputs":[],"name":"InvalidProbabilitySum","type":"error"},{"inputs":[],"name":"InvalidProvider","type":"error"},{"inputs":[],"name":"InvalidRollType","type":"error"},{"inputs":[],"name":"InvalidSender","type":"error"},{"inputs":[],"name":"InvalidTokenIndex","type":"error"},{"inputs":[{"internalType":"uint64","name":"sequenceNumber","type":"uint64"}],"name":"MintAlreadyCompleted","type":"error"},{"inputs":[{"internalType":"uint64","name":"sequenceNumber","type":"uint64"}],"name":"MintRequestAlreadyCancelled","type":"error"},{"inputs":[{"internalType":"uint64","name":"requestId","type":"uint64"},{"internalType":"uint256","name":"timeLeft","type":"uint256"}],"name":"MintRequestNotYetExpired","type":"error"},{"inputs":[],"name":"NoMintsLeft","type":"error"},{"inputs":[],"name":"NotInitializing","type":"error"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"NotOwnerOfToken","type":"error"},{"inputs":[],"name":"NotStakedOwner","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[],"name":"ReentrancyGuardReentrantCall","type":"error"},{"inputs":[{"internalType":"uint64","name":"sequenceNumber","type":"uint64"}],"name":"RequestAlreadyCancelled","type":"error"},{"inputs":[{"internalType":"uint64","name":"sequenceNumber","type":"uint64"}],"name":"RequestAlreadyCompleted","type":"error"},{"inputs":[{"internalType":"uint64","name":"sequenceNumber","type":"uint64"}],"name":"RequestNotCompleted","type":"error"},{"inputs":[],"name":"RollsNotInitialized","type":"error"},{"inputs":[],"name":"StakingClosed","type":"error"},{"inputs":[],"name":"TooManyRollTypes","type":"error"},{"inputs":[],"name":"UUPSUnauthorizedCallContext","type":"error"},{"inputs":[{"internalType":"bytes32","name":"slot","type":"bytes32"}],"name":"UUPSUnsupportedProxiableUUID","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint64","name":"version","type":"uint64"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint64","name":"requestId","type":"uint64"}],"name":"MintFailed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint64","name":"requestId","type":"uint64"}],"name":"MintRequested","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"points","type":"uint256"}],"name":"PointsPerDayPerTokenUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tokenType","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"points","type":"uint256"}],"name":"PointsRequiredUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"provider","type":"address"}],"name":"ProviderUpdated","type":"event"},{"anonymous":false,"inputs":[],"name":"RarityLevelsInitialized","type":"event"},{"anonymous":false,"inputs":[],"name":"RollTypesInitialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Staked","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"open","type":"bool"}],"name":"StakingModeUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"TokenMinted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint64","name":"requestId","type":"uint64"}],"name":"TokenReadyForMint","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Unstaked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"implementation","type":"address"}],"name":"Upgraded","type":"event"},{"inputs":[],"name":"UPGRADE_INTERFACE_VERSION","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint64","name":"sequence","type":"uint64"},{"internalType":"address","name":"provider","type":"address"},{"internalType":"bytes32","name":"randomNumber","type":"bytes32"}],"name":"_entropyCallback","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"allStakers","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"derpyDragons","outputs":[{"internalType":"contract IDerpyDragons","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"dragons","outputs":[{"internalType":"contract IERC721","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"entropy","outputs":[{"internalType":"contract IEntropy","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"existingRolls","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getAllStakers","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint8","name":"rollTypeId","type":"uint8"}],"name":"getRollTypeById","outputs":[{"components":[{"internalType":"uint256","name":"price","type":"uint256"},{"internalType":"uint256[]","name":"probabilities","type":"uint256[]"}],"internalType":"struct DragonsLair.RollType","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"getTokensStaked","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"getmintRequestsByUser","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"hasStaked","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"entropy_","type":"address"},{"internalType":"uint256","name":"pointsPerHourPerToken_","type":"uint256"},{"internalType":"address","name":"dragonsAddress_","type":"address"},{"internalType":"address","name":"derpyDragonsAddress_","type":"address"},{"internalType":"address","name":"provider_","type":"address"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"minted","type":"uint256"},{"internalType":"uint256","name":"maxSupply","type":"uint256"},{"internalType":"string","name":"tokenUri","type":"string"}],"internalType":"struct DragonsLair.RarityLevel[]","name":"_rarityLevels","type":"tuple[]"}],"name":"initializeRarityLevels","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint256","name":"price","type":"uint256"},{"internalType":"uint256[]","name":"probabilities","type":"uint256[]"}],"internalType":"struct DragonsLair.RollType[]","name":"newRollTypes","type":"tuple[]"}],"name":"initializeRollTypes","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"mintRequestId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint64","name":"","type":"uint64"}],"name":"mintRequests","outputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"randomNumber","type":"uint256"},{"internalType":"uint256","name":"timestamp","type":"uint256"},{"internalType":"string","name":"uri","type":"string"},{"internalType":"uint8","name":"rollType","type":"uint8"},{"internalType":"bool","name":"requestCompleted","type":"bool"},{"internalType":"bool","name":"cancelled","type":"bool"},{"internalType":"bool","name":"mintFinalized","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"mintRequestsByUser","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mintedDragonCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC721Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"owedRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"pendingRewards","outputs":[{"internalType":"uint256","name":"totalClaimable","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pointsPerDayPerToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pointsPerHourPerToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"provider","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"proxiableUUID","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint8","name":"","type":"uint8"}],"name":"rarityLevels","outputs":[{"internalType":"uint256","name":"minted","type":"uint256"},{"internalType":"uint256","name":"maxSupply","type":"uint256"},{"internalType":"string","name":"tokenUri","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rarityLevelsInitialized","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint64","name":"","type":"uint64"}],"name":"requestIdToMintId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint8","name":"rollType","type":"uint8"}],"name":"requestToken","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint64","name":"sequenceNumber","type":"uint64"}],"name":"resolveExpiredMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rolesInitialized","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint8","name":"","type":"uint8"}],"name":"rollTypes","outputs":[{"internalType":"uint256","name":"price","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint64","name":"sequenceNumber","type":"uint64"}],"name":"selectRarityAndMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"pointsPerDay","type":"uint256"}],"name":"setPointsPerDayPerToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"provider_","type":"address"}],"name":"setProvider","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"open","type":"bool"}],"name":"setStakingMode","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"stake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"stakedTokenIds","outputs":[{"internalType":"uint256","name":"stakedTokens","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"stakedTokenProps","outputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"checkInTimestamp","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stakingOpen","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"unstake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newImplementation","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"upgradeToAndCall","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"version","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 30 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.