Overview
S Balance
S Value
-More 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:
ItemNFT
Compiler Version
v0.8.28+commit.7893614a
Optimization Enabled:
Yes with 5000 runs
Other Settings:
cancun EvmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: MIT pragma solidity ^0.8.28; import {ERC1155Upgradeable} from "@openzeppelin/contracts-upgradeable/token/ERC1155/ERC1155Upgradeable.sol"; import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol"; import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol"; import {IERC2981, IERC165} from "@openzeppelin/contracts/interfaces/IERC2981.sol"; import {IItemNFT} from "./interfaces/IItemNFT.sol"; import {IPlayers} from "./interfaces/IPlayers.sol"; import {ItemNFTLibrary} from "./ItemNFTLibrary.sol"; import {IBankFactory} from "./interfaces/IBankFactory.sol"; import {AdminAccess} from "./AdminAccess.sol"; import {BoostType, BulkTransferInfo, CombatStats, EquipPosition, Item, ItemInput, Skill, IS_FULL_MODE_BIT, IS_AVAILABLE_BIT} from "./globals/all.sol"; // The NFT contract contains data related to the items and who owns them contract ItemNFT is UUPSUpgradeable, OwnableUpgradeable, ERC1155Upgradeable, IERC2981, IItemNFT { event AddItems(ItemInput[] items); event EditItems(ItemInput[] items); event RemoveItems(uint16[] tokenIds); error IdTooHigh(); error ItemNotTransferable(); error InvalidTokenId(); error ItemAlreadyExists(); error ItemDoesNotExist(uint16); error EquipmentPositionShouldNotChange(); error NotMinter(); error NotBurner(); error LengthMismatch(); struct ItemInfo { uint40 timestampFirstMint; uint216 balance; // can be smaller if we want to pack more data } uint16 private _totalSupplyAll; string private _baseURI; AdminAccess private _adminAccess; bool private _isBeta; IBankFactory private _bankFactory; IPlayers private _players; // Royalties address private _royaltyReceiver; uint8 private _royaltyFee; // base 1000, highest is 25.5 mapping(uint256 itemId => ItemInfo itemInfo) private _itemInfos; // (timestampFirstMint, balance) mapping(uint256 itemId => string tokenURI) private _tokenURIs; mapping(uint256 itemId => CombatStats combatStats) private _combatStats; mapping(uint256 itemId => Item item) private _items; mapping(address account => bool isApproved) private _approvals; modifier onlyMinters() { address sender = _msgSender(); require(_isApproved(sender) || (_adminAccess.isAdmin(sender) && _isBeta), NotMinter()); _; } modifier onlyBurners(address from) { address sender = _msgSender(); require(sender == from || isApprovedForAll(from, sender), NotBurner()); _; } /// @custom:oz-upgrades-unsafe-allow constructor constructor() { _disableInitializers(); } function initialize( address royaltyReceiver, string calldata baseURI, AdminAccess adminAccess, bool isBeta ) external initializer { __Ownable_init(_msgSender()); __UUPSUpgradeable_init(); __ERC1155_init(""); _baseURI = baseURI; _royaltyFee = 30; // 3% _royaltyReceiver = royaltyReceiver; _adminAccess = adminAccess; _isBeta = isBeta; } function mint(address to, uint256 tokenId, uint256 amount) external override onlyMinters { _mintItem(to, tokenId, amount); } function mintBatch(address to, uint256[] calldata ids, uint256[] calldata amounts) external override onlyMinters { _mintBatchItems(to, ids, amounts); } function burnBatch( address from, uint256[] calldata tokenIds, uint256[] calldata amounts ) external override onlyBurners(from) { _burnBatch(from, tokenIds, amounts); } function burn(address from, uint256 tokenId, uint256 amount) external override onlyBurners(from) { _burn(from, tokenId, amount); } function _getMinRequirement(uint16 tokenId) private view returns (Skill, uint32, bool isFullModeOnly) { Item memory item = _items[tokenId]; return (item.skill, item.minXP, _isItemFullMode(tokenId)); } function _isItemFullMode(uint256 tokenId) private view returns (bool) { return uint8(_items[tokenId].packedData >> IS_FULL_MODE_BIT) & 1 == 1; } // TODO: Not used yet function _isItemAvailable(uint16 tokenId) private view returns (bool) { return uint8(_items[tokenId].packedData >> IS_AVAILABLE_BIT) & 1 == 1; } function _premint(uint256 tokenId, uint256 amount) private returns (uint256 numNewUniqueItems) { require(tokenId < type(uint16).max, IdTooHigh()); uint256 existingBalance = _itemInfos[tokenId].balance; if (existingBalance == 0) { // Brand new item _itemInfos[tokenId].timestampFirstMint = uint40(block.timestamp); numNewUniqueItems++; } _itemInfos[tokenId].balance = uint216(existingBalance + amount); } function _mintItem(address to, uint256 tokenId, uint256 amount) internal { uint256 newlyMintedItems = _premint(tokenId, amount); if (newlyMintedItems != 0) { ++_totalSupplyAll; } _mint(to, uint256(tokenId), amount, ""); } function _mintBatchItems(address to, uint256[] memory tokenIds, uint256[] memory amounts) internal { uint256 numNewItems; uint256 tokenIdsLength = tokenIds.length; for (uint256 i; i < tokenIdsLength; ++i) { numNewItems = numNewItems + _premint(tokenIds[i], amounts[i]); } if (numNewItems != 0) { _totalSupplyAll += uint16(numNewItems); } _mintBatch(to, tokenIds, amounts, ""); } function safeBulkTransfer(BulkTransferInfo[] calldata nftsInfo) external { if (nftsInfo.length == 0) { return; } for (uint256 i = 0; i < nftsInfo.length; ++i) { BulkTransferInfo memory nftInfo = nftsInfo[i]; address to = nftInfo.to; if (nftInfo.tokenIds.length == 1) { safeTransferFrom(_msgSender(), to, nftInfo.tokenIds[0], nftInfo.amounts[0], ""); } else { safeBatchTransferFrom(_msgSender(), to, nftInfo.tokenIds, nftInfo.amounts, ""); } } } function _getItem(uint16 tokenId) private view returns (Item storage) { require(exists(tokenId), ItemDoesNotExist(tokenId)); return _items[tokenId]; } // If an item is burnt, remove it from the total function _removeAnyBurntFromTotal(uint256[] memory ids, uint256[] memory amounts) private { uint256 totalSupplyDelta; for (uint256 i = 0; i < ids.length; ++i) { uint256 newBalance = _itemInfos[ids[i]].balance - amounts[i]; if (newBalance == 0) { ++totalSupplyDelta; } _itemInfos[ids[i]].balance = uint216(newBalance); } _totalSupplyAll -= uint16(totalSupplyDelta); } function _checkIsTransferable(address from, uint256[] memory ids) private view { bool anyNonTransferable; for (uint256 i = 0; i < ids.length; ++i) { if (exists(ids[i]) && !_items[ids[i]].isTransferable) { anyNonTransferable = true; break; } } // Check if this is from a bank, that's the only place it's allowed to transfer non-transferable items require(!anyNonTransferable || _bankFactory.getCreatedHere(from), ItemNotTransferable()); } function _update(address from, address to, uint256[] memory ids, uint256[] memory amounts) internal virtual override { if (amounts.length != 0 && from != to) { bool isBurnt = to == address(0) || to == address(0xdEaD); bool isMinted = from == address(0); if (isBurnt) { _removeAnyBurntFromTotal(ids, amounts); } else if (!isMinted) { _checkIsTransferable(from, ids); } _players.beforeItemNFTTransfer(from, to, ids, amounts); } super._update(from, to, ids, amounts); } function _setItem(ItemInput calldata input) private { require(input.tokenId != 0, InvalidTokenId()); ItemNFTLibrary.setItem(input, _items[input.tokenId]); _tokenURIs[input.tokenId] = input.metadataURI; } function _editItem(ItemInput calldata inputItem) private { require(exists(inputItem.tokenId), ItemDoesNotExist(inputItem.tokenId)); EquipPosition oldPosition = _items[inputItem.tokenId].equipPosition; EquipPosition newPosition = inputItem.equipPosition; bool isRightHandPositionSwapWithBothHands = (oldPosition == EquipPosition.RIGHT_HAND && newPosition == EquipPosition.BOTH_HANDS) || (oldPosition == EquipPosition.BOTH_HANDS && newPosition == EquipPosition.RIGHT_HAND); // Allowed to go from BOTH_HANDS to RIGHT_HAND or RIGHT_HAND to BOTH_HANDS require( oldPosition == newPosition || oldPosition == EquipPosition.NONE || isRightHandPositionSwapWithBothHands, EquipmentPositionShouldNotChange() ); _setItem(inputItem); } function _isApproved(address account) private view returns (bool) { return _approvals[account]; } function uri(uint256 tokenId) public view virtual override returns (string memory) { require(exists(tokenId), ItemDoesNotExist(uint16(tokenId))); return string(abi.encodePacked(_baseURI, _tokenURIs[tokenId])); } function exists(uint256 tokenId) public view override returns (bool) { return _items[tokenId].packedData != 0; } function totalSupply(uint256 tokenId) external view override returns (uint256) { return _itemInfos[tokenId].balance; } function totalSupply() external view override returns (uint256) { return _totalSupplyAll; } function getItem(uint16 tokenId) external view override returns (Item memory) { return _getItem(tokenId); } function getItems(uint16[] calldata tokenIds) external view override returns (Item[] memory items) { uint256 tokenIdsLength = tokenIds.length; items = new Item[](tokenIdsLength); for (uint256 i; i < tokenIdsLength; ++i) { items[i] = _getItem(tokenIds[i]); } } function getTimestampFirstMint(uint256 tokenId) external view override returns (uint256) { return _itemInfos[tokenId].timestampFirstMint; } function getEquipPositionAndMinRequirement( uint16 item ) external view returns (Skill skill, uint32 minXP, EquipPosition equipPosition, bool isFullModeOnly) { (skill, minXP, isFullModeOnly) = _getMinRequirement(item); equipPosition = getEquipPosition(item); } function getMinRequirements( uint16[] calldata tokenIds ) external view returns (Skill[] memory skills, uint32[] memory minXPs, bool[] memory isFullModeOnly) { skills = new Skill[](tokenIds.length); minXPs = new uint32[](tokenIds.length); isFullModeOnly = new bool[](tokenIds.length); uint256 tokenIdsLength = tokenIds.length; for (uint256 i; i < tokenIdsLength; ++i) { (skills[i], minXPs[i], isFullModeOnly[i]) = _getMinRequirement(tokenIds[i]); } } function getEquipPositions(uint16[] calldata tokenIds) external view returns (EquipPosition[] memory equipPositions) { uint256 tokenIdsLength = tokenIds.length; equipPositions = new EquipPosition[](tokenIdsLength); for (uint256 i; i < tokenIdsLength; ++i) { equipPositions[i] = getEquipPosition(tokenIds[i]); } } function getEquipPosition(uint16 tokenId) public view returns (EquipPosition) { require(exists(tokenId), ItemDoesNotExist(uint16(tokenId))); return _items[tokenId].equipPosition; } /** * @dev See {IERC1155-balanceOfBatch}. This implementation is not standard ERC1155, it's optimized for the single account case */ function balanceOfs( address account, uint16[] memory ids ) external view override returns (uint256[] memory batchBalances) { batchBalances = new uint256[](ids.length); for (uint256 i = 0; i < ids.length; ++i) { batchBalances[i] = balanceOf(account, ids[i]); } } function balanceOfs10( address account, uint16[10] memory ids ) external view override returns (uint256[] memory batchBalances) { batchBalances = new uint256[](ids.length); for (uint256 i = 0; i < ids.length; ++i) { batchBalances[i] = balanceOf(account, ids[i]); } } function balanceOf(address account, uint256 id) public view override(IItemNFT, ERC1155Upgradeable) returns (uint256) { return ERC1155Upgradeable.balanceOf(account, id); } function royaltyInfo( uint256 /*tokenId*/, uint256 salePrice ) external view override returns (address receiver, uint256 royaltyAmount) { uint256 amount = (salePrice * _royaltyFee) / 1000; return (_royaltyReceiver, amount); } function getBoostInfo( uint16 tokenId ) external view returns (BoostType boostType, uint16 boostValue, uint24 boostDuration) { Item storage item = _getItem(tokenId); return (item.boostType, item.boostValue, item.boostDuration); } /** * @dev See {IERC1155-isApprovedForAll}. */ function isApprovedForAll(address account, address operator) public view virtual override returns (bool) { return super.isApprovedForAll(account, operator) || _approvals[operator]; } function supportsInterface(bytes4 interfaceId) public view override(IERC165, ERC1155Upgradeable) returns (bool) { return interfaceId == type(IERC2981).interfaceId || super.supportsInterface(interfaceId); } function name() external view returns (string memory) { return string(abi.encodePacked("Estfor Items", _isBeta ? " (Beta)" : "")); } function symbol() external view returns (string memory) { return string(abi.encodePacked("EK_I", _isBeta ? "B" : "")); } function addItems(ItemInput[] calldata inputItems) external onlyOwner { uint256 length = inputItems.length; for (uint256 i; i < length; ++i) { require(!exists(inputItems[i].tokenId), ItemAlreadyExists()); _setItem(inputItems[i]); } emit AddItems(inputItems); } function editItems(ItemInput[] calldata inputItems) external onlyOwner { for (uint256 i = 0; i < inputItems.length; ++i) { _editItem(inputItems[i]); } emit EditItems(inputItems); } // This should be only used when an item is not in active use // because it could mess up queued actions potentially function removeItems(uint16[] calldata itemTokenIds) external onlyOwner { for (uint256 i = 0; i < itemTokenIds.length; ++i) { require(exists(itemTokenIds[i]), ItemDoesNotExist(itemTokenIds[i])); delete _items[itemTokenIds[i]]; delete _tokenURIs[itemTokenIds[i]]; } emit RemoveItems(itemTokenIds); } function initializeAddresses(IBankFactory bankFactory, IPlayers players) external onlyOwner { _bankFactory = bankFactory; _players = players; } function setApproved(address[] calldata accounts, bool isApproved) external onlyOwner { for (uint256 i = 0; i < accounts.length; ++i) { _approvals[accounts[i]] = isApproved; } } function setBaseURI(string calldata baseURI) external onlyOwner { _baseURI = baseURI; } function airdrop(address[] calldata tos, uint256 tokenId, uint256[] calldata amounts) external onlyOwner { require(tos.length == amounts.length, LengthMismatch()); for (uint256 i = 0; i < tos.length; ++i) { _mintItem(tos[i], tokenId, amounts[i]); } } // solhint-disable-next-line no-empty-blocks function _authorizeUpgrade(address newImplementation) internal override onlyOwner {} }
// 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 ("memory-safe") { $.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 ("memory-safe") { $.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/ERC1155/ERC1155.sol) pragma solidity ^0.8.20; import {IERC1155} from "@openzeppelin/contracts/token/ERC1155/IERC1155.sol"; import {IERC1155MetadataURI} from "@openzeppelin/contracts/token/ERC1155/extensions/IERC1155MetadataURI.sol"; import {ERC1155Utils} from "@openzeppelin/contracts/token/ERC1155/utils/ERC1155Utils.sol"; import {ContextUpgradeable} from "../../utils/ContextUpgradeable.sol"; import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol"; import {ERC165Upgradeable} from "../../utils/introspection/ERC165Upgradeable.sol"; import {Arrays} from "@openzeppelin/contracts/utils/Arrays.sol"; import {IERC1155Errors} from "@openzeppelin/contracts/interfaces/draft-IERC6093.sol"; import {Initializable} from "../../proxy/utils/Initializable.sol"; /** * @dev Implementation of the basic standard multi-token. * See https://eips.ethereum.org/EIPS/eip-1155 * Originally based on code by Enjin: https://github.com/enjin/erc-1155 */ abstract contract ERC1155Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC1155, IERC1155MetadataURI, IERC1155Errors { using Arrays for uint256[]; using Arrays for address[]; /// @custom:storage-location erc7201:openzeppelin.storage.ERC1155 struct ERC1155Storage { mapping(uint256 id => mapping(address account => uint256)) _balances; mapping(address account => mapping(address operator => bool)) _operatorApprovals; // Used as the URI for all token types by relying on ID substitution, e.g. https://token-cdn-domain/{id}.json string _uri; } // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.ERC1155")) - 1)) & ~bytes32(uint256(0xff)) bytes32 private constant ERC1155StorageLocation = 0x88be536d5240c274a3b1d3a1be54482fd9caa294f08c62a7cde569f49a3c4500; function _getERC1155Storage() private pure returns (ERC1155Storage storage $) { assembly ("memory-safe") { $.slot := ERC1155StorageLocation } } /** * @dev See {_setURI}. */ function __ERC1155_init(string memory uri_) internal onlyInitializing { __ERC1155_init_unchained(uri_); } function __ERC1155_init_unchained(string memory uri_) internal onlyInitializing { _setURI(uri_); } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165) returns (bool) { return interfaceId == type(IERC1155).interfaceId || interfaceId == type(IERC1155MetadataURI).interfaceId || super.supportsInterface(interfaceId); } /** * @dev See {IERC1155MetadataURI-uri}. * * This implementation returns the same URI for *all* token types. It relies * on the token type ID substitution mechanism * https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the ERC]. * * Clients calling this function must replace the `\{id\}` substring with the * actual token type ID. */ function uri(uint256 /* id */) public view virtual returns (string memory) { ERC1155Storage storage $ = _getERC1155Storage(); return $._uri; } /** * @dev See {IERC1155-balanceOf}. */ function balanceOf(address account, uint256 id) public view virtual returns (uint256) { ERC1155Storage storage $ = _getERC1155Storage(); return $._balances[id][account]; } /** * @dev See {IERC1155-balanceOfBatch}. * * Requirements: * * - `accounts` and `ids` must have the same length. */ function balanceOfBatch( address[] memory accounts, uint256[] memory ids ) public view virtual returns (uint256[] memory) { if (accounts.length != ids.length) { revert ERC1155InvalidArrayLength(ids.length, accounts.length); } uint256[] memory batchBalances = new uint256[](accounts.length); for (uint256 i = 0; i < accounts.length; ++i) { batchBalances[i] = balanceOf(accounts.unsafeMemoryAccess(i), ids.unsafeMemoryAccess(i)); } return batchBalances; } /** * @dev See {IERC1155-setApprovalForAll}. */ function setApprovalForAll(address operator, bool approved) public virtual { _setApprovalForAll(_msgSender(), operator, approved); } /** * @dev See {IERC1155-isApprovedForAll}. */ function isApprovedForAll(address account, address operator) public view virtual returns (bool) { ERC1155Storage storage $ = _getERC1155Storage(); return $._operatorApprovals[account][operator]; } /** * @dev See {IERC1155-safeTransferFrom}. */ function safeTransferFrom(address from, address to, uint256 id, uint256 value, bytes memory data) public virtual { address sender = _msgSender(); if (from != sender && !isApprovedForAll(from, sender)) { revert ERC1155MissingApprovalForAll(sender, from); } _safeTransferFrom(from, to, id, value, data); } /** * @dev See {IERC1155-safeBatchTransferFrom}. */ function safeBatchTransferFrom( address from, address to, uint256[] memory ids, uint256[] memory values, bytes memory data ) public virtual { address sender = _msgSender(); if (from != sender && !isApprovedForAll(from, sender)) { revert ERC1155MissingApprovalForAll(sender, from); } _safeBatchTransferFrom(from, to, ids, values, data); } /** * @dev Transfers a `value` amount of tokens of type `id` from `from` to `to`. Will mint (or burn) if `from` * (or `to`) is the zero address. * * Emits a {TransferSingle} event if the arrays contain one element, and {TransferBatch} otherwise. * * Requirements: * * - If `to` refers to a smart contract, it must implement either {IERC1155Receiver-onERC1155Received} * or {IERC1155Receiver-onERC1155BatchReceived} and return the acceptance magic value. * - `ids` and `values` must have the same length. * * NOTE: The ERC-1155 acceptance check is not performed in this function. See {_updateWithAcceptanceCheck} instead. */ function _update(address from, address to, uint256[] memory ids, uint256[] memory values) internal virtual { ERC1155Storage storage $ = _getERC1155Storage(); if (ids.length != values.length) { revert ERC1155InvalidArrayLength(ids.length, values.length); } address operator = _msgSender(); for (uint256 i = 0; i < ids.length; ++i) { uint256 id = ids.unsafeMemoryAccess(i); uint256 value = values.unsafeMemoryAccess(i); if (from != address(0)) { uint256 fromBalance = $._balances[id][from]; if (fromBalance < value) { revert ERC1155InsufficientBalance(from, fromBalance, value, id); } unchecked { // Overflow not possible: value <= fromBalance $._balances[id][from] = fromBalance - value; } } if (to != address(0)) { $._balances[id][to] += value; } } if (ids.length == 1) { uint256 id = ids.unsafeMemoryAccess(0); uint256 value = values.unsafeMemoryAccess(0); emit TransferSingle(operator, from, to, id, value); } else { emit TransferBatch(operator, from, to, ids, values); } } /** * @dev Version of {_update} that performs the token acceptance check by calling * {IERC1155Receiver-onERC1155Received} or {IERC1155Receiver-onERC1155BatchReceived} on the receiver address if it * contains code (eg. is a smart contract at the moment of execution). * * IMPORTANT: Overriding this function is discouraged because it poses a reentrancy risk from the receiver. So any * update to the contract state after this function would break the check-effect-interaction pattern. Consider * overriding {_update} instead. */ function _updateWithAcceptanceCheck( address from, address to, uint256[] memory ids, uint256[] memory values, bytes memory data ) internal virtual { _update(from, to, ids, values); if (to != address(0)) { address operator = _msgSender(); if (ids.length == 1) { uint256 id = ids.unsafeMemoryAccess(0); uint256 value = values.unsafeMemoryAccess(0); ERC1155Utils.checkOnERC1155Received(operator, from, to, id, value, data); } else { ERC1155Utils.checkOnERC1155BatchReceived(operator, from, to, ids, values, data); } } } /** * @dev Transfers a `value` tokens of token type `id` from `from` to `to`. * * Emits a {TransferSingle} event. * * Requirements: * * - `to` cannot be the zero address. * - `from` must have a balance of tokens of type `id` of at least `value` amount. * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the * acceptance magic value. */ function _safeTransferFrom(address from, address to, uint256 id, uint256 value, bytes memory data) internal { if (to == address(0)) { revert ERC1155InvalidReceiver(address(0)); } if (from == address(0)) { revert ERC1155InvalidSender(address(0)); } (uint256[] memory ids, uint256[] memory values) = _asSingletonArrays(id, value); _updateWithAcceptanceCheck(from, to, ids, values, data); } /** * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_safeTransferFrom}. * * Emits a {TransferBatch} event. * * Requirements: * * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the * acceptance magic value. * - `ids` and `values` must have the same length. */ function _safeBatchTransferFrom( address from, address to, uint256[] memory ids, uint256[] memory values, bytes memory data ) internal { if (to == address(0)) { revert ERC1155InvalidReceiver(address(0)); } if (from == address(0)) { revert ERC1155InvalidSender(address(0)); } _updateWithAcceptanceCheck(from, to, ids, values, data); } /** * @dev Sets a new URI for all token types, by relying on the token type ID * substitution mechanism * https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the ERC]. * * By this mechanism, any occurrence of the `\{id\}` substring in either the * URI or any of the values in the JSON file at said URI will be replaced by * clients with the token type ID. * * For example, the `https://token-cdn-domain/\{id\}.json` URI would be * interpreted by clients as * `https://token-cdn-domain/000000000000000000000000000000000000000000000000000000000004cce0.json` * for token type ID 0x4cce0. * * See {uri}. * * Because these URIs cannot be meaningfully represented by the {URI} event, * this function emits no events. */ function _setURI(string memory newuri) internal virtual { ERC1155Storage storage $ = _getERC1155Storage(); $._uri = newuri; } /** * @dev Creates a `value` amount of tokens of type `id`, and assigns them to `to`. * * Emits a {TransferSingle} event. * * Requirements: * * - `to` cannot be the zero address. * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the * acceptance magic value. */ function _mint(address to, uint256 id, uint256 value, bytes memory data) internal { if (to == address(0)) { revert ERC1155InvalidReceiver(address(0)); } (uint256[] memory ids, uint256[] memory values) = _asSingletonArrays(id, value); _updateWithAcceptanceCheck(address(0), to, ids, values, data); } /** * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_mint}. * * Emits a {TransferBatch} event. * * Requirements: * * - `ids` and `values` must have the same length. * - `to` cannot be the zero address. * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the * acceptance magic value. */ function _mintBatch(address to, uint256[] memory ids, uint256[] memory values, bytes memory data) internal { if (to == address(0)) { revert ERC1155InvalidReceiver(address(0)); } _updateWithAcceptanceCheck(address(0), to, ids, values, data); } /** * @dev Destroys a `value` amount of tokens of type `id` from `from` * * Emits a {TransferSingle} event. * * Requirements: * * - `from` cannot be the zero address. * - `from` must have at least `value` amount of tokens of type `id`. */ function _burn(address from, uint256 id, uint256 value) internal { if (from == address(0)) { revert ERC1155InvalidSender(address(0)); } (uint256[] memory ids, uint256[] memory values) = _asSingletonArrays(id, value); _updateWithAcceptanceCheck(from, address(0), ids, values, ""); } /** * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_burn}. * * Emits a {TransferBatch} event. * * Requirements: * * - `from` cannot be the zero address. * - `from` must have at least `value` amount of tokens of type `id`. * - `ids` and `values` must have the same length. */ function _burnBatch(address from, uint256[] memory ids, uint256[] memory values) internal { if (from == address(0)) { revert ERC1155InvalidSender(address(0)); } _updateWithAcceptanceCheck(from, address(0), ids, values, ""); } /** * @dev Approve `operator` to operate on all of `owner` tokens * * Emits an {ApprovalForAll} event. * * Requirements: * * - `operator` cannot be the zero address. */ function _setApprovalForAll(address owner, address operator, bool approved) internal virtual { ERC1155Storage storage $ = _getERC1155Storage(); if (operator == address(0)) { revert ERC1155InvalidOperator(address(0)); } $._operatorApprovals[owner][operator] = approved; emit ApprovalForAll(owner, operator, approved); } /** * @dev Creates an array in memory with only one value for each of the elements provided. */ function _asSingletonArrays( uint256 element1, uint256 element2 ) private pure returns (uint256[] memory array1, uint256[] memory array2) { assembly ("memory-safe") { // Load the free memory pointer array1 := mload(0x40) // Set array length to 1 mstore(array1, 1) // Store the single element at the next word after the length (where content starts) mstore(add(array1, 0x20), element1) // Repeat for next array locating it right after the first array array2 := add(array1, 0x40) mstore(array2, 1) mstore(add(array2, 0x20), element2) // Update the free memory pointer by pointing after the second array mstore(0x40, add(array2, 0x40)) } } }
// 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) (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.1.0) (interfaces/IERC2981.sol) pragma solidity ^0.8.20; import {IERC165} from "../utils/introspection/IERC165.sol"; /** * @dev Interface for the NFT Royalty Standard. * * A standardized way to retrieve royalty payment information for non-fungible tokens (NFTs) to enable universal * support for royalty payments across all NFT marketplaces and ecosystem participants. */ interface IERC2981 is IERC165 { /** * @dev Returns how much royalty is owed and to whom, based on a sale price that may be denominated in any unit of * exchange. The royalty amount is denominated and should be paid in that same unit of exchange. * * NOTE: ERC-2981 allows setting the royalty to 100% of the price. In that case all the price would be sent to the * royalty receiver and 0 tokens to the seller. Contracts dealing with royalty should consider empty transfers. */ function royaltyInfo( uint256 tokenId, uint256 salePrice ) external view returns (address receiver, uint256 royaltyAmount); }
// 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.1.0) (token/ERC1155/extensions/IERC1155MetadataURI.sol) pragma solidity ^0.8.20; import {IERC1155} from "../IERC1155.sol"; /** * @dev Interface of the optional ERC1155MetadataExtension interface, as defined * in the https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[ERC]. */ interface IERC1155MetadataURI is IERC1155 { /** * @dev Returns the URI for token type `id`. * * If the `\{id\}` substring is present in the URI, it must be replaced by * clients with the actual token type ID. */ function uri(uint256 id) external view returns (string memory); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.1.0) (token/ERC1155/IERC1155.sol) pragma solidity ^0.8.20; import {IERC165} from "../../utils/introspection/IERC165.sol"; /** * @dev Required interface of an ERC-1155 compliant contract, as defined in the * https://eips.ethereum.org/EIPS/eip-1155[ERC]. */ interface IERC1155 is IERC165 { /** * @dev Emitted when `value` amount of tokens of type `id` are transferred from `from` to `to` by `operator`. */ event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value); /** * @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all * transfers. */ event TransferBatch( address indexed operator, address indexed from, address indexed to, uint256[] ids, uint256[] values ); /** * @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to * `approved`. */ event ApprovalForAll(address indexed account, address indexed operator, bool approved); /** * @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI. * * If an {URI} event was emitted for `id`, the standard * https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value * returned by {IERC1155MetadataURI-uri}. */ event URI(string value, uint256 indexed id); /** * @dev Returns the value of tokens of token type `id` owned by `account`. */ function balanceOf(address account, uint256 id) external view returns (uint256); /** * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}. * * Requirements: * * - `accounts` and `ids` must have the same length. */ function balanceOfBatch( address[] calldata accounts, uint256[] calldata ids ) external view returns (uint256[] memory); /** * @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`, * * Emits an {ApprovalForAll} event. * * Requirements: * * - `operator` cannot be the zero address. */ function setApprovalForAll(address operator, bool approved) external; /** * @dev Returns true if `operator` is approved to transfer ``account``'s tokens. * * See {setApprovalForAll}. */ function isApprovedForAll(address account, address operator) external view returns (bool); /** * @dev Transfers a `value` amount of tokens of type `id` from `from` to `to`. * * WARNING: This function can potentially allow a reentrancy attack when transferring tokens * to an untrusted contract, when invoking {onERC1155Received} on the receiver. * Ensure to follow the checks-effects-interactions pattern and consider employing * reentrancy guards when interacting with untrusted contracts. * * Emits a {TransferSingle} event. * * Requirements: * * - `to` cannot be the zero address. * - If the caller is not `from`, it must have been approved to spend ``from``'s tokens via {setApprovalForAll}. * - `from` must have a balance of tokens of type `id` of at least `value` amount. * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the * acceptance magic value. */ function safeTransferFrom(address from, address to, uint256 id, uint256 value, bytes calldata data) external; /** * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}. * * WARNING: This function can potentially allow a reentrancy attack when transferring tokens * to an untrusted contract, when invoking {onERC1155BatchReceived} on the receiver. * Ensure to follow the checks-effects-interactions pattern and consider employing * reentrancy guards when interacting with untrusted contracts. * * Emits either a {TransferSingle} or a {TransferBatch} event, depending on the length of the array arguments. * * Requirements: * * - `ids` and `values` must have the same length. * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the * acceptance magic value. */ function safeBatchTransferFrom( address from, address to, uint256[] calldata ids, uint256[] calldata values, bytes calldata data ) external; }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.1.0) (token/ERC1155/IERC1155Receiver.sol) pragma solidity ^0.8.20; import {IERC165} from "../../utils/introspection/IERC165.sol"; /** * @dev Interface that must be implemented by smart contracts in order to receive * ERC-1155 token transfers. */ interface IERC1155Receiver is IERC165 { /** * @dev Handles the receipt of a single ERC-1155 token type. This function is * called at the end of a `safeTransferFrom` after the balance has been updated. * * NOTE: To accept the transfer, this must return * `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` * (i.e. 0xf23a6e61, or its own function selector). * * @param operator The address which initiated the transfer (i.e. msg.sender) * @param from The address which previously owned the token * @param id The ID of the token being transferred * @param value The amount of tokens being transferred * @param data Additional data with no specified format * @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed */ function onERC1155Received( address operator, address from, uint256 id, uint256 value, bytes calldata data ) external returns (bytes4); /** * @dev Handles the receipt of a multiple ERC-1155 token types. This function * is called at the end of a `safeBatchTransferFrom` after the balances have * been updated. * * NOTE: To accept the transfer(s), this must return * `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` * (i.e. 0xbc197c81, or its own function selector). * * @param operator The address which initiated the batch transfer (i.e. msg.sender) * @param from The address which previously owned the token * @param ids An array containing ids of each token being transferred (order and length must match values array) * @param values An array containing amounts of each token being transferred (order and length must match ids array) * @param data Additional data with no specified format * @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed */ function onERC1155BatchReceived( address operator, address from, uint256[] calldata ids, uint256[] calldata values, bytes calldata data ) external returns (bytes4); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.1.0) (token/ERC1155/utils/ERC1155Utils.sol) pragma solidity ^0.8.20; import {IERC1155Receiver} from "../IERC1155Receiver.sol"; import {IERC1155Errors} from "../../../interfaces/draft-IERC6093.sol"; /** * @dev Library that provide common ERC-1155 utility functions. * * See https://eips.ethereum.org/EIPS/eip-1155[ERC-1155]. * * _Available since v5.1._ */ library ERC1155Utils { /** * @dev Performs an acceptance check for the provided `operator` by calling {IERC1155-onERC1155Received} * 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 {IERC1155Receiver-onERC1155Received} and return the acceptance magic value to accept * the transfer. */ function checkOnERC1155Received( address operator, address from, address to, uint256 id, uint256 value, bytes memory data ) internal { if (to.code.length > 0) { try IERC1155Receiver(to).onERC1155Received(operator, from, id, value, data) returns (bytes4 response) { if (response != IERC1155Receiver.onERC1155Received.selector) { // Tokens rejected revert IERC1155Errors.ERC1155InvalidReceiver(to); } } catch (bytes memory reason) { if (reason.length == 0) { // non-IERC1155Receiver implementer revert IERC1155Errors.ERC1155InvalidReceiver(to); } else { assembly ("memory-safe") { revert(add(32, reason), mload(reason)) } } } } } /** * @dev Performs a batch acceptance check for the provided `operator` by calling {IERC1155-onERC1155BatchReceived} * 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 {IERC1155Receiver-onERC1155Received} and return the acceptance magic value to accept * the transfer. */ function checkOnERC1155BatchReceived( address operator, address from, address to, uint256[] memory ids, uint256[] memory values, bytes memory data ) internal { if (to.code.length > 0) { try IERC1155Receiver(to).onERC1155BatchReceived(operator, from, ids, values, data) returns ( bytes4 response ) { if (response != IERC1155Receiver.onERC1155BatchReceived.selector) { // Tokens rejected revert IERC1155Errors.ERC1155InvalidReceiver(to); } } catch (bytes memory reason) { if (reason.length == 0) { // non-IERC1155Receiver implementer revert IERC1155Errors.ERC1155InvalidReceiver(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/Arrays.sol) // This file was procedurally generated from scripts/generate/templates/Arrays.js. pragma solidity ^0.8.20; import {Comparators} from "./Comparators.sol"; import {SlotDerivation} from "./SlotDerivation.sol"; import {StorageSlot} from "./StorageSlot.sol"; import {Math} from "./math/Math.sol"; /** * @dev Collection of functions related to array types. */ library Arrays { using SlotDerivation for bytes32; using StorageSlot for bytes32; /** * @dev Sort an array of uint256 (in memory) following the provided comparator function. * * This function does the sorting "in place", meaning that it overrides the input. The object is returned for * convenience, but that returned value can be discarded safely if the caller has a memory pointer to the array. * * NOTE: this function's cost is `O(n · log(n))` in average and `O(n²)` in the worst case, with n the length of the * array. Using it in view functions that are executed through `eth_call` is safe, but one should be very careful * when executing this as part of a transaction. If the array being sorted is too large, the sort operation may * consume more gas than is available in a block, leading to potential DoS. * * IMPORTANT: Consider memory side-effects when using custom comparator functions that access memory in an unsafe way. */ function sort( uint256[] memory array, function(uint256, uint256) pure returns (bool) comp ) internal pure returns (uint256[] memory) { _quickSort(_begin(array), _end(array), comp); return array; } /** * @dev Variant of {sort} that sorts an array of uint256 in increasing order. */ function sort(uint256[] memory array) internal pure returns (uint256[] memory) { sort(array, Comparators.lt); return array; } /** * @dev Sort an array of address (in memory) following the provided comparator function. * * This function does the sorting "in place", meaning that it overrides the input. The object is returned for * convenience, but that returned value can be discarded safely if the caller has a memory pointer to the array. * * NOTE: this function's cost is `O(n · log(n))` in average and `O(n²)` in the worst case, with n the length of the * array. Using it in view functions that are executed through `eth_call` is safe, but one should be very careful * when executing this as part of a transaction. If the array being sorted is too large, the sort operation may * consume more gas than is available in a block, leading to potential DoS. * * IMPORTANT: Consider memory side-effects when using custom comparator functions that access memory in an unsafe way. */ function sort( address[] memory array, function(address, address) pure returns (bool) comp ) internal pure returns (address[] memory) { sort(_castToUint256Array(array), _castToUint256Comp(comp)); return array; } /** * @dev Variant of {sort} that sorts an array of address in increasing order. */ function sort(address[] memory array) internal pure returns (address[] memory) { sort(_castToUint256Array(array), Comparators.lt); return array; } /** * @dev Sort an array of bytes32 (in memory) following the provided comparator function. * * This function does the sorting "in place", meaning that it overrides the input. The object is returned for * convenience, but that returned value can be discarded safely if the caller has a memory pointer to the array. * * NOTE: this function's cost is `O(n · log(n))` in average and `O(n²)` in the worst case, with n the length of the * array. Using it in view functions that are executed through `eth_call` is safe, but one should be very careful * when executing this as part of a transaction. If the array being sorted is too large, the sort operation may * consume more gas than is available in a block, leading to potential DoS. * * IMPORTANT: Consider memory side-effects when using custom comparator functions that access memory in an unsafe way. */ function sort( bytes32[] memory array, function(bytes32, bytes32) pure returns (bool) comp ) internal pure returns (bytes32[] memory) { sort(_castToUint256Array(array), _castToUint256Comp(comp)); return array; } /** * @dev Variant of {sort} that sorts an array of bytes32 in increasing order. */ function sort(bytes32[] memory array) internal pure returns (bytes32[] memory) { sort(_castToUint256Array(array), Comparators.lt); return array; } /** * @dev Performs a quick sort of a segment of memory. The segment sorted starts at `begin` (inclusive), and stops * at end (exclusive). Sorting follows the `comp` comparator. * * Invariant: `begin <= end`. This is the case when initially called by {sort} and is preserved in subcalls. * * IMPORTANT: Memory locations between `begin` and `end` are not validated/zeroed. This function should * be used only if the limits are within a memory array. */ function _quickSort(uint256 begin, uint256 end, function(uint256, uint256) pure returns (bool) comp) private pure { unchecked { if (end - begin < 0x40) return; // Use first element as pivot uint256 pivot = _mload(begin); // Position where the pivot should be at the end of the loop uint256 pos = begin; for (uint256 it = begin + 0x20; it < end; it += 0x20) { if (comp(_mload(it), pivot)) { // If the value stored at the iterator's position comes before the pivot, we increment the // position of the pivot and move the value there. pos += 0x20; _swap(pos, it); } } _swap(begin, pos); // Swap pivot into place _quickSort(begin, pos, comp); // Sort the left side of the pivot _quickSort(pos + 0x20, end, comp); // Sort the right side of the pivot } } /** * @dev Pointer to the memory location of the first element of `array`. */ function _begin(uint256[] memory array) private pure returns (uint256 ptr) { assembly ("memory-safe") { ptr := add(array, 0x20) } } /** * @dev Pointer to the memory location of the first memory word (32bytes) after `array`. This is the memory word * that comes just after the last element of the array. */ function _end(uint256[] memory array) private pure returns (uint256 ptr) { unchecked { return _begin(array) + array.length * 0x20; } } /** * @dev Load memory word (as a uint256) at location `ptr`. */ function _mload(uint256 ptr) private pure returns (uint256 value) { assembly ("memory-safe") { value := mload(ptr) } } /** * @dev Swaps the elements memory location `ptr1` and `ptr2`. */ function _swap(uint256 ptr1, uint256 ptr2) private pure { assembly ("memory-safe") { let value1 := mload(ptr1) let value2 := mload(ptr2) mstore(ptr1, value2) mstore(ptr2, value1) } } /// @dev Helper: low level cast address memory array to uint256 memory array function _castToUint256Array(address[] memory input) private pure returns (uint256[] memory output) { assembly ("memory-safe") { output := input } } /// @dev Helper: low level cast bytes32 memory array to uint256 memory array function _castToUint256Array(bytes32[] memory input) private pure returns (uint256[] memory output) { assembly ("memory-safe") { output := input } } /// @dev Helper: low level cast address comp function to uint256 comp function function _castToUint256Comp( function(address, address) pure returns (bool) input ) private pure returns (function(uint256, uint256) pure returns (bool) output) { assembly ("memory-safe") { output := input } } /// @dev Helper: low level cast bytes32 comp function to uint256 comp function function _castToUint256Comp( function(bytes32, bytes32) pure returns (bool) input ) private pure returns (function(uint256, uint256) pure returns (bool) output) { assembly ("memory-safe") { output := input } } /** * @dev Searches a sorted `array` and returns the first index that contains * a value greater or equal to `element`. If no such index exists (i.e. all * values in the array are strictly less than `element`), the array length is * returned. Time complexity O(log n). * * NOTE: The `array` is expected to be sorted in ascending order, and to * contain no repeated elements. * * IMPORTANT: Deprecated. This implementation behaves as {lowerBound} but lacks * support for repeated elements in the array. The {lowerBound} function should * be used instead. */ function findUpperBound(uint256[] storage array, uint256 element) internal view returns (uint256) { uint256 low = 0; uint256 high = array.length; if (high == 0) { return 0; } while (low < high) { uint256 mid = Math.average(low, high); // Note that mid will always be strictly less than high (i.e. it will be a valid array index) // because Math.average rounds towards zero (it does integer division with truncation). if (unsafeAccess(array, mid).value > element) { high = mid; } else { low = mid + 1; } } // At this point `low` is the exclusive upper bound. We will return the inclusive upper bound. if (low > 0 && unsafeAccess(array, low - 1).value == element) { return low - 1; } else { return low; } } /** * @dev Searches an `array` sorted in ascending order and returns the first * index that contains a value greater or equal than `element`. If no such index * exists (i.e. all values in the array are strictly less than `element`), the array * length is returned. Time complexity O(log n). * * See C++'s https://en.cppreference.com/w/cpp/algorithm/lower_bound[lower_bound]. */ function lowerBound(uint256[] storage array, uint256 element) internal view returns (uint256) { uint256 low = 0; uint256 high = array.length; if (high == 0) { return 0; } while (low < high) { uint256 mid = Math.average(low, high); // Note that mid will always be strictly less than high (i.e. it will be a valid array index) // because Math.average rounds towards zero (it does integer division with truncation). if (unsafeAccess(array, mid).value < element) { // this cannot overflow because mid < high unchecked { low = mid + 1; } } else { high = mid; } } return low; } /** * @dev Searches an `array` sorted in ascending order and returns the first * index that contains a value strictly greater than `element`. If no such index * exists (i.e. all values in the array are strictly less than `element`), the array * length is returned. Time complexity O(log n). * * See C++'s https://en.cppreference.com/w/cpp/algorithm/upper_bound[upper_bound]. */ function upperBound(uint256[] storage array, uint256 element) internal view returns (uint256) { uint256 low = 0; uint256 high = array.length; if (high == 0) { return 0; } while (low < high) { uint256 mid = Math.average(low, high); // Note that mid will always be strictly less than high (i.e. it will be a valid array index) // because Math.average rounds towards zero (it does integer division with truncation). if (unsafeAccess(array, mid).value > element) { high = mid; } else { // this cannot overflow because mid < high unchecked { low = mid + 1; } } } return low; } /** * @dev Same as {lowerBound}, but with an array in memory. */ function lowerBoundMemory(uint256[] memory array, uint256 element) internal pure returns (uint256) { uint256 low = 0; uint256 high = array.length; if (high == 0) { return 0; } while (low < high) { uint256 mid = Math.average(low, high); // Note that mid will always be strictly less than high (i.e. it will be a valid array index) // because Math.average rounds towards zero (it does integer division with truncation). if (unsafeMemoryAccess(array, mid) < element) { // this cannot overflow because mid < high unchecked { low = mid + 1; } } else { high = mid; } } return low; } /** * @dev Same as {upperBound}, but with an array in memory. */ function upperBoundMemory(uint256[] memory array, uint256 element) internal pure returns (uint256) { uint256 low = 0; uint256 high = array.length; if (high == 0) { return 0; } while (low < high) { uint256 mid = Math.average(low, high); // Note that mid will always be strictly less than high (i.e. it will be a valid array index) // because Math.average rounds towards zero (it does integer division with truncation). if (unsafeMemoryAccess(array, mid) > element) { high = mid; } else { // this cannot overflow because mid < high unchecked { low = mid + 1; } } } return low; } /** * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check. * * WARNING: Only use if you are certain `pos` is lower than the array length. */ function unsafeAccess(address[] storage arr, uint256 pos) internal pure returns (StorageSlot.AddressSlot storage) { bytes32 slot; assembly ("memory-safe") { slot := arr.slot } return slot.deriveArray().offset(pos).getAddressSlot(); } /** * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check. * * WARNING: Only use if you are certain `pos` is lower than the array length. */ function unsafeAccess(bytes32[] storage arr, uint256 pos) internal pure returns (StorageSlot.Bytes32Slot storage) { bytes32 slot; assembly ("memory-safe") { slot := arr.slot } return slot.deriveArray().offset(pos).getBytes32Slot(); } /** * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check. * * WARNING: Only use if you are certain `pos` is lower than the array length. */ function unsafeAccess(uint256[] storage arr, uint256 pos) internal pure returns (StorageSlot.Uint256Slot storage) { bytes32 slot; assembly ("memory-safe") { slot := arr.slot } return slot.deriveArray().offset(pos).getUint256Slot(); } /** * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check. * * WARNING: Only use if you are certain `pos` is lower than the array length. */ function unsafeMemoryAccess(address[] memory arr, uint256 pos) internal pure returns (address res) { assembly ("memory-safe") { res := mload(add(add(arr, 0x20), mul(pos, 0x20))) } } /** * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check. * * WARNING: Only use if you are certain `pos` is lower than the array length. */ function unsafeMemoryAccess(bytes32[] memory arr, uint256 pos) internal pure returns (bytes32 res) { assembly ("memory-safe") { res := mload(add(add(arr, 0x20), mul(pos, 0x20))) } } /** * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check. * * WARNING: Only use if you are certain `pos` is lower than the array length. */ function unsafeMemoryAccess(uint256[] memory arr, uint256 pos) internal pure returns (uint256 res) { assembly ("memory-safe") { res := mload(add(add(arr, 0x20), mul(pos, 0x20))) } } /** * @dev Helper to set the length of an dynamic array. Directly writing to `.length` is forbidden. * * WARNING: this does not clear elements if length is reduced, of initialize elements if length is increased. */ function unsafeSetLength(address[] storage array, uint256 len) internal { assembly ("memory-safe") { sstore(array.slot, len) } } /** * @dev Helper to set the length of an dynamic array. Directly writing to `.length` is forbidden. * * WARNING: this does not clear elements if length is reduced, of initialize elements if length is increased. */ function unsafeSetLength(bytes32[] storage array, uint256 len) internal { assembly ("memory-safe") { sstore(array.slot, len) } } /** * @dev Helper to set the length of an dynamic array. Directly writing to `.length` is forbidden. * * WARNING: this does not clear elements if length is reduced, of initialize elements if length is increased. */ function unsafeSetLength(uint256[] storage array, uint256 len) internal { assembly ("memory-safe") { sstore(array.slot, len) } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.1.0) (utils/Comparators.sol) pragma solidity ^0.8.20; /** * @dev Provides a set of functions to compare values. * * _Available since v5.1._ */ library Comparators { function lt(uint256 a, uint256 b) internal pure returns (bool) { return a < b; } function gt(uint256 a, uint256 b) internal pure returns (bool) { return a > b; } }
// 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 ("memory-safe") { 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 ("memory-safe") { // 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 ("memory-safe") { // 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/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/SlotDerivation.sol) // This file was procedurally generated from scripts/generate/templates/SlotDerivation.js. pragma solidity ^0.8.20; /** * @dev Library for computing storage (and transient storage) locations from namespaces and deriving slots * corresponding to standard patterns. The derivation method for array and mapping matches the storage layout used by * the solidity language / compiler. * * See https://docs.soliditylang.org/en/v0.8.20/internals/layout_in_storage.html#mappings-and-dynamic-arrays[Solidity docs for mappings and dynamic arrays.]. * * Example usage: * ```solidity * contract Example { * // Add the library methods * using StorageSlot for bytes32; * using SlotDerivation for bytes32; * * // Declare a namespace * string private constant _NAMESPACE = "<namespace>" // eg. OpenZeppelin.Slot * * function setValueInNamespace(uint256 key, address newValue) internal { * _NAMESPACE.erc7201Slot().deriveMapping(key).getAddressSlot().value = newValue; * } * * function getValueInNamespace(uint256 key) internal view returns (address) { * return _NAMESPACE.erc7201Slot().deriveMapping(key).getAddressSlot().value; * } * } * ``` * * TIP: Consider using this library along with {StorageSlot}. * * NOTE: This library provides a way to manipulate storage locations in a non-standard way. Tooling for checking * upgrade safety will ignore the slots accessed through this library. * * _Available since v5.1._ */ library SlotDerivation { /** * @dev Derive an ERC-7201 slot from a string (namespace). */ function erc7201Slot(string memory namespace) internal pure returns (bytes32 slot) { assembly ("memory-safe") { mstore(0x00, sub(keccak256(add(namespace, 0x20), mload(namespace)), 1)) slot := and(keccak256(0x00, 0x20), not(0xff)) } } /** * @dev Add an offset to a slot to get the n-th element of a structure or an array. */ function offset(bytes32 slot, uint256 pos) internal pure returns (bytes32 result) { unchecked { return bytes32(uint256(slot) + pos); } } /** * @dev Derive the location of the first element in an array from the slot where the length is stored. */ function deriveArray(bytes32 slot) internal pure returns (bytes32 result) { assembly ("memory-safe") { mstore(0x00, slot) result := keccak256(0x00, 0x20) } } /** * @dev Derive the location of a mapping element from the key. */ function deriveMapping(bytes32 slot, address key) internal pure returns (bytes32 result) { assembly ("memory-safe") { mstore(0x00, and(key, shr(96, not(0)))) mstore(0x20, slot) result := keccak256(0x00, 0x40) } } /** * @dev Derive the location of a mapping element from the key. */ function deriveMapping(bytes32 slot, bool key) internal pure returns (bytes32 result) { assembly ("memory-safe") { mstore(0x00, iszero(iszero(key))) mstore(0x20, slot) result := keccak256(0x00, 0x40) } } /** * @dev Derive the location of a mapping element from the key. */ function deriveMapping(bytes32 slot, bytes32 key) internal pure returns (bytes32 result) { assembly ("memory-safe") { mstore(0x00, key) mstore(0x20, slot) result := keccak256(0x00, 0x40) } } /** * @dev Derive the location of a mapping element from the key. */ function deriveMapping(bytes32 slot, uint256 key) internal pure returns (bytes32 result) { assembly ("memory-safe") { mstore(0x00, key) mstore(0x20, slot) result := keccak256(0x00, 0x40) } } /** * @dev Derive the location of a mapping element from the key. */ function deriveMapping(bytes32 slot, int256 key) internal pure returns (bytes32 result) { assembly ("memory-safe") { mstore(0x00, key) mstore(0x20, slot) result := keccak256(0x00, 0x40) } } /** * @dev Derive the location of a mapping element from the key. */ function deriveMapping(bytes32 slot, string memory key) internal pure returns (bytes32 result) { assembly ("memory-safe") { let length := mload(key) let begin := add(key, 0x20) let end := add(begin, length) let cache := mload(end) mstore(end, slot) result := keccak256(begin, add(length, 0x20)) mstore(end, cache) } } /** * @dev Derive the location of a mapping element from the key. */ function deriveMapping(bytes32 slot, bytes memory key) internal pure returns (bytes32 result) { assembly ("memory-safe") { let length := mload(key) let begin := add(key, 0x20) let end := add(begin, length) let cache := mload(end) mstore(end, slot) result := keccak256(begin, add(length, 0x20)) mstore(end, cache) } } }
// 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 pragma solidity ^0.8.28; import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol"; import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol"; contract AdminAccess is UUPSUpgradeable, OwnableUpgradeable { mapping(address admin => bool isAdmin) private _admins; mapping(address admin => bool isAdmin) private _promotionalAdmins; /// @custom:oz-upgrades-unsafe-allow constructor constructor() { _disableInitializers(); } function initialize(address[] calldata admins, address[] calldata promotionalAdmins) public initializer { __Ownable_init(_msgSender()); __UUPSUpgradeable_init(); _updateAdmins(admins, true); _updatePromotionalAdmins(promotionalAdmins, true); } function _updateAdmins(address[] calldata admins, bool hasAdmin) internal { uint256 bounds = admins.length; for (uint256 i; i < bounds; ++i) { _admins[admins[i]] = hasAdmin; } } function _updatePromotionalAdmins(address[] calldata promotionalAdmins, bool hasAdmin) internal { uint256 bounds = promotionalAdmins.length; for (uint256 i; i < bounds; ++i) { _promotionalAdmins[promotionalAdmins[i]] = hasAdmin; } } function isAdmin(address admin) external view returns (bool) { return _admins[admin]; } function addAdmins(address[] calldata admins) external onlyOwner { _updateAdmins(admins, true); } function removeAdmins(address[] calldata admins) external onlyOwner { _updateAdmins(admins, false); } function isPromotionalAdmin(address admin) external view returns (bool) { return _promotionalAdmins[admin]; } function addPromotionalAdmins(address[] calldata admins) external onlyOwner { _updatePromotionalAdmins(admins, true); } function removePromotionalAdmins(address[] calldata admins) external onlyOwner { _updatePromotionalAdmins(admins, false); } // solhint-disable-next-line no-empty-blocks function _authorizeUpgrade(address newImplementation) internal override onlyOwner {} }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.28; import {Skill, Attire, CombatStyle, CombatStats} from "./misc.sol"; import {GuaranteedReward, RandomReward} from "./rewards.sol"; enum ActionQueueStrategy { OVERWRITE, APPEND, KEEP_LAST_IN_PROGRESS } struct QueuedActionInput { Attire attire; uint16 actionId; uint16 regenerateId; // Food (combat), maybe something for non-combat later uint16 choiceId; // Melee/Ranged/Magic (combat), logs, ore (non-combat) uint16 rightHandEquipmentTokenId; // Axe/Sword/bow, can be empty uint16 leftHandEquipmentTokenId; // Shield, can be empty uint24 timespan; // How long to queue the action for uint8 combatStyle; // CombatStyle specific style of combat uint40 petId; // id of the pet (can be empty) } struct QueuedAction { uint16 actionId; uint16 regenerateId; // Food (combat), maybe something for non-combat later uint16 choiceId; // Melee/Ranged/Magic (combat), logs, ore (non-combat) uint16 rightHandEquipmentTokenId; // Axe/Sword/bow, can be empty uint16 leftHandEquipmentTokenId; // Shield, can be empty uint24 timespan; // How long to queue the action for uint24 prevProcessedTime; // How long the action has been processed for previously uint24 prevProcessedXPTime; // How much XP has been gained for this action so far uint64 queueId; // id of this queued action bytes1 packed; // 1st bit is isValid (not used yet), 2nd bit is for hasPet (decides if the 2nd storage slot is read) uint8 combatStyle; uint24 reserved; // Next storage slot uint40 petId; // id of the pet (can be empty) } // This is only used as an input arg (and events) struct ActionInput { uint16 actionId; ActionInfo info; GuaranteedReward[] guaranteedRewards; RandomReward[] randomRewards; CombatStats combatStats; } struct ActionInfo { uint8 skill; bool actionChoiceRequired; // If true, then the user must choose an action choice uint24 xpPerHour; uint32 minXP; uint24 numSpawned; // Mostly for combat, capped respawn rate for xp/drops. Per hour, base 10000 uint16 handItemTokenIdRangeMin; // Inclusive uint16 handItemTokenIdRangeMax; // Inclusive uint8 successPercent; // 0-100 uint8 worldLocation; // 0 is the main starting world bool isFullModeOnly; bool isAvailable; uint16 questPrerequisiteId; } uint16 constant ACTIONCHOICE_MELEE_BASIC_SWORD = 1500; uint16 constant ACTIONCHOICE_MAGIC_SHADOW_BLAST = 2000; uint16 constant ACTIONCHOICE_RANGED_BASIC_BOW = 3000; // Allows for 2, 4 or 8 hour respawn time uint256 constant SPAWN_MUL = 1000; uint256 constant RATE_MUL = 1000; uint256 constant GUAR_MUL = 10; // Guaranteeded reward multiplier (1 decimal, allows for 2 hour action times) uint256 constant MAX_QUEUEABLE_ACTIONS = 3; // Available slots to queue actions
// SPDX-License-Identifier: MIT pragma solidity ^0.8.28; import "./actions.sol"; import "./items.sol"; import "./misc.sol"; import "./players.sol"; import "./rewards.sol"; import "./quests.sol"; import "./promotions.sol"; import "./clans.sol"; import "./pets.sol";
// SPDX-License-Identifier: MIT pragma solidity ^0.8.28; import {IBank} from "../interfaces/IBank.sol"; enum ClanRank { NONE, // Not in a clan COMMONER, // Member of the clan SCOUT, // Invite and kick commoners COLONEL, // Can launch attacks and assign combatants TREASURER, // Can withdraw from bank LEADER, // Can edit clan details OWNER // Can do everything and transfer ownership } enum BattleResultEnum { DRAW, WIN, LOSE } struct ClanBattleInfo { uint40 lastClanIdAttackOtherClanIdCooldownTimestamp; uint8 numReattacks; uint40 lastOtherClanIdAttackClanIdCooldownTimestamp; uint8 numReattacksOtherClan; } // Packed for gas efficiency struct Vault { bool claimed; // Only applies to the first one, if it's claimed without the second one being claimed uint40 timestamp; uint80 amount; uint40 timestamp1; uint80 amount1; } struct VaultClanInfo { IBank bank; uint96 totalBrushLocked; // New storage slot uint40 attackingCooldownTimestamp; uint40 assignCombatantsCooldownTimestamp; bool currentlyAttacking; uint24 defendingVaultsOffset; uint40 blockAttacksTimestamp; uint8 blockAttacksCooldownHours; bool isInMMRArray; uint40 superAttackCooldownTimestamp; uint64[] playerIds; Vault[] defendingVaults; // Append only, and use defendingVaultsOffset to decide where the real start is } uint256 constant MAX_CLAN_COMBATANTS = 20; uint256 constant CLAN_WARS_GAS_PRICE_WINDOW_SIZE = 4; bool constant XP_EMITTED_ELSEWHERE = true;
// SPDX-License-Identifier: MIT pragma solidity ^0.8.28; uint16 constant NONE = 0; uint16 constant COMBAT_BASE = 2048; // Melee uint16 constant SWORD_BASE = COMBAT_BASE; uint16 constant BRONZE_SWORD = SWORD_BASE; // Woodcutting (2816 - 3071) uint16 constant WOODCUTTING_BASE = 2816; uint16 constant BRONZE_AXE = WOODCUTTING_BASE; // Firemaking (3328 - 3583) uint16 constant FIRE_BASE = 3328; uint16 constant MAGIC_FIRE_STARTER = FIRE_BASE; uint16 constant FIRE_MAX = FIRE_BASE + 255; // Fishing (3072 - 3327) uint16 constant FISHING_BASE = 3072; uint16 constant NET_STICK = FISHING_BASE; // Mining (2560 - 2815) uint16 constant MINING_BASE = 2560; uint16 constant BRONZE_PICKAXE = MINING_BASE; // Magic uint16 constant STAFF_BASE = COMBAT_BASE + 50; uint16 constant TOTEM_STAFF = STAFF_BASE; // Ranged uint16 constant BOW_BASE = COMBAT_BASE + 100; uint16 constant BASIC_BOW = BOW_BASE; // Cooked fish uint16 constant COOKED_FISH_BASE = 11008; uint16 constant COOKED_FEOLA = COOKED_FISH_BASE + 3; // Scrolls uint16 constant SCROLL_BASE = 12032; uint16 constant SHADOW_SCROLL = SCROLL_BASE; // Boosts uint16 constant BOOST_BASE = 12800; uint16 constant COMBAT_BOOST = BOOST_BASE; uint16 constant XP_BOOST = BOOST_BASE + 1; uint16 constant GATHERING_BOOST = BOOST_BASE + 2; uint16 constant SKILL_BOOST = BOOST_BASE + 3; uint16 constant ABSENCE_BOOST = BOOST_BASE + 4; uint16 constant LUCKY_POTION = BOOST_BASE + 5; uint16 constant LUCK_OF_THE_DRAW = BOOST_BASE + 6; uint16 constant PRAY_TO_THE_BEARDIE = BOOST_BASE + 7; uint16 constant PRAY_TO_THE_BEARDIE_2 = BOOST_BASE + 8; uint16 constant PRAY_TO_THE_BEARDIE_3 = BOOST_BASE + 9; uint16 constant BOOST_RESERVED_1 = BOOST_BASE + 10; uint16 constant BOOST_RESERVED_2 = BOOST_BASE + 11; uint16 constant BOOST_RESERVED_3 = BOOST_BASE + 12; uint16 constant GO_OUTSIDE = BOOST_BASE + 13; uint16 constant RAINING_RARES = BOOST_BASE + 14; uint16 constant CLAN_BOOSTER = BOOST_BASE + 15; uint16 constant CLAN_BOOSTER_2 = BOOST_BASE + 16; uint16 constant CLAN_BOOSTER_3 = BOOST_BASE + 17; uint16 constant BOOST_RESERVED_4 = BOOST_BASE + 18; uint16 constant BOOST_RESERVED_5 = BOOST_BASE + 19; uint16 constant BOOST_RESERVED_6 = BOOST_BASE + 20; uint16 constant BOOST_MAX = 13055; // Eggs uint16 constant EGG_BASE = 12544; uint16 constant SECRET_EGG_1_TIER1 = EGG_BASE; uint16 constant SECRET_EGG_2_TIER1 = EGG_BASE + 1; uint16 constant EGG_MAX = 12799; // Miscs uint16 constant MISC_BASE = 65535; uint16 constant RAID_PASS = MISC_BASE - 1; struct BulkTransferInfo { uint256[] tokenIds; uint256[] amounts; address to; }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.28; enum BoostType { NONE, ANY_XP, COMBAT_XP, NON_COMBAT_XP, GATHERING, ABSENCE, PASSIVE_SKIP_CHANCE, // Clan wars PVP_BLOCK, PVP_REATTACK, PVP_SUPER_ATTACK, // Combat stats COMBAT_FIXED } struct Equipment { uint16 itemTokenId; uint24 amount; } enum Skill { NONE, COMBAT, // This is a helper which incorporates all combat skills, attack <-> magic, defence, health etc MELEE, RANGED, MAGIC, DEFENCE, HEALTH, RESERVED_COMBAT, MINING, WOODCUTTING, FISHING, SMITHING, THIEVING, CRAFTING, COOKING, FIREMAKING, FARMING, ALCHEMY, FLETCHING, FORGING, RESERVED2, RESERVED3, RESERVED4, RESERVED5, RESERVED6, RESERVED7, RESERVED8, RESERVED9, RESERVED10, RESERVED11, RESERVED12, RESERVED13, RESERVED14, RESERVED15, RESERVED16, RESERVED17, RESERVED18, RESERVED19, RESERVED20, TRAVELING // Helper Skill for travelling } struct Attire { uint16 head; uint16 neck; uint16 body; uint16 arms; uint16 legs; uint16 feet; uint16 ring; uint16 reserved1; } struct CombatStats { // From skill points int16 meleeAttack; int16 magicAttack; int16 rangedAttack; int16 health; // These include equipment int16 meleeDefence; int16 magicDefence; int16 rangedDefence; } enum CombatStyle { NONE, ATTACK, DEFENCE }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.28; import {Skill} from "./misc.sol"; enum PetSkin { NONE, DEFAULT, OG, ONEKIN, FROST, CRYSTAL, ANNIV1, KRAGSTYR } enum PetEnhancementType { NONE, MELEE, MAGIC, RANGED, DEFENCE, HEALTH, MELEE_AND_DEFENCE, MAGIC_AND_DEFENCE, RANGED_AND_DEFENCE } struct Pet { Skill skillEnhancement1; uint8 skillFixedEnhancement1; uint8 skillPercentageEnhancement1; Skill skillEnhancement2; uint8 skillFixedEnhancement2; uint8 skillPercentageEnhancement2; uint40 lastAssignmentTimestamp; address owner; // Will be used as an optimization to avoid having to look up the owner of the pet in another storage slot bool isTransferable; // New storage slot uint24 baseId; // These are used when training a pet uint40 lastTrainedTimestamp; uint8 skillFixedEnhancementMax1; // The maximum possible value for skillFixedEnhancement1 when training uint8 skillFixedEnhancementMax2; uint8 skillPercentageEnhancementMax1; uint8 skillPercentageEnhancementMax2; uint64 xp; } struct BasePetMetadata { string description; uint8 tier; PetSkin skin; PetEnhancementType enhancementType; Skill skillEnhancement1; uint8 skillFixedMin1; uint8 skillFixedMax1; uint8 skillFixedIncrement1; uint8 skillPercentageMin1; uint8 skillPercentageMax1; uint8 skillPercentageIncrement1; uint8 skillMinLevel1; Skill skillEnhancement2; uint8 skillFixedMin2; uint8 skillFixedMax2; uint8 skillFixedIncrement2; uint8 skillPercentageMin2; uint8 skillPercentageMax2; uint8 skillPercentageIncrement2; uint8 skillMinLevel2; uint16 fixedStarThreshold; uint16 percentageStarThreshold; bool isTransferable; }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.28; import {QueuedAction} from "./actions.sol"; import {Skill, BoostType, CombatStats, Equipment} from "./misc.sol"; import {PlayerQuest} from "./quests.sol"; // 4 bytes for each level. 0x00000000 is the first level, 0x00000054 is the second, etc. bytes constant XP_BYTES = hex"0000000000000054000000AE0000010E00000176000001E60000025E000002DE00000368000003FD0000049B00000546000005FC000006C000000792000008730000096400000A6600000B7B00000CA400000DE100000F36000010A200001229000013CB0000158B0000176B0000196E00001B9400001DE20000205A000022FF000025D5000028DD00002C1E00002F99000033540000375200003B9A000040300000451900004A5C00004FFF0000560900005C810000637000006ADD000072D100007B570000847900008E42000098BE0000A3F90000B0020000BCE70000CAB80000D9860000E9630000FA6200010C990001201D0001350600014B6F0001637300017D2E000198C10001B64E0001D5F80001F7E600021C430002433B00026CFD000299BE0002C9B30002FD180003342B00036F320003AE730003F23D00043AE3000488BE0004DC2F0005359B000595700005FC2400066A360006E02D00075E990007E6160008774C000912EB0009B9B4000A6C74000B2C06000BF956000CD561000DC134000EBDF3000FCCD40010EF2400122648001373BF0014D9230016582C0017F2B00019AAA9001B8234001D7B95001F99390021DDBC00244BE60026E6B60029B15F002CAF51002FE43A0033540D00370303003AF5A4003F30CC0043B9B0004895E3004DCB600053609100595C53005FC6030066A585006E034D0075E86C007E5E980087703B0091287D009B935300A6BD8F00B2B4EE00BF882800CD470500DC026F00EBCC8500FCB8B7010EDBD5"; uint256 constant MAX_LEVEL = 140; // Original max level uint256 constant MAX_LEVEL_1 = 160; // TODO: Update later uint256 constant MAX_LEVEL_2 = 190; // TODO: Update later enum EquipPosition { NONE, HEAD, NECK, BODY, ARMS, LEGS, FEET, RING, SPARE2, LEFT_HAND, RIGHT_HAND, BOTH_HANDS, QUIVER, MAGIC_BAG, FOOD, AUX, // wood, seeds etc.. BOOST_VIAL, EXTRA_BOOST_VIAL, GLOBAL_BOOST_VIAL, CLAN_BOOST_VIAL, PASSIVE_BOOST_VIAL, LOCKED_VAULT, TERRITORY } struct Player { uint40 currentActionStartTimestamp; // The in-progress start time of the first queued action Skill currentActionProcessedSkill1; // The skill that the queued action has already gained XP in uint24 currentActionProcessedXPGained1; // The amount of XP that the queued action has already gained Skill currentActionProcessedSkill2; uint24 currentActionProcessedXPGained2; Skill currentActionProcessedSkill3; uint24 currentActionProcessedXPGained3; uint16 currentActionProcessedFoodConsumed; uint16 currentActionProcessedBaseInputItemsConsumedNum; // e.g scrolls, crafting materials etc Skill skillBoosted1; // The first skill that is boosted Skill skillBoosted2; // The second skill that is boosted (if applicable) uint48 totalXP; uint16 totalLevel; // Doesn't not automatically add new skills to it bytes1 packedData; // Contains worldLocation in first 6 bits (0 is the main starting randomnessBeacon), and full mode unlocked in the upper most bit // TODO: Can be up to 7 QueuedAction[] actionQueue; string name; // Raw name } struct Item { EquipPosition equipPosition; bytes1 packedData; // 0x1 exists, upper most bit is full mode uint16 questPrerequisiteId; // Can it be transferred? bool isTransferable; // TODO: Move into packedData // Food uint16 healthRestored; // Boost vial BoostType boostType; uint16 boostValue; // Varies, could be the % increase uint24 boostDuration; // How long the effect of the boost last // Combat stats int16 meleeAttack; int16 magicAttack; int16 rangedAttack; int16 meleeDefence; int16 magicDefence; int16 rangedDefence; int16 health; // Minimum requirements in this skill to use this item (can be NONE) Skill skill; uint32 minXP; } // Used for events struct BoostInfo { uint40 startTime; uint24 duration; uint16 value; uint16 itemTokenId; // Get the effect of it BoostType boostType; } struct PlayerBoostInfo { uint40 startTime; uint24 duration; uint16 value; uint16 itemTokenId; // Get the effect of it BoostType boostType; // Another boost slot (for global/clan boosts this is the "last", for users it is the "extra") uint40 extraOrLastStartTime; uint24 extraOrLastDuration; uint16 extraOrLastValue; uint16 extraOrLastItemTokenId; BoostType extraOrLastBoostType; uint40 cooldown; // Just put here for packing } // This is effectively a ratio to produce 1 of outputTokenId. // Available choices that can be undertaken for an action struct ActionChoiceInput { uint8 skill; // Skill that this action choice is related to uint24 rate; // Rate of output produced per hour (base 1000) 3 decimals uint24 xpPerHour; uint16[] inputTokenIds; uint24[] inputAmounts; uint16 outputTokenId; uint8 outputAmount; uint8 successPercent; // 0-100 uint16 handItemTokenIdRangeMin; // Inclusive uint16 handItemTokenIdRangeMax; // Inclusive bool isFullModeOnly; bool isAvailable; uint16 questPrerequisiteId; uint8[] skills; // Skills required to do this action choice uint32[] skillMinXPs; // Min XP in the corresponding skills to be able to do this action choice int16[] skillDiffs; // How much the skill is increased/decreased by this action choice } struct ActionChoice { uint8 skill; // Skill that this action choice is related to uint24 rate; // Rate of output produced per hour (base 1000) 3 decimals uint24 xpPerHour; uint16 inputTokenId1; uint24 inputAmount1; uint16 inputTokenId2; uint24 inputAmount2; uint16 inputTokenId3; uint24 inputAmount3; uint16 outputTokenId; uint8 outputAmount; uint8 successPercent; // 0-100 uint8 skill1; // Skills required to do this action choice, commonly the same as skill uint32 skillMinXP1; // Min XP in the skill to be able to do this action choice int16 skillDiff1; // How much the skill is increased/decreased by this action choice uint8 skill2; uint32 skillMinXP2; int16 skillDiff2; uint8 skill3; uint32 skillMinXP3; int16 skillDiff3; uint16 handItemTokenIdRangeMin; // Inclusive uint16 handItemTokenIdRangeMax; // Inclusive uint16 questPrerequisiteId; // FullMode is last bit, first 6 bits is worldLocation, // 2nd last bit is if there are other skills in next storage slot to check, // 3rd last bit if the input amounts should be used bytes1 packedData; } // Must be in the same order as Skill enum struct PackedXP { uint40 melee; uint40 ranged; uint40 magic; uint40 defence; uint40 health; uint40 reservedCombat; bytes2 packedDataIsMaxed; // 2 bits per skill to indicate whether the maxed skill is reached. I think this was added in case we added a new max level which a user had already passed so old & new levels are the same and it would not trigger a level up event. // Next slot uint40 mining; uint40 woodcutting; uint40 fishing; uint40 smithing; uint40 thieving; uint40 crafting; bytes2 packedDataIsMaxed1; // 2 bits per skill to indicate whether the maxed skill is reached // Next slot uint40 cooking; uint40 firemaking; uint40 farming; uint40 alchemy; uint40 fletching; uint40 forging; bytes2 packedDataIsMaxed2; // 2 bits per skill to indicate whether the maxed skill is reached } struct AvatarInfo { string name; string description; string imageURI; Skill[2] startSkills; // Can be NONE } struct PastRandomRewardInfo { uint16 itemTokenId; uint24 amount; uint64 queueId; } struct PendingQueuedActionEquipmentState { uint256[] consumedItemTokenIds; uint256[] consumedAmounts; uint256[] producedItemTokenIds; uint256[] producedAmounts; } struct PendingQueuedActionMetadata { uint32 xpGained; // total xp gained uint32 rolls; bool died; uint16 actionId; uint64 queueId; uint24 elapsedTime; uint24 xpElapsedTime; uint8 checkpoint; } struct PendingQueuedActionData { // The amount of XP that the queued action has already gained Skill skill1; uint24 xpGained1; Skill skill2; // Most likely health uint24 xpGained2; Skill skill3; // Could come uint24 xpGained3; // How much food is consumed in the current action so far uint16 foodConsumed; // How many base consumables are consumed in the current action so far uint16 baseInputItemsConsumedNum; } struct PendingQueuedActionProcessed { // XP gained during this session Skill[] skills; uint32[] xpGainedSkills; // Data for the current action which has been previously processed, this is used to store on the Player PendingQueuedActionData currentAction; } struct QuestState { uint256[] consumedItemTokenIds; uint256[] consumedAmounts; uint256[] rewardItemTokenIds; uint256[] rewardAmounts; PlayerQuest[] activeQuestInfo; uint256[] questsCompleted; Skill[] skills; // Skills gained XP in uint32[] xpGainedSkills; // XP gained in these skills } struct LotteryWinnerInfo { uint16 lotteryId; uint24 raffleId; uint16 itemTokenId; uint16 amount; bool instantConsume; uint64 playerId; } struct PendingQueuedActionState { // These 2 are in sync. Separated to reduce gas/deployment costs as these are passed down many layers. PendingQueuedActionEquipmentState[] equipmentStates; PendingQueuedActionMetadata[] actionMetadatas; QueuedAction[] remainingQueuedActions; PastRandomRewardInfo[] producedPastRandomRewards; uint256[] xpRewardItemTokenIds; uint256[] xpRewardAmounts; uint256[] dailyRewardItemTokenIds; uint256[] dailyRewardAmounts; PendingQueuedActionProcessed processedData; bytes32 dailyRewardMask; QuestState quests; uint256 numPastRandomRewardInstancesToRemove; uint8 worldLocation; LotteryWinnerInfo lotteryWinner; } struct FullAttireBonusInput { Skill skill; uint8 bonusXPPercent; uint8 bonusRewardsPercent; // 3 = 3% uint16[5] itemTokenIds; // 0 = head, 1 = body, 2 arms, 3 body, 4 = feet } // Contains everything you need to create an item struct ItemInput { CombatStats combatStats; uint16 tokenId; EquipPosition equipPosition; bool isTransferable; bool isFullModeOnly; bool isAvailable; uint16 questPrerequisiteId; // Minimum requirements in this skill Skill skill; uint32 minXP; // Food uint16 healthRestored; // Boost BoostType boostType; uint16 boostValue; // Varies, could be the % increase uint24 boostDuration; // How long the effect of the boost vial last // uri string metadataURI; string name; } /* Order head, neck, body, arms, legs, feet, ring, reserved1, leftHandEquipment, rightHandEquipment, Not used yet: input1, input2,input3, regenerate, reserved2, reserved3 */ struct CheckpointEquipments { uint16[16] itemTokenIds; uint16[16] balances; } struct ActivePlayerInfo { uint64 playerId; uint40 checkpoint; uint24 timespan; uint24 timespan1; uint24 timespan2; } uint8 constant START_LEVEL = 17; // Needs updating when there is a new skill. Only useful for new heroes. uint256 constant MAX_UNIQUE_TICKETS = 64; // Used in a bunch of places uint256 constant IS_FULL_MODE_BIT = 7; // Passive/Instant/InstantVRF/Actions/ActionChoices/Item action uint256 constant IS_AVAILABLE_BIT = 6; // Passive actions uint256 constant HAS_RANDOM_REWARDS_BIT = 5; // The rest use world location for first 4 bits // Queued action uint256 constant HAS_PET_BIT = 2; uint256 constant IS_VALID_BIT = 1;
// SPDX-License-Identifier: MIT pragma solidity ^0.8.28; enum Promotion { NONE, STARTER, HALLOWEEN_2023, XMAS_2023, HALLOWEEN_2024, HOLIDAY4, // Just have placeholders for now HOLIDAY5, HOLIDAY6, HOLIDAY7, HOLIDAY8, HOLIDAY9, HOLIDAY10 } enum PromotionMintStatus { NONE, SUCCESS, PROMOTION_ALREADY_CLAIMED, ORACLE_NOT_CALLED, MINTING_OUTSIDE_AVAILABLE_DATE, PLAYER_DOES_NOT_QUALIFY, PLAYER_NOT_HIT_ENOUGH_CLAIMS_FOR_STREAK_BONUS, DEPENDENT_QUEST_NOT_COMPLETED } struct PromotionInfoInput { Promotion promotion; uint40 startTime; uint40 endTime; // Exclusive uint8 numDailyRandomItemsToPick; // Number of items to pick uint40 minTotalXP; // Minimum xp required to claim uint256 tokenCost; // Cost in brush to start the promotion, max 16mil // Special promotion specific (like 1kin) uint8 redeemCodeLength; // Length of the redeem code bool adminOnly; // Only admins can mint the promotion, like for 1kin (Not used yet) bool promotionTiedToUser; // If the promotion is tied to a user bool promotionTiedToPlayer; // If the promotion is tied to the player bool promotionMustOwnPlayer; // Must own the player to get the promotion // Evolution specific bool evolvedHeroOnly; // Only allow evolved heroes to claim // Multiday specific bool isMultiday; // The promotion is multi-day uint256 brushCostMissedDay; // Cost in brush to mint the promotion if they miss a day (in ether), max 25.6 (base 100) uint8 numDaysHitNeededForStreakBonus; // How many days to hit for the streak bonus uint8 numDaysClaimablePeriodStreakBonus; // If there is a streak bonus, how many days to claim it after the promotion ends. If no final day bonus, set to 0 uint8 numRandomStreakBonusItemsToPick1; // Number of items to pick for the streak bonus uint8 numRandomStreakBonusItemsToPick2; // Number of random items to pick for the streak bonus uint16[] randomStreakBonusItemTokenIds1; uint32[] randomStreakBonusAmounts1; uint16[] randomStreakBonusItemTokenIds2; uint32[] randomStreakBonusAmounts2; uint16[] guaranteedStreakBonusItemTokenIds; uint16[] guaranteedStreakBonusAmounts; // Single and multiday uint16[] guaranteedItemTokenIds; // Guaranteed items for the promotions each day, if empty then they are handled in a specific way for the promotion like daily rewards uint32[] guaranteedAmounts; // Corresponding amounts to the itemTokenIds uint16[] randomItemTokenIds; // Possible items for the promotions each day, if empty then they are handled in a specific way for the promotion like daily rewards uint32[] randomAmounts; // Corresponding amounts to the randomItemTokenIds // Quests uint16 questPrerequisiteId; } struct PromotionInfo { Promotion promotion; uint40 startTime; uint8 numDays; uint8 numDailyRandomItemsToPick; // Number of items to pick uint40 minTotalXP; // Minimum xp required to claim uint24 tokenCost; // Cost in brush to mint the promotion (in ether), max 16mil // Quests uint16 questPrerequisiteId; // Special promotion specific (like 1kin), could pack these these later uint8 redeemCodeLength; // Length of the redeem code bool adminOnly; // Only admins can mint the promotion, like for 1kin bool promotionTiedToUser; // If the promotion is tied to a user bool promotionTiedToPlayer; // If the promotion is tied to the player bool promotionMustOwnPlayer; // Must own the player to get the promotion // Evolution specific bool evolvedHeroOnly; // Only allow evolved heroes to claim // Multiday specific bool isMultiday; // The promotion is multi-day uint8 brushCostMissedDay; // Cost in brush to mint the promotion if they miss a day (in ether), max 25.5, base 100 uint8 numDaysHitNeededForStreakBonus; // How many days to hit for the streak bonus uint8 numDaysClaimablePeriodStreakBonus; // If there is a streak bonus, how many days to claim it after the promotion ends. If no final day bonus, set to 0 uint8 numRandomStreakBonusItemsToPick1; // Number of items to pick for the streak bonus uint8 numRandomStreakBonusItemsToPick2; // Number of random items to pick for the streak bonus // Misc uint16[] randomStreakBonusItemTokenIds1; uint32[] randomStreakBonusAmounts1; uint16[] randomStreakBonusItemTokenIds2; // Not used yet uint32[] randomStreakBonusAmounts2; // Not used yet uint16[] guaranteedStreakBonusItemTokenIds; // Not used yet uint16[] guaranteedStreakBonusAmounts; // Not used yet // Single and multiday uint16[] guaranteedItemTokenIds; // Guaranteed items for the promotions each day, if empty then they are handled in a specific way for the promotion like daily rewards uint32[] guaranteedAmounts; // Corresponding amounts to the itemTokenIds uint16[] randomItemTokenIds; // Possible items for the promotions each day, if empty then they are handled in a specific way for the promotion like daily rewards uint32[] randomAmounts; // Corresponding amounts to the randomItemTokenIds } uint256 constant BRUSH_COST_MISSED_DAY_MUL = 10;
// SPDX-License-Identifier: MIT pragma solidity ^0.8.28; import {Skill} from "./misc.sol"; struct QuestInput { uint16 dependentQuestId; // The quest that must be completed before this one can be started uint16 actionId1; // action to do uint16 actionNum1; // how many (up to 65535) uint16 actionId2; // another action to do uint16 actionNum2; // how many (up to 65535) uint16 actionChoiceId; // actionChoice to perform uint16 actionChoiceNum; // how many to do (base number), (up to 65535) Skill skillReward; // The skill to reward XP to uint24 skillXPGained; // The amount of XP to give (up to 65535) uint16 rewardItemTokenId1; // Reward an item uint16 rewardAmount1; // amount of the reward (up to 65535) uint16 rewardItemTokenId2; // Reward another item uint16 rewardAmount2; // amount of the reward (up to 65535) uint16 burnItemTokenId; // Burn an item uint16 burnAmount; // amount of the burn (up to 65535) uint16 questId; // Unique id for this quest bool isFullModeOnly; // If true this quest requires the user be evolved uint8 worldLocation; // 0 is the main starting world } struct Quest { uint16 dependentQuestId; // The quest that must be completed before this one can be started uint16 actionId1; // action to do uint16 actionNum1; // how many (up to 65535) uint16 actionId2; // another action to do uint16 actionNum2; // how many (up to 65535) uint16 actionChoiceId; // actionChoice to perform uint16 actionChoiceNum; // how many to do (base number), (up to 65535) Skill skillReward; // The skill to reward XP to uint24 skillXPGained; // The amount of XP to give (up to 65535) uint16 rewardItemTokenId1; // Reward an item uint16 rewardAmount1; // amount of the reward (up to 65535) uint16 rewardItemTokenId2; // Reward another item uint16 rewardAmount2; // amount of the reward (up to 65535) uint16 burnItemTokenId; // Burn an item uint16 burnAmount; // amount of the burn (up to 65535) uint16 reserved; // Reserved for future use (previously was questId and cleared) bytes1 packedData; // FullMode is last bit, first 6 bits is worldLocation } struct PlayerQuest { uint32 questId; uint16 actionCompletedNum1; uint16 actionCompletedNum2; uint16 actionChoiceCompletedNum; uint16 burnCompletedAmount; } uint256 constant QUEST_PURSE_STRINGS = 5; // MAKE SURE THIS MATCHES definitions
// SPDX-License-Identifier: MIT pragma solidity ^0.8.28; import {BoostType, Equipment} from "./misc.sol"; struct GuaranteedReward { uint16 itemTokenId; uint16 rate; // num per hour (base 10, 1 decimal) for actions and num per duration for passive actions } struct RandomReward { uint16 itemTokenId; uint16 chance; // out of 65535 uint8 amount; // out of 255 } struct PendingRandomReward { uint16 actionId; uint40 startTime; uint24 xpElapsedTime; uint16 boostItemTokenId; uint24 elapsedTime; uint40 boostStartTime; // When the boost was started uint24 sentinelElapsedTime; // Full equipment at the time this was generated uint8 fullAttireBonusRewardsPercent; uint64 queueId; // TODO: Could reduce this if more stuff is needed } struct ActionRewards { uint16 guaranteedRewardTokenId1; uint16 guaranteedRewardRate1; // Num per hour base 10 (1 decimal) for actions (Max 6553.5 per hour), num per duration for passive actions uint16 guaranteedRewardTokenId2; uint16 guaranteedRewardRate2; uint16 guaranteedRewardTokenId3; uint16 guaranteedRewardRate3; // Random chance rewards uint16 randomRewardTokenId1; uint16 randomRewardChance1; // out of 65535 uint8 randomRewardAmount1; // out of 255 uint16 randomRewardTokenId2; uint16 randomRewardChance2; uint8 randomRewardAmount2; uint16 randomRewardTokenId3; uint16 randomRewardChance3; uint8 randomRewardAmount3; uint16 randomRewardTokenId4; uint16 randomRewardChance4; uint8 randomRewardAmount4; // No more room in this storage slot! } struct XPThresholdReward { uint32 xpThreshold; Equipment[] rewards; } enum InstantVRFActionType { NONE, GENERIC, FORGING, EGG } struct InstantVRFActionInput { uint16 actionId; uint16[] inputTokenIds; uint24[] inputAmounts; bytes data; InstantVRFActionType actionType; bool isFullModeOnly; bool isAvailable; uint16 questPrerequisiteId; } struct InstantVRFRandomReward { uint16 itemTokenId; uint16 chance; // out of 65535 uint16 amount; // out of 65535 } uint256 constant MAX_GUARANTEED_REWARDS_PER_ACTION = 3; uint256 constant MAX_RANDOM_REWARDS_PER_ACTION = 4; uint256 constant MAX_REWARDS_PER_ACTION = MAX_GUARANTEED_REWARDS_PER_ACTION + MAX_RANDOM_REWARDS_PER_ACTION; uint256 constant MAX_CONSUMED_PER_ACTION = 3; uint256 constant MAX_QUEST_REWARDS = 2; uint256 constant TIER_1_DAILY_REWARD_START_XP = 0; uint256 constant TIER_2_DAILY_REWARD_START_XP = 7_650; uint256 constant TIER_3_DAILY_REWARD_START_XP = 33_913; uint256 constant TIER_4_DAILY_REWARD_START_XP = 195_864; uint256 constant TIER_5_DAILY_REWARD_START_XP = 784_726; uint256 constant TIER_6_DAILY_REWARD_START_XP = 2_219_451; // 4 bytes for each threshold, starts at 500 xp in decimal bytes constant XP_THRESHOLD_REWARDS = hex"00000000000001F4000003E8000009C40000138800002710000075300000C350000186A00001D4C0000493E0000557300007A120000927C0000B71B0000DBBA0000F424000124F800016E360001B7740001E8480002625A0002932E0002DC6C0003567E0003D0900004C4B40005B8D80006ACFC0007A1200008954400098968000A7D8C000B71B0000C65D4000D59F8000E4E1C0";
// SPDX-License-Identifier: MIT pragma solidity ^0.8.28; interface IBank { function initialize() external; function initializeAddresses( uint256 clanId, address bankRegistry, address bankRelay, address playerNFT, address itemNFT, address clans, address players, address lockedBankVaults, address raids ) external; function depositToken(address sender, address from, uint256 playerId, address token, uint256 amount) external; function setAllowBreachedCapacity(bool allow) external; }
//SPDX-License-Identifier: MIT pragma solidity ^0.8.28; interface IBankFactory { function getBankAddress(uint256 clanId) external view returns (address); function getCreatedHere(address bank) external view returns (bool); function createBank(address from, uint256 clanId) external returns (address); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.28; import {Item} from "../globals/players.sol"; interface IItemNFT { function balanceOfs(address account, uint16[] memory ids) external view returns (uint256[] memory); function balanceOfs10(address account, uint16[10] memory ids) external view returns (uint256[] memory); function balanceOf(address account, uint256 id) external view returns (uint256); function getItem(uint16 tokenId) external view returns (Item memory); function getItems(uint16[] calldata tokenIds) external view returns (Item[] memory); function totalSupply(uint256 id) external view returns (uint256); // ERC1155Supply function totalSupply() external view returns (uint256); // ERC1155Supply function mint(address to, uint256 id, uint256 quantity) external; function mintBatch(address to, uint256[] calldata ids, uint256[] calldata quantities) external; function burn(address account, uint256 id, uint256 value) external; function burnBatch(address account, uint256[] calldata ids, uint256[] calldata values) external; function getTimestampFirstMint(uint256 id) external view returns (uint256); function exists(uint256 id) external view returns (bool); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.28; import "../globals/misc.sol"; import "../globals/players.sol"; interface IPlayers { function clearEverythingBeforeTokenTransfer(address from, uint256 tokenId) external; function beforeTokenTransferTo(address to, uint256 tokenId) external; function getURI( uint256 playerId, string calldata name, string calldata avatarName, string calldata avatarDescription, string calldata imageURI ) external view returns (string memory); function mintedPlayer( address from, uint256 playerId, Skill[2] calldata startSkills, bool makeActive, uint256[] calldata startingItemTokenIds, uint256[] calldata startingAmounts ) external; function upgradePlayer(uint256 playerId) external; function isPlayerEvolved(uint256 playerId) external view returns (bool); function isOwnerOfPlayerAndActive(address from, uint256 playerId) external view returns (bool); function getAlphaCombatParams() external view returns (uint8 alphaCombat, uint8 betaCombat, uint8 alphaCombatHealing); function getActivePlayer(address owner) external view returns (uint256 playerId); function getPlayerXP(uint256 playerId, Skill skill) external view returns (uint256 xp); function getLevel(uint256 playerId, Skill skill) external view returns (uint256 level); function getTotalXP(uint256 playerId) external view returns (uint256 totalXP); function getTotalLevel(uint256 playerId) external view returns (uint256 totalLevel); function getActiveBoost(uint256 playerId) external view returns (PlayerBoostInfo memory); function modifyXP(address from, uint256 playerId, Skill skill, uint56 xp, bool skipEffects) external; function beforeItemNFTTransfer(address from, address to, uint256[] calldata ids, uint256[] calldata amounts) external; }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.28; // solhint-disable-next-line no-global-import import "./globals/players.sol"; // This file contains methods for interacting with the item NFT, used to decrease implementation deployment bytecode code. library ItemNFTLibrary { function setItem(ItemInput calldata inputItem, Item storage item) external { bool hasCombat; CombatStats calldata combatStats = inputItem.combatStats; assembly ("memory-safe") { hasCombat := not(iszero(combatStats)) } item.equipPosition = inputItem.equipPosition; item.isTransferable = inputItem.isTransferable; bytes1 packedData = bytes1(uint8(0x1)); // Exists packedData = packedData | bytes1(uint8(inputItem.isFullModeOnly ? 1 << IS_FULL_MODE_BIT : 0)); if (inputItem.isAvailable) { packedData |= bytes1(uint8(1 << IS_AVAILABLE_BIT)); } item.packedData = packedData; item.questPrerequisiteId = inputItem.questPrerequisiteId; if (hasCombat) { // Combat stats item.meleeAttack = inputItem.combatStats.meleeAttack; item.rangedAttack = inputItem.combatStats.rangedAttack; item.magicAttack = inputItem.combatStats.magicAttack; item.meleeDefence = inputItem.combatStats.meleeDefence; item.rangedDefence = inputItem.combatStats.rangedDefence; item.magicDefence = inputItem.combatStats.magicDefence; item.health = inputItem.combatStats.health; } if (inputItem.healthRestored != 0) { item.healthRestored = inputItem.healthRestored; } if (inputItem.boostType != BoostType.NONE) { item.boostType = inputItem.boostType; item.boostValue = inputItem.boostValue; item.boostDuration = inputItem.boostDuration; } item.minXP = inputItem.minXP; item.skill = inputItem.skill; } }
{ "evmVersion": "cancun", "optimizer": { "enabled": true, "runs": 5000, "details": { "yul": true } }, "viaIR": true, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } }, "metadata": { "useLiteralContent": true }, "libraries": { "contracts/ItemNFTLibrary.sol": { "ItemNFTLibrary": "0x8ef4472a1792ae0c326d50c82145d0e0716aed0f" } } }
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":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ERC1155InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC1155InvalidApprover","type":"error"},{"inputs":[{"internalType":"uint256","name":"idsLength","type":"uint256"},{"internalType":"uint256","name":"valuesLength","type":"uint256"}],"name":"ERC1155InvalidArrayLength","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"ERC1155InvalidOperator","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC1155InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC1155InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"address","name":"owner","type":"address"}],"name":"ERC1155MissingApprovalForAll","type":"error"},{"inputs":[{"internalType":"address","name":"implementation","type":"address"}],"name":"ERC1967InvalidImplementation","type":"error"},{"inputs":[],"name":"ERC1967NonPayable","type":"error"},{"inputs":[],"name":"EquipmentPositionShouldNotChange","type":"error"},{"inputs":[],"name":"FailedCall","type":"error"},{"inputs":[],"name":"IdTooHigh","type":"error"},{"inputs":[],"name":"InvalidInitialization","type":"error"},{"inputs":[],"name":"InvalidTokenId","type":"error"},{"inputs":[],"name":"ItemAlreadyExists","type":"error"},{"inputs":[{"internalType":"uint16","name":"","type":"uint16"}],"name":"ItemDoesNotExist","type":"error"},{"inputs":[],"name":"ItemNotTransferable","type":"error"},{"inputs":[],"name":"LengthMismatch","type":"error"},{"inputs":[],"name":"NotBurner","type":"error"},{"inputs":[],"name":"NotInitializing","type":"error"},{"inputs":[],"name":"NotMinter","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":"UUPSUnauthorizedCallContext","type":"error"},{"inputs":[{"internalType":"bytes32","name":"slot","type":"bytes32"}],"name":"UUPSUnsupportedProxiableUUID","type":"error"},{"anonymous":false,"inputs":[{"components":[{"components":[{"internalType":"int16","name":"meleeAttack","type":"int16"},{"internalType":"int16","name":"magicAttack","type":"int16"},{"internalType":"int16","name":"rangedAttack","type":"int16"},{"internalType":"int16","name":"health","type":"int16"},{"internalType":"int16","name":"meleeDefence","type":"int16"},{"internalType":"int16","name":"magicDefence","type":"int16"},{"internalType":"int16","name":"rangedDefence","type":"int16"}],"internalType":"struct CombatStats","name":"combatStats","type":"tuple"},{"internalType":"uint16","name":"tokenId","type":"uint16"},{"internalType":"enum EquipPosition","name":"equipPosition","type":"uint8"},{"internalType":"bool","name":"isTransferable","type":"bool"},{"internalType":"bool","name":"isFullModeOnly","type":"bool"},{"internalType":"bool","name":"isAvailable","type":"bool"},{"internalType":"uint16","name":"questPrerequisiteId","type":"uint16"},{"internalType":"enum Skill","name":"skill","type":"uint8"},{"internalType":"uint32","name":"minXP","type":"uint32"},{"internalType":"uint16","name":"healthRestored","type":"uint16"},{"internalType":"enum BoostType","name":"boostType","type":"uint8"},{"internalType":"uint16","name":"boostValue","type":"uint16"},{"internalType":"uint24","name":"boostDuration","type":"uint24"},{"internalType":"string","name":"metadataURI","type":"string"},{"internalType":"string","name":"name","type":"string"}],"indexed":false,"internalType":"struct ItemInput[]","name":"items","type":"tuple[]"}],"name":"AddItems","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"components":[{"components":[{"internalType":"int16","name":"meleeAttack","type":"int16"},{"internalType":"int16","name":"magicAttack","type":"int16"},{"internalType":"int16","name":"rangedAttack","type":"int16"},{"internalType":"int16","name":"health","type":"int16"},{"internalType":"int16","name":"meleeDefence","type":"int16"},{"internalType":"int16","name":"magicDefence","type":"int16"},{"internalType":"int16","name":"rangedDefence","type":"int16"}],"internalType":"struct CombatStats","name":"combatStats","type":"tuple"},{"internalType":"uint16","name":"tokenId","type":"uint16"},{"internalType":"enum EquipPosition","name":"equipPosition","type":"uint8"},{"internalType":"bool","name":"isTransferable","type":"bool"},{"internalType":"bool","name":"isFullModeOnly","type":"bool"},{"internalType":"bool","name":"isAvailable","type":"bool"},{"internalType":"uint16","name":"questPrerequisiteId","type":"uint16"},{"internalType":"enum Skill","name":"skill","type":"uint8"},{"internalType":"uint32","name":"minXP","type":"uint32"},{"internalType":"uint16","name":"healthRestored","type":"uint16"},{"internalType":"enum BoostType","name":"boostType","type":"uint8"},{"internalType":"uint16","name":"boostValue","type":"uint16"},{"internalType":"uint24","name":"boostDuration","type":"uint24"},{"internalType":"string","name":"metadataURI","type":"string"},{"internalType":"string","name":"name","type":"string"}],"indexed":false,"internalType":"struct ItemInput[]","name":"items","type":"tuple[]"}],"name":"EditItems","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint64","name":"version","type":"uint64"}],"name":"Initialized","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":"uint16[]","name":"tokenIds","type":"uint16[]"}],"name":"RemoveItems","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"indexed":false,"internalType":"uint256[]","name":"values","type":"uint256[]"}],"name":"TransferBatch","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"TransferSingle","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"value","type":"string"},{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"}],"name":"URI","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":[{"components":[{"components":[{"internalType":"int16","name":"meleeAttack","type":"int16"},{"internalType":"int16","name":"magicAttack","type":"int16"},{"internalType":"int16","name":"rangedAttack","type":"int16"},{"internalType":"int16","name":"health","type":"int16"},{"internalType":"int16","name":"meleeDefence","type":"int16"},{"internalType":"int16","name":"magicDefence","type":"int16"},{"internalType":"int16","name":"rangedDefence","type":"int16"}],"internalType":"struct CombatStats","name":"combatStats","type":"tuple"},{"internalType":"uint16","name":"tokenId","type":"uint16"},{"internalType":"enum EquipPosition","name":"equipPosition","type":"uint8"},{"internalType":"bool","name":"isTransferable","type":"bool"},{"internalType":"bool","name":"isFullModeOnly","type":"bool"},{"internalType":"bool","name":"isAvailable","type":"bool"},{"internalType":"uint16","name":"questPrerequisiteId","type":"uint16"},{"internalType":"enum Skill","name":"skill","type":"uint8"},{"internalType":"uint32","name":"minXP","type":"uint32"},{"internalType":"uint16","name":"healthRestored","type":"uint16"},{"internalType":"enum BoostType","name":"boostType","type":"uint8"},{"internalType":"uint16","name":"boostValue","type":"uint16"},{"internalType":"uint24","name":"boostDuration","type":"uint24"},{"internalType":"string","name":"metadataURI","type":"string"},{"internalType":"string","name":"name","type":"string"}],"internalType":"struct ItemInput[]","name":"inputItems","type":"tuple[]"}],"name":"addItems","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"tos","type":"address[]"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"name":"airdrop","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"accounts","type":"address[]"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"}],"name":"balanceOfBatch","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint16[]","name":"ids","type":"uint16[]"}],"name":"balanceOfs","outputs":[{"internalType":"uint256[]","name":"batchBalances","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint16[10]","name":"ids","type":"uint16[10]"}],"name":"balanceOfs10","outputs":[{"internalType":"uint256[]","name":"batchBalances","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"name":"burnBatch","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"components":[{"internalType":"int16","name":"meleeAttack","type":"int16"},{"internalType":"int16","name":"magicAttack","type":"int16"},{"internalType":"int16","name":"rangedAttack","type":"int16"},{"internalType":"int16","name":"health","type":"int16"},{"internalType":"int16","name":"meleeDefence","type":"int16"},{"internalType":"int16","name":"magicDefence","type":"int16"},{"internalType":"int16","name":"rangedDefence","type":"int16"}],"internalType":"struct CombatStats","name":"combatStats","type":"tuple"},{"internalType":"uint16","name":"tokenId","type":"uint16"},{"internalType":"enum EquipPosition","name":"equipPosition","type":"uint8"},{"internalType":"bool","name":"isTransferable","type":"bool"},{"internalType":"bool","name":"isFullModeOnly","type":"bool"},{"internalType":"bool","name":"isAvailable","type":"bool"},{"internalType":"uint16","name":"questPrerequisiteId","type":"uint16"},{"internalType":"enum Skill","name":"skill","type":"uint8"},{"internalType":"uint32","name":"minXP","type":"uint32"},{"internalType":"uint16","name":"healthRestored","type":"uint16"},{"internalType":"enum BoostType","name":"boostType","type":"uint8"},{"internalType":"uint16","name":"boostValue","type":"uint16"},{"internalType":"uint24","name":"boostDuration","type":"uint24"},{"internalType":"string","name":"metadataURI","type":"string"},{"internalType":"string","name":"name","type":"string"}],"internalType":"struct ItemInput[]","name":"inputItems","type":"tuple[]"}],"name":"editItems","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"exists","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint16","name":"tokenId","type":"uint16"}],"name":"getBoostInfo","outputs":[{"internalType":"enum BoostType","name":"boostType","type":"uint8"},{"internalType":"uint16","name":"boostValue","type":"uint16"},{"internalType":"uint24","name":"boostDuration","type":"uint24"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint16","name":"tokenId","type":"uint16"}],"name":"getEquipPosition","outputs":[{"internalType":"enum EquipPosition","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint16","name":"item","type":"uint16"}],"name":"getEquipPositionAndMinRequirement","outputs":[{"internalType":"enum Skill","name":"skill","type":"uint8"},{"internalType":"uint32","name":"minXP","type":"uint32"},{"internalType":"enum EquipPosition","name":"equipPosition","type":"uint8"},{"internalType":"bool","name":"isFullModeOnly","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint16[]","name":"tokenIds","type":"uint16[]"}],"name":"getEquipPositions","outputs":[{"internalType":"enum EquipPosition[]","name":"equipPositions","type":"uint8[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint16","name":"tokenId","type":"uint16"}],"name":"getItem","outputs":[{"components":[{"internalType":"enum EquipPosition","name":"equipPosition","type":"uint8"},{"internalType":"bytes1","name":"packedData","type":"bytes1"},{"internalType":"uint16","name":"questPrerequisiteId","type":"uint16"},{"internalType":"bool","name":"isTransferable","type":"bool"},{"internalType":"uint16","name":"healthRestored","type":"uint16"},{"internalType":"enum BoostType","name":"boostType","type":"uint8"},{"internalType":"uint16","name":"boostValue","type":"uint16"},{"internalType":"uint24","name":"boostDuration","type":"uint24"},{"internalType":"int16","name":"meleeAttack","type":"int16"},{"internalType":"int16","name":"magicAttack","type":"int16"},{"internalType":"int16","name":"rangedAttack","type":"int16"},{"internalType":"int16","name":"meleeDefence","type":"int16"},{"internalType":"int16","name":"magicDefence","type":"int16"},{"internalType":"int16","name":"rangedDefence","type":"int16"},{"internalType":"int16","name":"health","type":"int16"},{"internalType":"enum Skill","name":"skill","type":"uint8"},{"internalType":"uint32","name":"minXP","type":"uint32"}],"internalType":"struct Item","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint16[]","name":"tokenIds","type":"uint16[]"}],"name":"getItems","outputs":[{"components":[{"internalType":"enum EquipPosition","name":"equipPosition","type":"uint8"},{"internalType":"bytes1","name":"packedData","type":"bytes1"},{"internalType":"uint16","name":"questPrerequisiteId","type":"uint16"},{"internalType":"bool","name":"isTransferable","type":"bool"},{"internalType":"uint16","name":"healthRestored","type":"uint16"},{"internalType":"enum BoostType","name":"boostType","type":"uint8"},{"internalType":"uint16","name":"boostValue","type":"uint16"},{"internalType":"uint24","name":"boostDuration","type":"uint24"},{"internalType":"int16","name":"meleeAttack","type":"int16"},{"internalType":"int16","name":"magicAttack","type":"int16"},{"internalType":"int16","name":"rangedAttack","type":"int16"},{"internalType":"int16","name":"meleeDefence","type":"int16"},{"internalType":"int16","name":"magicDefence","type":"int16"},{"internalType":"int16","name":"rangedDefence","type":"int16"},{"internalType":"int16","name":"health","type":"int16"},{"internalType":"enum Skill","name":"skill","type":"uint8"},{"internalType":"uint32","name":"minXP","type":"uint32"}],"internalType":"struct Item[]","name":"items","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint16[]","name":"tokenIds","type":"uint16[]"}],"name":"getMinRequirements","outputs":[{"internalType":"enum Skill[]","name":"skills","type":"uint8[]"},{"internalType":"uint32[]","name":"minXPs","type":"uint32[]"},{"internalType":"bool[]","name":"isFullModeOnly","type":"bool[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getTimestampFirstMint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"royaltyReceiver","type":"address"},{"internalType":"string","name":"baseURI","type":"string"},{"internalType":"contract AdminAccess","name":"adminAccess","type":"address"},{"internalType":"bool","name":"isBeta","type":"bool"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IBankFactory","name":"bankFactory","type":"address"},{"internalType":"contract IPlayers","name":"players","type":"address"}],"name":"initializeAddresses","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"name":"mintBatch","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","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":"uint16[]","name":"itemTokenIds","type":"uint16[]"}],"name":"removeItems","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"salePrice","type":"uint256"}],"name":"royaltyInfo","outputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint256","name":"royaltyAmount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"internalType":"uint256[]","name":"values","type":"uint256[]"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeBatchTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"},{"internalType":"address","name":"to","type":"address"}],"internalType":"struct BulkTransferInfo[]","name":"nftsInfo","type":"tuple[]"}],"name":"safeBulkTransfer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"accounts","type":"address[]"},{"internalType":"bool","name":"isApproved","type":"bool"}],"name":"setApproved","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"baseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","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":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"uri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","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.