Source Code
Overview
HYPE Balance
0 HYPEHYPE Value
$0.00Latest 1 from a total of 1 transactions
| Transaction Hash |
|
Block
|
From
|
To
|
|||||
|---|---|---|---|---|---|---|---|---|---|
| Set Collection A... | 5462871 | 228 days ago | IN | 0 HYPE | 0.00004146 |
Cross-Chain Transactions
Loading...
Loading
Contract Name:
Marketplace202502231813
Compiler Version
v0.8.24+commit.e11b9ed9
Optimization Enabled:
Yes with 200 runs
Other Settings:
cancun EvmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
import {AccessControlEnumerableUpgradeable} from '@openzeppelin/contracts-upgradeable/access/extensions/AccessControlEnumerableUpgradeable.sol';
import {PausableUpgradeable} from '@openzeppelin/contracts-upgradeable/utils/PausableUpgradeable.sol';
import {ReentrancyGuardUpgradeable} from '@openzeppelin/contracts-upgradeable/utils/ReentrancyGuardUpgradeable.sol';
import {IERC721} from '@openzeppelin/contracts/token/ERC721/IERC721.sol';
import {IERC1155} from '@openzeppelin/contracts/token/ERC1155/IERC1155.sol';
import {IERC20} from '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import {IERC165} from '@openzeppelin/contracts/utils/introspection/IERC165.sol';
import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
import {SafeERC20} from '@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol';
/**
* @title Drip.Trade marketplace contract
* @notice The Drip.Trade contract supports NFT trading on Hyperliquid.
*
* The contract allows enforcement of royalties onchain, and supports multi-token
* marketplace operations in a single transaction for almost all functionalities.
*
* This contract is based on the Trove marketplace contract (TreasureProject/treasure-marketplace-contracts)
* at commit fc3b17f50e08b65426193e8e13893d5644b42569.
*/
contract Marketplace202502231813 is AccessControlEnumerableUpgradeable, PausableUpgradeable, ReentrancyGuardUpgradeable {
using SafeERC20 for IERC20;
struct ListingOrBid {
/**
* @dev number of tokens for sale or requested
*
* If ERC-721 token is active for sale, quantity should be 1. For bids, quantity for ERC-721 can
* be greater than 1 (in order to support collection bids).
*/
uint64 quantity;
/**
* @dev price per token sold
*
* Sale price equals this times quantity purchased. For bids, price offered per item.
*/
uint128 pricePerItem;
/**
* @dev timestamp after which the listing/bid is invalid
*/
uint64 expirationTime;
/**
* @dev the payment token for this listing/bid.
*/
address paymentTokenAddress;
}
struct CollectionCreatorFee {
/**
* @dev the fee, out of 10,000, that this collection owner will be given for each sale
*/
uint32 fee;
/**
* @dev the recipient of the collection specific fee
*/
address recipient;
}
enum CollectionApprovalStatus {
NOT_APPROVED,
ERC_721_APPROVED,
ERC_1155_APPROVED
}
/**
* @notice ERC165 interface signatures
*/
bytes4 private constant INTERFACE_ID_ERC721 = 0x80ac58cd;
bytes4 private constant INTERFACE_ID_ERC1155 = 0xd9b67a26;
/**
* @notice MARKETPLACE_ADMIN_ROLE role hash
*/
bytes32 public constant MARKETPLACE_ADMIN_ROLE = keccak256('MARKETPLACE_ADMIN_ROLE');
/**
* @notice the denominator for fraction calculations
*
* This is the number of parts allowed in 100%.
*/
uint256 public constant BASIS_POINTS = 10000;
/**
* @notice the maximum fee which the owner may set (in units of basis points)
*/
uint256 public constant MAX_FEE = 1500;
/**
* @notice the maximum fee which the collection owner may set
*/
uint256 public constant MAX_COLLECTION_FEE = 2000;
/**
* @notice The default token that is used for marketplace sales and fee payments.
*
* Can be overridden by `collectionToPaymentToken`.
*/
IERC20 public paymentToken;
/**
* @notice the marketplace fee (in basis points) for each sale for collections without creator fees
*/
uint256 public fee;
/**
* @notice the marketplace fee (in basis points) for each sale for collections with creator fees set
*/
uint256 public feeForCollectionWithCreatorFee;
/**
* @notice address that receives marketplace fees
*/
address public feeReceipient;
/**
* @notice mapping for listings, maps: nftAddress => tokenId => seller
*/
mapping(address => mapping(uint256 => mapping(address => ListingOrBid))) public listings;
/**
* @notice collections which have been approved to be sold on the marketplace, maps: nftAddress => status
*/
mapping(address => CollectionApprovalStatus) public collectionApprovals;
/**
* @notice Maps the collection address to the collection's creator fees.
*/
mapping(address => CollectionCreatorFee) public collectionCreatorFees;
/**
* @notice Maps the collection address to the payment token that will be used for purchasing.
*
* If the address is the zero address, it will default to use `paymentToken`.
*/
mapping(address => address) public collectionToPaymentToken;
/**
* @notice Maps the collection address to its minimum allowed price for bids/listings.
*
* This minimum price is denominated in the collection's paymentToken as specified in `collectionToPaymentToken`.
*/
mapping(address => uint256) public collectionToMinPrice;
/**
* @notice the address for the wrapped native token
*/
IERC20 public wnative;
/**
* @notice mapping for token bids (721/1155): nftAddress => tokneId => bidder
*/
mapping(address => mapping(uint256 => mapping(address => ListingOrBid))) public tokenBids;
/**
* @notice mapping for collection level bids (721 only): nftAddress => bidder
*/
mapping(address => mapping(address => ListingOrBid)) public collectionBids;
/**
* @notice Indicates if bid related functions are enabled.
*/
bool public areBidsActive;
/**
* @notice The marketplace fees were updated
* @param fee new fee amount (in units of basis points)
* for collections without creator fees
* @param feeForCollectionWithCreatorFee new fee amount (in units of basis points)
* for collections with creator fees
*/
event UpdateFees(uint256 fee, uint256 feeForCollectionWithCreatorFee);
/**
* @notice The fee recipient was updated
* @param feeRecipient the new recipient to get fees
*/
event UpdateFeeRecipient(address feeRecipient);
/**
* @notice A collection's fees have changed
* @param collection the collection
* @param recipient the recipient of the fees. If the address is 0, the collection
* fees for this collection have been removed.
* @param fee the fee amount (in units of basis points)
*/
event UpdateCollectionCreatorFee(address collection, address recipient, uint256 fee);
/**
* @notice The approval status for a collection was updated
* @param nftAddress the collection contract
* @param status the new status
* @param paymentToken the token that will be used for payments for this collection
*/
event ApprovalStatusUpdated(address nftAddress, CollectionApprovalStatus status, address paymentToken);
/**
* @notice A token bid was created or updated
* @param bidder the bidder for the token
* @param nftAddress which token contract holds the wanted token
* @param tokenId the identifier for the wanted token
* @param quantity how many of this token identifier are wanted
* @param pricePerItem the price (in units of the paymentToken) for each token wanted
* @param expirationTime UNIX timestamp after when this bid expires
* @param paymentToken the token used to pay
*/
event TokenBidCreatedOrUpdated(
address bidder,
address nftAddress,
uint256 tokenId,
uint64 quantity,
uint128 pricePerItem,
uint64 expirationTime,
address paymentToken
);
/**
* @notice A collection bid was created or updated
* @param bidder the bidder for the tokens
* @param nftAddress which token contract holds the wanted tokens
* @param quantity how many of this collection's tokens are wanted
* @param pricePerItem the price (in units of the paymentToken) for each token wanted
* @param expirationTime UNIX timestamp after when this bid expires
* @param paymentToken the token used to pay
*/
event CollectionBidCreatedOrUpdated(
address bidder,
address nftAddress,
uint64 quantity,
uint128 pricePerItem,
uint64 expirationTime,
address paymentToken
);
/**
* @notice A token bid was cancelled
* @param bidder the bidder for the token
* @param nftAddress which token contract holds the bidded token
* @param tokenId the identifier for the bidded token
*/
event TokenBidCancelled(address bidder, address nftAddress, uint256 tokenId);
/**
* @notice A token bid was cancelled
* @param bidder the bidder for the token
* @param nftAddress which token contract holds the bidded token
*/
event CollectionBidCancelled(address bidder, address nftAddress);
/**
* @notice A bid was accepted
* @param seller the user who accepted the bid
* @param bidder the bidder for the tokens
* @param nftAddress which token contract holds the exchanged tokens
* @param tokenId the identifier for the exchanged token
* @param quantity the number of tokens exchanged
* @param pricePerItem the price (in units of the paymentToken) for each token exchanged
* @param paymentToken the token used to pay
* @param bidType whether the bid was a token bid (0) or collection bid (1)
*/
event BidAccepted(
address seller,
address bidder,
address nftAddress,
uint256 tokenId,
uint64 quantity,
uint128 pricePerItem,
address paymentToken,
BidType bidType
);
/**
* @notice An item was listed for sale
* @param seller the offeror of the item
* @param nftAddress which token contract holds the offered token
* @param tokenId the identifier for the offered token
* @param quantity how many of this token identifier are offered (or 1 for a ERC-721 token)
* @param pricePerItem the price (in units of the paymentToken) for each token offered
* @param expirationTime UNIX timestamp after when this listing expires
* @param paymentToken the token used to list this item
*/
event ItemListed(
address seller,
address nftAddress,
uint256 tokenId,
uint64 quantity,
uint128 pricePerItem,
uint64 expirationTime,
address paymentToken
);
/**
* @notice An item listing was updated
* @param seller the offeror of the item
* @param nftAddress which token contract holds the offered token
* @param tokenId the identifier for the offered token
* @param quantity how many of this token identifier are offered (or 1 for a ERC-721 token)
* @param pricePerItem the price (in units of the paymentToken) for each token offered
* @param expirationTime UNIX timestamp after when this listing expires
* @param paymentToken the token used to list this item
*/
event ItemUpdated(
address seller,
address nftAddress,
uint256 tokenId,
uint64 quantity,
uint128 pricePerItem,
uint64 expirationTime,
address paymentToken
);
/**
* @notice An item is no longer listed for sale
* @param seller former offeror of the item
* @param nftAddress which token contract holds the formerly offered token
* @param tokenId the identifier for the formerly offered token
*/
event ItemCanceled(address indexed seller, address indexed nftAddress, uint256 indexed tokenId);
/**
* @notice A listed item was sold
* @param seller the offeror of the item
* @param buyer the buyer of the item
* @param nftAddress which token contract holds the sold token
* @param tokenId the identifier for the sold token
* @param quantity how many of this token identifier where sold (or 1 for a ERC-721 token)
* @param pricePerItem the price (in units of the paymentToken) for each token sold
* @param paymentToken the payment token that was used to pay for this item
*/
event ItemSold(
address seller,
address buyer,
address nftAddress,
uint256 tokenId,
uint64 quantity,
uint128 pricePerItem,
address paymentToken
);
/**
* @dev Collection had no approval status found in `collectionApprovals`.
*/
error CollectionNotApprovedForTrading(address nftAddress);
/**
* @dev Collection bids on ERC1155 collections are not allowed.
*/
error CollectionBidOnErc1155(address nftAddress);
/**
* @custom:oz-upgrades-unsafe-allow constructor
*/
constructor() initializer {}
/**
* @notice Perform initial contract setup
* @dev The initializer modifier ensures this is only called once, the owner should confirm this was properly
* performed before publishing this contract address.
* @param _initialFee marketplace fees, in basis points
* @param _initialFeeRecipient wallet to collet marketplace fees
* @param _initialPaymentToken address of the default token that is used for settlement
*/
function initialize(
uint256 _initialFee,
address _initialFeeRecipient,
IERC20 _initialPaymentToken
) external initializer {
require(address(_initialPaymentToken) != address(0), 'Marketplace: cannot set address(0)');
__AccessControl_init_unchained();
__Pausable_init_unchained();
__ReentrancyGuard_init_unchained();
_setRoleAdmin(MARKETPLACE_ADMIN_ROLE, MARKETPLACE_ADMIN_ROLE);
_grantRole(MARKETPLACE_ADMIN_ROLE, msg.sender);
setFees(_initialFee, _initialFee);
setFeeRecipient(_initialFeeRecipient);
paymentToken = _initialPaymentToken;
}
/************************************/
/* Public Marketplace Functionality */
/************************************/
/**
* @notice Create or update multiple listings. You must first authorize this marketplace with your
* item's token contract in order to list.
* @param _createOrUpdateListingParamsBatch an array of listing params
*
* Listing params:
* - nftAddress which token contract holds the offered token
* - tokenId the identifier for the offered token
* - quantity how many of this token identifier are offered (or 1 for a ERC-721 token)
* - pricePerItem the price (in units of the paymentToken) for each token offered
* - expirationTime UNIX timestamp after when this listing expires
* - paymentToken the payment token used to pay for this item
*/
function createOrUpdateListings(
CreateOrUpdateListingParams[] calldata _createOrUpdateListingParamsBatch
) external nonReentrant whenNotPaused {
for (uint256 i = 0; i < _createOrUpdateListingParamsBatch.length;) {
CreateOrUpdateListingParams calldata _createOrUpdateListingParams = _createOrUpdateListingParamsBatch[i];
_createOrUpdateListing(
_createOrUpdateListingParams.nftAddress,
_createOrUpdateListingParams.tokenId,
_createOrUpdateListingParams.quantity,
_createOrUpdateListingParams.pricePerItem,
_createOrUpdateListingParams.expirationTime,
_createOrUpdateListingParams.paymentToken
);
unchecked { i += 1; }
}
}
/**
* @notice Remove multiple listings. This will succeed even if the listings to be cancelled do
* not exist.
* @param _cancelListingParamsBatch an array of cancel-listing params
*
* Cancel-listing params:
* - nftAddress which token contract holds the listed token
* - tokenId the identifier for the listed token
*/
function cancelListings(CancelListingParams[] calldata _cancelListingParamsBatch) external nonReentrant {
for (uint256 i = 0; i < _cancelListingParamsBatch.length; ) {
CancelListingParams calldata _cancelListingParams = _cancelListingParamsBatch[i];
_cancelListing(_cancelListingParams.nftAddress, _cancelListingParams.tokenId, _msgSender());
unchecked { i += 1; }
}
}
/**
* @notice Remove multiple bids. This will succeed even if the bids to be cancelled do not
* exist.
* @param _cancelBidParamsBatch an array of cancel-bid params
*
* Cancel-bid params:
* - bidType whether the bid was a token bid (0) or collection bid (1)
* - nftAddress which token contract holds the offered token
* - tokenId the identifier for the offered token
*/
function cancelBids(CancelBidParams[] calldata _cancelBidParamsBatch) external nonReentrant {
for (uint256 i = 0; i < _cancelBidParamsBatch.length;) {
CancelBidParams calldata _cancelBidParams = _cancelBidParamsBatch[i];
if (_cancelBidParams.bidType == BidType.COLLECTION) {
_cancelCollectionBid(_cancelBidParams.nftAddress, _msgSender());
} else {
_cancelTokenBid(_cancelBidParams.nftAddress, _cancelBidParams.tokenId, _msgSender());
}
unchecked { i += 1; }
}
}
/**
* @notice Create or update multiple token bids. You must first authorize this marketplace with your
* payment token's ERC20 contract.
* @param _createOrUpdateTokenBidParamsBatch an array of token bid params
*
* Listing params:
* - nftAddress which token contract holds the wanted token
* - tokenId the identifier for the wanted token
* - quantity how many of this token identifier are wanted
* - pricePerItem the price (in units of the paymentToken) for each token wanted
* - expirationTime UNIX timestamp after when this listing expires
* - paymentToken the payment token used to pay for the wanted token
*/
function createOrUpdateTokenBids(
CreateOrUpdateTokenBidParams[] calldata _createOrUpdateTokenBidParamsBatch
) external nonReentrant whenNotPaused whenBiddingActive {
for (uint256 i = 0; i < _createOrUpdateTokenBidParamsBatch.length;) {
CreateOrUpdateTokenBidParams calldata _createOrUpdateTokenBidParams = _createOrUpdateTokenBidParamsBatch[i];
_createOrUpdateTokenBid(
_createOrUpdateTokenBidParams.nftAddress,
_createOrUpdateTokenBidParams.tokenId,
_createOrUpdateTokenBidParams.quantity,
_createOrUpdateTokenBidParams.pricePerItem,
_createOrUpdateTokenBidParams.expirationTime,
_createOrUpdateTokenBidParams.paymentToken
);
unchecked { i += 1; }
}
}
/**
* @notice Create or update a collection bid. You must first authorize this marketplace with your
* payment token's ERC20 contract.
* @param _nftAddress which token contract holds the wanted token
* @param _quantity how many of this token identifier are wanted
* @param _pricePerItem the price (in units of the paymentToken) for each token wanted
* @param _expirationTime UNIX timestamp after when this listing expires
* @param _paymentToken the payment token used to pay for the wanted token
*/
function createOrUpdateCollectionBid(
address _nftAddress,
uint64 _quantity,
uint128 _pricePerItem,
uint64 _expirationTime,
address _paymentToken
) external nonReentrant whenNotPaused whenBiddingActive {
if (collectionApprovals[_nftAddress] == CollectionApprovalStatus.ERC_721_APPROVED) {
require(_quantity > 0, 'Marketplace: Bad quantity');
} else if (collectionApprovals[_nftAddress] == CollectionApprovalStatus.ERC_1155_APPROVED) {
revert CollectionBidOnErc1155({nftAddress: _nftAddress});
} else {
revert CollectionNotApprovedForTrading({nftAddress: _nftAddress});
}
_createBidWithoutEvent(
_nftAddress,
_quantity,
_pricePerItem,
_expirationTime,
_paymentToken,
collectionBids[_nftAddress][_msgSender()]
);
emit CollectionBidCreatedOrUpdated(
_msgSender(),
_nftAddress,
_quantity,
_pricePerItem,
_expirationTime,
_paymentToken
);
}
/**
* @notice Accepts multiple bids. The accepted bids can be mix of token bids and collection
* bids. You must first authorize this marketplace with your items' token contracts
* in order to accept.
*
* If the user has a listing for the exchanged token, the listing is automatically
* cancelled.
* @param _acceptBidParamsBatch an array of accept-bid params
*
* Accept-bid params:
* - bidType whether the bid is a token bid (0) or collection bid (1)
* - nftAddress which token contract holds the wanted token
* - tokenId the identifier for the wanted token
* - bidder the address who's bid you wish to accept
* - quantity how many of this token identifier are wanted
* - pricePerItem the price (in units of the paymentToken) for each token wanted
* - paymentToken the payment token used to pay for the wanted token
*/
function acceptBids(
AcceptBidParams[] calldata _acceptBidParamsBatch
) external nonReentrant whenNotPaused whenBiddingActive {
for (uint256 i = 0; i < _acceptBidParamsBatch.length;) {
_acceptBid(_acceptBidParamsBatch[i]);
unchecked { i += 1; }
}
}
/**
* @notice Buy multiple listed items. You must authorize this marketplace with your payment
* token to complete the buy, or purchase with native token if it is a wnative
* collection.
*
* If the user has a token bid on the exchanged token, the token bid is automatically
* cancelled.
* @param _buyItemParamsBatch an array of buy-item params
*
* Buy-item params:
* - nftAddress which token contract holds the offered token
* - tokenId the identifier for the offered token
* - owner the address currently holding the offered token
* - quantity how many of this token identifier are wanted (or 1 for a ERC-721 token)
* - maxPricePerItem the maximum price (in units of the paymentToken) for each token offered
* - paymentToken the payment token used to pay for the wanted token
* - usingNative indicates if the user is purchasing this item with native token
*/
function buyItems(BuyItemParams[] calldata _buyItemParamsBatch) external payable nonReentrant whenNotPaused {
uint256 _nativeAmountRequired;
for (uint256 i = 0; i < _buyItemParamsBatch.length;) {
_nativeAmountRequired += _buyItem(_buyItemParamsBatch[i]);
unchecked { i += 1; }
}
require(msg.value == _nativeAmountRequired, 'Marketplace: Wrong amount of native tokens sent');
}
/**
* @notice Transfers multiple tokens. You must first authorize this marketplace with your
* items' token contracts prior to transferring.
*
* Transfers will fail silently if the token is not owned by the sender or if the
* sender has not authorized the marketplace to do the transfer.
*
* If the sender has an active listing for a transferred ERC721 token, the listing
* will be cancelled. If the recipient has an active bid for a transferred ERC721
* token, the bid will be cancelled.
* @param _transferTokenParamsBatch an array of transfer params
*
* Transfer params:
* - nftAddress which token contract holds the transferred token
* - tokenId the identifier for the transferred token
* - quantity how many of this token identifier are transferred (ignored for ERC-721s)
* - recipient the transfer destination address
*/
function transferTokens(TransferTokenParams[] calldata _transferTokenParamsBatch) external nonReentrant {
for (uint256 i = 0; i < _transferTokenParamsBatch.length;) {
TransferTokenParams calldata _params = _transferTokenParamsBatch[i];
_transferToken(
_params.nftAddress,
_params.tokenId,
_params.quantity,
_params.recipient
);
unchecked { i += 1; }
}
}
/***********************************/
/* Marketplace Admin Functionality */
/***********************************/
/**
* @notice Updates the fee amount which is collected during sales fro a specific collection
* @dev This is callable only by the owner
* @param _collectionAddress The collection in question. This must be whitelisted.
* @param _collectionCreatorFee The fee and recipient for the collection. If the 0 address is
* passed as the recipient, collection specific fees will not be
* collected.
*/
function setCollectionCreatorFee(
address _collectionAddress,
CollectionCreatorFee calldata _collectionCreatorFee
) external onlyRole(MARKETPLACE_ADMIN_ROLE) {
require(
collectionApprovals[_collectionAddress] == CollectionApprovalStatus.ERC_1155_APPROVED ||
collectionApprovals[_collectionAddress] == CollectionApprovalStatus.ERC_721_APPROVED,
'Marketplace: Collection is not approved'
);
require(_collectionCreatorFee.fee <= MAX_COLLECTION_FEE, 'Marketplace: Creator fee too high');
// The collection recipient can be the 0 address, meaning we will treat
// this as a collection with no collection owner fee.
collectionCreatorFees[_collectionAddress] = _collectionCreatorFee;
emit UpdateCollectionCreatorFee(
_collectionAddress,
_collectionCreatorFee.recipient,
_collectionCreatorFee.fee
);
}
/**
* @notice Sets a token as an approved kind of NFT or as ineligible for trading
* @dev This is callable only by the owner.
* @param _nft address of the NFT to be approved
* @param _status the kind of NFT approved, or NOT_APPROVED to remove approval
* @param _paymentToken the paymentToken used for trading this NFT
* @param _minPrice minimum allowed listing/bid price for this NFT
*/
function setCollectionApprovalStatus(
address _nft,
CollectionApprovalStatus _status,
address _paymentToken,
uint256 _minPrice
) external onlyRole(MARKETPLACE_ADMIN_ROLE) {
if (_status == CollectionApprovalStatus.ERC_721_APPROVED) {
require(IERC165(_nft).supportsInterface(INTERFACE_ID_ERC721), 'Marketplace: not an ERC721 contract');
} else if (_status == CollectionApprovalStatus.ERC_1155_APPROVED) {
require(IERC165(_nft).supportsInterface(INTERFACE_ID_ERC1155), 'Marketplace: not an ERC1155 contract');
}
if (_paymentToken == address(0)) {
_paymentToken = address(paymentToken);
}
collectionApprovals[_nft] = _status;
collectionToMinPrice[_nft] = Math.max(1, _minPrice);
collectionToPaymentToken[_nft] = _paymentToken;
emit ApprovalStatusUpdated(_nft, _status, _paymentToken);
}
/**
* @notice Configures the wrapped native token address. This cannot be changed after it is set.
* @dev This is callable only by the owner.
* @param _wnativeAddress address for the wrapped native token
*/
function setWnative(address _wnativeAddress) external onlyRole(MARKETPLACE_ADMIN_ROLE) {
require(address(wnative) == address(0), 'Marketplace: Wrapped native token address already set');
wnative = IERC20(_wnativeAddress);
}
/**
* @notice Enables accepting bids and placing new bids.
* @dev This is callable only by the owner.
*/
function enableBids() external onlyRole(MARKETPLACE_ADMIN_ROLE) {
areBidsActive = true;
}
/**
* @notice Disables accepting bids or placing new bids.
* @dev This is callable only by the owner.
*/
function disableBids() external onlyRole(MARKETPLACE_ADMIN_ROLE) {
areBidsActive = false;
}
/**
* @notice Pauses the marketplace. Users will not be able to create new listings and bids, nor
* execute existing listings and bids.
* @dev This is callable only by the owner. Canceling listings and bids are still allowed.
*/
function pause() external onlyRole(MARKETPLACE_ADMIN_ROLE) {
_pause();
}
/**
* @notice Unpauses the marketplace, all functionality is restored
* @dev This is callable only by the owner.
*/
function unpause() external onlyRole(MARKETPLACE_ADMIN_ROLE) {
_unpause();
}
/**
* @notice Updates the marketplace fees, for both collections with and without creator fees.
* @dev This is callable only by the owner. Both fees may not exceed MAX_FEE.
* @param _newFee the updated marketplace fee, in basis points, for
* collections without creator fees
* @param _newFeeForCollectionWithCreatorFee the updated marketplace fee, in basis points, for
* collections with creator fees
*/
function setFees(
uint256 _newFee,
uint256 _newFeeForCollectionWithCreatorFee
) public onlyRole(MARKETPLACE_ADMIN_ROLE) {
require(_newFee <= MAX_FEE && _newFeeForCollectionWithCreatorFee <= MAX_FEE, 'Marketplace: max fee');
fee = _newFee;
feeForCollectionWithCreatorFee = _newFeeForCollectionWithCreatorFee;
emit UpdateFees(_newFee, _newFeeForCollectionWithCreatorFee);
}
/**
* @notice Updates the marketplace fee recipient
* @dev This is callable only by the owner.
* @param _newFeeRecipient the wallet to receive fees
*/
function setFeeRecipient(address _newFeeRecipient) public onlyRole(MARKETPLACE_ADMIN_ROLE) {
require(_newFeeRecipient != address(0), 'Marketplace: cannot set 0x0 address');
feeReceipient = _newFeeRecipient;
emit UpdateFeeRecipient(_newFeeRecipient);
}
/******************/
/* Public Getters */
/******************/
function getPaymentTokenForCollection(address _collection) public view returns (address) {
address _collectionPaymentToken = collectionToPaymentToken[_collection];
// For backwards compatability. If a collection payment wasn't set at the collection level, it was using the payment token.
return _collectionPaymentToken == address(0) ? address(paymentToken) : _collectionPaymentToken;
}
function getMinPriceForCollection(address _collection) public view returns (uint256) {
uint256 _collectionMinPrice = collectionToMinPrice[_collection];
// For backwards compatability. If a collection min price wasn't set, it should default to 1.
return _collectionMinPrice == 0 ? 1 : _collectionMinPrice;
}
function getListing(address _collection, uint256 _tokenId, address _seller) public view returns (ListingOrBid memory) {
return listings[_collection][_tokenId][_seller];
}
function getCollectionBid(address _collection, address _bidder) public view returns (ListingOrBid memory) {
return collectionBids[_collection][_bidder];
}
function getTokenBid(address _collection, uint256 _tokenId, address _bidder) public view returns (ListingOrBid memory) {
return tokenBids[_collection][_tokenId][_bidder];
}
/********************************/
/* Internal + Private Functions */
/********************************/
function _createOrUpdateListing(
address _nftAddress,
uint256 _tokenId,
uint64 _quantity,
uint128 _pricePerItem,
uint64 _expirationTime,
address _paymentToken
) private {
bool _existingListing = listings[_nftAddress][_tokenId][_msgSender()].quantity > 0;
_createListingWithoutEvent(_nftAddress, _tokenId, _quantity, _pricePerItem, _expirationTime, _paymentToken);
// Keep the events the same as they were before.
if (_existingListing) {
emit ItemUpdated(
_msgSender(),
_nftAddress,
_tokenId,
_quantity,
_pricePerItem,
_expirationTime,
_paymentToken
);
} else {
emit ItemListed(
_msgSender(),
_nftAddress,
_tokenId,
_quantity,
_pricePerItem,
_expirationTime,
_paymentToken
);
}
}
/// @notice Performs the listing and does not emit the event
/// @param _nftAddress which token contract holds the offered token
/// @param _tokenId the identifier for the offered token
/// @param _quantity how many of this token identifier are offered (or 1 for a ERC-721 token)
/// @param _pricePerItem the price (in units of the paymentToken) for each token offered
/// @param _expirationTime UNIX timestamp after when this listing expires
function _createListingWithoutEvent(
address _nftAddress,
uint256 _tokenId,
uint64 _quantity,
uint128 _pricePerItem,
uint64 _expirationTime,
address _paymentToken
) private {
require(_expirationTime > block.timestamp, 'Marketplace: invalid expiration time');
uint256 _minPrice = getMinPriceForCollection(_nftAddress);
require(_pricePerItem >= _minPrice, 'Marketplace: below min price');
require(_pricePerItem % _minPrice == 0, 'Marketplace: disallowed precision below min price');
if (collectionApprovals[_nftAddress] == CollectionApprovalStatus.ERC_721_APPROVED) {
require(_quantity == 1, 'Marketplace: cannot list multiple ERC721');
IERC721 nft = IERC721(_nftAddress);
require(nft.ownerOf(_tokenId) == _msgSender(), 'Marketplace: not owning item');
require(nft.isApprovedForAll(_msgSender(), address(this)), 'Marketplace: item not approved');
} else if (collectionApprovals[_nftAddress] == CollectionApprovalStatus.ERC_1155_APPROVED) {
require(_quantity > 0, 'Marketplace: nothing to list');
IERC1155 nft = IERC1155(_nftAddress);
require(nft.balanceOf(_msgSender(), _tokenId) >= _quantity, 'Marketplace: must hold enough nfts');
require(nft.isApprovedForAll(_msgSender(), address(this)), 'Marketplace: item not approved');
} else {
revert CollectionNotApprovedForTrading({nftAddress: _nftAddress});
}
address _paymentTokenForCollection = getPaymentTokenForCollection(_nftAddress);
require(_paymentTokenForCollection == _paymentToken, 'Marketplace: Wrong payment token');
listings[_nftAddress][_tokenId][_msgSender()] = ListingOrBid(
_quantity,
_pricePerItem,
_expirationTime,
_paymentToken
);
}
function _cancelListing(address _nftAddress, uint256 _tokenId, address _seller) private {
uint256 _listedQty = listings[_nftAddress][_tokenId][_seller].quantity;
delete listings[_nftAddress][_tokenId][_seller];
if (_listedQty > 0) {
emit ItemCanceled(_seller, _nftAddress, _tokenId);
}
}
function _createOrUpdateTokenBid(
address _nftAddress,
uint256 _tokenId,
uint64 _quantity,
uint128 _pricePerItem,
uint64 _expirationTime,
address _paymentToken
) private {
if (collectionApprovals[_nftAddress] == CollectionApprovalStatus.ERC_721_APPROVED) {
require(_quantity == 1, 'Marketplace: token bid quantity 1 for ERC721');
} else if (collectionApprovals[_nftAddress] == CollectionApprovalStatus.ERC_1155_APPROVED) {
require(_quantity > 0, 'Marketplace: bad quantity');
} else {
revert CollectionNotApprovedForTrading({nftAddress: _nftAddress});
}
_createBidWithoutEvent(
_nftAddress,
_quantity,
_pricePerItem,
_expirationTime,
_paymentToken,
tokenBids[_nftAddress][_tokenId][_msgSender()]
);
emit TokenBidCreatedOrUpdated(
_msgSender(),
_nftAddress,
_tokenId,
_quantity,
_pricePerItem,
_expirationTime,
_paymentToken
);
}
function _createBidWithoutEvent(
address _nftAddress,
uint64 _quantity,
uint128 _pricePerItem,
uint64 _expirationTime,
address _paymentToken,
ListingOrBid storage _bid
) private {
require(_expirationTime > block.timestamp, 'Marketplace: invalid expiration time');
uint256 _minPrice = getMinPriceForCollection(_nftAddress);
require(_pricePerItem >= _minPrice, 'Marketplace: below min price');
require(_pricePerItem % _minPrice == 0, 'Marketplace: disallowed precision below min price');
address _paymentTokenForCollection = getPaymentTokenForCollection(_nftAddress);
require(_paymentTokenForCollection == _paymentToken, 'Marketplace: Bad payment token');
IERC20 _token = IERC20(_paymentToken);
uint256 _totalAmountNeeded = _pricePerItem * _quantity;
require(
_token.allowance(_msgSender(), address(this)) >= _totalAmountNeeded &&
_token.balanceOf(_msgSender()) >= _totalAmountNeeded,
'Marketplace: Not enough tokens owned or allowed for bid'
);
_bid.quantity = _quantity;
_bid.pricePerItem = _pricePerItem;
_bid.expirationTime = _expirationTime;
_bid.paymentTokenAddress = _paymentToken;
}
function _cancelCollectionBid(address _nftAddress, address _bidder) private {
uint256 _bidQty = collectionBids[_nftAddress][_bidder].quantity;
delete collectionBids[_nftAddress][_bidder];
if (_bidQty > 0) {
emit CollectionBidCancelled(_bidder, _nftAddress);
}
}
function _cancelTokenBid(address _nftAddress, uint256 _tokenId, address _bidder) private {
uint256 _bidQty = tokenBids[_nftAddress][_tokenId][_bidder].quantity;
delete tokenBids[_nftAddress][_tokenId][_bidder];
if (_bidQty > 0) {
emit TokenBidCancelled(_bidder, _nftAddress, _tokenId);
}
}
function _acceptBid(AcceptBidParams calldata _acceptBidParams) private {
// Validate buy order
require(_msgSender() != _acceptBidParams.bidder, 'Marketplace: Cannot supply own bid');
require(_acceptBidParams.quantity > 0, 'Marketplace: Nothing to supply to bidder');
// Validate bid
ListingOrBid storage _bid = _acceptBidParams.bidType == BidType.COLLECTION
? collectionBids[_acceptBidParams.nftAddress][_acceptBidParams.bidder]
: tokenBids[_acceptBidParams.nftAddress][_acceptBidParams.tokenId][_acceptBidParams.bidder];
require(_bid.quantity > 0, 'Marketplace: bid does not exist');
require(_bid.expirationTime >= block.timestamp, 'Marketplace: bid expired');
require(_bid.pricePerItem > 0, 'Marketplace: bid price invalid');
require(_bid.quantity >= _acceptBidParams.quantity, 'Marketplace: not enough quantity');
require(_bid.pricePerItem == _acceptBidParams.pricePerItem, 'Marketplace: price does not match');
// Ensure the accepter, the bidder, and the collection all agree on the token to be used for the purchase.
// If the token used for buying/selling has changed since the bid was created, this effectively blocks
// all the old bids with the old payment tokens from being bought.
address _paymentTokenForCollection = getPaymentTokenForCollection(_acceptBidParams.nftAddress);
require(
_bid.paymentTokenAddress == _acceptBidParams.paymentToken &&
_acceptBidParams.paymentToken == _paymentTokenForCollection,
'Marketplace: Wrong payment token'
);
uint128 _storedPricePerItem = _bid.pricePerItem;
// Deplete bid quantity
if (_bid.quantity == _acceptBidParams.quantity) {
if (_acceptBidParams.bidType == BidType.COLLECTION) {
delete collectionBids[_acceptBidParams.nftAddress][_acceptBidParams.bidder];
} else {
delete tokenBids[_acceptBidParams.nftAddress][_acceptBidParams.tokenId][_acceptBidParams.bidder];
}
} else {
_bid.quantity -= _acceptBidParams.quantity;
}
// Transfer NFT to buyer, also validates owner owns it, and token is approved for trading
if (collectionApprovals[_acceptBidParams.nftAddress] == CollectionApprovalStatus.ERC_721_APPROVED) {
require(_acceptBidParams.quantity == 1, 'Marketplace: Cannot supply multiple ERC721s');
// Clean up any active listings
_cancelListing(_acceptBidParams.nftAddress, _acceptBidParams.tokenId, _msgSender());
IERC721(_acceptBidParams.nftAddress).safeTransferFrom(
_msgSender(),
_acceptBidParams.bidder,
_acceptBidParams.tokenId
);
} else if (collectionApprovals[_acceptBidParams.nftAddress] == CollectionApprovalStatus.ERC_1155_APPROVED) {
IERC1155(_acceptBidParams.nftAddress).safeTransferFrom(
_msgSender(),
_acceptBidParams.bidder,
_acceptBidParams.tokenId,
_acceptBidParams.quantity,
bytes('')
);
} else {
revert CollectionNotApprovedForTrading({nftAddress: _acceptBidParams.nftAddress});
}
_payFees(
_storedPricePerItem,
_acceptBidParams.quantity,
_acceptBidParams.nftAddress,
_acceptBidParams.bidder,
_msgSender(),
_acceptBidParams.paymentToken,
false
);
// Announce accepting bid
emit BidAccepted(
_msgSender(),
_acceptBidParams.bidder,
_acceptBidParams.nftAddress,
_acceptBidParams.tokenId,
_acceptBidParams.quantity,
_acceptBidParams.pricePerItem,
_acceptBidParams.paymentToken,
_acceptBidParams.bidType
);
}
/// @return the amount of native tokens a user needed to have sent.
function _buyItem(BuyItemParams calldata _buyItemParams) private returns (uint256) {
// Validate buy order
require(_msgSender() != _buyItemParams.owner, 'Marketplace: Cannot buy your own item');
require(_buyItemParams.quantity > 0, 'Marketplace: Nothing to buy');
// Validate listing
ListingOrBid memory _listedItem = listings[_buyItemParams.nftAddress][_buyItemParams.tokenId][
_buyItemParams.owner
];
require(_listedItem.quantity > 0, 'Marketplace: not listed item');
require(_listedItem.expirationTime >= block.timestamp, 'Marketplace: listing expired');
require(_listedItem.pricePerItem > 0, 'Marketplace: listing price invalid');
require(_listedItem.quantity >= _buyItemParams.quantity, 'Marketplace: not enough quantity');
require(_listedItem.pricePerItem <= _buyItemParams.maxPricePerItem, 'Marketplace: price increased');
// Ensure the buyer, the seller, and the collection all agree on the token to be used for the purchase.
// If the token used for buying/selling has changed since the listing was created, this effectively blocks
// all the old listings with the old payment tokens from being bought.
address _paymentTokenForCollection = getPaymentTokenForCollection(_buyItemParams.nftAddress);
address _paymentTokenForListing = _getPaymentTokenForListing(_listedItem);
require(
_paymentTokenForListing == _buyItemParams.paymentToken &&
_buyItemParams.paymentToken == _paymentTokenForCollection,
'Marketplace: Wrong payment token'
);
if (_buyItemParams.usingNative) {
require(
_paymentTokenForListing == address(wnative),
'Marketplace: Native token can only be used if collection payments support wrapped native token.'
);
}
// derive the amount of native tokens required
uint128 _storedPricePerItem = _listedItem.pricePerItem;
uint256 _nativeTokensRequired = _buyItemParams.usingNative ? _buyItemParams.quantity * _storedPricePerItem : 0;
// Deplete listing quantity
if (_listedItem.quantity == _buyItemParams.quantity) {
delete listings[_buyItemParams.nftAddress][_buyItemParams.tokenId][_buyItemParams.owner];
} else {
listings[_buyItemParams.nftAddress][_buyItemParams.tokenId][_buyItemParams.owner].quantity -= _buyItemParams
.quantity;
}
// Transfer NFT to buyer, also validates owner owns it, and token is approved for trading
if (collectionApprovals[_buyItemParams.nftAddress] == CollectionApprovalStatus.ERC_721_APPROVED) {
require(_buyItemParams.quantity == 1, 'Marketplace: Cannot buy multiple ERC721');
// Clean up any active bids
_cancelTokenBid(_buyItemParams.nftAddress, _buyItemParams.tokenId, _msgSender());
IERC721(_buyItemParams.nftAddress).safeTransferFrom(
_buyItemParams.owner,
_msgSender(),
_buyItemParams.tokenId
);
} else if (collectionApprovals[_buyItemParams.nftAddress] == CollectionApprovalStatus.ERC_1155_APPROVED) {
IERC1155(_buyItemParams.nftAddress).safeTransferFrom(
_buyItemParams.owner,
_msgSender(),
_buyItemParams.tokenId,
_buyItemParams.quantity,
bytes('')
);
} else {
revert CollectionNotApprovedForTrading({nftAddress: _buyItemParams.nftAddress});
}
_payFees(
_storedPricePerItem,
_buyItemParams.quantity,
_buyItemParams.nftAddress,
_msgSender(),
_buyItemParams.owner,
_buyItemParams.paymentToken,
_buyItemParams.usingNative
);
// Announce sale
emit ItemSold(
_buyItemParams.owner,
_msgSender(),
_buyItemParams.nftAddress,
_buyItemParams.tokenId,
_buyItemParams.quantity,
_storedPricePerItem,
_buyItemParams.paymentToken
);
return _nativeTokensRequired;
}
function _transferToken(address _nftAddress, uint256 _tokenId, uint256 _quantity, address _recipient) private {
if (IERC165(_nftAddress).supportsInterface(INTERFACE_ID_ERC721)) {
IERC721 nft = IERC721(_nftAddress);
if (nft.isApprovedForAll(_msgSender(), address(this))) {
if (nft.ownerOf(_tokenId) == _msgSender()) {
// clean up any listings from the sender
_cancelListing(_nftAddress, _tokenId, _msgSender());
// clean up any bids from the recipient
_cancelTokenBid(_nftAddress, _tokenId, _recipient);
IERC721(_nftAddress).safeTransferFrom(
_msgSender(),
_recipient,
_tokenId
);
}
}
} else if (IERC165(_nftAddress).supportsInterface(INTERFACE_ID_ERC1155)) {
IERC1155 nft = IERC1155(_nftAddress);
if (nft.isApprovedForAll(_msgSender(), address(this))) {
if (nft.balanceOf(_msgSender(), _tokenId) >= _quantity) {
nft.safeTransferFrom(
_msgSender(),
_recipient,
_tokenId,
_quantity,
bytes('')
);
}
}
}
}
/**
* @dev pays the fees to the marketplace fee recipient, the creator fee recipient if one
* exists, and to the seller of the item.
* @param _storedPricePerItem the price of the item that is being purchased/accepted
* @param _quantity the quantity of the item being purchased/accepted
* @param _collectionAddress the collection to which this item belongs
* @param _from the buyer
* @param _to the seller
* @param _paymentTokenAddress the token to use for settlement
* @param _usingNative indicates if the user is purchasing this item with native token
*/
function _payFees(
uint128 _storedPricePerItem,
uint256 _quantity,
address _collectionAddress,
address _from,
address _to,
address _paymentTokenAddress,
bool _usingNative
) private {
IERC20 _paymentToken = IERC20(_paymentTokenAddress);
// Handle purchase price payment
uint256 _totalPrice = _storedPricePerItem * _quantity;
address _collectionFeeRecipient = collectionCreatorFees[_collectionAddress].recipient;
uint256 _protocolFee;
uint256 _collectionFee;
if (_collectionFeeRecipient != address(0)) {
_protocolFee = feeForCollectionWithCreatorFee;
_collectionFee = collectionCreatorFees[_collectionAddress].fee;
} else {
_protocolFee = fee;
_collectionFee = 0;
}
uint256 _protocolFeeAmount = (_totalPrice * _protocolFee) / BASIS_POINTS;
uint256 _collectionFeeAmount = (_totalPrice * _collectionFee) / BASIS_POINTS;
_transferAmount(_from, feeReceipient, _protocolFeeAmount, _paymentToken, _usingNative);
_transferAmount(_from, _collectionFeeRecipient, _collectionFeeAmount, _paymentToken, _usingNative);
// Transfer rest to seller
_transferAmount(_from, _to, _totalPrice - _protocolFeeAmount - _collectionFeeAmount, _paymentToken, _usingNative);
}
function _transferAmount(
address _from,
address _to,
uint256 _amount,
IERC20 _paymentToken,
bool _usingNative
) private {
if (_amount == 0) {
return;
}
if (_usingNative) {
(bool _success,) = payable(_to).call{ value: _amount }('');
require(_success, 'Marketplace: Sending native token was not successful');
} else {
_paymentToken.safeTransferFrom(_from, _to, _amount);
}
}
function _getPaymentTokenForListing(ListingOrBid memory listedItem) private view returns (address) {
// For backwards compatability. If a listing has no payment token address, it was using the original, default payment token.
return listedItem.paymentTokenAddress == address(0) ? address(paymentToken) : listedItem.paymentTokenAddress;
}
modifier whenBiddingActive() {
require(areBidsActive, 'Marketplace: Bidding is not active');
_;
}
}
enum BidType {
TOKEN,
COLLECTION
}
struct CreateOrUpdateListingParams {
/// which token contract holds the offered token
address nftAddress;
/// the identifier for the token to be bought
uint256 tokenId;
/// how many of this token identifier to be bought (or 1 for a ERC-721 token)
uint64 quantity;
/// the maximum price (in units of the paymentToken) for each token offered
uint128 pricePerItem;
/// UNIX timestamp after when this listing expires
uint64 expirationTime;
/// the payment token to be used
address paymentToken;
}
struct CancelListingParams {
/// which token contract holds the offered token
address nftAddress;
/// the identifier for the token to be bought
uint256 tokenId;
}
struct BuyItemParams {
/// which token contract holds the offered token
address nftAddress;
/// the identifier for the token to be bought
uint256 tokenId;
/// current owner of the item(s) to be bought
address owner;
/// how many of this token identifier to be bought (or 1 for a ERC-721 token)
uint64 quantity;
/// the maximum price (in units of the paymentToken) for each token offered
uint128 maxPricePerItem;
/// the payment token to be used
address paymentToken;
/// indicates if the user is purchasing this item with native token.
bool usingNative;
}
struct CreateOrUpdateTokenBidParams {
/// which token contract holds the offered token
address nftAddress;
/// the identifier for the token to be bought
uint256 tokenId;
/// how many of this token identifier to be bought (or 1 for a ERC-721 token)
uint64 quantity;
/// the maximum price (in units of the paymentToken) for each token offered
uint128 pricePerItem;
/// UNIX timestamp after when this listing expires
uint64 expirationTime;
/// the payment token to be used
address paymentToken;
}
struct AcceptBidParams {
BidType bidType;
// Which token contract holds the given tokens
address nftAddress;
// The token id being given
uint256 tokenId;
// The user who created the bid initially
address bidder;
// The quantity of items being supplied to the bidder
uint64 quantity;
// The price per item that the bidder is offering
uint128 pricePerItem;
/// the payment token to be used
address paymentToken;
}
struct CancelBidParams {
BidType bidType;
address nftAddress;
uint256 tokenId;
}
struct TransferTokenParams {
address nftAddress;
uint256 tokenId;
uint256 quantity;
address recipient;
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/AccessControl.sol)
pragma solidity ^0.8.20;
import {IAccessControl} from "@openzeppelin/contracts/access/IAccessControl.sol";
import {ContextUpgradeable} from "../utils/ContextUpgradeable.sol";
import {ERC165Upgradeable} from "../utils/introspection/ERC165Upgradeable.sol";
import {Initializable} from "../proxy/utils/Initializable.sol";
/**
* @dev Contract module that allows children to implement role-based access
* control mechanisms. This is a lightweight version that doesn't allow enumerating role
* members except through off-chain means by accessing the contract event logs. Some
* applications may benefit from on-chain enumerability, for those cases see
* {AccessControlEnumerable}.
*
* Roles are referred to by their `bytes32` identifier. These should be exposed
* in the external API and be unique. The best way to achieve this is by
* using `public constant` hash digests:
*
* ```solidity
* bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
* ```
*
* Roles can be used to represent a set of permissions. To restrict access to a
* function call, use {hasRole}:
*
* ```solidity
* function foo() public {
* require(hasRole(MY_ROLE, msg.sender));
* ...
* }
* ```
*
* Roles can be granted and revoked dynamically via the {grantRole} and
* {revokeRole} functions. Each role has an associated admin role, and only
* accounts that have a role's admin role can call {grantRole} and {revokeRole}.
*
* By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
* that only accounts with this role will be able to grant or revoke other
* roles. More complex role relationships can be created by using
* {_setRoleAdmin}.
*
* WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
* grant and revoke this role. Extra precautions should be taken to secure
* accounts that have been granted it. We recommend using {AccessControlDefaultAdminRules}
* to enforce additional security measures for this role.
*/
abstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControl, ERC165Upgradeable {
struct RoleData {
mapping(address account => bool) hasRole;
bytes32 adminRole;
}
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
/// @custom:storage-location erc7201:openzeppelin.storage.AccessControl
struct AccessControlStorage {
mapping(bytes32 role => RoleData) _roles;
}
// keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.AccessControl")) - 1)) & ~bytes32(uint256(0xff))
bytes32 private constant AccessControlStorageLocation = 0x02dd7bc7dec4dceedda775e58dd541e08a116c6c53815c0bd028192f7b626800;
function _getAccessControlStorage() private pure returns (AccessControlStorage storage $) {
assembly {
$.slot := AccessControlStorageLocation
}
}
/**
* @dev Modifier that checks that an account has a specific role. Reverts
* with an {AccessControlUnauthorizedAccount} error including the required role.
*/
modifier onlyRole(bytes32 role) {
_checkRole(role);
_;
}
function __AccessControl_init() internal onlyInitializing {
}
function __AccessControl_init_unchained() internal onlyInitializing {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);
}
/**
* @dev Returns `true` if `account` has been granted `role`.
*/
function hasRole(bytes32 role, address account) public view virtual returns (bool) {
AccessControlStorage storage $ = _getAccessControlStorage();
return $._roles[role].hasRole[account];
}
/**
* @dev Reverts with an {AccessControlUnauthorizedAccount} error if `_msgSender()`
* is missing `role`. Overriding this function changes the behavior of the {onlyRole} modifier.
*/
function _checkRole(bytes32 role) internal view virtual {
_checkRole(role, _msgSender());
}
/**
* @dev Reverts with an {AccessControlUnauthorizedAccount} error if `account`
* is missing `role`.
*/
function _checkRole(bytes32 role, address account) internal view virtual {
if (!hasRole(role, account)) {
revert AccessControlUnauthorizedAccount(account, role);
}
}
/**
* @dev Returns the admin role that controls `role`. See {grantRole} and
* {revokeRole}.
*
* To change a role's admin, use {_setRoleAdmin}.
*/
function getRoleAdmin(bytes32 role) public view virtual returns (bytes32) {
AccessControlStorage storage $ = _getAccessControlStorage();
return $._roles[role].adminRole;
}
/**
* @dev Grants `role` to `account`.
*
* If `account` had not been already granted `role`, emits a {RoleGranted}
* event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*
* May emit a {RoleGranted} event.
*/
function grantRole(bytes32 role, address account) public virtual onlyRole(getRoleAdmin(role)) {
_grantRole(role, account);
}
/**
* @dev Revokes `role` from `account`.
*
* If `account` had been granted `role`, emits a {RoleRevoked} event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*
* May emit a {RoleRevoked} event.
*/
function revokeRole(bytes32 role, address account) public virtual onlyRole(getRoleAdmin(role)) {
_revokeRole(role, account);
}
/**
* @dev Revokes `role` from the calling account.
*
* Roles are often managed via {grantRole} and {revokeRole}: this function's
* purpose is to provide a mechanism for accounts to lose their privileges
* if they are compromised (such as when a trusted device is misplaced).
*
* If the calling account had been revoked `role`, emits a {RoleRevoked}
* event.
*
* Requirements:
*
* - the caller must be `callerConfirmation`.
*
* May emit a {RoleRevoked} event.
*/
function renounceRole(bytes32 role, address callerConfirmation) public virtual {
if (callerConfirmation != _msgSender()) {
revert AccessControlBadConfirmation();
}
_revokeRole(role, callerConfirmation);
}
/**
* @dev Sets `adminRole` as ``role``'s admin role.
*
* Emits a {RoleAdminChanged} event.
*/
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
AccessControlStorage storage $ = _getAccessControlStorage();
bytes32 previousAdminRole = getRoleAdmin(role);
$._roles[role].adminRole = adminRole;
emit RoleAdminChanged(role, previousAdminRole, adminRole);
}
/**
* @dev Attempts to grant `role` to `account` and returns a boolean indicating if `role` was granted.
*
* Internal function without access restriction.
*
* May emit a {RoleGranted} event.
*/
function _grantRole(bytes32 role, address account) internal virtual returns (bool) {
AccessControlStorage storage $ = _getAccessControlStorage();
if (!hasRole(role, account)) {
$._roles[role].hasRole[account] = true;
emit RoleGranted(role, account, _msgSender());
return true;
} else {
return false;
}
}
/**
* @dev Attempts to revoke `role` to `account` and returns a boolean indicating if `role` was revoked.
*
* Internal function without access restriction.
*
* May emit a {RoleRevoked} event.
*/
function _revokeRole(bytes32 role, address account) internal virtual returns (bool) {
AccessControlStorage storage $ = _getAccessControlStorage();
if (hasRole(role, account)) {
$._roles[role].hasRole[account] = false;
emit RoleRevoked(role, account, _msgSender());
return true;
} else {
return false;
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (access/extensions/AccessControlEnumerable.sol)
pragma solidity ^0.8.20;
import {IAccessControlEnumerable} from "@openzeppelin/contracts/access/extensions/IAccessControlEnumerable.sol";
import {AccessControlUpgradeable} from "../AccessControlUpgradeable.sol";
import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import {Initializable} from "../../proxy/utils/Initializable.sol";
/**
* @dev Extension of {AccessControl} that allows enumerating the members of each role.
*/
abstract contract AccessControlEnumerableUpgradeable is Initializable, IAccessControlEnumerable, AccessControlUpgradeable {
using EnumerableSet for EnumerableSet.AddressSet;
/// @custom:storage-location erc7201:openzeppelin.storage.AccessControlEnumerable
struct AccessControlEnumerableStorage {
mapping(bytes32 role => EnumerableSet.AddressSet) _roleMembers;
}
// keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.AccessControlEnumerable")) - 1)) & ~bytes32(uint256(0xff))
bytes32 private constant AccessControlEnumerableStorageLocation = 0xc1f6fe24621ce81ec5827caf0253cadb74709b061630e6b55e82371705932000;
function _getAccessControlEnumerableStorage() private pure returns (AccessControlEnumerableStorage storage $) {
assembly {
$.slot := AccessControlEnumerableStorageLocation
}
}
function __AccessControlEnumerable_init() internal onlyInitializing {
}
function __AccessControlEnumerable_init_unchained() internal onlyInitializing {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IAccessControlEnumerable).interfaceId || super.supportsInterface(interfaceId);
}
/**
* @dev Returns one of the accounts that have `role`. `index` must be a
* value between 0 and {getRoleMemberCount}, non-inclusive.
*
* Role bearers are not sorted in any particular way, and their ordering may
* change at any point.
*
* WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
* you perform all queries on the same block. See the following
* https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]
* for more information.
*/
function getRoleMember(bytes32 role, uint256 index) public view virtual returns (address) {
AccessControlEnumerableStorage storage $ = _getAccessControlEnumerableStorage();
return $._roleMembers[role].at(index);
}
/**
* @dev Returns the number of accounts that have `role`. Can be used
* together with {getRoleMember} to enumerate all bearers of a role.
*/
function getRoleMemberCount(bytes32 role) public view virtual returns (uint256) {
AccessControlEnumerableStorage storage $ = _getAccessControlEnumerableStorage();
return $._roleMembers[role].length();
}
/**
* @dev Return all accounts that have `role`
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function getRoleMembers(bytes32 role) public view virtual returns (address[] memory) {
AccessControlEnumerableStorage storage $ = _getAccessControlEnumerableStorage();
return $._roleMembers[role].values();
}
/**
* @dev Overload {AccessControl-_grantRole} to track enumerable memberships
*/
function _grantRole(bytes32 role, address account) internal virtual override returns (bool) {
AccessControlEnumerableStorage storage $ = _getAccessControlEnumerableStorage();
bool granted = super._grantRole(role, account);
if (granted) {
$._roleMembers[role].add(account);
}
return granted;
}
/**
* @dev Overload {AccessControl-_revokeRole} to track enumerable memberships
*/
function _revokeRole(bytes32 role, address account) internal virtual override returns (bool) {
AccessControlEnumerableStorage storage $ = _getAccessControlEnumerableStorage();
bool revoked = super._revokeRole(role, account);
if (revoked) {
$._roleMembers[role].remove(account);
}
return revoked;
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (proxy/utils/Initializable.sol)
pragma solidity ^0.8.20;
/**
* @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
* behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
* external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
* function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
*
* The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
* reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
* case an upgrade adds a module that needs to be initialized.
*
* For example:
*
* [.hljs-theme-light.nopadding]
* ```solidity
* contract MyToken is ERC20Upgradeable {
* function initialize() initializer public {
* __ERC20_init("MyToken", "MTK");
* }
* }
*
* contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
* function initializeV2() reinitializer(2) public {
* __ERC20Permit_init("MyToken");
* }
* }
* ```
*
* TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
* possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
*
* CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
* that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
*
* [CAUTION]
* ====
* Avoid leaving a contract uninitialized.
*
* An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
* contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
* the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
*
* [.hljs-theme-light.nopadding]
* ```
* /// @custom:oz-upgrades-unsafe-allow constructor
* constructor() {
* _disableInitializers();
* }
* ```
* ====
*/
abstract contract Initializable {
/**
* @dev Storage of the initializable contract.
*
* It's implemented on a custom ERC-7201 namespace to reduce the risk of storage collisions
* when using with upgradeable contracts.
*
* @custom:storage-location erc7201:openzeppelin.storage.Initializable
*/
struct InitializableStorage {
/**
* @dev Indicates that the contract has been initialized.
*/
uint64 _initialized;
/**
* @dev Indicates that the contract is in the process of being initialized.
*/
bool _initializing;
}
// keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Initializable")) - 1)) & ~bytes32(uint256(0xff))
bytes32 private constant INITIALIZABLE_STORAGE = 0xf0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a00;
/**
* @dev The contract is already initialized.
*/
error InvalidInitialization();
/**
* @dev The contract is not initializing.
*/
error NotInitializing();
/**
* @dev Triggered when the contract has been initialized or reinitialized.
*/
event Initialized(uint64 version);
/**
* @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
* `onlyInitializing` functions can be used to initialize parent contracts.
*
* Similar to `reinitializer(1)`, except that in the context of a constructor an `initializer` may be invoked any
* number of times. This behavior in the constructor can be useful during testing and is not expected to be used in
* production.
*
* Emits an {Initialized} event.
*/
modifier initializer() {
// solhint-disable-next-line var-name-mixedcase
InitializableStorage storage $ = _getInitializableStorage();
// Cache values to avoid duplicated sloads
bool isTopLevelCall = !$._initializing;
uint64 initialized = $._initialized;
// Allowed calls:
// - initialSetup: the contract is not in the initializing state and no previous version was
// initialized
// - construction: the contract is initialized at version 1 (no reininitialization) and the
// current contract is just being deployed
bool initialSetup = initialized == 0 && isTopLevelCall;
bool construction = initialized == 1 && address(this).code.length == 0;
if (!initialSetup && !construction) {
revert InvalidInitialization();
}
$._initialized = 1;
if (isTopLevelCall) {
$._initializing = true;
}
_;
if (isTopLevelCall) {
$._initializing = false;
emit Initialized(1);
}
}
/**
* @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
* contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
* used to initialize parent contracts.
*
* A reinitializer may be used after the original initialization step. This is essential to configure modules that
* are added through upgrades and that require initialization.
*
* When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`
* cannot be nested. If one is invoked in the context of another, execution will revert.
*
* Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
* a contract, executing them in the right order is up to the developer or operator.
*
* WARNING: Setting the version to 2**64 - 1 will prevent any future reinitialization.
*
* Emits an {Initialized} event.
*/
modifier reinitializer(uint64 version) {
// solhint-disable-next-line var-name-mixedcase
InitializableStorage storage $ = _getInitializableStorage();
if ($._initializing || $._initialized >= version) {
revert InvalidInitialization();
}
$._initialized = version;
$._initializing = true;
_;
$._initializing = false;
emit Initialized(version);
}
/**
* @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
* {initializer} and {reinitializer} modifiers, directly or indirectly.
*/
modifier onlyInitializing() {
_checkInitializing();
_;
}
/**
* @dev Reverts if the contract is not in an initializing state. See {onlyInitializing}.
*/
function _checkInitializing() internal view virtual {
if (!_isInitializing()) {
revert NotInitializing();
}
}
/**
* @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
* Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
* to any version. It is recommended to use this to lock implementation contracts that are designed to be called
* through proxies.
*
* Emits an {Initialized} event the first time it is successfully executed.
*/
function _disableInitializers() internal virtual {
// solhint-disable-next-line var-name-mixedcase
InitializableStorage storage $ = _getInitializableStorage();
if ($._initializing) {
revert InvalidInitialization();
}
if ($._initialized != type(uint64).max) {
$._initialized = type(uint64).max;
emit Initialized(type(uint64).max);
}
}
/**
* @dev Returns the highest version that has been initialized. See {reinitializer}.
*/
function _getInitializedVersion() internal view returns (uint64) {
return _getInitializableStorage()._initialized;
}
/**
* @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.
*/
function _isInitializing() internal view returns (bool) {
return _getInitializableStorage()._initializing;
}
/**
* @dev Returns a pointer to the storage namespace.
*/
// solhint-disable-next-line var-name-mixedcase
function _getInitializableStorage() private pure returns (InitializableStorage storage $) {
assembly {
$.slot := INITIALIZABLE_STORAGE
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.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.0.0) (utils/Pausable.sol)
pragma solidity ^0.8.20;
import {ContextUpgradeable} from "../utils/ContextUpgradeable.sol";
import {Initializable} from "../proxy/utils/Initializable.sol";
/**
* @dev Contract module which allows children to implement an emergency stop
* mechanism that can be triggered by an authorized account.
*
* This module is used through inheritance. It will make available the
* modifiers `whenNotPaused` and `whenPaused`, which can be applied to
* the functions of your contract. Note that they will not be pausable by
* simply including this module, only once the modifiers are put in place.
*/
abstract contract PausableUpgradeable is Initializable, ContextUpgradeable {
/// @custom:storage-location erc7201:openzeppelin.storage.Pausable
struct PausableStorage {
bool _paused;
}
// keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Pausable")) - 1)) & ~bytes32(uint256(0xff))
bytes32 private constant PausableStorageLocation = 0xcd5ed15c6e187e77e9aee88184c21f4f2182ab5827cb3b7e07fbedcd63f03300;
function _getPausableStorage() private pure returns (PausableStorage storage $) {
assembly {
$.slot := PausableStorageLocation
}
}
/**
* @dev Emitted when the pause is triggered by `account`.
*/
event Paused(address account);
/**
* @dev Emitted when the pause is lifted by `account`.
*/
event Unpaused(address account);
/**
* @dev The operation failed because the contract is paused.
*/
error EnforcedPause();
/**
* @dev The operation failed because the contract is not paused.
*/
error ExpectedPause();
/**
* @dev Initializes the contract in unpaused state.
*/
function __Pausable_init() internal onlyInitializing {
__Pausable_init_unchained();
}
function __Pausable_init_unchained() internal onlyInitializing {
PausableStorage storage $ = _getPausableStorage();
$._paused = false;
}
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*
* Requirements:
*
* - The contract must not be paused.
*/
modifier whenNotPaused() {
_requireNotPaused();
_;
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*
* Requirements:
*
* - The contract must be paused.
*/
modifier whenPaused() {
_requirePaused();
_;
}
/**
* @dev Returns true if the contract is paused, and false otherwise.
*/
function paused() public view virtual returns (bool) {
PausableStorage storage $ = _getPausableStorage();
return $._paused;
}
/**
* @dev Throws if the contract is paused.
*/
function _requireNotPaused() internal view virtual {
if (paused()) {
revert EnforcedPause();
}
}
/**
* @dev Throws if the contract is not paused.
*/
function _requirePaused() internal view virtual {
if (!paused()) {
revert ExpectedPause();
}
}
/**
* @dev Triggers stopped state.
*
* Requirements:
*
* - The contract must not be paused.
*/
function _pause() internal virtual whenNotPaused {
PausableStorage storage $ = _getPausableStorage();
$._paused = true;
emit Paused(_msgSender());
}
/**
* @dev Returns to normal state.
*
* Requirements:
*
* - The contract must be paused.
*/
function _unpause() internal virtual whenPaused {
PausableStorage storage $ = _getPausableStorage();
$._paused = false;
emit Unpaused(_msgSender());
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/ReentrancyGuard.sol)
pragma solidity ^0.8.20;
import {Initializable} from "../proxy/utils/Initializable.sol";
/**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If EIP-1153 (transient storage) is available on the chain you're deploying at,
* consider using {ReentrancyGuardTransient} instead.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/
abstract contract ReentrancyGuardUpgradeable is Initializable {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant NOT_ENTERED = 1;
uint256 private constant ENTERED = 2;
/// @custom:storage-location erc7201:openzeppelin.storage.ReentrancyGuard
struct ReentrancyGuardStorage {
uint256 _status;
}
// keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.ReentrancyGuard")) - 1)) & ~bytes32(uint256(0xff))
bytes32 private constant ReentrancyGuardStorageLocation = 0x9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00;
function _getReentrancyGuardStorage() private pure returns (ReentrancyGuardStorage storage $) {
assembly {
$.slot := ReentrancyGuardStorageLocation
}
}
/**
* @dev Unauthorized reentrant call.
*/
error ReentrancyGuardReentrantCall();
function __ReentrancyGuard_init() internal onlyInitializing {
__ReentrancyGuard_init_unchained();
}
function __ReentrancyGuard_init_unchained() internal onlyInitializing {
ReentrancyGuardStorage storage $ = _getReentrancyGuardStorage();
$._status = NOT_ENTERED;
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and making it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
_nonReentrantBefore();
_;
_nonReentrantAfter();
}
function _nonReentrantBefore() private {
ReentrancyGuardStorage storage $ = _getReentrancyGuardStorage();
// On the first call to nonReentrant, _status will be NOT_ENTERED
if ($._status == ENTERED) {
revert ReentrancyGuardReentrantCall();
}
// Any calls to nonReentrant after this point will fail
$._status = ENTERED;
}
function _nonReentrantAfter() private {
ReentrancyGuardStorage storage $ = _getReentrancyGuardStorage();
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
$._status = NOT_ENTERED;
}
/**
* @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
* `nonReentrant` function in the call stack.
*/
function _reentrancyGuardEntered() internal view returns (bool) {
ReentrancyGuardStorage storage $ = _getReentrancyGuardStorage();
return $._status == ENTERED;
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (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) (access/IAccessControl.sol)
pragma solidity ^0.8.20;
/**
* @dev External interface of AccessControl declared to support ERC-165 detection.
*/
interface IAccessControl {
/**
* @dev The `account` is missing a role.
*/
error AccessControlUnauthorizedAccount(address account, bytes32 neededRole);
/**
* @dev The caller of a function is not the expected one.
*
* NOTE: Don't confuse with {AccessControlUnauthorizedAccount}.
*/
error AccessControlBadConfirmation();
/**
* @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
*
* `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
* {RoleAdminChanged} not being emitted signaling this.
*/
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
/**
* @dev Emitted when `account` is granted `role`.
*
* `sender` is the account that originated the contract call. This account bears the admin role (for the granted role).
* Expected in cases where the role was granted using the internal {AccessControl-_grantRole}.
*/
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
/**
* @dev Emitted when `account` is revoked `role`.
*
* `sender` is the account that originated the contract call:
* - if using `revokeRole`, it is the admin role bearer
* - if using `renounceRole`, it is the role bearer (i.e. `account`)
*/
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
/**
* @dev Returns `true` if `account` has been granted `role`.
*/
function hasRole(bytes32 role, address account) external view returns (bool);
/**
* @dev Returns the admin role that controls `role`. See {grantRole} and
* {revokeRole}.
*
* To change a role's admin, use {AccessControl-_setRoleAdmin}.
*/
function getRoleAdmin(bytes32 role) external view returns (bytes32);
/**
* @dev Grants `role` to `account`.
*
* If `account` had not been already granted `role`, emits a {RoleGranted}
* event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*/
function grantRole(bytes32 role, address account) external;
/**
* @dev Revokes `role` from `account`.
*
* If `account` had been granted `role`, emits a {RoleRevoked} event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*/
function revokeRole(bytes32 role, address account) external;
/**
* @dev Revokes `role` from the calling account.
*
* Roles are often managed via {grantRole} and {revokeRole}: this function's
* purpose is to provide a mechanism for accounts to lose their privileges
* if they are compromised (such as when a trusted device is misplaced).
*
* If the calling account had been granted `role`, emits a {RoleRevoked}
* event.
*
* Requirements:
*
* - the caller must be `callerConfirmation`.
*/
function renounceRole(bytes32 role, address callerConfirmation) external;
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (access/extensions/IAccessControlEnumerable.sol)
pragma solidity ^0.8.20;
import {IAccessControl} from "../IAccessControl.sol";
/**
* @dev External interface of AccessControlEnumerable declared to support ERC-165 detection.
*/
interface IAccessControlEnumerable is IAccessControl {
/**
* @dev Returns one of the accounts that have `role`. `index` must be a
* value between 0 and {getRoleMemberCount}, non-inclusive.
*
* Role bearers are not sorted in any particular way, and their ordering may
* change at any point.
*
* WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
* you perform all queries on the same block. See the following
* https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]
* for more information.
*/
function getRoleMember(bytes32 role, uint256 index) external view returns (address);
/**
* @dev Returns the number of accounts that have `role`. Can be used
* together with {getRoleMember} to enumerate all bearers of a role.
*/
function getRoleMemberCount(bytes32 role) external view returns (uint256);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/IERC1363.sol)
pragma solidity ^0.8.20;
import {IERC20} from "./IERC20.sol";
import {IERC165} from "./IERC165.sol";
/**
* @title IERC1363
* @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].
*
* Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract
* after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.
*/
interface IERC1363 is IERC20, IERC165 {
/*
* Note: the ERC-165 identifier for this interface is 0xb0202a11.
* 0xb0202a11 ===
* bytes4(keccak256('transferAndCall(address,uint256)')) ^
* bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^
* bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^
* bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^
* bytes4(keccak256('approveAndCall(address,uint256)')) ^
* bytes4(keccak256('approveAndCall(address,uint256,bytes)'))
*/
/**
* @dev Moves a `value` amount of tokens from the caller's account to `to`
* and then calls {IERC1363Receiver-onTransferReceived} on `to`.
* @param to The address which you want to transfer to.
* @param value The amount of tokens to be transferred.
* @return A boolean value indicating whether the operation succeeded unless throwing.
*/
function transferAndCall(address to, uint256 value) external returns (bool);
/**
* @dev Moves a `value` amount of tokens from the caller's account to `to`
* and then calls {IERC1363Receiver-onTransferReceived} on `to`.
* @param to The address which you want to transfer to.
* @param value The amount of tokens to be transferred.
* @param data Additional data with no specified format, sent in call to `to`.
* @return A boolean value indicating whether the operation succeeded unless throwing.
*/
function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);
/**
* @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
* and then calls {IERC1363Receiver-onTransferReceived} on `to`.
* @param from The address which you want to send tokens from.
* @param to The address which you want to transfer to.
* @param value The amount of tokens to be transferred.
* @return A boolean value indicating whether the operation succeeded unless throwing.
*/
function transferFromAndCall(address from, address to, uint256 value) external returns (bool);
/**
* @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
* and then calls {IERC1363Receiver-onTransferReceived} on `to`.
* @param from The address which you want to send tokens from.
* @param to The address which you want to transfer to.
* @param value The amount of tokens to be transferred.
* @param data Additional data with no specified format, sent in call to `to`.
* @return A boolean value indicating whether the operation succeeded unless throwing.
*/
function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);
/**
* @dev Sets a `value` amount of tokens as the allowance of `spender` over the
* caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
* @param spender The address which will spend the funds.
* @param value The amount of tokens to be spent.
* @return A boolean value indicating whether the operation succeeded unless throwing.
*/
function approveAndCall(address spender, uint256 value) external returns (bool);
/**
* @dev Sets a `value` amount of tokens as the allowance of `spender` over the
* caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
* @param spender The address which will spend the funds.
* @param value The amount of tokens to be spent.
* @param data Additional data with no specified format, sent in call to `spender`.
* @return A boolean value indicating whether the operation succeeded unless throwing.
*/
function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC165.sol)
pragma solidity ^0.8.20;
import {IERC165} from "../utils/introspection/IERC165.sol";// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC20.sol)
pragma solidity ^0.8.20;
import {IERC20} from "../token/ERC20/IERC20.sol";// 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/ERC20/IERC20.sol)
pragma solidity ^0.8.20;
/**
* @dev Interface of the ERC-20 standard as defined in the ERC.
*/
interface IERC20 {
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Returns the value of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the value of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves a `value` amount of tokens from the caller's account to `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address to, uint256 value) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets a `value` amount of tokens as the allowance of `spender` over the
* caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 value) external returns (bool);
/**
* @dev Moves a `value` amount of tokens from `from` to `to` using the
* allowance mechanism. `value` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address from, address to, uint256 value) external returns (bool);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/utils/SafeERC20.sol)
pragma solidity ^0.8.20;
import {IERC20} from "../IERC20.sol";
import {IERC1363} from "../../../interfaces/IERC1363.sol";
import {Address} from "../../../utils/Address.sol";
/**
* @title SafeERC20
* @dev Wrappers around ERC-20 operations that throw on failure (when the token
* contract returns false). Tokens that return no value (and instead revert or
* throw on failure) are also supported, non-reverting calls are assumed to be
* successful.
* To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
* which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
*/
library SafeERC20 {
/**
* @dev An operation with an ERC-20 token failed.
*/
error SafeERC20FailedOperation(address token);
/**
* @dev Indicates a failed `decreaseAllowance` request.
*/
error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);
/**
* @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
* non-reverting calls are assumed to be successful.
*/
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
}
/**
* @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
* calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
*/
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
}
/**
* @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
* non-reverting calls are assumed to be successful.
*
* IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the "client"
* smart contract uses ERC-7674 to set temporary allowances, then the "client" smart contract should avoid using
* this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract
* that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.
*/
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 oldAllowance = token.allowance(address(this), spender);
forceApprove(token, spender, oldAllowance + value);
}
/**
* @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
* value, non-reverting calls are assumed to be successful.
*
* IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the "client"
* smart contract uses ERC-7674 to set temporary allowances, then the "client" smart contract should avoid using
* this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract
* that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.
*/
function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
unchecked {
uint256 currentAllowance = token.allowance(address(this), spender);
if (currentAllowance < requestedDecrease) {
revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
}
forceApprove(token, spender, currentAllowance - requestedDecrease);
}
}
/**
* @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
* non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
* to be set to zero before setting it to a non-zero value, such as USDT.
*
* NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function
* only sets the "standard" allowance. Any temporary allowance will remain active, in addition to the value being
* set here.
*/
function forceApprove(IERC20 token, address spender, uint256 value) internal {
bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));
if (!_callOptionalReturnBool(token, approvalCall)) {
_callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
_callOptionalReturn(token, approvalCall);
}
}
/**
* @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no
* code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
* targeting contracts.
*
* Reverts if the returned value is other than `true`.
*/
function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {
if (to.code.length == 0) {
safeTransfer(token, to, value);
} else if (!token.transferAndCall(to, value, data)) {
revert SafeERC20FailedOperation(address(token));
}
}
/**
* @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target
* has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
* targeting contracts.
*
* Reverts if the returned value is other than `true`.
*/
function transferFromAndCallRelaxed(
IERC1363 token,
address from,
address to,
uint256 value,
bytes memory data
) internal {
if (to.code.length == 0) {
safeTransferFrom(token, from, to, value);
} else if (!token.transferFromAndCall(from, to, value, data)) {
revert SafeERC20FailedOperation(address(token));
}
}
/**
* @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no
* code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
* targeting contracts.
*
* NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.
* Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}
* once without retrying, and relies on the returned value to be true.
*
* Reverts if the returned value is other than `true`.
*/
function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {
if (to.code.length == 0) {
forceApprove(token, to, value);
} else if (!token.approveAndCall(to, value, data)) {
revert SafeERC20FailedOperation(address(token));
}
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*
* This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.
*/
function _callOptionalReturn(IERC20 token, bytes memory data) private {
uint256 returnSize;
uint256 returnValue;
assembly ("memory-safe") {
let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)
// bubble errors
if iszero(success) {
let ptr := mload(0x40)
returndatacopy(ptr, 0, returndatasize())
revert(ptr, returndatasize())
}
returnSize := returndatasize()
returnValue := mload(0)
}
if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {
revert SafeERC20FailedOperation(address(token));
}
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*
* This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.
*/
function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
bool success;
uint256 returnSize;
uint256 returnValue;
assembly ("memory-safe") {
success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)
returnSize := returndatasize()
returnValue := mload(0)
}
return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC721/IERC721.sol)
pragma solidity ^0.8.20;
import {IERC165} from "../../utils/introspection/IERC165.sol";
/**
* @dev Required interface of an ERC-721 compliant contract.
*/
interface IERC721 is IERC165 {
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
*/
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/**
* @dev Returns the number of tokens in ``owner``'s account.
*/
function balanceOf(address owner) external view returns (uint256 balance);
/**
* @dev Returns the owner of the `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function ownerOf(uint256 tokenId) external view returns (address owner);
/**
* @dev Safely transfers `tokenId` token from `from` to `to`.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon
* a safe transfer.
*
* Emits a {Transfer} event.
*/
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC-721 protocol to prevent tokens from being forever locked.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must have been allowed to move this token by either {approve} or
* {setApprovalForAll}.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon
* a safe transfer.
*
* Emits a {Transfer} event.
*/
function safeTransferFrom(address from, address to, uint256 tokenId) external;
/**
* @dev Transfers `tokenId` token from `from` to `to`.
*
* WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC-721
* or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
* understand this adds an external call which potentially creates a reentrancy vulnerability.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
*
* Emits a {Transfer} event.
*/
function transferFrom(address from, address to, uint256 tokenId) external;
/**
* @dev Gives permission to `to` to transfer `tokenId` token to another account.
* The approval is cleared when the token is transferred.
*
* Only a single account can be approved at a time, so approving the zero address clears previous approvals.
*
* Requirements:
*
* - The caller must own the token or be an approved operator.
* - `tokenId` must exist.
*
* Emits an {Approval} event.
*/
function approve(address to, uint256 tokenId) external;
/**
* @dev Approve or remove `operator` as an operator for the caller.
* Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
*
* Requirements:
*
* - The `operator` cannot be the address zero.
*
* Emits an {ApprovalForAll} event.
*/
function setApprovalForAll(address operator, bool approved) external;
/**
* @dev Returns the account approved for `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function getApproved(uint256 tokenId) external view returns (address operator);
/**
* @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
*
* See {setApprovalForAll}
*/
function isApprovedForAll(address owner, address operator) external view returns (bool);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/Address.sol)
pragma solidity ^0.8.20;
import {Errors} from "./Errors.sol";
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev There's no code at `target` (it is not a contract).
*/
error AddressEmptyCode(address target);
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
if (address(this).balance < amount) {
revert Errors.InsufficientBalance(address(this).balance, amount);
}
(bool success, ) = recipient.call{value: amount}("");
if (!success) {
revert Errors.FailedCall();
}
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason or custom error, it is bubbled
* up by this function (like regular Solidity function calls). However, if
* the call reverted with no returned reason, this function reverts with a
* {Errors.FailedCall} error.
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
if (address(this).balance < value) {
revert Errors.InsufficientBalance(address(this).balance, value);
}
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata);
}
/**
* @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
* was not a contract or bubbling up the revert reason (falling back to {Errors.FailedCall}) in case
* of an unsuccessful call.
*/
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata
) internal view returns (bytes memory) {
if (!success) {
_revert(returndata);
} else {
// only check if target is a contract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
if (returndata.length == 0 && target.code.length == 0) {
revert AddressEmptyCode(target);
}
return returndata;
}
}
/**
* @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
* revert reason or with a default {Errors.FailedCall} error.
*/
function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
if (!success) {
_revert(returndata);
} else {
return returndata;
}
}
/**
* @dev Reverts with returndata if present. Otherwise reverts with {Errors.FailedCall}.
*/
function _revert(bytes memory returndata) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
assembly ("memory-safe") {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert Errors.FailedCall();
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/Errors.sol)
pragma solidity ^0.8.20;
/**
* @dev Collection of common custom errors used in multiple contracts
*
* IMPORTANT: Backwards compatibility is not guaranteed in future versions of the library.
* It is recommended to avoid relying on the error API for critical functionality.
*
* _Available since v5.1._
*/
library Errors {
/**
* @dev The ETH balance of the account is not enough to perform the operation.
*/
error InsufficientBalance(uint256 balance, uint256 needed);
/**
* @dev A call to an address target failed. The target may have reverted.
*/
error FailedCall();
/**
* @dev The deployment failed.
*/
error FailedDeployment();
/**
* @dev A necessary precompile is missing.
*/
error MissingPrecompile(address);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/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/introspection/IERC165.sol)
pragma solidity ^0.8.20;
/**
* @dev Interface of the ERC-165 standard, as defined in the
* https://eips.ethereum.org/EIPS/eip-165[ERC].
*
* Implementers can declare support of contract interfaces, which can then be
* queried by others ({ERC165Checker}).
*
* For an implementation, see {ERC165}.
*/
interface IERC165 {
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/Math.sol)
pragma solidity ^0.8.20;
import {Panic} from "../Panic.sol";
import {SafeCast} from "./SafeCast.sol";
/**
* @dev Standard math utilities missing in the Solidity language.
*/
library Math {
enum Rounding {
Floor, // Toward negative infinity
Ceil, // Toward positive infinity
Trunc, // Toward zero
Expand // Away from zero
}
/**
* @dev Returns the addition of two unsigned integers, with an success flag (no overflow).
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
/**
* @dev Returns the subtraction of two unsigned integers, with an success flag (no overflow).
*/
function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
/**
* @dev Returns the multiplication of two unsigned integers, with an success flag (no overflow).
*/
function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
/**
* @dev Returns the division of two unsigned integers, with a success flag (no division by zero).
*/
function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
/**
* @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).
*/
function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
/**
* @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.
*
* IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.
* However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute
* one branch when needed, making this function more expensive.
*/
function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {
unchecked {
// branchless ternary works because:
// b ^ (a ^ b) == a
// b ^ 0 == b
return b ^ ((a ^ b) * SafeCast.toUint(condition));
}
}
/**
* @dev Returns the largest of two numbers.
*/
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return ternary(a > b, a, b);
}
/**
* @dev Returns the smallest of two numbers.
*/
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return ternary(a < b, a, b);
}
/**
* @dev Returns the average of two numbers. The result is rounded towards
* zero.
*/
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow.
return (a & b) + (a ^ b) / 2;
}
/**
* @dev Returns the ceiling of the division of two numbers.
*
* This differs from standard division with `/` in that it rounds towards infinity instead
* of rounding towards zero.
*/
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
if (b == 0) {
// Guarantee the same behavior as in a regular Solidity division.
Panic.panic(Panic.DIVISION_BY_ZERO);
}
// The following calculation ensures accurate ceiling division without overflow.
// Since a is non-zero, (a - 1) / b will not overflow.
// The largest possible result occurs when (a - 1) / b is type(uint256).max,
// but the largest value we can obtain is type(uint256).max - 1, which happens
// when a = type(uint256).max and b = 1.
unchecked {
return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);
}
}
/**
* @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or
* denominator == 0.
*
* Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by
* Uniswap Labs also under MIT license.
*/
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
// 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2²⁵⁶ and mod 2²⁵⁶ - 1, then use
// the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
// variables such that product = prod1 * 2²⁵⁶ + prod0.
uint256 prod0 = x * y; // Least significant 256 bits of the product
uint256 prod1; // Most significant 256 bits of the product
assembly {
let mm := mulmod(x, y, not(0))
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
// Handle non-overflow cases, 256 by 256 division.
if (prod1 == 0) {
// Solidity will revert if denominator == 0, unlike the div opcode on its own.
// The surrounding unchecked block does not change this fact.
// See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
return prod0 / denominator;
}
// Make sure the result is less than 2²⁵⁶. Also prevents denominator == 0.
if (denominator <= prod1) {
Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));
}
///////////////////////////////////////////////
// 512 by 256 division.
///////////////////////////////////////////////
// Make division exact by subtracting the remainder from [prod1 prod0].
uint256 remainder;
assembly {
// Compute remainder using mulmod.
remainder := mulmod(x, y, denominator)
// Subtract 256 bit number from 512 bit number.
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
// Factor powers of two out of denominator and compute largest power of two divisor of denominator.
// Always >= 1. See https://cs.stackexchange.com/q/138556/92363.
uint256 twos = denominator & (0 - denominator);
assembly {
// Divide denominator by twos.
denominator := div(denominator, twos)
// Divide [prod1 prod0] by twos.
prod0 := div(prod0, twos)
// Flip twos such that it is 2²⁵⁶ / twos. If twos is zero, then it becomes one.
twos := add(div(sub(0, twos), twos), 1)
}
// Shift in bits from prod1 into prod0.
prod0 |= prod1 * twos;
// Invert denominator mod 2²⁵⁶. Now that denominator is an odd number, it has an inverse modulo 2²⁵⁶ such
// that denominator * inv ≡ 1 mod 2²⁵⁶. Compute the inverse by starting with a seed that is correct for
// four bits. That is, denominator * inv ≡ 1 mod 2⁴.
uint256 inverse = (3 * denominator) ^ 2;
// Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also
// works in modular arithmetic, doubling the correct bits in each step.
inverse *= 2 - denominator * inverse; // inverse mod 2⁸
inverse *= 2 - denominator * inverse; // inverse mod 2¹⁶
inverse *= 2 - denominator * inverse; // inverse mod 2³²
inverse *= 2 - denominator * inverse; // inverse mod 2⁶⁴
inverse *= 2 - denominator * inverse; // inverse mod 2¹²⁸
inverse *= 2 - denominator * inverse; // inverse mod 2²⁵⁶
// Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
// This will give us the correct result modulo 2²⁵⁶. Since the preconditions guarantee that the outcome is
// less than 2²⁵⁶, this is the final result. We don't need to compute the high bits of the result and prod1
// is no longer required.
result = prod0 * inverse;
return result;
}
}
/**
* @dev Calculates x * y / denominator with full precision, following the selected rounding direction.
*/
function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);
}
/**
* @dev Calculate the modular multiplicative inverse of a number in Z/nZ.
*
* If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.
* If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.
*
* If the input value is not inversible, 0 is returned.
*
* NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the
* inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.
*/
function invMod(uint256 a, uint256 n) internal pure returns (uint256) {
unchecked {
if (n == 0) return 0;
// The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)
// Used to compute integers x and y such that: ax + ny = gcd(a, n).
// When the gcd is 1, then the inverse of a modulo n exists and it's x.
// ax + ny = 1
// ax = 1 + (-y)n
// ax ≡ 1 (mod n) # x is the inverse of a modulo n
// If the remainder is 0 the gcd is n right away.
uint256 remainder = a % n;
uint256 gcd = n;
// Therefore the initial coefficients are:
// ax + ny = gcd(a, n) = n
// 0a + 1n = n
int256 x = 0;
int256 y = 1;
while (remainder != 0) {
uint256 quotient = gcd / remainder;
(gcd, remainder) = (
// The old remainder is the next gcd to try.
remainder,
// Compute the next remainder.
// Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd
// where gcd is at most n (capped to type(uint256).max)
gcd - remainder * quotient
);
(x, y) = (
// Increment the coefficient of a.
y,
// Decrement the coefficient of n.
// Can overflow, but the result is casted to uint256 so that the
// next value of y is "wrapped around" to a value between 0 and n - 1.
x - y * int256(quotient)
);
}
if (gcd != 1) return 0; // No inverse exists.
return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.
}
}
/**
* @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.
*
* From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is
* prime, then `a**(p-1) ≡ 1 mod p`. As a consequence, we have `a * a**(p-2) ≡ 1 mod p`, which means that
* `a**(p-2)` is the modular multiplicative inverse of a in Fp.
*
* NOTE: this function does NOT check that `p` is a prime greater than `2`.
*/
function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {
unchecked {
return Math.modExp(a, p - 2, p);
}
}
/**
* @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)
*
* Requirements:
* - modulus can't be zero
* - underlying staticcall to precompile must succeed
*
* IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make
* sure the chain you're using it on supports the precompiled contract for modular exponentiation
* at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,
* the underlying function will succeed given the lack of a revert, but the result may be incorrectly
* interpreted as 0.
*/
function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {
(bool success, uint256 result) = tryModExp(b, e, m);
if (!success) {
Panic.panic(Panic.DIVISION_BY_ZERO);
}
return result;
}
/**
* @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).
* It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying
* to operate modulo 0 or if the underlying precompile reverted.
*
* IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain
* you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in
* https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack
* of a revert, but the result may be incorrectly interpreted as 0.
*/
function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {
if (m == 0) return (false, 0);
assembly ("memory-safe") {
let ptr := mload(0x40)
// | Offset | Content | Content (Hex) |
// |-----------|------------|--------------------------------------------------------------------|
// | 0x00:0x1f | size of b | 0x0000000000000000000000000000000000000000000000000000000000000020 |
// | 0x20:0x3f | size of e | 0x0000000000000000000000000000000000000000000000000000000000000020 |
// | 0x40:0x5f | size of m | 0x0000000000000000000000000000000000000000000000000000000000000020 |
// | 0x60:0x7f | value of b | 0x<.............................................................b> |
// | 0x80:0x9f | value of e | 0x<.............................................................e> |
// | 0xa0:0xbf | value of m | 0x<.............................................................m> |
mstore(ptr, 0x20)
mstore(add(ptr, 0x20), 0x20)
mstore(add(ptr, 0x40), 0x20)
mstore(add(ptr, 0x60), b)
mstore(add(ptr, 0x80), e)
mstore(add(ptr, 0xa0), m)
// Given the result < m, it's guaranteed to fit in 32 bytes,
// so we can use the memory scratch space located at offset 0.
success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)
result := mload(0x00)
}
}
/**
* @dev Variant of {modExp} that supports inputs of arbitrary length.
*/
function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {
(bool success, bytes memory result) = tryModExp(b, e, m);
if (!success) {
Panic.panic(Panic.DIVISION_BY_ZERO);
}
return result;
}
/**
* @dev Variant of {tryModExp} that supports inputs of arbitrary length.
*/
function tryModExp(
bytes memory b,
bytes memory e,
bytes memory m
) internal view returns (bool success, bytes memory result) {
if (_zeroBytes(m)) return (false, new bytes(0));
uint256 mLen = m.length;
// Encode call args in result and move the free memory pointer
result = abi.encodePacked(b.length, e.length, mLen, b, e, m);
assembly ("memory-safe") {
let dataPtr := add(result, 0x20)
// Write result on top of args to avoid allocating extra memory.
success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)
// Overwrite the length.
// result.length > returndatasize() is guaranteed because returndatasize() == m.length
mstore(result, mLen)
// Set the memory pointer after the returned data.
mstore(0x40, add(dataPtr, mLen))
}
}
/**
* @dev Returns whether the provided byte array is zero.
*/
function _zeroBytes(bytes memory byteArray) private pure returns (bool) {
for (uint256 i = 0; i < byteArray.length; ++i) {
if (byteArray[i] != 0) {
return false;
}
}
return true;
}
/**
* @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded
* towards zero.
*
* This method is based on Newton's method for computing square roots; the algorithm is restricted to only
* using integer operations.
*/
function sqrt(uint256 a) internal pure returns (uint256) {
unchecked {
// Take care of easy edge cases when a == 0 or a == 1
if (a <= 1) {
return a;
}
// In this function, we use Newton's method to get a root of `f(x) := x² - a`. It involves building a
// sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between
// the current value as `ε_n = | x_n - sqrt(a) |`.
//
// For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root
// of the target. (i.e. `2**(e-1) ≤ sqrt(a) < 2**e`). We know that `e ≤ 128` because `(2¹²⁸)² = 2²⁵⁶` is
// bigger than any uint256.
//
// By noticing that
// `2**(e-1) ≤ sqrt(a) < 2**e → (2**(e-1))² ≤ a < (2**e)² → 2**(2*e-2) ≤ a < 2**(2*e)`
// we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar
// to the msb function.
uint256 aa = a;
uint256 xn = 1;
if (aa >= (1 << 128)) {
aa >>= 128;
xn <<= 64;
}
if (aa >= (1 << 64)) {
aa >>= 64;
xn <<= 32;
}
if (aa >= (1 << 32)) {
aa >>= 32;
xn <<= 16;
}
if (aa >= (1 << 16)) {
aa >>= 16;
xn <<= 8;
}
if (aa >= (1 << 8)) {
aa >>= 8;
xn <<= 4;
}
if (aa >= (1 << 4)) {
aa >>= 4;
xn <<= 2;
}
if (aa >= (1 << 2)) {
xn <<= 1;
}
// We now have x_n such that `x_n = 2**(e-1) ≤ sqrt(a) < 2**e = 2 * x_n`. This implies ε_n ≤ 2**(e-1).
//
// We can refine our estimation by noticing that the middle of that interval minimizes the error.
// If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to ε_n ≤ 2**(e-2).
// This is going to be our x_0 (and ε_0)
xn = (3 * xn) >> 1; // ε_0 := | x_0 - sqrt(a) | ≤ 2**(e-2)
// From here, Newton's method give us:
// x_{n+1} = (x_n + a / x_n) / 2
//
// One should note that:
// x_{n+1}² - a = ((x_n + a / x_n) / 2)² - a
// = ((x_n² + a) / (2 * x_n))² - a
// = (x_n⁴ + 2 * a * x_n² + a²) / (4 * x_n²) - a
// = (x_n⁴ + 2 * a * x_n² + a² - 4 * a * x_n²) / (4 * x_n²)
// = (x_n⁴ - 2 * a * x_n² + a²) / (4 * x_n²)
// = (x_n² - a)² / (2 * x_n)²
// = ((x_n² - a) / (2 * x_n))²
// ≥ 0
// Which proves that for all n ≥ 1, sqrt(a) ≤ x_n
//
// This gives us the proof of quadratic convergence of the sequence:
// ε_{n+1} = | x_{n+1} - sqrt(a) |
// = | (x_n + a / x_n) / 2 - sqrt(a) |
// = | (x_n² + a - 2*x_n*sqrt(a)) / (2 * x_n) |
// = | (x_n - sqrt(a))² / (2 * x_n) |
// = | ε_n² / (2 * x_n) |
// = ε_n² / | (2 * x_n) |
//
// For the first iteration, we have a special case where x_0 is known:
// ε_1 = ε_0² / | (2 * x_0) |
// ≤ (2**(e-2))² / (2 * (2**(e-1) + 2**(e-2)))
// ≤ 2**(2*e-4) / (3 * 2**(e-1))
// ≤ 2**(e-3) / 3
// ≤ 2**(e-3-log2(3))
// ≤ 2**(e-4.5)
//
// For the following iterations, we use the fact that, 2**(e-1) ≤ sqrt(a) ≤ x_n:
// ε_{n+1} = ε_n² / | (2 * x_n) |
// ≤ (2**(e-k))² / (2 * 2**(e-1))
// ≤ 2**(2*e-2*k) / 2**e
// ≤ 2**(e-2*k)
xn = (xn + a / xn) >> 1; // ε_1 := | x_1 - sqrt(a) | ≤ 2**(e-4.5) -- special case, see above
xn = (xn + a / xn) >> 1; // ε_2 := | x_2 - sqrt(a) | ≤ 2**(e-9) -- general case with k = 4.5
xn = (xn + a / xn) >> 1; // ε_3 := | x_3 - sqrt(a) | ≤ 2**(e-18) -- general case with k = 9
xn = (xn + a / xn) >> 1; // ε_4 := | x_4 - sqrt(a) | ≤ 2**(e-36) -- general case with k = 18
xn = (xn + a / xn) >> 1; // ε_5 := | x_5 - sqrt(a) | ≤ 2**(e-72) -- general case with k = 36
xn = (xn + a / xn) >> 1; // ε_6 := | x_6 - sqrt(a) | ≤ 2**(e-144) -- general case with k = 72
// Because e ≤ 128 (as discussed during the first estimation phase), we know have reached a precision
// ε_6 ≤ 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either
// sqrt(a) or sqrt(a) + 1.
return xn - SafeCast.toUint(xn > a / xn);
}
}
/**
* @dev Calculates sqrt(a), following the selected rounding direction.
*/
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);
}
}
/**
* @dev Return the log in base 2 of a positive value rounded towards zero.
* Returns 0 if given 0.
*/
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
uint256 exp;
unchecked {
exp = 128 * SafeCast.toUint(value > (1 << 128) - 1);
value >>= exp;
result += exp;
exp = 64 * SafeCast.toUint(value > (1 << 64) - 1);
value >>= exp;
result += exp;
exp = 32 * SafeCast.toUint(value > (1 << 32) - 1);
value >>= exp;
result += exp;
exp = 16 * SafeCast.toUint(value > (1 << 16) - 1);
value >>= exp;
result += exp;
exp = 8 * SafeCast.toUint(value > (1 << 8) - 1);
value >>= exp;
result += exp;
exp = 4 * SafeCast.toUint(value > (1 << 4) - 1);
value >>= exp;
result += exp;
exp = 2 * SafeCast.toUint(value > (1 << 2) - 1);
value >>= exp;
result += exp;
result += SafeCast.toUint(value > 1);
}
return result;
}
/**
* @dev Return the log in base 2, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);
}
}
/**
* @dev Return the log in base 10 of a positive value rounded towards zero.
* Returns 0 if given 0.
*/
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10 ** 64) {
value /= 10 ** 64;
result += 64;
}
if (value >= 10 ** 32) {
value /= 10 ** 32;
result += 32;
}
if (value >= 10 ** 16) {
value /= 10 ** 16;
result += 16;
}
if (value >= 10 ** 8) {
value /= 10 ** 8;
result += 8;
}
if (value >= 10 ** 4) {
value /= 10 ** 4;
result += 4;
}
if (value >= 10 ** 2) {
value /= 10 ** 2;
result += 2;
}
if (value >= 10 ** 1) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 10, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);
}
}
/**
* @dev Return the log in base 256 of a positive value rounded towards zero.
* Returns 0 if given 0.
*
* Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
*/
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
uint256 isGt;
unchecked {
isGt = SafeCast.toUint(value > (1 << 128) - 1);
value >>= isGt * 128;
result += isGt * 16;
isGt = SafeCast.toUint(value > (1 << 64) - 1);
value >>= isGt * 64;
result += isGt * 8;
isGt = SafeCast.toUint(value > (1 << 32) - 1);
value >>= isGt * 32;
result += isGt * 4;
isGt = SafeCast.toUint(value > (1 << 16) - 1);
value >>= isGt * 16;
result += isGt * 2;
result += SafeCast.toUint(value > (1 << 8) - 1);
}
return result;
}
/**
* @dev Return the log in base 256, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);
}
}
/**
* @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
*/
function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
return uint8(rounding) % 2 == 1;
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)
// This file was procedurally generated from scripts/generate/templates/SafeCast.js.
pragma solidity ^0.8.20;
/**
* @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow
* checks.
*
* Downcasting from uint256/int256 in Solidity does not revert on overflow. This can
* easily result in undesired exploitation or bugs, since developers usually
* assume that overflows raise errors. `SafeCast` restores this intuition by
* reverting the transaction when such an operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/
library SafeCast {
/**
* @dev Value doesn't fit in an uint of `bits` size.
*/
error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);
/**
* @dev An int value doesn't fit in an uint of `bits` size.
*/
error SafeCastOverflowedIntToUint(int256 value);
/**
* @dev Value doesn't fit in an int of `bits` size.
*/
error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);
/**
* @dev An uint value doesn't fit in an int of `bits` size.
*/
error SafeCastOverflowedUintToInt(uint256 value);
/**
* @dev Returns the downcasted uint248 from uint256, reverting on
* overflow (when the input is greater than largest uint248).
*
* Counterpart to Solidity's `uint248` operator.
*
* Requirements:
*
* - input must fit into 248 bits
*/
function toUint248(uint256 value) internal pure returns (uint248) {
if (value > type(uint248).max) {
revert SafeCastOverflowedUintDowncast(248, value);
}
return uint248(value);
}
/**
* @dev Returns the downcasted uint240 from uint256, reverting on
* overflow (when the input is greater than largest uint240).
*
* Counterpart to Solidity's `uint240` operator.
*
* Requirements:
*
* - input must fit into 240 bits
*/
function toUint240(uint256 value) internal pure returns (uint240) {
if (value > type(uint240).max) {
revert SafeCastOverflowedUintDowncast(240, value);
}
return uint240(value);
}
/**
* @dev Returns the downcasted uint232 from uint256, reverting on
* overflow (when the input is greater than largest uint232).
*
* Counterpart to Solidity's `uint232` operator.
*
* Requirements:
*
* - input must fit into 232 bits
*/
function toUint232(uint256 value) internal pure returns (uint232) {
if (value > type(uint232).max) {
revert SafeCastOverflowedUintDowncast(232, value);
}
return uint232(value);
}
/**
* @dev Returns the downcasted uint224 from uint256, reverting on
* overflow (when the input is greater than largest uint224).
*
* Counterpart to Solidity's `uint224` operator.
*
* Requirements:
*
* - input must fit into 224 bits
*/
function toUint224(uint256 value) internal pure returns (uint224) {
if (value > type(uint224).max) {
revert SafeCastOverflowedUintDowncast(224, value);
}
return uint224(value);
}
/**
* @dev Returns the downcasted uint216 from uint256, reverting on
* overflow (when the input is greater than largest uint216).
*
* Counterpart to Solidity's `uint216` operator.
*
* Requirements:
*
* - input must fit into 216 bits
*/
function toUint216(uint256 value) internal pure returns (uint216) {
if (value > type(uint216).max) {
revert SafeCastOverflowedUintDowncast(216, value);
}
return uint216(value);
}
/**
* @dev Returns the downcasted uint208 from uint256, reverting on
* overflow (when the input is greater than largest uint208).
*
* Counterpart to Solidity's `uint208` operator.
*
* Requirements:
*
* - input must fit into 208 bits
*/
function toUint208(uint256 value) internal pure returns (uint208) {
if (value > type(uint208).max) {
revert SafeCastOverflowedUintDowncast(208, value);
}
return uint208(value);
}
/**
* @dev Returns the downcasted uint200 from uint256, reverting on
* overflow (when the input is greater than largest uint200).
*
* Counterpart to Solidity's `uint200` operator.
*
* Requirements:
*
* - input must fit into 200 bits
*/
function toUint200(uint256 value) internal pure returns (uint200) {
if (value > type(uint200).max) {
revert SafeCastOverflowedUintDowncast(200, value);
}
return uint200(value);
}
/**
* @dev Returns the downcasted uint192 from uint256, reverting on
* overflow (when the input is greater than largest uint192).
*
* Counterpart to Solidity's `uint192` operator.
*
* Requirements:
*
* - input must fit into 192 bits
*/
function toUint192(uint256 value) internal pure returns (uint192) {
if (value > type(uint192).max) {
revert SafeCastOverflowedUintDowncast(192, value);
}
return uint192(value);
}
/**
* @dev Returns the downcasted uint184 from uint256, reverting on
* overflow (when the input is greater than largest uint184).
*
* Counterpart to Solidity's `uint184` operator.
*
* Requirements:
*
* - input must fit into 184 bits
*/
function toUint184(uint256 value) internal pure returns (uint184) {
if (value > type(uint184).max) {
revert SafeCastOverflowedUintDowncast(184, value);
}
return uint184(value);
}
/**
* @dev Returns the downcasted uint176 from uint256, reverting on
* overflow (when the input is greater than largest uint176).
*
* Counterpart to Solidity's `uint176` operator.
*
* Requirements:
*
* - input must fit into 176 bits
*/
function toUint176(uint256 value) internal pure returns (uint176) {
if (value > type(uint176).max) {
revert SafeCastOverflowedUintDowncast(176, value);
}
return uint176(value);
}
/**
* @dev Returns the downcasted uint168 from uint256, reverting on
* overflow (when the input is greater than largest uint168).
*
* Counterpart to Solidity's `uint168` operator.
*
* Requirements:
*
* - input must fit into 168 bits
*/
function toUint168(uint256 value) internal pure returns (uint168) {
if (value > type(uint168).max) {
revert SafeCastOverflowedUintDowncast(168, value);
}
return uint168(value);
}
/**
* @dev Returns the downcasted uint160 from uint256, reverting on
* overflow (when the input is greater than largest uint160).
*
* Counterpart to Solidity's `uint160` operator.
*
* Requirements:
*
* - input must fit into 160 bits
*/
function toUint160(uint256 value) internal pure returns (uint160) {
if (value > type(uint160).max) {
revert SafeCastOverflowedUintDowncast(160, value);
}
return uint160(value);
}
/**
* @dev Returns the downcasted uint152 from uint256, reverting on
* overflow (when the input is greater than largest uint152).
*
* Counterpart to Solidity's `uint152` operator.
*
* Requirements:
*
* - input must fit into 152 bits
*/
function toUint152(uint256 value) internal pure returns (uint152) {
if (value > type(uint152).max) {
revert SafeCastOverflowedUintDowncast(152, value);
}
return uint152(value);
}
/**
* @dev Returns the downcasted uint144 from uint256, reverting on
* overflow (when the input is greater than largest uint144).
*
* Counterpart to Solidity's `uint144` operator.
*
* Requirements:
*
* - input must fit into 144 bits
*/
function toUint144(uint256 value) internal pure returns (uint144) {
if (value > type(uint144).max) {
revert SafeCastOverflowedUintDowncast(144, value);
}
return uint144(value);
}
/**
* @dev Returns the downcasted uint136 from uint256, reverting on
* overflow (when the input is greater than largest uint136).
*
* Counterpart to Solidity's `uint136` operator.
*
* Requirements:
*
* - input must fit into 136 bits
*/
function toUint136(uint256 value) internal pure returns (uint136) {
if (value > type(uint136).max) {
revert SafeCastOverflowedUintDowncast(136, value);
}
return uint136(value);
}
/**
* @dev Returns the downcasted uint128 from uint256, reverting on
* overflow (when the input is greater than largest uint128).
*
* Counterpart to Solidity's `uint128` operator.
*
* Requirements:
*
* - input must fit into 128 bits
*/
function toUint128(uint256 value) internal pure returns (uint128) {
if (value > type(uint128).max) {
revert SafeCastOverflowedUintDowncast(128, value);
}
return uint128(value);
}
/**
* @dev Returns the downcasted uint120 from uint256, reverting on
* overflow (when the input is greater than largest uint120).
*
* Counterpart to Solidity's `uint120` operator.
*
* Requirements:
*
* - input must fit into 120 bits
*/
function toUint120(uint256 value) internal pure returns (uint120) {
if (value > type(uint120).max) {
revert SafeCastOverflowedUintDowncast(120, value);
}
return uint120(value);
}
/**
* @dev Returns the downcasted uint112 from uint256, reverting on
* overflow (when the input is greater than largest uint112).
*
* Counterpart to Solidity's `uint112` operator.
*
* Requirements:
*
* - input must fit into 112 bits
*/
function toUint112(uint256 value) internal pure returns (uint112) {
if (value > type(uint112).max) {
revert SafeCastOverflowedUintDowncast(112, value);
}
return uint112(value);
}
/**
* @dev Returns the downcasted uint104 from uint256, reverting on
* overflow (when the input is greater than largest uint104).
*
* Counterpart to Solidity's `uint104` operator.
*
* Requirements:
*
* - input must fit into 104 bits
*/
function toUint104(uint256 value) internal pure returns (uint104) {
if (value > type(uint104).max) {
revert SafeCastOverflowedUintDowncast(104, value);
}
return uint104(value);
}
/**
* @dev Returns the downcasted uint96 from uint256, reverting on
* overflow (when the input is greater than largest uint96).
*
* Counterpart to Solidity's `uint96` operator.
*
* Requirements:
*
* - input must fit into 96 bits
*/
function toUint96(uint256 value) internal pure returns (uint96) {
if (value > type(uint96).max) {
revert SafeCastOverflowedUintDowncast(96, value);
}
return uint96(value);
}
/**
* @dev Returns the downcasted uint88 from uint256, reverting on
* overflow (when the input is greater than largest uint88).
*
* Counterpart to Solidity's `uint88` operator.
*
* Requirements:
*
* - input must fit into 88 bits
*/
function toUint88(uint256 value) internal pure returns (uint88) {
if (value > type(uint88).max) {
revert SafeCastOverflowedUintDowncast(88, value);
}
return uint88(value);
}
/**
* @dev Returns the downcasted uint80 from uint256, reverting on
* overflow (when the input is greater than largest uint80).
*
* Counterpart to Solidity's `uint80` operator.
*
* Requirements:
*
* - input must fit into 80 bits
*/
function toUint80(uint256 value) internal pure returns (uint80) {
if (value > type(uint80).max) {
revert SafeCastOverflowedUintDowncast(80, value);
}
return uint80(value);
}
/**
* @dev Returns the downcasted uint72 from uint256, reverting on
* overflow (when the input is greater than largest uint72).
*
* Counterpart to Solidity's `uint72` operator.
*
* Requirements:
*
* - input must fit into 72 bits
*/
function toUint72(uint256 value) internal pure returns (uint72) {
if (value > type(uint72).max) {
revert SafeCastOverflowedUintDowncast(72, value);
}
return uint72(value);
}
/**
* @dev Returns the downcasted uint64 from uint256, reverting on
* overflow (when the input is greater than largest uint64).
*
* Counterpart to Solidity's `uint64` operator.
*
* Requirements:
*
* - input must fit into 64 bits
*/
function toUint64(uint256 value) internal pure returns (uint64) {
if (value > type(uint64).max) {
revert SafeCastOverflowedUintDowncast(64, value);
}
return uint64(value);
}
/**
* @dev Returns the downcasted uint56 from uint256, reverting on
* overflow (when the input is greater than largest uint56).
*
* Counterpart to Solidity's `uint56` operator.
*
* Requirements:
*
* - input must fit into 56 bits
*/
function toUint56(uint256 value) internal pure returns (uint56) {
if (value > type(uint56).max) {
revert SafeCastOverflowedUintDowncast(56, value);
}
return uint56(value);
}
/**
* @dev Returns the downcasted uint48 from uint256, reverting on
* overflow (when the input is greater than largest uint48).
*
* Counterpart to Solidity's `uint48` operator.
*
* Requirements:
*
* - input must fit into 48 bits
*/
function toUint48(uint256 value) internal pure returns (uint48) {
if (value > type(uint48).max) {
revert SafeCastOverflowedUintDowncast(48, value);
}
return uint48(value);
}
/**
* @dev Returns the downcasted uint40 from uint256, reverting on
* overflow (when the input is greater than largest uint40).
*
* Counterpart to Solidity's `uint40` operator.
*
* Requirements:
*
* - input must fit into 40 bits
*/
function toUint40(uint256 value) internal pure returns (uint40) {
if (value > type(uint40).max) {
revert SafeCastOverflowedUintDowncast(40, value);
}
return uint40(value);
}
/**
* @dev Returns the downcasted uint32 from uint256, reverting on
* overflow (when the input is greater than largest uint32).
*
* Counterpart to Solidity's `uint32` operator.
*
* Requirements:
*
* - input must fit into 32 bits
*/
function toUint32(uint256 value) internal pure returns (uint32) {
if (value > type(uint32).max) {
revert SafeCastOverflowedUintDowncast(32, value);
}
return uint32(value);
}
/**
* @dev Returns the downcasted uint24 from uint256, reverting on
* overflow (when the input is greater than largest uint24).
*
* Counterpart to Solidity's `uint24` operator.
*
* Requirements:
*
* - input must fit into 24 bits
*/
function toUint24(uint256 value) internal pure returns (uint24) {
if (value > type(uint24).max) {
revert SafeCastOverflowedUintDowncast(24, value);
}
return uint24(value);
}
/**
* @dev Returns the downcasted uint16 from uint256, reverting on
* overflow (when the input is greater than largest uint16).
*
* Counterpart to Solidity's `uint16` operator.
*
* Requirements:
*
* - input must fit into 16 bits
*/
function toUint16(uint256 value) internal pure returns (uint16) {
if (value > type(uint16).max) {
revert SafeCastOverflowedUintDowncast(16, value);
}
return uint16(value);
}
/**
* @dev Returns the downcasted uint8 from uint256, reverting on
* overflow (when the input is greater than largest uint8).
*
* Counterpart to Solidity's `uint8` operator.
*
* Requirements:
*
* - input must fit into 8 bits
*/
function toUint8(uint256 value) internal pure returns (uint8) {
if (value > type(uint8).max) {
revert SafeCastOverflowedUintDowncast(8, value);
}
return uint8(value);
}
/**
* @dev Converts a signed int256 into an unsigned uint256.
*
* Requirements:
*
* - input must be greater than or equal to 0.
*/
function toUint256(int256 value) internal pure returns (uint256) {
if (value < 0) {
revert SafeCastOverflowedIntToUint(value);
}
return uint256(value);
}
/**
* @dev Returns the downcasted int248 from int256, reverting on
* overflow (when the input is less than smallest int248 or
* greater than largest int248).
*
* Counterpart to Solidity's `int248` operator.
*
* Requirements:
*
* - input must fit into 248 bits
*/
function toInt248(int256 value) internal pure returns (int248 downcasted) {
downcasted = int248(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(248, value);
}
}
/**
* @dev Returns the downcasted int240 from int256, reverting on
* overflow (when the input is less than smallest int240 or
* greater than largest int240).
*
* Counterpart to Solidity's `int240` operator.
*
* Requirements:
*
* - input must fit into 240 bits
*/
function toInt240(int256 value) internal pure returns (int240 downcasted) {
downcasted = int240(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(240, value);
}
}
/**
* @dev Returns the downcasted int232 from int256, reverting on
* overflow (when the input is less than smallest int232 or
* greater than largest int232).
*
* Counterpart to Solidity's `int232` operator.
*
* Requirements:
*
* - input must fit into 232 bits
*/
function toInt232(int256 value) internal pure returns (int232 downcasted) {
downcasted = int232(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(232, value);
}
}
/**
* @dev Returns the downcasted int224 from int256, reverting on
* overflow (when the input is less than smallest int224 or
* greater than largest int224).
*
* Counterpart to Solidity's `int224` operator.
*
* Requirements:
*
* - input must fit into 224 bits
*/
function toInt224(int256 value) internal pure returns (int224 downcasted) {
downcasted = int224(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(224, value);
}
}
/**
* @dev Returns the downcasted int216 from int256, reverting on
* overflow (when the input is less than smallest int216 or
* greater than largest int216).
*
* Counterpart to Solidity's `int216` operator.
*
* Requirements:
*
* - input must fit into 216 bits
*/
function toInt216(int256 value) internal pure returns (int216 downcasted) {
downcasted = int216(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(216, value);
}
}
/**
* @dev Returns the downcasted int208 from int256, reverting on
* overflow (when the input is less than smallest int208 or
* greater than largest int208).
*
* Counterpart to Solidity's `int208` operator.
*
* Requirements:
*
* - input must fit into 208 bits
*/
function toInt208(int256 value) internal pure returns (int208 downcasted) {
downcasted = int208(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(208, value);
}
}
/**
* @dev Returns the downcasted int200 from int256, reverting on
* overflow (when the input is less than smallest int200 or
* greater than largest int200).
*
* Counterpart to Solidity's `int200` operator.
*
* Requirements:
*
* - input must fit into 200 bits
*/
function toInt200(int256 value) internal pure returns (int200 downcasted) {
downcasted = int200(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(200, value);
}
}
/**
* @dev Returns the downcasted int192 from int256, reverting on
* overflow (when the input is less than smallest int192 or
* greater than largest int192).
*
* Counterpart to Solidity's `int192` operator.
*
* Requirements:
*
* - input must fit into 192 bits
*/
function toInt192(int256 value) internal pure returns (int192 downcasted) {
downcasted = int192(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(192, value);
}
}
/**
* @dev Returns the downcasted int184 from int256, reverting on
* overflow (when the input is less than smallest int184 or
* greater than largest int184).
*
* Counterpart to Solidity's `int184` operator.
*
* Requirements:
*
* - input must fit into 184 bits
*/
function toInt184(int256 value) internal pure returns (int184 downcasted) {
downcasted = int184(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(184, value);
}
}
/**
* @dev Returns the downcasted int176 from int256, reverting on
* overflow (when the input is less than smallest int176 or
* greater than largest int176).
*
* Counterpart to Solidity's `int176` operator.
*
* Requirements:
*
* - input must fit into 176 bits
*/
function toInt176(int256 value) internal pure returns (int176 downcasted) {
downcasted = int176(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(176, value);
}
}
/**
* @dev Returns the downcasted int168 from int256, reverting on
* overflow (when the input is less than smallest int168 or
* greater than largest int168).
*
* Counterpart to Solidity's `int168` operator.
*
* Requirements:
*
* - input must fit into 168 bits
*/
function toInt168(int256 value) internal pure returns (int168 downcasted) {
downcasted = int168(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(168, value);
}
}
/**
* @dev Returns the downcasted int160 from int256, reverting on
* overflow (when the input is less than smallest int160 or
* greater than largest int160).
*
* Counterpart to Solidity's `int160` operator.
*
* Requirements:
*
* - input must fit into 160 bits
*/
function toInt160(int256 value) internal pure returns (int160 downcasted) {
downcasted = int160(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(160, value);
}
}
/**
* @dev Returns the downcasted int152 from int256, reverting on
* overflow (when the input is less than smallest int152 or
* greater than largest int152).
*
* Counterpart to Solidity's `int152` operator.
*
* Requirements:
*
* - input must fit into 152 bits
*/
function toInt152(int256 value) internal pure returns (int152 downcasted) {
downcasted = int152(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(152, value);
}
}
/**
* @dev Returns the downcasted int144 from int256, reverting on
* overflow (when the input is less than smallest int144 or
* greater than largest int144).
*
* Counterpart to Solidity's `int144` operator.
*
* Requirements:
*
* - input must fit into 144 bits
*/
function toInt144(int256 value) internal pure returns (int144 downcasted) {
downcasted = int144(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(144, value);
}
}
/**
* @dev Returns the downcasted int136 from int256, reverting on
* overflow (when the input is less than smallest int136 or
* greater than largest int136).
*
* Counterpart to Solidity's `int136` operator.
*
* Requirements:
*
* - input must fit into 136 bits
*/
function toInt136(int256 value) internal pure returns (int136 downcasted) {
downcasted = int136(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(136, value);
}
}
/**
* @dev Returns the downcasted int128 from int256, reverting on
* overflow (when the input is less than smallest int128 or
* greater than largest int128).
*
* Counterpart to Solidity's `int128` operator.
*
* Requirements:
*
* - input must fit into 128 bits
*/
function toInt128(int256 value) internal pure returns (int128 downcasted) {
downcasted = int128(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(128, value);
}
}
/**
* @dev Returns the downcasted int120 from int256, reverting on
* overflow (when the input is less than smallest int120 or
* greater than largest int120).
*
* Counterpart to Solidity's `int120` operator.
*
* Requirements:
*
* - input must fit into 120 bits
*/
function toInt120(int256 value) internal pure returns (int120 downcasted) {
downcasted = int120(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(120, value);
}
}
/**
* @dev Returns the downcasted int112 from int256, reverting on
* overflow (when the input is less than smallest int112 or
* greater than largest int112).
*
* Counterpart to Solidity's `int112` operator.
*
* Requirements:
*
* - input must fit into 112 bits
*/
function toInt112(int256 value) internal pure returns (int112 downcasted) {
downcasted = int112(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(112, value);
}
}
/**
* @dev Returns the downcasted int104 from int256, reverting on
* overflow (when the input is less than smallest int104 or
* greater than largest int104).
*
* Counterpart to Solidity's `int104` operator.
*
* Requirements:
*
* - input must fit into 104 bits
*/
function toInt104(int256 value) internal pure returns (int104 downcasted) {
downcasted = int104(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(104, value);
}
}
/**
* @dev Returns the downcasted int96 from int256, reverting on
* overflow (when the input is less than smallest int96 or
* greater than largest int96).
*
* Counterpart to Solidity's `int96` operator.
*
* Requirements:
*
* - input must fit into 96 bits
*/
function toInt96(int256 value) internal pure returns (int96 downcasted) {
downcasted = int96(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(96, value);
}
}
/**
* @dev Returns the downcasted int88 from int256, reverting on
* overflow (when the input is less than smallest int88 or
* greater than largest int88).
*
* Counterpart to Solidity's `int88` operator.
*
* Requirements:
*
* - input must fit into 88 bits
*/
function toInt88(int256 value) internal pure returns (int88 downcasted) {
downcasted = int88(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(88, value);
}
}
/**
* @dev Returns the downcasted int80 from int256, reverting on
* overflow (when the input is less than smallest int80 or
* greater than largest int80).
*
* Counterpart to Solidity's `int80` operator.
*
* Requirements:
*
* - input must fit into 80 bits
*/
function toInt80(int256 value) internal pure returns (int80 downcasted) {
downcasted = int80(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(80, value);
}
}
/**
* @dev Returns the downcasted int72 from int256, reverting on
* overflow (when the input is less than smallest int72 or
* greater than largest int72).
*
* Counterpart to Solidity's `int72` operator.
*
* Requirements:
*
* - input must fit into 72 bits
*/
function toInt72(int256 value) internal pure returns (int72 downcasted) {
downcasted = int72(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(72, value);
}
}
/**
* @dev Returns the downcasted int64 from int256, reverting on
* overflow (when the input is less than smallest int64 or
* greater than largest int64).
*
* Counterpart to Solidity's `int64` operator.
*
* Requirements:
*
* - input must fit into 64 bits
*/
function toInt64(int256 value) internal pure returns (int64 downcasted) {
downcasted = int64(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(64, value);
}
}
/**
* @dev Returns the downcasted int56 from int256, reverting on
* overflow (when the input is less than smallest int56 or
* greater than largest int56).
*
* Counterpart to Solidity's `int56` operator.
*
* Requirements:
*
* - input must fit into 56 bits
*/
function toInt56(int256 value) internal pure returns (int56 downcasted) {
downcasted = int56(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(56, value);
}
}
/**
* @dev Returns the downcasted int48 from int256, reverting on
* overflow (when the input is less than smallest int48 or
* greater than largest int48).
*
* Counterpart to Solidity's `int48` operator.
*
* Requirements:
*
* - input must fit into 48 bits
*/
function toInt48(int256 value) internal pure returns (int48 downcasted) {
downcasted = int48(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(48, value);
}
}
/**
* @dev Returns the downcasted int40 from int256, reverting on
* overflow (when the input is less than smallest int40 or
* greater than largest int40).
*
* Counterpart to Solidity's `int40` operator.
*
* Requirements:
*
* - input must fit into 40 bits
*/
function toInt40(int256 value) internal pure returns (int40 downcasted) {
downcasted = int40(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(40, value);
}
}
/**
* @dev Returns the downcasted int32 from int256, reverting on
* overflow (when the input is less than smallest int32 or
* greater than largest int32).
*
* Counterpart to Solidity's `int32` operator.
*
* Requirements:
*
* - input must fit into 32 bits
*/
function toInt32(int256 value) internal pure returns (int32 downcasted) {
downcasted = int32(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(32, value);
}
}
/**
* @dev Returns the downcasted int24 from int256, reverting on
* overflow (when the input is less than smallest int24 or
* greater than largest int24).
*
* Counterpart to Solidity's `int24` operator.
*
* Requirements:
*
* - input must fit into 24 bits
*/
function toInt24(int256 value) internal pure returns (int24 downcasted) {
downcasted = int24(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(24, value);
}
}
/**
* @dev Returns the downcasted int16 from int256, reverting on
* overflow (when the input is less than smallest int16 or
* greater than largest int16).
*
* Counterpart to Solidity's `int16` operator.
*
* Requirements:
*
* - input must fit into 16 bits
*/
function toInt16(int256 value) internal pure returns (int16 downcasted) {
downcasted = int16(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(16, value);
}
}
/**
* @dev Returns the downcasted int8 from int256, reverting on
* overflow (when the input is less than smallest int8 or
* greater than largest int8).
*
* Counterpart to Solidity's `int8` operator.
*
* Requirements:
*
* - input must fit into 8 bits
*/
function toInt8(int256 value) internal pure returns (int8 downcasted) {
downcasted = int8(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(8, value);
}
}
/**
* @dev Converts an unsigned uint256 into a signed int256.
*
* Requirements:
*
* - input must be less than or equal to maxInt256.
*/
function toInt256(uint256 value) internal pure returns (int256) {
// Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive
if (value > uint256(type(int256).max)) {
revert SafeCastOverflowedUintToInt(value);
}
return int256(value);
}
/**
* @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.
*/
function toUint(bool b) internal pure returns (uint256 u) {
assembly ("memory-safe") {
u := iszero(iszero(b))
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/structs/EnumerableSet.sol)
// This file was procedurally generated from scripts/generate/templates/EnumerableSet.js.
pragma solidity ^0.8.20;
/**
* @dev Library for managing
* https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
* types.
*
* Sets have the following properties:
*
* - Elements are added, removed, and checked for existence in constant time
* (O(1)).
* - Elements are enumerated in O(n). No guarantees are made on the ordering.
*
* ```solidity
* contract Example {
* // Add the library methods
* using EnumerableSet for EnumerableSet.AddressSet;
*
* // Declare a set state variable
* EnumerableSet.AddressSet private mySet;
* }
* ```
*
* As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
* and `uint256` (`UintSet`) are supported.
*
* [WARNING]
* ====
* Trying to delete such a structure from storage will likely result in data corruption, rendering the structure
* unusable.
* See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
*
* In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an
* array of EnumerableSet.
* ====
*/
library EnumerableSet {
// To implement this library for multiple types with as little code
// repetition as possible, we write it in terms of a generic Set type with
// bytes32 values.
// The Set implementation uses private functions, and user-facing
// implementations (such as AddressSet) are just wrappers around the
// underlying Set.
// This means that we can only create new EnumerableSets for types that fit
// in bytes32.
struct Set {
// Storage of set values
bytes32[] _values;
// Position is the index of the value in the `values` array plus 1.
// Position 0 is used to mean a value is not in the set.
mapping(bytes32 value => uint256) _positions;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
// The value is stored at length-1, but we add 1 to all indexes
// and use 0 as a sentinel value
set._positions[value] = set._values.length;
return true;
} else {
return false;
}
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function _remove(Set storage set, bytes32 value) private returns (bool) {
// We cache the value's position to prevent multiple reads from the same storage slot
uint256 position = set._positions[value];
if (position != 0) {
// Equivalent to contains(set, value)
// To delete an element from the _values array in O(1), we swap the element to delete with the last one in
// the array, and then remove the last element (sometimes called as 'swap and pop').
// This modifies the order of the array, as noted in {at}.
uint256 valueIndex = position - 1;
uint256 lastIndex = set._values.length - 1;
if (valueIndex != lastIndex) {
bytes32 lastValue = set._values[lastIndex];
// Move the lastValue to the index where the value to delete is
set._values[valueIndex] = lastValue;
// Update the tracked position of the lastValue (that was just moved)
set._positions[lastValue] = position;
}
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the tracked position for the deleted slot
delete set._positions[value];
return true;
} else {
return false;
}
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._positions[value] != 0;
}
/**
* @dev Returns the number of values on the set. O(1).
*/
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function _at(Set storage set, uint256 index) private view returns (bytes32) {
return set._values[index];
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function _values(Set storage set) private view returns (bytes32[] memory) {
return set._values;
}
// Bytes32Set
struct Bytes32Set {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
bytes32[] memory store = _values(set._inner);
bytes32[] memory result;
assembly ("memory-safe") {
result := store
}
return result;
}
// AddressSet
struct AddressSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(uint160(value))));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(uint160(value))));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(uint160(value))));
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint160(uint256(_at(set._inner, index))));
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function values(AddressSet storage set) internal view returns (address[] memory) {
bytes32[] memory store = _values(set._inner);
address[] memory result;
assembly ("memory-safe") {
result := store
}
return result;
}
// UintSet
struct UintSet {
Set _inner;
}
/**
* @dev Add a value to a set. O(1).
*
* Returns true if the value was added to the set, that is if it was not
* already present.
*/
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
/**
* @dev Removes a value from a set. O(1).
*
* Returns true if the value was removed from the set, that is if it was
* present.
*/
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
/**
* @dev Returns true if the value is in the set. O(1).
*/
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
/**
* @dev Returns the number of values in the set. O(1).
*/
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
/**
* @dev Returns the value stored at position `index` in the set. O(1).
*
* Note that there are no guarantees on the ordering of values inside the
* array, and it may change when more values are added or removed.
*
* Requirements:
*
* - `index` must be strictly less than {length}.
*/
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
/**
* @dev Return the entire set in an array
*
* WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
* to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
* this function has an unbounded cost, and using it as part of a state-changing function may render the function
* uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
*/
function values(UintSet storage set) internal view returns (uint256[] memory) {
bytes32[] memory store = _values(set._inner);
uint256[] memory result;
assembly ("memory-safe") {
result := store
}
return result;
}
}{
"evmVersion": "cancun",
"libraries": {},
"optimizer": {
"enabled": true,
"runs": 200
},
"outputSelection": {
"*": {
"*": [
"evm.bytecode",
"evm.deployedBytecode",
"devdoc",
"userdoc",
"metadata",
"abi"
]
}
}
}Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
Contract ABI
API[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AccessControlBadConfirmation","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bytes32","name":"neededRole","type":"bytes32"}],"name":"AccessControlUnauthorizedAccount","type":"error"},{"inputs":[{"internalType":"address","name":"nftAddress","type":"address"}],"name":"CollectionBidOnErc1155","type":"error"},{"inputs":[{"internalType":"address","name":"nftAddress","type":"address"}],"name":"CollectionNotApprovedForTrading","type":"error"},{"inputs":[],"name":"EnforcedPause","type":"error"},{"inputs":[],"name":"ExpectedPause","type":"error"},{"inputs":[],"name":"InvalidInitialization","type":"error"},{"inputs":[],"name":"NotInitializing","type":"error"},{"inputs":[],"name":"ReentrancyGuardReentrantCall","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"nftAddress","type":"address"},{"indexed":false,"internalType":"enum Marketplace202502231813.CollectionApprovalStatus","name":"status","type":"uint8"},{"indexed":false,"internalType":"address","name":"paymentToken","type":"address"}],"name":"ApprovalStatusUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"seller","type":"address"},{"indexed":false,"internalType":"address","name":"bidder","type":"address"},{"indexed":false,"internalType":"address","name":"nftAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"uint64","name":"quantity","type":"uint64"},{"indexed":false,"internalType":"uint128","name":"pricePerItem","type":"uint128"},{"indexed":false,"internalType":"address","name":"paymentToken","type":"address"},{"indexed":false,"internalType":"enum BidType","name":"bidType","type":"uint8"}],"name":"BidAccepted","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"bidder","type":"address"},{"indexed":false,"internalType":"address","name":"nftAddress","type":"address"}],"name":"CollectionBidCancelled","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"bidder","type":"address"},{"indexed":false,"internalType":"address","name":"nftAddress","type":"address"},{"indexed":false,"internalType":"uint64","name":"quantity","type":"uint64"},{"indexed":false,"internalType":"uint128","name":"pricePerItem","type":"uint128"},{"indexed":false,"internalType":"uint64","name":"expirationTime","type":"uint64"},{"indexed":false,"internalType":"address","name":"paymentToken","type":"address"}],"name":"CollectionBidCreatedOrUpdated","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":"seller","type":"address"},{"indexed":true,"internalType":"address","name":"nftAddress","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ItemCanceled","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"seller","type":"address"},{"indexed":false,"internalType":"address","name":"nftAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"uint64","name":"quantity","type":"uint64"},{"indexed":false,"internalType":"uint128","name":"pricePerItem","type":"uint128"},{"indexed":false,"internalType":"uint64","name":"expirationTime","type":"uint64"},{"indexed":false,"internalType":"address","name":"paymentToken","type":"address"}],"name":"ItemListed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"seller","type":"address"},{"indexed":false,"internalType":"address","name":"buyer","type":"address"},{"indexed":false,"internalType":"address","name":"nftAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"uint64","name":"quantity","type":"uint64"},{"indexed":false,"internalType":"uint128","name":"pricePerItem","type":"uint128"},{"indexed":false,"internalType":"address","name":"paymentToken","type":"address"}],"name":"ItemSold","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"seller","type":"address"},{"indexed":false,"internalType":"address","name":"nftAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"uint64","name":"quantity","type":"uint64"},{"indexed":false,"internalType":"uint128","name":"pricePerItem","type":"uint128"},{"indexed":false,"internalType":"uint64","name":"expirationTime","type":"uint64"},{"indexed":false,"internalType":"address","name":"paymentToken","type":"address"}],"name":"ItemUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"bidder","type":"address"},{"indexed":false,"internalType":"address","name":"nftAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"TokenBidCancelled","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"bidder","type":"address"},{"indexed":false,"internalType":"address","name":"nftAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"uint64","name":"quantity","type":"uint64"},{"indexed":false,"internalType":"uint128","name":"pricePerItem","type":"uint128"},{"indexed":false,"internalType":"uint64","name":"expirationTime","type":"uint64"},{"indexed":false,"internalType":"address","name":"paymentToken","type":"address"}],"name":"TokenBidCreatedOrUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"collection","type":"address"},{"indexed":false,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"uint256","name":"fee","type":"uint256"}],"name":"UpdateCollectionCreatorFee","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"feeRecipient","type":"address"}],"name":"UpdateFeeRecipient","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"fee","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"feeForCollectionWithCreatorFee","type":"uint256"}],"name":"UpdateFees","type":"event"},{"inputs":[],"name":"BASIS_POINTS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MARKETPLACE_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_COLLECTION_FEE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_FEE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"enum BidType","name":"bidType","type":"uint8"},{"internalType":"address","name":"nftAddress","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"address","name":"bidder","type":"address"},{"internalType":"uint64","name":"quantity","type":"uint64"},{"internalType":"uint128","name":"pricePerItem","type":"uint128"},{"internalType":"address","name":"paymentToken","type":"address"}],"internalType":"struct AcceptBidParams[]","name":"_acceptBidParamsBatch","type":"tuple[]"}],"name":"acceptBids","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"areBidsActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"nftAddress","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint64","name":"quantity","type":"uint64"},{"internalType":"uint128","name":"maxPricePerItem","type":"uint128"},{"internalType":"address","name":"paymentToken","type":"address"},{"internalType":"bool","name":"usingNative","type":"bool"}],"internalType":"struct BuyItemParams[]","name":"_buyItemParamsBatch","type":"tuple[]"}],"name":"buyItems","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"components":[{"internalType":"enum BidType","name":"bidType","type":"uint8"},{"internalType":"address","name":"nftAddress","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"internalType":"struct CancelBidParams[]","name":"_cancelBidParamsBatch","type":"tuple[]"}],"name":"cancelBids","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"nftAddress","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"internalType":"struct CancelListingParams[]","name":"_cancelListingParamsBatch","type":"tuple[]"}],"name":"cancelListings","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"collectionApprovals","outputs":[{"internalType":"enum Marketplace202502231813.CollectionApprovalStatus","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"collectionBids","outputs":[{"internalType":"uint64","name":"quantity","type":"uint64"},{"internalType":"uint128","name":"pricePerItem","type":"uint128"},{"internalType":"uint64","name":"expirationTime","type":"uint64"},{"internalType":"address","name":"paymentTokenAddress","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"collectionCreatorFees","outputs":[{"internalType":"uint32","name":"fee","type":"uint32"},{"internalType":"address","name":"recipient","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"collectionToMinPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"collectionToPaymentToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_nftAddress","type":"address"},{"internalType":"uint64","name":"_quantity","type":"uint64"},{"internalType":"uint128","name":"_pricePerItem","type":"uint128"},{"internalType":"uint64","name":"_expirationTime","type":"uint64"},{"internalType":"address","name":"_paymentToken","type":"address"}],"name":"createOrUpdateCollectionBid","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"nftAddress","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint64","name":"quantity","type":"uint64"},{"internalType":"uint128","name":"pricePerItem","type":"uint128"},{"internalType":"uint64","name":"expirationTime","type":"uint64"},{"internalType":"address","name":"paymentToken","type":"address"}],"internalType":"struct CreateOrUpdateListingParams[]","name":"_createOrUpdateListingParamsBatch","type":"tuple[]"}],"name":"createOrUpdateListings","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"nftAddress","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint64","name":"quantity","type":"uint64"},{"internalType":"uint128","name":"pricePerItem","type":"uint128"},{"internalType":"uint64","name":"expirationTime","type":"uint64"},{"internalType":"address","name":"paymentToken","type":"address"}],"internalType":"struct CreateOrUpdateTokenBidParams[]","name":"_createOrUpdateTokenBidParamsBatch","type":"tuple[]"}],"name":"createOrUpdateTokenBids","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"disableBids","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"enableBids","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"fee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"feeForCollectionWithCreatorFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"feeReceipient","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_collection","type":"address"},{"internalType":"address","name":"_bidder","type":"address"}],"name":"getCollectionBid","outputs":[{"components":[{"internalType":"uint64","name":"quantity","type":"uint64"},{"internalType":"uint128","name":"pricePerItem","type":"uint128"},{"internalType":"uint64","name":"expirationTime","type":"uint64"},{"internalType":"address","name":"paymentTokenAddress","type":"address"}],"internalType":"struct Marketplace202502231813.ListingOrBid","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_collection","type":"address"},{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"address","name":"_seller","type":"address"}],"name":"getListing","outputs":[{"components":[{"internalType":"uint64","name":"quantity","type":"uint64"},{"internalType":"uint128","name":"pricePerItem","type":"uint128"},{"internalType":"uint64","name":"expirationTime","type":"uint64"},{"internalType":"address","name":"paymentTokenAddress","type":"address"}],"internalType":"struct Marketplace202502231813.ListingOrBid","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_collection","type":"address"}],"name":"getMinPriceForCollection","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_collection","type":"address"}],"name":"getPaymentTokenForCollection","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"getRoleMember","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleMemberCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleMembers","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_collection","type":"address"},{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"address","name":"_bidder","type":"address"}],"name":"getTokenBid","outputs":[{"components":[{"internalType":"uint64","name":"quantity","type":"uint64"},{"internalType":"uint128","name":"pricePerItem","type":"uint128"},{"internalType":"uint64","name":"expirationTime","type":"uint64"},{"internalType":"address","name":"paymentTokenAddress","type":"address"}],"internalType":"struct Marketplace202502231813.ListingOrBid","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_initialFee","type":"uint256"},{"internalType":"address","name":"_initialFeeRecipient","type":"address"},{"internalType":"contract IERC20","name":"_initialPaymentToken","type":"address"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"}],"name":"listings","outputs":[{"internalType":"uint64","name":"quantity","type":"uint64"},{"internalType":"uint128","name":"pricePerItem","type":"uint128"},{"internalType":"uint64","name":"expirationTime","type":"uint64"},{"internalType":"address","name":"paymentTokenAddress","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"paymentToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"callerConfirmation","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_nft","type":"address"},{"internalType":"enum Marketplace202502231813.CollectionApprovalStatus","name":"_status","type":"uint8"},{"internalType":"address","name":"_paymentToken","type":"address"},{"internalType":"uint256","name":"_minPrice","type":"uint256"}],"name":"setCollectionApprovalStatus","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_collectionAddress","type":"address"},{"components":[{"internalType":"uint32","name":"fee","type":"uint32"},{"internalType":"address","name":"recipient","type":"address"}],"internalType":"struct Marketplace202502231813.CollectionCreatorFee","name":"_collectionCreatorFee","type":"tuple"}],"name":"setCollectionCreatorFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newFeeRecipient","type":"address"}],"name":"setFeeRecipient","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newFee","type":"uint256"},{"internalType":"uint256","name":"_newFeeForCollectionWithCreatorFee","type":"uint256"}],"name":"setFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_wnativeAddress","type":"address"}],"name":"setWnative","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":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"}],"name":"tokenBids","outputs":[{"internalType":"uint64","name":"quantity","type":"uint64"},{"internalType":"uint128","name":"pricePerItem","type":"uint128"},{"internalType":"uint64","name":"expirationTime","type":"uint64"},{"internalType":"address","name":"paymentTokenAddress","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"nftAddress","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"quantity","type":"uint256"},{"internalType":"address","name":"recipient","type":"address"}],"internalType":"struct TransferTokenParams[]","name":"_transferTokenParamsBatch","type":"tuple[]"}],"name":"transferTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"wnative","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"}]Contract Creation Code
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
Deployed Bytecode
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
Loading...
Loading
Loading...
Loading
Loading...
Loading
0xC49081da8DE94537578c80992C9fdb27b225849a
Net Worth in USD
$0.00
Net Worth in HYPE
0
Multichain Portfolio | 35 Chains
| Chain | Token | Portfolio % | Price | Amount | Value |
|---|
Loading...
Loading
Loading...
Loading
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
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.