Token
Overview ERC1155
Total Supply:
11,652 N/A
Holders:
1,165 addresses
Transfers:
-
Contract:
[ Download CSV Export ]
| # | Exchange | Pair | Price | 24H Volume | % Volume |
|---|
Minimal Proxy Contract for 0x55af6bc69d624229e265d57e4195f5b7ff67ded6
Contract Name:
JoeJourneyStamp
Compiler Version
v0.8.6+commit.11564f7e
Optimization Enabled:
Yes with 200 runs
Other Settings:
default evmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
/** Imports **/
import "./interfaces/IJoeJourneyStamp.sol";
import "./BaseLaunchpeg1155.sol";
/// @title JoeJourneyStamp
/// @author Trader Joe
/// @notice Implements a simple minting NFT contract with an allowlist and public sale phase.
contract JoeJourneyStamp is BaseLaunchpeg1155, IJoeJourneyStamp {
/** Public variables **/
/// @notice Price of one NFT for people on the mint list
/// @dev allowlistPrice is scaled to 1e18
uint256 public override allowlistPrice;
/// @notice Price of one NFT during the public sale
/// @dev salePrice is scaled to 1e18
uint256 public override salePrice;
/// @notice Total amount of Stamps
/// Stamps IDs start from 1
uint256 public constant override stampsAmount = 12;
/// @notice LaunchpegLens address
address public override lens;
/// @notice If NFTs are transferable (true) or not (false)
bool public override transferable;
/** Private variables **/
/// @notice The list of Stamps each allowed address can mint during allowlist mint
/// @dev Lists of Stamps are stored in bytes32 variable.
/// Egligibilty for every Stamp individually are checked by `_checkIfStampAllowlisted` function
mapping(address => bytes32) private stampAllowlist;
/// @notice The amount of NFTs each address minted
mapping(address => uint256) private amountMintedByAddress;
/** Events **/
/// @dev Emitted on initializePhases()
/// @param preMintStartTime Pre-mint start time in seconds
/// @param allowlistStartTime Allowlist mint start time in seconds
/// @param publicSaleStartTime Public sale start time in seconds
/// @param publicSaleEndTime Public sale end time in seconds
/// @param allowlistPrice Price of the allowlist sale in Avax
/// @param salePrice Price of the public sale in Avax
event Initialized(
uint256 preMintStartTime,
uint256 allowlistStartTime,
uint256 publicSaleStartTime,
uint256 publicSaleEndTime,
uint256 allowlistPrice,
uint256 salePrice
);
/// @dev Emitted on removeAllowlistSpots()
event AllowlistModified();
/// @dev Emitted on setTransferable()
/// @param transferable If NFTs are now transferable (true) or not (false)
event TransferableChanged(bool transferable);
/** External Functions **/
/// @notice Used to return 0 values for non-existing functions called by existing LaunchpegLens
fallback(bytes calldata) external returns (bytes memory) {
if (msg.sender != lens) revert Launchpeg__NotImplemented();
return abi.encode(0);
}
/// @notice FlatLaunchpeg initialization
/// Can only be called once
/// @param _collectionData Launchpeg collection data
/// @param _ownerData Launchpeg owner data
function initialize(
CollectionData calldata _collectionData,
CollectionOwnerData calldata _ownerData
) external override initializer {
initializeBaseLaunchpeg(_collectionData, _ownerData);
}
/// @notice Initialize the two phases of the sale
/// @dev Can only be called once
/// @param _allowlistStartTime Allowlist mint start time in seconds
/// @param _publicSaleEndTime Public sale end time in seconds
/// @param _allowlistPrice Price of the allowlist sale in Avax
function initializePhases(
uint256,
uint256 _allowlistStartTime,
uint256,
uint256 _publicSaleEndTime,
uint256 _allowlistPrice,
uint256
) external override onlyOwner atPhase(Phase.NotStarted) {
if (_allowlistStartTime < block.timestamp) {
revert Launchpeg__AllowlistBeforePreMint();
}
if (_publicSaleEndTime < _allowlistStartTime) {
revert Launchpeg__PublicSaleEndBeforePublicSaleStart();
}
allowlistPrice = _allowlistPrice;
preMintStartTime = _allowlistStartTime; // there is no premint planned
allowlistStartTime = _allowlistStartTime;
publicSaleStartTime = _publicSaleEndTime; // there is no public sale planned
publicSaleEndTime = _publicSaleEndTime;
emit Initialized(
preMintStartTime,
allowlistStartTime,
publicSaleStartTime,
publicSaleEndTime,
allowlistPrice,
salePrice
);
}
/// @notice Mint NFTs during the allowlist mint
/// @param _quantity Quantity of NFTs to mint
function allowlistMint(uint256 _quantity)
external
payable
override
whenNotPaused
atPhase(Phase.Allowlist)
{
if (_quantity > _allowlist(msg.sender)) {
revert Launchpeg__NotEligibleForAllowlistMint();
}
if (_numberMinted(msg.sender) + _quantity > maxPerAddressDuringMint) {
revert Launchpeg__CanNotMintThisMany();
}
bytes32 allowlistedStamps = stampAllowlist[msg.sender];
uint256[] memory stampsList = new uint256[](_quantity);
uint256[] memory amountsList = new uint256[](_quantity);
uint256 j;
for (uint256 i = 1; i <= stampsAmount; i++) {
if (_checkIfStampAllowlisted(i, allowlistedStamps)) {
amountsList[j] = 1;
stampsList[j++] = i;
allowlistedStamps = _removeStamp(i, allowlistedStamps);
if (j == _quantity) {
break;
}
}
}
stampAllowlist[msg.sender] = allowlistedStamps;
uint256 price = _getAllowlistPrice();
uint256 totalCost = price * _quantity;
_mintBatch(msg.sender, stampsList, amountsList, "");
amountMintedDuringAllowlist += _quantity;
amountMintedByAddress[msg.sender] += _quantity;
emit Mint(msg.sender, _quantity, price, Phase.Allowlist);
_refundIfOver(totalCost);
}
/// @notice Set stampIds mintable per address during the allowlist phase
/// @param _addresses List of addresses allowed to mint during the allowlist phase
/// @param _stampIds List of Stamp IDs lists to mint per address
function seedAllowlist(
address[] calldata _addresses,
uint256[][] calldata _stampIds
) external override onlyOwner {
uint256 stampsAmountToSeed;
bytes32 currentStamps;
uint256 addressesLength = _addresses.length;
if (addressesLength != _stampIds.length) {
revert Launchpeg__WrongAddressesAndNumSlotsLength();
}
for (uint256 i; i < addressesLength; i++) {
currentStamps = stampAllowlist[_addresses[i]];
stampsAmountToSeed = _stampIds[i].length;
for (uint256 j; j < stampsAmountToSeed; j++) {
if (_stampIds[i][j] == 0 || _stampIds[i][j] > stampsAmount)
revert Launchpeg__WrongStampNumber();
currentStamps = _addStamp(_stampIds[i][j], currentStamps);
}
stampAllowlist[_addresses[i]] = currentStamps;
}
emit AllowlistSeeded();
}
/// @notice Remove stampIds mintable per address during the allowlist phase
/// @param _addresses List of addresses to remove spots during the allowlist phase
/// @param _stampIds List of Stamp IDs lists to remove per address
function removeAllowlistSpots(
address[] calldata _addresses,
uint256[][] calldata _stampIds
) external override onlyOwner {
bytes32 allowlistedStamps;
uint256 addressesLength = _addresses.length;
if (addressesLength != _stampIds.length) {
revert Launchpeg__WrongAddressesAndNumSlotsLength();
}
for (uint256 i; i < addressesLength; i++) {
uint256 amount = _stampIds[i].length;
allowlistedStamps = stampAllowlist[_addresses[i]];
for (uint256 j; j < amount; j++) {
allowlistedStamps = _removeStamp(
_stampIds[i][j],
allowlistedStamps
);
}
stampAllowlist[_addresses[i]] = allowlistedStamps;
}
emit AllowlistModified();
}
/// @notice Set LaunchpegLens address
/// @param _lens LaunchpegLens address
function setLensAddress(address _lens) external override onlyOwner {
lens = _lens;
}
/// @notice Set if the NFTs are transferable
/// @param _transferable If the NFTs are transferable (true) or not (false)
function setTransferable(bool _transferable) external override onlyOwner {
transferable = _transferable;
emit TransferableChanged(_transferable);
}
/** External View Functions **/
/// @notice Returns the current phase
/// @return phase Current phase
function currentPhase()
public
view
override(IBaseLaunchpeg1155, BaseLaunchpeg1155)
returns (Phase)
{
if (
allowlistStartTime == 0 ||
publicSaleEndTime == 0 ||
block.timestamp < allowlistStartTime
) {
return Phase.NotStarted;
} else if (
block.timestamp >= allowlistStartTime &&
block.timestamp < publicSaleStartTime
) {
return Phase.Allowlist;
}
return Phase.Ended;
}
/// @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[EIP section]
/// to learn more about how these IDs are created.
/// This function call must use less than 30 000 gas.
/// @param _interfaceId InterfaceId to consider. Comes from type(Interface).interfaceId
/// @return isInterfaceSupported True if the considered interface is supported
function supportsInterface(bytes4 _interfaceId)
public
view
virtual
override(BaseLaunchpeg1155, IERC165Upgradeable)
returns (bool)
{
return
_interfaceId == type(IJoeJourneyStamp).interfaceId ||
super.supportsInterface(_interfaceId);
}
/// @dev Returns allowlist price. Used by mint methods.
function _getAllowlistPrice() internal view override returns (uint256) {
return allowlistPrice;
}
/// @notice Sum of amount of all stamps owned by user.
/// @param _user User address
function balanceOf(address _user) external view override returns (uint256) {
uint256 totalBalanceAllIds;
for (uint256 i = 1; i <= stampsAmount; i++) {
totalBalanceAllIds += balanceOf(_user, i);
}
return totalBalanceAllIds;
}
/// @notice Returns total amount of minted Stamps
/// @return Total amount of minted Stamps
function totalSupply() external view override returns (uint256) {
uint256 totalSupplyAllIds;
for (uint256 i = 1; i <= stampsAmount; i++) {
totalSupplyAllIds += totalSupply(i);
}
return totalSupplyAllIds;
}
/// @notice Returns the number of NFTs minted by a specific address
/// @param _owner The owner of the NFTs
/// @return numberMinted Number of NFTs minted
function numberMinted(address _owner)
public
view
override
returns (uint256)
{
return _numberMinted(_owner);
}
/// @notice Number of NFTs to mint for user
/// @param user User address
function allowlist(address user) public view override returns (uint256) {
return _allowlist(user);
}
/// @notice Number minted by user
function numberMintedWithPreMint(address _owner)
public
view
override
returns (uint256)
{
return _numberMinted(_owner);
}
/** Internal Functions **/
/// @notice Number of NFTs to mint for user
/// @param user User address
function _allowlist(address user) internal view returns (uint256) {
uint256 allowslistedAmount;
bytes32 userStamps = stampAllowlist[user];
for (uint256 i = 1; i <= stampsAmount; i++) {
if (_checkIfStampAllowlisted(i, userStamps)) {
allowslistedAmount += 1;
}
}
return allowslistedAmount;
}
///@notice Adds Stamp to bytes32 variable to update allowlist
function _addStamp(uint256 stamp, bytes32 currentStamps)
internal
pure
returns (bytes32 newStamps)
{
newStamps = currentStamps | bytes32(1 << stamp);
}
/// @notice Removes Stamp from bytes32 variable to update allowlist
/// @dev does not revert, if Stamp isn't removed
function _removeStamp(uint256 stamp, bytes32 currentStamps)
internal
pure
returns (bytes32 newStamps)
{
newStamps = currentStamps & bytes32(~(1 << stamp));
}
///@notice Returns true if Stamp is allowlisted in `userStamps`
function _checkIfStampAllowlisted(uint256 stamp, bytes32 userStamps)
internal
pure
returns (bool)
{
return (uint256(userStamps) >> stamp) & 1 != 0;
}
/// @notice Returns amount of Stamps minted by _owner
/// @param _owner The owner of the Stamps
/// @return Number of Stamps minted by _owner
function _numberMinted(address _owner) internal view returns (uint256) {
return amountMintedByAddress[_owner];
}
/// @notice Hook called before mint/burn/transfer and batch variants of any token(s)
/// JoeJourneyStamp cannot be transferred
/// @dev See openzeppelin-contract {ERC1155-_beforeTokenTransfer}
function _beforeTokenTransfer(
address _operator,
address _from,
address _to,
uint256[] memory _ids,
uint256[] memory _amounts,
bytes memory _data
) internal virtual override {
if (_from != address(0) && _to != address(0)) {
if (!transferable) {
revert Launchpeg__TokensAreNonTransferable();
}
}
super._beforeTokenTransfer(
_operator,
_from,
_to,
_ids,
_amounts,
_data
);
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "./IBaseLaunchpeg1155.sol";
/// @title IJoeJourneyStamp
/// @author Trader Joe
/// @notice Defines the basic interface of JoeJourneyStamp
interface IJoeJourneyStamp is IBaseLaunchpeg1155 {
function initialize(
CollectionData calldata _collectionData,
CollectionOwnerData calldata _ownerData
) external;
function initializePhases(
uint256 preMintStartTime,
uint256 allowlistStartTime,
uint256 publicSaleStartTime,
uint256 publicSaleEndTime,
uint256 allowlistPrice,
uint256 salePrice
) external;
function lens() external returns (address);
function stampsAmount() external returns (uint256);
function allowlistMint(uint256 quantity) external payable;
function seedAllowlist(
address[] calldata addresses,
uint256[][] calldata stampIds
) external;
function removeAllowlistSpots(
address[] calldata addresses,
uint256[][] calldata stampIds
) external;
function setTransferable(bool transferable) external;
function setLensAddress(address) external;
function balanceOf(address) external view returns (uint256);
function totalSupply() external view returns (uint256);
function numberMinted(address) external view returns (uint256);
function allowlist(address) external view returns (uint256);
function numberMintedWithPreMint(address) external view returns (uint256);
function transferable() external view returns (bool);
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts-upgradeable/token/ERC1155/extensions/ERC1155SupplyUpgradeable.sol";
import "./LaunchpegErrors.sol";
import "./interfaces/IBaseLaunchpeg1155.sol";
import "./utils/SafePausableUpgradeable.sol";
/// @title BaseLaunchpeg1155
/// @author Trader Joe
/// @notice Implements the functionalities shared between Launchpeg1155, and FlatLaunchpeg1155 contracts.
abstract contract BaseLaunchpeg1155 is
IBaseLaunchpeg1155,
ERC1155SupplyUpgradeable,
SafePausableUpgradeable
{
using StringsUpgradeable for uint256;
/// @notice Max amount of NFTs an address can mint in public phases
uint256 public override maxPerAddressDuringMint;
// Used as the URI for all token types by relying on ID substitution, e.g. https://token-cdn-domain/{id}.json
string private _uri;
/// @notice Tracks the amount of NFTs minted by `projectOwner`
uint256 public override amountMintedByDevs;
/// @notice Tracks the amount of NFTs minted on Allowlist phase
uint256 public override amountMintedDuringAllowlist;
/// @notice Start time of the pre-mint in seconds
uint256 public override preMintStartTime;
/// @notice Start time of the allowlist mint in seconds
uint256 public override allowlistStartTime;
/// @notice Start time of the public sale in seconds
/// @dev A timestamp greater than the allowlist mint start
uint256 public override publicSaleStartTime;
/// @notice End time of the public sale in seconds
/// @dev A timestamp greater than the public sale start
uint256 public override publicSaleEndTime;
/// @notice Start time when funds can be withdrawn
uint256 public override withdrawAVAXStartTime;
/// @notice Checks if the current phase matches the required phase
modifier atPhase(Phase _phase) {
if (currentPhase() != _phase) {
revert Launchpeg__WrongPhase();
}
_;
}
/// @notice Phase time can be updated if it has been initialized and
// the time has not passed
modifier isTimeUpdateAllowed(uint256 _phaseTime) {
if (_phaseTime == 0) {
revert Launchpeg__NotInitialized();
}
if (_phaseTime <= block.timestamp) {
revert Launchpeg__WrongPhase();
}
_;
}
/// @notice Checks if new time is equal to or after block timestamp
modifier isNotBeforeBlockTimestamp(uint256 _newTime) {
if (_newTime < block.timestamp) {
revert Launchpeg__InvalidStartTime();
}
_;
}
/// @dev BaseLaunchpeg initialization
/// @param _collectionData Launchpeg collection data
/// @param _ownerData Launchpeg owner data
function initializeBaseLaunchpeg(
CollectionData calldata _collectionData,
CollectionOwnerData calldata _ownerData
) internal onlyInitializing {
__SafePausable_init();
__ERC1155_init("");
if (_ownerData.owner == address(0)) {
revert Launchpeg__InvalidOwner();
}
if (_ownerData.projectOwner == address(0)) {
revert Launchpeg__InvalidProjectOwner();
}
if (
_collectionData.collectionSize == 0 ||
_collectionData.amountForDevs + _collectionData.amountForAllowlist >
_collectionData.collectionSize
) {
revert Launchpeg__LargerCollectionSizeNeeded();
}
if (
_collectionData.maxPerAddressDuringMint >
_collectionData.collectionSize
) {
revert Launchpeg__InvalidMaxPerAddressDuringMint();
}
maxPerAddressDuringMint = _collectionData.maxPerAddressDuringMint;
grantRole(PAUSER_ROLE, msg.sender);
_transferOwnership(_ownerData.owner);
}
/// @notice Set the allowlist start time. Can only be set after phases
/// have been initialized.
/// @dev Only callable by owner
/// @param _allowlistStartTime New allowlist start time
function setAllowlistStartTime(uint256 _allowlistStartTime)
external
override
onlyOwner
isTimeUpdateAllowed(allowlistStartTime)
isNotBeforeBlockTimestamp(_allowlistStartTime)
{
if (publicSaleStartTime < _allowlistStartTime) {
revert Launchpeg__PublicSaleBeforeAllowlist();
}
allowlistStartTime = _allowlistStartTime;
emit AllowlistStartTimeSet(_allowlistStartTime);
}
/// @notice Set the public sale end time. Can only be set after phases
/// have been initialized.
/// @dev Only callable by owner
/// @param _publicSaleEndTime New public sale end time
function setPublicSaleEndTime(uint256 _publicSaleEndTime)
external
override
onlyOwner
isTimeUpdateAllowed(publicSaleEndTime)
isNotBeforeBlockTimestamp(_publicSaleEndTime)
{
publicSaleEndTime = _publicSaleEndTime;
publicSaleStartTime = _publicSaleEndTime;
emit PublicSaleEndTimeSet(_publicSaleEndTime);
}
/// @notice Sets the URI for all token IDs
/// @param _newURI new URI for all token IDs
function setURI(string memory _newURI) external override onlyOwner {
_setURI(_newURI);
}
/// @notice Burns an amount of tokens from a users balance
/// @param _id Token ID of tokens to burn
/// @param _amount Amount of tokens to burn
function burn(uint256 _id, uint256 _amount) external override {
uint256 balanceOfSender = balanceOf(_msgSender(), _id);
if (balanceOfSender == 0) {
revert Launchpeg__ZeroTokenBalance(_id);
}
if (balanceOfSender < _amount) {
revert Launchpeg__AmountExceedsBalance(balanceOfSender);
}
_burn(_msgSender(), _id, _amount);
}
/// @dev Returns allowlist price. Used by mint methods.
function _getAllowlistPrice() internal view virtual returns (uint256);
/// @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[EIP section]
/// to learn more about how these IDs are created.
/// This function call must use less than 30 000 gas.
/// @param _interfaceId InterfaceId to consider. Comes from type(InterfaceContract).interfaceId
/// @return isInterfaceSupported True if the considered interface is supported
function supportsInterface(bytes4 _interfaceId)
public
view
virtual
override(
ERC1155Upgradeable,
IERC165Upgradeable,
SafePausableUpgradeable
)
returns (bool)
{
return
_interfaceId == type(IBaseLaunchpeg1155).interfaceId ||
ERC1155Upgradeable.supportsInterface(_interfaceId) ||
ERC165Upgradeable.supportsInterface(_interfaceId) ||
SafePausableUpgradeable.supportsInterface(_interfaceId) ||
super.supportsInterface(_interfaceId);
}
/// @dev Verifies that enough AVAX has been sent by the sender and refunds the extra tokens if any
/// @param _price The price paid by the sender for minting NFTs
function _refundIfOver(uint256 _price) internal {
if (msg.value < _price) {
revert Launchpeg__NotEnoughAVAX(msg.value);
}
if (msg.value > _price) {
(bool success, ) = msg.sender.call{value: msg.value - _price}("");
if (!success) {
revert Launchpeg__TransferFailed();
}
}
}
/// @notice Returns the current phase
/// @return phase Current phase
function currentPhase() public view virtual override returns (Phase);
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts-upgradeable/token/ERC1155/IERC1155Upgradeable.sol";
/// @title IBaseLaunchpeg
/// @author Trader Joe
/// @notice Defines the basic interface of BaseLaunchpeg
interface IBaseLaunchpeg1155 is IERC1155Upgradeable {
enum Phase {
NotStarted,
DutchAuction,
PreMint,
Allowlist,
PublicSale,
Ended
}
/// @notice Collection data to initialize Launchpeg
/// @param name ERC721 name
/// @param symbol ERC721 symbol
/// @param maxPerAddressDuringMint Max amount of NFTs an address can mint in public phases
/// @param collectionSize The collection size (e.g 10000)
/// @param amountForDevs Amount of NFTs reserved for `projectOwner` (e.g 200)
/// @param amountForAuction Amount of NFTs available for the auction (e.g 8000)
/// @param amountForAllowlist Amount of NFTs available for the allowlist mint (e.g 1000)
struct CollectionData {
string name;
string symbol;
address batchReveal;
uint256 maxPerAddressDuringMint;
uint256 collectionSize;
uint256 amountForDevs;
uint256 amountForAuction;
uint256 amountForAllowlist;
}
/// @notice Collection owner data to initialize Launchpeg
/// @param owner The contract owner
/// @param projectOwner The project owner
/// @param royaltyReceiver Royalty fee collector
/// @param joeFeeCollector The address to which the fees on the sale will be sent
/// @param joeFeePercent The fees collected by the fee collector on the sale benefits
struct CollectionOwnerData {
address owner;
address projectOwner;
address royaltyReceiver;
address joeFeeCollector;
uint256 joeFeePercent;
}
/// @dev Emitted on allowlistMint()
/// @param sender The address that minted
/// @param quantity Amount of NFTs minted
/// @param price Price in AVAX for the NFTs
/// @param phase The phase in which the mint occurs
event Mint(
address indexed sender,
uint256 quantity,
uint256 price,
Phase phase
);
/// @dev Emitted on seedAllowlist()
event AllowlistSeeded();
/// @dev Emitted on setAllowlistStartTime()
/// @param allowlistStartTime New allowlist start time
event AllowlistStartTimeSet(uint256 allowlistStartTime);
/// @dev Emitted on setPublicSaleEndTime()
/// @param publicSaleEndTime New public sale end time
event PublicSaleEndTimeSet(uint256 publicSaleEndTime);
function maxPerAddressDuringMint() external view returns (uint256);
function amountMintedByDevs() external view returns (uint256);
function amountMintedDuringAllowlist() external view returns (uint256);
function preMintStartTime() external view returns (uint256);
function allowlistStartTime() external view returns (uint256);
function publicSaleStartTime() external view returns (uint256);
function publicSaleEndTime() external view returns (uint256);
function withdrawAVAXStartTime() external view returns (uint256);
function allowlistPrice() external view returns (uint256);
function salePrice() external view returns (uint256);
function setAllowlistStartTime(uint256 allowlistStartTime) external;
function setPublicSaleEndTime(uint256 publicSaleEndTime) external;
function setURI(string memory) external;
function burn(uint256, uint256) external;
function currentPhase() external view returns (Phase);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC1155/IERC1155.sol)
pragma solidity ^0.8.0;
import "../../utils/introspection/IERC165Upgradeable.sol";
/**
* @dev Required interface of an ERC1155 compliant contract, as defined in the
* https://eips.ethereum.org/EIPS/eip-1155[EIP].
*
* _Available since v3.1._
*/
interface IERC1155Upgradeable is IERC165Upgradeable {
/**
* @dev Emitted when `value` tokens of token 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 amount of tokens of token type `id` owned by `account`.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
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 caller.
*/
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 `amount` tokens of token type `id` from `from` to `to`.
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - If the caller is not `from`, it must be have been approved to spend ``from``'s tokens via {setApprovalForAll}.
* - `from` must have a balance of tokens of type `id` of at least `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 amount,
bytes calldata data
) external;
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}.
*
* Emits a {TransferBatch} event.
*
* Requirements:
*
* - `ids` and `amounts` 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 amounts,
bytes calldata data
) external;
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC165 standard, as defined in the
* https://eips.ethereum.org/EIPS/eip-165[EIP].
*
* Implementers can declare support of contract interfaces, which can then be
* queried by others ({ERC165Checker}).
*
* For an implementation, see {ERC165}.
*/
interface IERC165Upgradeable {
/**
* @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[EIP 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 v4.4.1 (token/ERC1155/extensions/ERC1155Supply.sol)
pragma solidity ^0.8.0;
import "../ERC1155Upgradeable.sol";
import "../../../proxy/utils/Initializable.sol";
/**
* @dev Extension of ERC1155 that adds tracking of total supply per id.
*
* Useful for scenarios where Fungible and Non-fungible tokens have to be
* clearly identified. Note: While a totalSupply of 1 might mean the
* corresponding is an NFT, there is no guarantees that no other token with the
* same id are not going to be minted.
*/
abstract contract ERC1155SupplyUpgradeable is Initializable, ERC1155Upgradeable {
function __ERC1155Supply_init() internal onlyInitializing {
}
function __ERC1155Supply_init_unchained() internal onlyInitializing {
}
mapping(uint256 => uint256) private _totalSupply;
/**
* @dev Total amount of tokens in with a given id.
*/
function totalSupply(uint256 id) public view virtual returns (uint256) {
return _totalSupply[id];
}
/**
* @dev Indicates whether any token exist with a given id, or not.
*/
function exists(uint256 id) public view virtual returns (bool) {
return ERC1155SupplyUpgradeable.totalSupply(id) > 0;
}
/**
* @dev See {ERC1155-_beforeTokenTransfer}.
*/
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual override {
super._beforeTokenTransfer(operator, from, to, ids, amounts, data);
if (from == address(0)) {
for (uint256 i = 0; i < ids.length; ++i) {
_totalSupply[ids[i]] += amounts[i];
}
}
if (to == address(0)) {
for (uint256 i = 0; i < ids.length; ++i) {
_totalSupply[ids[i]] -= amounts[i];
}
}
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[49] private __gap;
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
// LaunchpegFactory
error LaunchpegFactory__InvalidBatchReveal();
error LaunchpegFactory__InvalidImplementation();
// Non-transferable Launchpeg
error Launchpeg__TokensAreNonTransferable();
error Launchpeg__OnlyAllowlistMint();
error Launchpeg__ZeroTokenBalance(uint256 id);
error Launchpeg__AmountExceedsBalance(uint256 balanceOf);
error Launchpeg__AlreadyRemovedOrMinted(address user, uint256 stampId);
error Launchpeg__NotImplemented();
error Launchpeg__WrongStampNumber();
// Launchpeg
error Launchpeg__AllowlistBeforePreMint();
error Launchpeg__BatchRevealAlreadyInitialized();
error Launchpeg__BatchRevealDisabled();
error Launchpeg__BatchRevealNotInitialized();
error Launchpeg__BatchRevealStarted();
error Launchpeg__CanNotMintThisMany();
error Launchpeg__EndPriceGreaterThanStartPrice();
error Launchpeg__HasBeenForceRevealed();
error Launchpeg__InvalidAllowlistPrice();
error Launchpeg__InvalidAuctionDropInterval();
error Launchpeg__InvalidBatchReveal();
error Launchpeg__InvalidBatchRevealSize();
error Launchpeg__InvalidCallbackGasLimit();
error Launchpeg__InvalidClaim();
error Launchpeg__InvalidCoordinator();
error Launchpeg__InvalidKeyHash();
error Launchpeg__InvalidJoeFeeCollector();
error Launchpeg__InvalidMaxPerAddressDuringMint();
error Launchpeg__InvalidOwner();
error Launchpeg__InvalidProjectOwner();
error Launchpeg__InvalidPercent();
error Launchpeg__InvalidQuantity();
error Launchpeg__InvalidRevealDates();
error Launchpeg__InvalidRoyaltyInfo();
error Launchpeg__InvalidStartTime();
error Launchpeg__IsNotInTheConsumerList();
error Launchpeg__LargerCollectionSizeNeeded();
error Launchpeg__MaxSupplyForDevReached();
error Launchpeg__MaxSupplyReached();
error Launchpeg__NotEligibleForAllowlistMint();
error Launchpeg__NotEnoughAVAX(uint256 avaxSent);
error Launchpeg__NotInitialized();
error Launchpeg__PreMintBeforeAuction();
error Launchpeg__PublicSaleBeforeAllowlist();
error Launchpeg__PublicSaleEndBeforePublicSaleStart();
error Launchpeg__RevealNextBatchNotAvailable();
error Launchpeg__TransferFailed();
error Launchpeg__Unauthorized();
error Launchpeg__WithdrawAVAXNotAvailable();
error Launchpeg__WrongAddressesAndNumSlotsLength();
error Launchpeg__WrongPhase();
// PendingOwnableUpgradeable
error PendingOwnableUpgradeable__NotOwner();
error PendingOwnableUpgradeable__AddressZero();
error PendingOwnableUpgradeable__NotPendingOwner();
error PendingOwnableUpgradeable__PendingOwnerAlreadySet();
error PendingOwnableUpgradeable__NoPendingOwner();
// SafeAccessControlEnumerableUpgradeable
error SafeAccessControlEnumerableUpgradeable__SenderMissingRoleAndIsNotOwner(
bytes32 role,
address sender
);
error SafeAccessControlEnumerableUpgradeable__RoleIsDefaultAdmin();
// SafePausableUpgradeable
error SafePausableUpgradeable__AlreadyPaused();
error SafePausableUpgradeable__AlreadyUnpaused();// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol";
import "../LaunchpegErrors.sol";
import "../interfaces/ISafePausableUpgradeable.sol";
import "./SafeAccessControlEnumerableUpgradeable.sol";
abstract contract SafePausableUpgradeable is
SafeAccessControlEnumerableUpgradeable,
PausableUpgradeable,
ISafePausableUpgradeable
{
bytes32 public constant override PAUSER_ROLE = keccak256("PAUSER_ROLE");
bytes32 public constant override UNPAUSER_ROLE = keccak256("UNPAUSER_ROLE");
bytes32 public constant override PAUSER_ADMIN_ROLE =
keccak256("PAUSER_ADMIN_ROLE");
bytes32 public constant override UNPAUSER_ADMIN_ROLE =
keccak256("UNPAUSER_ADMIN_ROLE");
function __SafePausable_init() internal onlyInitializing {
__SafeAccessControlEnumerable_init();
__Pausable_init();
__SafePausable_init_unchained();
}
function __SafePausable_init_unchained() internal onlyInitializing {
_setRoleAdmin(PAUSER_ROLE, PAUSER_ADMIN_ROLE);
_setRoleAdmin(UNPAUSER_ROLE, UNPAUSER_ADMIN_ROLE);
}
/**
* @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[EIP section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(SafeAccessControlEnumerableUpgradeable)
returns (bool)
{
return
interfaceId == type(ISafePausableUpgradeable).interfaceId ||
SafeAccessControlEnumerableUpgradeable.supportsInterface(
interfaceId
);
}
/**
* @notice Pauses the contract.
* @dev Sensible part of a contract might be pausable for security reasons.
*
* Requirements:
* - the caller must be the `owner` or have the ``role`` role.
* - the contrat needs to be unpaused.
*/
function pause() public virtual override onlyOwnerOrRole(PAUSER_ROLE) {
if (paused()) revert SafePausableUpgradeable__AlreadyPaused();
_pause();
}
/**
* @notice Unpauses the contract.
* @dev Sensible part of a contract might be pausable for security reasons.
*
* Requirements:
* - the caller must be the `owner` or have the ``role`` role.
* - the contrat needs to be unpaused.
*/
function unpause() public virtual override onlyOwnerOrRole(UNPAUSER_ROLE) {
if (!paused()) revert SafePausableUpgradeable__AlreadyUnpaused();
_unpause();
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC1155/ERC1155.sol)
pragma solidity ^0.8.0;
import "./IERC1155Upgradeable.sol";
import "./IERC1155ReceiverUpgradeable.sol";
import "./extensions/IERC1155MetadataURIUpgradeable.sol";
import "../../utils/AddressUpgradeable.sol";
import "../../utils/ContextUpgradeable.sol";
import "../../utils/introspection/ERC165Upgradeable.sol";
import "../../proxy/utils/Initializable.sol";
/**
* @dev Implementation of the basic standard multi-token.
* See https://eips.ethereum.org/EIPS/eip-1155
* Originally based on code by Enjin: https://github.com/enjin/erc-1155
*
* _Available since v3.1._
*/
contract ERC1155Upgradeable is Initializable, ContextUpgradeable, ERC165Upgradeable, IERC1155Upgradeable, IERC1155MetadataURIUpgradeable {
using AddressUpgradeable for address;
// Mapping from token ID to account balances
mapping(uint256 => mapping(address => uint256)) private _balances;
// Mapping from account to operator approvals
mapping(address => mapping(address => bool)) private _operatorApprovals;
// Used as the URI for all token types by relying on ID substitution, e.g. https://token-cdn-domain/{id}.json
string private _uri;
/**
* @dev See {_setURI}.
*/
function __ERC1155_init(string memory uri_) internal onlyInitializing {
__ERC1155_init_unchained(uri_);
}
function __ERC1155_init_unchained(string memory uri_) internal onlyInitializing {
_setURI(uri_);
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165Upgradeable, IERC165Upgradeable) returns (bool) {
return
interfaceId == type(IERC1155Upgradeable).interfaceId ||
interfaceId == type(IERC1155MetadataURIUpgradeable).interfaceId ||
super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC1155MetadataURI-uri}.
*
* This implementation returns the same URI for *all* token types. It relies
* on the token type ID substitution mechanism
* https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
*
* Clients calling this function must replace the `\{id\}` substring with the
* actual token type ID.
*/
function uri(uint256) public view virtual override returns (string memory) {
return _uri;
}
/**
* @dev See {IERC1155-balanceOf}.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {
require(account != address(0), "ERC1155: balance query for the zero address");
return _balances[id][account];
}
/**
* @dev See {IERC1155-balanceOfBatch}.
*
* Requirements:
*
* - `accounts` and `ids` must have the same length.
*/
function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
public
view
virtual
override
returns (uint256[] memory)
{
require(accounts.length == ids.length, "ERC1155: accounts and ids length mismatch");
uint256[] memory batchBalances = new uint256[](accounts.length);
for (uint256 i = 0; i < accounts.length; ++i) {
batchBalances[i] = balanceOf(accounts[i], ids[i]);
}
return batchBalances;
}
/**
* @dev See {IERC1155-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual override {
_setApprovalForAll(_msgSender(), operator, approved);
}
/**
* @dev See {IERC1155-isApprovedForAll}.
*/
function isApprovedForAll(address account, address operator) public view virtual override returns (bool) {
return _operatorApprovals[account][operator];
}
/**
* @dev See {IERC1155-safeTransferFrom}.
*/
function safeTransferFrom(
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) public virtual override {
require(
from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: caller is not owner nor approved"
);
_safeTransferFrom(from, to, id, amount, data);
}
/**
* @dev See {IERC1155-safeBatchTransferFrom}.
*/
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override {
require(
from == _msgSender() || isApprovedForAll(from, _msgSender()),
"ERC1155: transfer caller is not owner nor approved"
);
_safeBatchTransferFrom(from, to, ids, amounts, data);
}
/**
* @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `from` must have a balance of tokens of type `id` of at least `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 amount,
bytes memory data
) internal virtual {
require(to != address(0), "ERC1155: transfer to the zero address");
address operator = _msgSender();
_beforeTokenTransfer(operator, from, to, _asSingletonArray(id), _asSingletonArray(amount), data);
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
unchecked {
_balances[id][from] = fromBalance - amount;
}
_balances[id][to] += amount;
emit TransferSingle(operator, from, to, id, amount);
_doSafeTransferAcceptanceCheck(operator, from, to, id, amount, data);
}
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_safeTransferFrom}.
*
* Emits a {TransferBatch} event.
*
* Requirements:
*
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
* acceptance magic value.
*/
function _safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
require(to != address(0), "ERC1155: transfer to the zero address");
address operator = _msgSender();
_beforeTokenTransfer(operator, from, to, ids, amounts, data);
for (uint256 i = 0; i < ids.length; ++i) {
uint256 id = ids[i];
uint256 amount = amounts[i];
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
unchecked {
_balances[id][from] = fromBalance - amount;
}
_balances[id][to] += amount;
}
emit TransferBatch(operator, from, to, ids, amounts);
_doSafeBatchTransferAcceptanceCheck(operator, from, to, ids, amounts, data);
}
/**
* @dev Sets a new URI for all token types, by relying on the token type ID
* substitution mechanism
* https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
*
* By this mechanism, any occurrence of the `\{id\}` substring in either the
* URI or any of the amounts in the JSON file at said URI will be replaced by
* clients with the token type ID.
*
* For example, the `https://token-cdn-domain/\{id\}.json` URI would be
* interpreted by clients as
* `https://token-cdn-domain/000000000000000000000000000000000000000000000000000000000004cce0.json`
* for token type ID 0x4cce0.
*
* See {uri}.
*
* Because these URIs cannot be meaningfully represented by the {URI} event,
* this function emits no events.
*/
function _setURI(string memory newuri) internal virtual {
_uri = newuri;
}
/**
* @dev Creates `amount` tokens of token type `id`, and assigns them to `to`.
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
* acceptance magic value.
*/
function _mint(
address to,
uint256 id,
uint256 amount,
bytes memory data
) internal virtual {
require(to != address(0), "ERC1155: mint to the zero address");
address operator = _msgSender();
_beforeTokenTransfer(operator, address(0), to, _asSingletonArray(id), _asSingletonArray(amount), data);
_balances[id][to] += amount;
emit TransferSingle(operator, address(0), to, id, amount);
_doSafeTransferAcceptanceCheck(operator, address(0), to, id, amount, data);
}
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_mint}.
*
* Requirements:
*
* - `ids` and `amounts` must have the same length.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
* acceptance magic value.
*/
function _mintBatch(
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {
require(to != address(0), "ERC1155: mint to the zero address");
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
address operator = _msgSender();
_beforeTokenTransfer(operator, address(0), to, ids, amounts, data);
for (uint256 i = 0; i < ids.length; i++) {
_balances[ids[i]][to] += amounts[i];
}
emit TransferBatch(operator, address(0), to, ids, amounts);
_doSafeBatchTransferAcceptanceCheck(operator, address(0), to, ids, amounts, data);
}
/**
* @dev Destroys `amount` tokens of token type `id` from `from`
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `from` must have at least `amount` tokens of token type `id`.
*/
function _burn(
address from,
uint256 id,
uint256 amount
) internal virtual {
require(from != address(0), "ERC1155: burn from the zero address");
address operator = _msgSender();
_beforeTokenTransfer(operator, from, address(0), _asSingletonArray(id), _asSingletonArray(amount), "");
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: burn amount exceeds balance");
unchecked {
_balances[id][from] = fromBalance - amount;
}
emit TransferSingle(operator, from, address(0), id, amount);
}
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_burn}.
*
* Requirements:
*
* - `ids` and `amounts` must have the same length.
*/
function _burnBatch(
address from,
uint256[] memory ids,
uint256[] memory amounts
) internal virtual {
require(from != address(0), "ERC1155: burn from the zero address");
require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
address operator = _msgSender();
_beforeTokenTransfer(operator, from, address(0), ids, amounts, "");
for (uint256 i = 0; i < ids.length; i++) {
uint256 id = ids[i];
uint256 amount = amounts[i];
uint256 fromBalance = _balances[id][from];
require(fromBalance >= amount, "ERC1155: burn amount exceeds balance");
unchecked {
_balances[id][from] = fromBalance - amount;
}
}
emit TransferBatch(operator, from, address(0), ids, amounts);
}
/**
* @dev Approve `operator` to operate on all of `owner` tokens
*
* Emits a {ApprovalForAll} event.
*/
function _setApprovalForAll(
address owner,
address operator,
bool approved
) internal virtual {
require(owner != operator, "ERC1155: setting approval status for self");
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
/**
* @dev Hook that is called before any token transfer. This includes minting
* and burning, as well as batched variants.
*
* The same hook is called on both single and batched variants. For single
* transfers, the length of the `id` and `amount` arrays will be 1.
*
* Calling conditions (for each `id` and `amount` pair):
*
* - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* of token type `id` will be transferred to `to`.
* - When `from` is zero, `amount` tokens of token type `id` will be minted
* for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens of token type `id`
* will be burned.
* - `from` and `to` are never both zero.
* - `ids` and `amounts` have the same, non-zero length.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) internal virtual {}
function _doSafeTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) private {
if (to.isContract()) {
try IERC1155ReceiverUpgradeable(to).onERC1155Received(operator, from, id, amount, data) returns (bytes4 response) {
if (response != IERC1155ReceiverUpgradeable.onERC1155Received.selector) {
revert("ERC1155: ERC1155Receiver rejected tokens");
}
} catch Error(string memory reason) {
revert(reason);
} catch {
revert("ERC1155: transfer to non ERC1155Receiver implementer");
}
}
}
function _doSafeBatchTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) private {
if (to.isContract()) {
try IERC1155ReceiverUpgradeable(to).onERC1155BatchReceived(operator, from, ids, amounts, data) returns (
bytes4 response
) {
if (response != IERC1155ReceiverUpgradeable.onERC1155BatchReceived.selector) {
revert("ERC1155: ERC1155Receiver rejected tokens");
}
} catch Error(string memory reason) {
revert(reason);
} catch {
revert("ERC1155: transfer to non ERC1155Receiver implementer");
}
}
}
function _asSingletonArray(uint256 element) private pure returns (uint256[] memory) {
uint256[] memory array = new uint256[](1);
array[0] = element;
return array;
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[47] private __gap;
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (proxy/utils/Initializable.sol)
pragma solidity ^0.8.0;
import "../../utils/AddressUpgradeable.sol";
/**
* @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.
*
* 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 initialize the implementation contract, you can either invoke the
* initializer manually, or you can include a constructor to automatically mark it as initialized when it is deployed:
*
* [.hljs-theme-light.nopadding]
* ```
* /// @custom:oz-upgrades-unsafe-allow constructor
* constructor() initializer {}
* ```
* ====
*/
abstract contract Initializable {
/**
* @dev Indicates that the contract has been initialized.
*/
bool private _initialized;
/**
* @dev Indicates that the contract is in the process of being initialized.
*/
bool private _initializing;
/**
* @dev Modifier to protect an initializer function from being invoked twice.
*/
modifier initializer() {
// If the contract is initializing we ignore whether _initialized is set in order to support multiple
// inheritance patterns, but we only do this in the context of a constructor, because in other contexts the
// contract may have been reentered.
require(_initializing ? _isConstructor() : !_initialized, "Initializable: contract is already initialized");
bool isTopLevelCall = !_initializing;
if (isTopLevelCall) {
_initializing = true;
_initialized = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
}
}
/**
* @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
* {initializer} modifier, directly or indirectly.
*/
modifier onlyInitializing() {
require(_initializing, "Initializable: contract is not initializing");
_;
}
function _isConstructor() private view returns (bool) {
return !AddressUpgradeable.isContract(address(this));
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/IERC1155Receiver.sol)
pragma solidity ^0.8.0;
import "../../utils/introspection/IERC165Upgradeable.sol";
/**
* @dev _Available since v3.1._
*/
interface IERC1155ReceiverUpgradeable is IERC165Upgradeable {
/**
* @dev Handles the receipt of a single ERC1155 token type. This function is
* called at the end of a `safeTransferFrom` after the balance has been updated.
*
* NOTE: To accept the transfer, this must return
* `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`
* (i.e. 0xf23a6e61, or its own function selector).
*
* @param operator The address which initiated the transfer (i.e. msg.sender)
* @param from The address which previously owned the token
* @param id The ID of the token being transferred
* @param value The amount of tokens being transferred
* @param data Additional data with no specified format
* @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed
*/
function onERC1155Received(
address operator,
address from,
uint256 id,
uint256 value,
bytes calldata data
) external returns (bytes4);
/**
* @dev Handles the receipt of a multiple ERC1155 token types. This function
* is called at the end of a `safeBatchTransferFrom` after the balances have
* been updated.
*
* NOTE: To accept the transfer(s), this must return
* `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))`
* (i.e. 0xbc197c81, or its own function selector).
*
* @param operator The address which initiated the batch transfer (i.e. msg.sender)
* @param from The address which previously owned the token
* @param ids An array containing ids of each token being transferred (order and length must match values array)
* @param values An array containing amounts of each token being transferred (order and length must match ids array)
* @param data Additional data with no specified format
* @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed
*/
function onERC1155BatchReceived(
address operator,
address from,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
) external returns (bytes4);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC1155/extensions/IERC1155MetadataURI.sol)
pragma solidity ^0.8.0;
import "../IERC1155Upgradeable.sol";
/**
* @dev Interface of the optional ERC1155MetadataExtension interface, as defined
* in the https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[EIP].
*
* _Available since v3.1._
*/
interface IERC1155MetadataURIUpgradeable is IERC1155Upgradeable {
/**
* @dev Returns the URI for token type `id`.
*
* If the `\{id\}` substring is present in the URI, it must be replaced by
* clients with the actual token type ID.
*/
function uri(uint256 id) external view returns (string memory);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (utils/Address.sol)
pragma solidity ^0.8.1;
/**
* @dev Collection of functions related to the address type
*/
library AddressUpgradeable {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*
* [IMPORTANT]
* ====
* You shouldn't rely on `isContract` to protect against flash loan attacks!
*
* Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
* like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
* constructor.
* ====
*/
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
/**
* @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://diligence.consensys.net/posts/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.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @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, it is bubbled up by this
* function (like regular Solidity function calls).
*
* 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.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @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`.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason using the provided one.
*
* _Available since v4.3._
*/
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// 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 {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
pragma solidity ^0.8.0;
import "../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;
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[50] private __gap;
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)
pragma solidity ^0.8.0;
import "./IERC165Upgradeable.sol";
import "../../proxy/utils/Initializable.sol";
/**
* @dev Implementation of the {IERC165} interface.
*
* Contracts that want to implement ERC165 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);
* }
* ```
*
* Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
*/
abstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {
function __ERC165_init() internal onlyInitializing {
}
function __ERC165_init_unchained() internal onlyInitializing {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165Upgradeable).interfaceId;
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[50] private __gap;
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (security/Pausable.sol)
pragma solidity ^0.8.0;
import "../utils/ContextUpgradeable.sol";
import "../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 {
/**
* @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);
bool private _paused;
/**
* @dev Initializes the contract in unpaused state.
*/
function __Pausable_init() internal onlyInitializing {
__Pausable_init_unchained();
}
function __Pausable_init_unchained() internal onlyInitializing {
_paused = false;
}
/**
* @dev Returns true if the contract is paused, and false otherwise.
*/
function paused() public view virtual returns (bool) {
return _paused;
}
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*
* Requirements:
*
* - The contract must not be paused.
*/
modifier whenNotPaused() {
require(!paused(), "Pausable: paused");
_;
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*
* Requirements:
*
* - The contract must be paused.
*/
modifier whenPaused() {
require(paused(), "Pausable: not paused");
_;
}
/**
* @dev Triggers stopped state.
*
* Requirements:
*
* - The contract must not be paused.
*/
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
/**
* @dev Returns to normal state.
*
* Requirements:
*
* - The contract must be paused.
*/
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[49] private __gap;
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts-upgradeable/access/IAccessControlEnumerableUpgradeable.sol";
import "../interfaces/IPendingOwnableUpgradeable.sol";
interface ISafePausableUpgradeable is
IAccessControlEnumerableUpgradeable,
IPendingOwnableUpgradeable
{
function PAUSER_ROLE() external pure returns (bytes32);
function UNPAUSER_ROLE() external pure returns (bytes32);
function PAUSER_ADMIN_ROLE() external pure returns (bytes32);
function UNPAUSER_ADMIN_ROLE() external pure returns (bytes32);
function pause() external;
function unpause() external;
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts-upgradeable/access/AccessControlEnumerableUpgradeable.sol";
import "../LaunchpegErrors.sol";
import "./PendingOwnableUpgradeable.sol";
abstract contract SafeAccessControlEnumerableUpgradeable is
PendingOwnableUpgradeable,
AccessControlEnumerableUpgradeable
{
/**
* @dev Modifier that checks that the role is not the `DEFAULT_ADMIN_ROLE`
*/
modifier roleIsNotDefaultAdmin(bytes32 role) {
if (role == DEFAULT_ADMIN_ROLE)
revert SafeAccessControlEnumerableUpgradeable__RoleIsDefaultAdmin();
_;
}
/**
* @dev Modifier that checks that an account is the `owner` or has a specific role
*/
modifier onlyOwnerOrRole(bytes32 role) {
if (msg.sender != owner() && !hasRole(role, msg.sender))
revert SafeAccessControlEnumerableUpgradeable__SenderMissingRoleAndIsNotOwner(
role,
msg.sender
);
_;
}
function __SafeAccessControlEnumerable_init() internal onlyInitializing {
__PendingOwnable_init();
__AccessControlEnumerable_init();
__SafeAccessControlEnumerable_init_unchained();
}
function __SafeAccessControlEnumerable_init_unchained()
internal
onlyInitializing
{}
/**
* @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[EIP section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(PendingOwnableUpgradeable, AccessControlEnumerableUpgradeable)
returns (bool)
{
return
PendingOwnableUpgradeable.supportsInterface(interfaceId) ||
AccessControlEnumerableUpgradeable.supportsInterface(interfaceId);
}
/**
* @notice Grants `role` to `account`.
* @dev If `account` had not been already granted `role`, emits a {RoleGranted} event.
*
* Requirements:
*
* - the caller must be the `owner` or have ``role``'s admin role.
* - the role granted can't be `DEFAULT_ADMIN`
*
* @param role The role to grant
* @param account The address of the account
*/
function grantRole(bytes32 role, address account)
public
virtual
override
roleIsNotDefaultAdmin(role)
onlyOwnerOrRole(getRoleAdmin(role))
{
_grantRole(role, account);
}
/**
* @notice Revokes `role` from `account`.
* @dev If `account` had been granted `role`, emits a {RoleRevoked} event.
*
* Requirements:
*
* - the caller must be the `owner` or have ``role``'s admin role.
* - the role revoked can't be `DEFAULT_ADMIN`
*
* @param role The role to revoke
* @param account The address of the account
*/
function revokeRole(bytes32 role, address account)
public
virtual
override
roleIsNotDefaultAdmin(role)
onlyOwnerOrRole(getRoleAdmin(role))
{
_revokeRole(role, account);
}
/**
* @notice Revokes `role` from the calling account.
*
* @dev 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 `account`.
* - the role renounced can't be `DEFAULT_ADMIN`
*
* @param role The role to renounce
* @param account The address of the account
*/
function renounceRole(bytes32 role, address account)
public
virtual
override
roleIsNotDefaultAdmin(role)
{
super.renounceRole(role, account);
}
/**
* @notice Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
* @dev This also transfer the `DEFAULT_ADMIN` role to the new owner
* @param _newOwner The address of the new owner
*/
function _transferOwnership(address _newOwner) internal virtual override {
_revokeRole(DEFAULT_ADMIN_ROLE, owner());
if (_newOwner != address(0)) _grantRole(DEFAULT_ADMIN_ROLE, _newOwner);
super._transferOwnership(_newOwner);
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (access/IAccessControlEnumerable.sol)
pragma solidity ^0.8.0;
import "./IAccessControlUpgradeable.sol";
/**
* @dev External interface of AccessControlEnumerable declared to support ERC165 detection.
*/
interface IAccessControlEnumerableUpgradeable is IAccessControlUpgradeable {
/**
* @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
pragma solidity ^0.8.4;
interface IPendingOwnableUpgradeable {
event PendingOwnerSet(address indexed pendingOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
function owner() external view returns (address);
function pendingOwner() external view returns (address);
function setPendingOwner(address pendingOwner) external;
function revokePendingOwner() external;
function becomeOwner() external;
function renounceOwnership() external;
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)
pragma solidity ^0.8.0;
/**
* @dev External interface of AccessControl declared to support ERC165 detection.
*/
interface IAccessControlUpgradeable {
/**
* @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.
*
* _Available since v3.1._
*/
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, an admin role
* bearer except when using {AccessControl-_setupRole}.
*/
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 `account`.
*/
function renounceRole(bytes32 role, address account) external;
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (access/AccessControlEnumerable.sol)
pragma solidity ^0.8.0;
import "./IAccessControlEnumerableUpgradeable.sol";
import "./AccessControlUpgradeable.sol";
import "../utils/structs/EnumerableSetUpgradeable.sol";
import "../proxy/utils/Initializable.sol";
/**
* @dev Extension of {AccessControl} that allows enumerating the members of each role.
*/
abstract contract AccessControlEnumerableUpgradeable is Initializable, IAccessControlEnumerableUpgradeable, AccessControlUpgradeable {
function __AccessControlEnumerable_init() internal onlyInitializing {
}
function __AccessControlEnumerable_init_unchained() internal onlyInitializing {
}
using EnumerableSetUpgradeable for EnumerableSetUpgradeable.AddressSet;
mapping(bytes32 => EnumerableSetUpgradeable.AddressSet) private _roleMembers;
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IAccessControlEnumerableUpgradeable).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 override returns (address) {
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 override returns (uint256) {
return _roleMembers[role].length();
}
/**
* @dev Overload {_grantRole} to track enumerable memberships
*/
function _grantRole(bytes32 role, address account) internal virtual override {
super._grantRole(role, account);
_roleMembers[role].add(account);
}
/**
* @dev Overload {_revokeRole} to track enumerable memberships
*/
function _revokeRole(bytes32 role, address account) internal virtual override {
super._revokeRole(role, account);
_roleMembers[role].remove(account);
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[49] private __gap;
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "../interfaces/IPendingOwnableUpgradeable.sol";
import "../LaunchpegErrors.sol";
/**
* @title Pending Ownable
* @author Trader Joe
* @notice Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions. The ownership of this contract is transferred using the
* push and pull pattern, the current owner set a `pendingOwner` using
* {setPendingOwner} and that address can then call {becomeOwner} to become the
* owner of that contract. The main logic and comments comes from OpenZeppelin's
* Ownable contract.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {setPendingOwner} and {becomeOwner}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner
*/
abstract contract PendingOwnableUpgradeable is
Initializable,
ERC165Upgradeable,
IPendingOwnableUpgradeable
{
address private _owner;
address private _pendingOwner;
/**
* @notice Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
if (msg.sender != _owner) revert PendingOwnableUpgradeable__NotOwner();
_;
}
/**
* @notice Throws if called by any account other than the pending owner.
*/
modifier onlyPendingOwner() {
if (msg.sender != _pendingOwner || msg.sender == address(0))
revert PendingOwnableUpgradeable__NotPendingOwner();
_;
}
/**
* @dev Initializes the contract setting `msg.sender` as the initial owner
*/
function __PendingOwnable_init() internal onlyInitializing {
__ERC165_init();
__PendingOwnable_init_unchained();
}
function __PendingOwnable_init_unchained() internal onlyInitializing {
_transferOwnership(msg.sender);
}
/**
* @notice Returns the address of the current owner
* @return The address of the current owner
*/
function owner() public view virtual override returns (address) {
return _owner;
}
/**
* @notice Returns the address of the current pending owner
* @return The address of the current pending owner
*/
function pendingOwner() public view virtual override returns (address) {
return _pendingOwner;
}
/**
* @notice Sets the pending owner address. This address will be able to become
* the owner of this contract by calling {becomeOwner}
*/
function setPendingOwner(address pendingOwner_)
public
virtual
override
onlyOwner
{
if (pendingOwner_ == address(0))
revert PendingOwnableUpgradeable__AddressZero();
if (_pendingOwner != address(0))
revert PendingOwnableUpgradeable__PendingOwnerAlreadySet();
_setPendingOwner(pendingOwner_);
}
/**
* @notice Revoke the pending owner address. This address will not be able to
* call {becomeOwner} to become the owner anymore.
* Can only be called by the owner
*/
function revokePendingOwner() public virtual override onlyOwner {
if (_pendingOwner == address(0))
revert PendingOwnableUpgradeable__NoPendingOwner();
_setPendingOwner(address(0));
}
/**
* @notice Transfers the ownership to the new owner (`pendingOwner`).
* Can only be called by the pending owner
*/
function becomeOwner() public virtual override onlyPendingOwner {
_transferOwnership(msg.sender);
}
/**
* @notice Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual override onlyOwner {
_transferOwnership(address(0));
}
/**
* @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[EIP section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override
returns (bool)
{
return
interfaceId == type(IPendingOwnableUpgradeable).interfaceId ||
super.supportsInterface(interfaceId);
}
/**
* @notice Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
* @param _newOwner The address of the new owner
*/
function _transferOwnership(address _newOwner) internal virtual {
address _oldOwner = _owner;
_owner = _newOwner;
_pendingOwner = address(0);
emit OwnershipTransferred(_oldOwner, _newOwner);
}
/**
* @notice Push the new owner, it needs to be pulled to be effective.
* Internal function without access restriction.
* @param pendingOwner_ The address of the new pending owner
*/
function _setPendingOwner(address pendingOwner_) internal virtual {
_pendingOwner = pendingOwner_;
emit PendingOwnerSet(pendingOwner_);
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (access/AccessControl.sol)
pragma solidity ^0.8.0;
import "./IAccessControlUpgradeable.sol";
import "../utils/ContextUpgradeable.sol";
import "../utils/StringsUpgradeable.sol";
import "../utils/introspection/ERC165Upgradeable.sol";
import "../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:
*
* ```
* 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}:
*
* ```
* 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.
*/
abstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {
function __AccessControl_init() internal onlyInitializing {
}
function __AccessControl_init_unchained() internal onlyInitializing {
}
struct RoleData {
mapping(address => bool) members;
bytes32 adminRole;
}
mapping(bytes32 => RoleData) private _roles;
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
/**
* @dev Modifier that checks that an account has a specific role. Reverts
* with a standardized message including the required role.
*
* The format of the revert reason is given by the following regular expression:
*
* /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
*
* _Available since v4.1._
*/
modifier onlyRole(bytes32 role) {
_checkRole(role, _msgSender());
_;
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IAccessControlUpgradeable).interfaceId || super.supportsInterface(interfaceId);
}
/**
* @dev Returns `true` if `account` has been granted `role`.
*/
function hasRole(bytes32 role, address account) public view virtual override returns (bool) {
return _roles[role].members[account];
}
/**
* @dev Revert with a standard message if `account` is missing `role`.
*
* The format of the revert reason is given by the following regular expression:
*
* /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
*/
function _checkRole(bytes32 role, address account) internal view virtual {
if (!hasRole(role, account)) {
revert(
string(
abi.encodePacked(
"AccessControl: account ",
StringsUpgradeable.toHexString(uint160(account), 20),
" is missing role ",
StringsUpgradeable.toHexString(uint256(role), 32)
)
)
);
}
}
/**
* @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 override returns (bytes32) {
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.
*/
function grantRole(bytes32 role, address account) public virtual override 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.
*/
function revokeRole(bytes32 role, address account) public virtual override 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 `account`.
*/
function renounceRole(bytes32 role, address account) public virtual override {
require(account == _msgSender(), "AccessControl: can only renounce roles for self");
_revokeRole(role, account);
}
/**
* @dev Grants `role` to `account`.
*
* If `account` had not been already granted `role`, emits a {RoleGranted}
* event. Note that unlike {grantRole}, this function doesn't perform any
* checks on the calling account.
*
* [WARNING]
* ====
* This function should only be called from the constructor when setting
* up the initial roles for the system.
*
* Using this function in any other way is effectively circumventing the admin
* system imposed by {AccessControl}.
* ====
*
* NOTE: This function is deprecated in favor of {_grantRole}.
*/
function _setupRole(bytes32 role, address account) internal virtual {
_grantRole(role, account);
}
/**
* @dev Sets `adminRole` as ``role``'s admin role.
*
* Emits a {RoleAdminChanged} event.
*/
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
bytes32 previousAdminRole = getRoleAdmin(role);
_roles[role].adminRole = adminRole;
emit RoleAdminChanged(role, previousAdminRole, adminRole);
}
/**
* @dev Grants `role` to `account`.
*
* Internal function without access restriction.
*/
function _grantRole(bytes32 role, address account) internal virtual {
if (!hasRole(role, account)) {
_roles[role].members[account] = true;
emit RoleGranted(role, account, _msgSender());
}
}
/**
* @dev Revokes `role` from `account`.
*
* Internal function without access restriction.
*/
function _revokeRole(bytes32 role, address account) internal virtual {
if (hasRole(role, account)) {
_roles[role].members[account] = false;
emit RoleRevoked(role, account, _msgSender());
}
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[49] private __gap;
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/structs/EnumerableSet.sol)
pragma solidity ^0.8.0;
/**
* @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.
*
* ```
* 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.
*/
library EnumerableSetUpgradeable {
// 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 of the value in the `values` array, plus 1 because index 0
// means a value is not in the set.
mapping(bytes32 => uint256) _indexes;
}
/**
* @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._indexes[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 read and store the value's index to prevent multiple reads from the same storage slot
uint256 valueIndex = set._indexes[value];
if (valueIndex != 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 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
if (lastIndex != toDeleteIndex) {
bytes32 lastvalue = set._values[lastIndex];
// Move the last value to the index where the value to delete is
set._values[toDeleteIndex] = lastvalue;
// Update the index for the moved value
set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex
}
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the index for the deleted slot
delete set._indexes[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._indexes[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) {
return _values(set._inner);
}
// 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 {
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 on 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 {
result := store
}
return result;
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Strings.sol)
pragma solidity ^0.8.0;
/**
* @dev String operations.
*/
library StringsUpgradeable {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
// Inspired by OraclizeAPI's implementation - MIT licence
// https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _HEX_SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
}{
"optimizer": {
"enabled": true,
"runs": 200
},
"outputSelection": {
"*": {
"*": [
"evm.bytecode",
"evm.deployedBytecode",
"devdoc",
"userdoc",
"metadata",
"abi"
]
}
},
"metadata": {
"useLiteralContent": true
},
"libraries": {}
}[{"inputs":[],"name":"Launchpeg__AllowlistBeforePreMint","type":"error"},{"inputs":[{"internalType":"uint256","name":"balanceOf","type":"uint256"}],"name":"Launchpeg__AmountExceedsBalance","type":"error"},{"inputs":[],"name":"Launchpeg__CanNotMintThisMany","type":"error"},{"inputs":[],"name":"Launchpeg__InvalidMaxPerAddressDuringMint","type":"error"},{"inputs":[],"name":"Launchpeg__InvalidOwner","type":"error"},{"inputs":[],"name":"Launchpeg__InvalidProjectOwner","type":"error"},{"inputs":[],"name":"Launchpeg__InvalidStartTime","type":"error"},{"inputs":[],"name":"Launchpeg__LargerCollectionSizeNeeded","type":"error"},{"inputs":[],"name":"Launchpeg__NotEligibleForAllowlistMint","type":"error"},{"inputs":[{"internalType":"uint256","name":"avaxSent","type":"uint256"}],"name":"Launchpeg__NotEnoughAVAX","type":"error"},{"inputs":[],"name":"Launchpeg__NotImplemented","type":"error"},{"inputs":[],"name":"Launchpeg__NotInitialized","type":"error"},{"inputs":[],"name":"Launchpeg__PublicSaleBeforeAllowlist","type":"error"},{"inputs":[],"name":"Launchpeg__PublicSaleEndBeforePublicSaleStart","type":"error"},{"inputs":[],"name":"Launchpeg__TokensAreNonTransferable","type":"error"},{"inputs":[],"name":"Launchpeg__TransferFailed","type":"error"},{"inputs":[],"name":"Launchpeg__WrongAddressesAndNumSlotsLength","type":"error"},{"inputs":[],"name":"Launchpeg__WrongPhase","type":"error"},{"inputs":[],"name":"Launchpeg__WrongStampNumber","type":"error"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"Launchpeg__ZeroTokenBalance","type":"error"},{"inputs":[],"name":"PendingOwnableUpgradeable__AddressZero","type":"error"},{"inputs":[],"name":"PendingOwnableUpgradeable__NoPendingOwner","type":"error"},{"inputs":[],"name":"PendingOwnableUpgradeable__NotOwner","type":"error"},{"inputs":[],"name":"PendingOwnableUpgradeable__NotPendingOwner","type":"error"},{"inputs":[],"name":"PendingOwnableUpgradeable__PendingOwnerAlreadySet","type":"error"},{"inputs":[],"name":"SafeAccessControlEnumerableUpgradeable__RoleIsDefaultAdmin","type":"error"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"sender","type":"address"}],"name":"SafeAccessControlEnumerableUpgradeable__SenderMissingRoleAndIsNotOwner","type":"error"},{"inputs":[],"name":"SafePausableUpgradeable__AlreadyPaused","type":"error"},{"inputs":[],"name":"SafePausableUpgradeable__AlreadyUnpaused","type":"error"},{"anonymous":false,"inputs":[],"name":"AllowlistModified","type":"event"},{"anonymous":false,"inputs":[],"name":"AllowlistSeeded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"allowlistStartTime","type":"uint256"}],"name":"AllowlistStartTimeSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"preMintStartTime","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"allowlistStartTime","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"publicSaleStartTime","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"publicSaleEndTime","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"allowlistPrice","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"salePrice","type":"uint256"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"quantity","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"price","type":"uint256"},{"indexed":false,"internalType":"enum IBaseLaunchpeg1155.Phase","name":"phase","type":"uint8"}],"name":"Mint","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"pendingOwner","type":"address"}],"name":"PendingOwnerSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"publicSaleEndTime","type":"uint256"}],"name":"PublicSaleEndTimeSet","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":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"indexed":false,"internalType":"uint256[]","name":"values","type":"uint256[]"}],"name":"TransferBatch","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"TransferSingle","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"transferable","type":"bool"}],"name":"TransferableChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"value","type":"string"},{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"}],"name":"URI","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"stateMutability":"nonpayable","type":"fallback"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PAUSER_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PAUSER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"UNPAUSER_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"UNPAUSER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"allowlist","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_quantity","type":"uint256"}],"name":"allowlistMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"allowlistPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"allowlistStartTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"amountMintedByDevs","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"amountMintedDuringAllowlist","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"accounts","type":"address[]"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"}],"name":"balanceOfBatch","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"becomeOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_id","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"currentPhase","outputs":[{"internalType":"enum IBaseLaunchpeg1155.Phase","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"exists","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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"},{"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":[{"components":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"address","name":"batchReveal","type":"address"},{"internalType":"uint256","name":"maxPerAddressDuringMint","type":"uint256"},{"internalType":"uint256","name":"collectionSize","type":"uint256"},{"internalType":"uint256","name":"amountForDevs","type":"uint256"},{"internalType":"uint256","name":"amountForAuction","type":"uint256"},{"internalType":"uint256","name":"amountForAllowlist","type":"uint256"}],"internalType":"struct IBaseLaunchpeg1155.CollectionData","name":"_collectionData","type":"tuple"},{"components":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"projectOwner","type":"address"},{"internalType":"address","name":"royaltyReceiver","type":"address"},{"internalType":"address","name":"joeFeeCollector","type":"address"},{"internalType":"uint256","name":"joeFeePercent","type":"uint256"}],"internalType":"struct IBaseLaunchpeg1155.CollectionOwnerData","name":"_ownerData","type":"tuple"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"_allowlistStartTime","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"_publicSaleEndTime","type":"uint256"},{"internalType":"uint256","name":"_allowlistPrice","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"initializePhases","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lens","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxPerAddressDuringMint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"numberMinted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"numberMintedWithPreMint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","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":"pendingOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"preMintStartTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"publicSaleEndTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"publicSaleStartTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"_addresses","type":"address[]"},{"internalType":"uint256[][]","name":"_stampIds","type":"uint256[][]"}],"name":"removeAllowlistSpots","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"revokePendingOwner","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":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeBatchTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"salePrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"_addresses","type":"address[]"},{"internalType":"uint256[][]","name":"_stampIds","type":"uint256[][]"}],"name":"seedAllowlist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_allowlistStartTime","type":"uint256"}],"name":"setAllowlistStartTime","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_lens","type":"address"}],"name":"setLensAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"pendingOwner_","type":"address"}],"name":"setPendingOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_publicSaleEndTime","type":"uint256"}],"name":"setPublicSaleEndTime","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_transferable","type":"bool"}],"name":"setTransferable","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_newURI","type":"string"}],"name":"setURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stampsAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"_interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"transferable","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"uri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdrawAVAXStartTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]