Sponsored
Сoins.game
100 free spins for registration. Spin now!
Everyday giveaways up to 100 ETH, Lucky Spins. Deposit BONUS 300% and Cashbacks!
BC.GAME
- The Best ETH Casino Claim Now!
5000+ Slots & Live Casino Games, 50+cryptos. Register with Etherscan and get 760% deposit bonus. Win Big$, withdraw it fast.
Sponsored
BC.GAME
- The Best ETH Casino Claim Now!
5000+ Slots & Live Casino Games, 50+cryptos. Register with Etherscan and get 760% deposit bonus. Win Big$, withdraw it fast.
CryptoWins
$5 Freebie + 137% Match up to 1 BTC Welcome Booster! Claim Now!
Dive into 100s of games and play anonymously with major cryptos. Join CryptoWins today!
CryptoSlots
Play & Get 25 Free Spins at CryptoSlots Play Now
Anonymous play on awesome games - sign up now for 25 free jackpot spins - worth $100s!
ERC-1155
Overview
Max Total Supply
10,000 xTAO
Holders
54
Market
Volume (24H)
N/A
Min Price (24H)
N/A
Max Price (24H)
N/A
Other Info
Token Contract
Loading...
Loading
Loading...
Loading
Loading...
Loading
| # | Exchange | Pair | Price | 24H Volume | % Volume |
|---|
Contract Source Code Verified (Exact Match)
Contract Name:
Token
Compiler Version
v0.8.24+commit.e11b9ed9
Optimization Enabled:
Yes with 200 runs
Other Settings:
shanghai EvmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: MIT
// BRAINTENSOR $xTAO powered by ERC-X NFT
// https://braintensor.gold
// https://t.me/braintensor
// https://x.com/braintensor
pragma solidity 0.8.24;
import {Address} from "@openzeppelin/contracts/utils/Address.sol";
import {Context} from "@openzeppelin/contracts/utils/Context.sol";
import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import {IERC20Errors} from "@openzeppelin/contracts/interfaces/draft-IERC6093.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import {IERC721Metadata} from "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol";
import {IERC721Receiver} from "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import {IERC1155} from "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import {IERC1155Receiver} from "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
import {IERC1155MetadataURI} from "@openzeppelin/contracts/token/ERC1155/extensions/IERC1155MetadataURI.sol";
import {IERC165, ERC165} from "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import {IERC721Errors} from "@openzeppelin/contracts/interfaces/draft-IERC6093.sol";
import {LibBitmap} from "./LibBitmap.sol";
import {LibBit} from "./LibBit.sol";
interface IERCX {
/**
* The caller must own the token or be an approved operator.
*/
error ApprovalCallerNotOwnerNorApproved();
/**
* Cannot query the balance for the zero address.
*/
error BalanceQueryForZeroAddress();
/**
* Cannot mint to the zero address.
*/
error MintToZeroAddress();
/**
* The quantity of tokens minted must be more than zero.
*/
error MintZeroQuantity();
/**
* Cannot burn from the zero address.
*/
error BurnFromZeroAddress();
/**
* Cannot burn from the address that doesn't owne the token.
*/
error BurnFromNonOwnerAddress();
/**
* The caller must own the token or be an approved operator.
*/
error TransferCallerNotOwnerNorApproved();
/**
* The token must be owned by `from` or the `amount` is not 1.
*/
error TransferFromIncorrectOwnerOrInvalidAmount();
/**
* Cannot safely transfer to a contract that does not implement the
* ERC1155Receiver interface.
*/
error TransferToNonERC1155ReceiverImplementer();
error TransferToNonERC721ReceiverImplementer();
/**
* Cannot transfer to the zero address.
*/
error TransferToZeroAddress();
/**
* The length of input arraies is not matching.
*/
error InputLengthMistmatch();
// Contract has been re-entered during safe transfer
error Reentrance();
function isOwnerOf(
address account,
uint256 id
) external view returns (bool);
}
abstract contract ERC721Receiver is IERC721Receiver {
function onERC721Received(
address,
address,
uint256,
bytes calldata
) external virtual returns (bytes4) {
return ERC721Receiver.onERC721Received.selector;
}
}
contract ERCX is
Context,
ERC165,
IERC1155,
IERC1155MetadataURI,
IERCX,
IERC20Metadata,
IERC20Errors,
Ownable
{
using Address for address;
using LibBitmap for LibBitmap.Bitmap;
error InvalidQueryRange();
event WhitelistEnabled(address indexed wallet);
event WhitelistDisabled(address indexed wallet);
event URIUpdated();
event TransfersDelayUpdated(bool status);
event MaxWalletUpdated(uint256 max);
// The mask of the lower 160 bits for addresses.
uint256 private constant _BITMASK_ADDRESS = (1 << 160) - 1;
// The `Transfer` event signature is given by:
// `keccak256(bytes("Transfer(address,address,uint256)"))`.
bytes32 private constant _TRANSFER_EVENT_SIGNATURE =
0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef;
// Mapping from accout to owned tokens
mapping(address => LibBitmap.Bitmap) internal _owned;
// 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;
// The next token ID to be minted.
uint256 private _currentIndex;
// NFT Approval
mapping(uint256 => address) public getApproved;
//Token balances
mapping(address => uint256) internal _balances;
//Token allowances
mapping(address account => mapping(address spender => uint256))
private _allowances;
// Token name
string public name;
// Token symbol
string public symbol;
// Decimals for supply
uint8 public immutable decimals;
// Total ERC20 supply
uint256 public immutable totalSupply;
// Tokens Per NFT
uint256 public immutable decimalFactor;
uint256 public immutable tokensPerNFT;
// Don't mint for these wallets
mapping(address => bool) public whitelist;
// Easy Launch - auto-whitelist first transfer which is probably the LP
uint256 public easyLaunch = 1;
/**
* @dev See {_setURI}.
*/
constructor(
string memory uri_,
string memory _name,
string memory _symbol,
uint8 _decimals,
uint256 _totalNativeSupply,
uint256 _tokensPerNFT
) Ownable(msg.sender) {
_setURI(uri_);
_currentIndex = _startTokenId();
name = _name;
symbol = _symbol;
decimals = _decimals;
decimalFactor = 10 ** decimals;
tokensPerNFT = _tokensPerNFT * decimalFactor;
totalSupply = _totalNativeSupply * decimalFactor;
whitelist[msg.sender] = true;
_balances[msg.sender] = totalSupply;
emit Transfer(address(0), msg.sender, totalSupply);
}
/** @notice Initialization function to set pairs / etc
* saving gas by avoiding mint / burn on unnecessary targets.
* Burns held NFTs if entering whitelist mode.
*/
function setWhitelist(address target, bool state) public virtual onlyOwner {
require(whitelist[target] != state, "No change to status");
if (state) {
uint256 bal = balanceOf(target, 0, _nextTokenId());
if (bal > 0) _burnBatch(target, bal);
emit WhitelistEnabled(target);
} else {
uint256 bal = balanceOf(target);
uint256 tokens_to_mint = bal / tokensPerNFT;
if (tokens_to_mint > 0) _mintWithoutCheck(target, tokens_to_mint);
emit WhitelistDisabled(target);
}
whitelist[target] = state;
}
/**
* @dev Returns the starting token ID.
* To change the starting token ID, please override this function.
*/
function _startTokenId() internal pure virtual returns (uint256) {
return 1;
}
/**
* @dev Returns the next token ID to be minted.
*/
function _nextTokenId() internal view returns (uint256) {
return _currentIndex;
}
/**
* @dev Returns the total amount of tokens minted in the contract.
*/
function _totalMinted() internal view returns (uint256) {
return _nextTokenId() - _startTokenId();
}
/**
* @dev Returns true if the account owns the `id` token.
*/
function isOwnerOf(
address account,
uint256 id
) public view virtual override returns (bool) {
return _owned[account].get(id);
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC1155).interfaceId ||
interfaceId == type(IERC1155MetadataURI).interfaceId ||
interfaceId == type(IERCX).interfaceId ||
interfaceId == 0x80ac58cd || // ERC165 interface ID for ERC721.
interfaceId == 0x5b5e139f || // ERC165 interface ID for ERC721Metadata.
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 Returns the number of tokens owned by `owner`.
*/
function balanceOf(address owner) public view virtual returns (uint256) {
return _balances[owner];
}
/**
* @dev Returns the number of nfts owned by `owner`,
* in the range [`start`, `stop`)
* (i.e. `start <= tokenId < stop`).
*
* Requirements:
*
* - `start < stop`
*/
function balanceOf(
address owner,
uint256 start,
uint256 stop
) public view virtual returns (uint256) {
return _owned[owner].popCount(start, stop - start);
}
/**
* @dev See {IERC1155-balanceOf}.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
function balanceOf(
address account,
uint256 id
) public view virtual override returns (uint256) {
if (account == address(0)) {
revert BalanceQueryForZeroAddress();
}
if (_owned[account].get(id)) {
return 1;
} else {
return 0;
}
}
/**
* @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) {
if (accounts.length != ids.length) {
revert InputLengthMistmatch();
}
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 {
if (from == _msgSender() || isApprovedForAll(from, _msgSender())) {
_safeTransferFrom(from, to, id, amount, data, true);
} else {
revert TransferCallerNotOwnerNorApproved();
}
}
/**
* @dev See {IERC1155-safeBatchTransferFrom}.
*/
function safeBatchTransferFrom(
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) public virtual override {
if (!(from == _msgSender() || isApprovedForAll(from, _msgSender()))) {
revert TransferCallerNotOwnerNorApproved();
}
_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.
* - `amount` cannot be zero.
* - `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,
bool check
) internal virtual {
if (to == address(0)) {
revert TransferToZeroAddress();
}
address operator = _msgSender();
uint256[] memory ids = _asSingletonArray(id);
_beforeTokenTransfer(operator, from, to, ids);
if (amount == 1 && _owned[from].get(id)) {
_owned[from].unset(id);
_owned[to].set(id);
_transfer(from, to, tokensPerNFT, false);
} else {
revert TransferFromIncorrectOwnerOrInvalidAmount();
}
uint256 toMasked;
uint256 fromMasked;
assembly {
// Mask `to` to the lower 160 bits, in case the upper bits somehow aren't clean.
toMasked := and(to, _BITMASK_ADDRESS)
fromMasked := and(from, _BITMASK_ADDRESS)
// Emit the `Transfer` event.
log4(
0, // Start of data (0, since no data).
0, // End of data (0, since no data).
_TRANSFER_EVENT_SIGNATURE, // Signature.
fromMasked, // `from`.
toMasked, // `to`.
amount // `tokenId`.
)
}
emit TransferSingle(operator, from, to, id, amount);
_afterTokenTransfer(operator, from, to, ids);
if (check) {
uint256 end = _nextTokenId();
_doSafeTransferAcceptanceCheck(
operator,
from,
to,
id,
amount,
data
);
if (_nextTokenId() != end) revert Reentrance();
}
}
/**
* @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 {
if (ids.length != amounts.length) {
revert InputLengthMistmatch();
}
if (to == address(0)) {
revert TransferToZeroAddress();
}
address operator = _msgSender();
_beforeTokenTransfer(operator, from, to, ids);
for (uint256 i = 0; i < ids.length; ++i) {
uint256 id = ids[i];
uint256 amount = amounts[i];
if (amount == 1 && _owned[from].get(id)) {
_owned[from].unset(id);
_owned[to].set(id);
} else {
revert TransferFromIncorrectOwnerOrInvalidAmount();
}
}
_transfer(from, to, tokensPerNFT * ids.length, false);
uint256 toMasked;
uint256 fromMasked;
uint256 end = ids.length + 1;
// Use assembly to loop and emit the `Transfer` event for gas savings.
// The duplicated `log4` removes an extra check and reduces stack juggling.
// The assembly, together with the surrounding Solidity code, have been
// delicately arranged to nudge the compiler into producing optimized opcodes.
assembly {
// Mask `to` to the lower 160 bits, in case the upper bits somehow aren't clean.
fromMasked := and(from, _BITMASK_ADDRESS)
toMasked := and(to, _BITMASK_ADDRESS)
// Emit the `Transfer` event.
log4(
0, // Start of data (0, since no data).
0, // End of data (0, since no data).
_TRANSFER_EVENT_SIGNATURE, // Signature.
fromMasked, // `from`.
toMasked, // `to`.
mload(add(ids, 0x20)) // `tokenId`.
)
// The `iszero(eq(,))` check ensures that large values of `quantity`
// that overflows uint256 will make the loop run out of gas.
// The compiler will optimize the `iszero` away for performance.
for {
let arrayId := 2
} iszero(eq(arrayId, end)) {
arrayId := add(arrayId, 1)
} {
// Emit the `Transfer` event. Similar to above.
log4(
0,
0,
_TRANSFER_EVENT_SIGNATURE,
fromMasked,
toMasked,
mload(add(ids, mul(0x20, arrayId)))
)
}
}
emit TransferBatch(operator, from, to, ids, amounts);
_afterTokenTransfer(operator, from, to, ids);
uint256 tokID = _nextTokenId();
_doSafeBatchTransferAcceptanceCheck(
operator,
from,
to,
ids,
amounts,
data
);
if (_nextTokenId() != tokID) revert Reentrance();
}
/**
* @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, and assigns them to `to`.
*
* Emits a {TransferBatch} event.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `amount` cannot be zero.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
* acceptance magic value.
*/
function _mint(
address to,
uint256 amount,
bytes memory data
) internal virtual {
(uint256[] memory ids, uint256[] memory amounts) = _mintWithoutCheck(
to,
amount
);
uint256 end = _nextTokenId();
_doSafeBatchTransferAcceptanceCheck(
_msgSender(),
address(0),
to,
ids,
amounts,
data
);
if (_nextTokenId() != end) revert Reentrance();
}
function _mintWithoutCheck(
address to,
uint256 amount
)
internal
virtual
returns (uint256[] memory ids, uint256[] memory amounts)
{
if (to == address(0)) {
revert MintToZeroAddress();
}
if (amount == 0) {
revert MintZeroQuantity();
}
address operator = _msgSender();
ids = new uint256[](amount);
amounts = new uint256[](amount);
uint256 startTokenId = _nextTokenId();
unchecked {
require(
type(uint256).max - amount >= startTokenId,
"Minting limits reached"
);
for (uint256 i = 0; i < amount; i++) {
ids[i] = startTokenId + i;
amounts[i] = 1;
}
}
_beforeTokenTransfer(operator, address(0), to, ids);
_owned[to].setBatch(startTokenId, amount);
_currentIndex += amount;
uint256 toMasked;
uint256 end = startTokenId + amount;
assembly {
toMasked := and(to, _BITMASK_ADDRESS)
log4(0, 0, _TRANSFER_EVENT_SIGNATURE, 0, toMasked, startTokenId)
for {
let tokenId := add(startTokenId, 1)
} iszero(eq(tokenId, end)) {
tokenId := add(tokenId, 1)
} {
log4(0, 0, _TRANSFER_EVENT_SIGNATURE, 0, toMasked, tokenId)
}
}
emit TransferBatch(operator, address(0), to, ids, amounts);
_afterTokenTransfer(operator, address(0), to, ids);
}
/**
* @dev Destroys token of token type `id` from `from`
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `from` must have the token of token type `id`.
*/
function _burn(address from, uint256 id) internal virtual {
if (from == address(0)) {
revert BurnFromZeroAddress();
}
address operator = _msgSender();
uint256[] memory ids = _asSingletonArray(id);
_beforeTokenTransfer(operator, from, address(0), ids);
if (!_owned[from].get(id)) {
revert BurnFromNonOwnerAddress();
}
_owned[from].unset(id);
uint256 fromMasked;
assembly {
fromMasked := and(from, _BITMASK_ADDRESS)
log4(0, 0, _TRANSFER_EVENT_SIGNATURE, fromMasked, 0, id)
}
emit TransferSingle(operator, from, address(0), id, 1);
_afterTokenTransfer(operator, from, address(0), ids);
}
/**
* @dev Destroys tokens of token types in `ids` from `from`
*
* Emits a {TransferBatch} event.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `from` must have the token of token types in `ids`.
*/
function _burnBatch(address from, uint256[] memory ids) internal virtual {
if (from == address(0)) {
revert BurnFromZeroAddress();
}
address operator = _msgSender();
uint256[] memory amounts = new uint256[](ids.length);
_beforeTokenTransfer(operator, from, address(0), ids);
unchecked {
for (uint256 i = 0; i < ids.length; i++) {
amounts[i] = 1;
uint256 id = ids[i];
if (!_owned[from].get(id)) {
revert BurnFromNonOwnerAddress();
}
_owned[from].unset(id);
}
}
uint256 fromMasked;
uint256 end = ids.length + 1;
assembly {
fromMasked := and(from, _BITMASK_ADDRESS)
log4(
0,
0,
_TRANSFER_EVENT_SIGNATURE,
fromMasked,
0,
mload(add(ids, 0x20))
)
for {
let arrayId := 2
} iszero(eq(arrayId, end)) {
arrayId := add(arrayId, 1)
} {
log4(
0,
0,
_TRANSFER_EVENT_SIGNATURE,
fromMasked,
0,
mload(add(ids, mul(0x20, arrayId)))
)
}
}
emit TransferBatch(operator, from, address(0), ids, amounts);
_afterTokenTransfer(operator, from, address(0), ids);
}
function _burnBatch(address from, uint256 amount) internal virtual {
if (from == address(0)) {
revert BurnFromZeroAddress();
}
address operator = _msgSender();
uint256 searchFrom = _nextTokenId();
uint256[] memory amounts = new uint256[](amount);
uint256[] memory ids = new uint256[](amount);
unchecked {
for (uint256 i = 0; i < amount; i++) {
amounts[i] = 1;
uint256 id = _owned[from].findLastSet(searchFrom);
if (id == LibBitmap.NOT_FOUND) revert BurnFromNonOwnerAddress();
ids[i] = id;
_owned[from].unset(id);
searchFrom = id;
}
}
//technically after, but we didn't have the IDs then
_beforeTokenTransfer(operator, from, address(0), ids);
uint256 fromMasked;
uint256 end = amount + 1;
assembly {
fromMasked := and(from, _BITMASK_ADDRESS)
log4(
0,
0,
_TRANSFER_EVENT_SIGNATURE,
fromMasked,
0,
mload(add(ids, 0x20))
)
for {
let arrayId := 2
} iszero(eq(arrayId, end)) {
arrayId := add(arrayId, 1)
} {
log4(
0,
0,
_TRANSFER_EVENT_SIGNATURE,
fromMasked,
0,
mload(add(ids, mul(0x20, arrayId)))
)
}
}
if (amount == 1)
emit TransferSingle(operator, from, address(0), ids[0], 1);
else emit TransferBatch(operator, from, address(0), ids, amounts);
_afterTokenTransfer(operator, from, address(0), ids);
}
/**
* @dev Approve `operator` to operate on all of `owner` tokens
*
* Emits an {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 `ids` and `amounts` 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
) internal virtual {}
/**
* @dev Hook that is called after 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 _afterTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids
) internal virtual {}
function _doSafeTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256 id,
uint256 amount,
bytes memory data
) private {
if (to.code.length > 0) {
if (IERC165(to).supportsInterface(type(IERC1155).interfaceId)) {
try
IERC1155Receiver(to).onERC1155Received(
operator,
from,
id,
amount,
data
)
returns (bytes4 response) {
if (
response != IERC1155Receiver.onERC1155Received.selector
) {
revert TransferToNonERC1155ReceiverImplementer();
}
} catch Error(string memory reason) {
revert(reason);
} catch {
revert TransferToNonERC1155ReceiverImplementer();
}
} else {
try
ERC721Receiver(to).onERC721Received(
operator,
from,
id,
data
)
returns (bytes4 response) {
if (response != ERC721Receiver.onERC721Received.selector) {
revert TransferToNonERC721ReceiverImplementer();
}
} catch Error(string memory reason) {
revert(reason);
} catch {
revert TransferToNonERC721ReceiverImplementer();
}
}
}
}
function _doSafeBatchTransferAcceptanceCheck(
address operator,
address from,
address to,
uint256[] memory ids,
uint256[] memory amounts,
bytes memory data
) private {
if (to.code.length > 0) {
try
IERC1155Receiver(to).onERC1155BatchReceived(
operator,
from,
ids,
amounts,
data
)
returns (bytes4 response) {
if (
response != IERC1155Receiver.onERC1155BatchReceived.selector
) {
revert TransferToNonERC1155ReceiverImplementer();
}
} catch Error(string memory reason) {
revert(reason);
} catch {
revert TransferToNonERC1155ReceiverImplementer();
}
}
}
function _asSingletonArray(
uint256 element
) private pure returns (uint256[] memory array) {
array = new uint256[](1);
array[0] = element;
}
function transfer(address to, uint256 value) public virtual returns (bool) {
address owner = msg.sender;
_transfer(owner, to, value, true);
return true;
}
function allowance(
address owner,
address spender
) public view virtual returns (uint256) {
return _allowances[owner][spender];
}
function approve(
address spender,
uint256 value
) public virtual returns (bool) {
address owner = msg.sender;
if (value < _nextTokenId() && value > 0) {
if (!isOwnerOf(owner, value)) {
revert ERC20InvalidSender(owner);
}
getApproved[value] = spender;
emit Approval(owner, spender, value);
} else {
_approve(owner, spender, value);
}
return true;
}
/// @notice Function for mixed transfers
/// @dev This function assumes id / native if amount less than or equal to current max id
function transferFrom(
address from,
address to,
uint256 value
) public virtual returns (bool) {
if (value < _nextTokenId()) {
if (!_owned[from].get(value)) {
revert ERC20InvalidSpender(from);
}
if (
msg.sender != from &&
!isApprovedForAll(from, msg.sender) &&
msg.sender != getApproved[value]
) {
revert ERC20InvalidSpender(msg.sender);
}
delete getApproved[value];
_safeTransferFrom(from, to, value, 1, "", false);
} else {
_spendAllowance(from, msg.sender, value);
_transfer(from, to, value, true);
}
return true;
}
function _transfer(
address from,
address to,
uint256 value,
bool mint
) internal {
if (from == address(0)) {
revert ERC20InvalidSender(address(0));
}
if (to == address(0)) {
revert ERC20InvalidReceiver(address(0));
}
_update(from, to, value, mint);
}
function _update(
address from,
address to,
uint256 value,
bool mint
) internal virtual {
uint256 fromBalance = _balances[from];
uint256 toBalance = _balances[to];
if (fromBalance < value) {
revert ERC20InsufficientBalance(from, fromBalance, value);
}
//No need to adjust balances when transfer is to self, prevent self NFT-grind
if (from != to) {
unchecked {
// Overflow not possible: value <= fromBalance <= totalSupply.
_balances[from] = fromBalance - value;
// Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.
_balances[to] = toBalance + value;
}
if (mint) {
// Skip burn for certain addresses to save gas
bool wlf = whitelist[from];
if (!wlf) {
uint256 tokens_to_burn = (fromBalance / tokensPerNFT) -
((fromBalance - value) / tokensPerNFT);
if (tokens_to_burn > 0) _burnBatch(from, tokens_to_burn);
}
// Skip minting for certain addresses to save gas
if (!whitelist[to]) {
if (easyLaunch == 1 && wlf && from == owner()) {
//auto-initialize first (assumed) LP
whitelist[to] = true;
easyLaunch = 2;
} else {
uint256 tokens_to_mint = ((toBalance + value) /
tokensPerNFT) - (toBalance / tokensPerNFT);
if (tokens_to_mint > 0)
_mintWithoutCheck(to, tokens_to_mint);
}
}
}
}
emit Transfer(from, to, value);
}
function _approve(address owner, address spender, uint256 value) internal {
_approve(owner, spender, value, true);
}
function _approve(
address owner,
address spender,
uint256 value,
bool emitEvent
) internal virtual {
if (owner == address(0)) {
revert ERC20InvalidApprover(address(0));
}
if (spender == address(0)) {
revert ERC20InvalidSpender(address(0));
}
_allowances[owner][spender] = value;
if (emitEvent) {
emit Approval(owner, spender, value);
}
}
function _spendAllowance(
address owner,
address spender,
uint256 value
) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
if (currentAllowance < value) {
revert ERC20InsufficientAllowance(
spender,
currentAllowance,
value
);
}
unchecked {
_approve(owner, spender, currentAllowance - value, false);
}
}
}
/**
* @dev Returns an array of token IDs owned by `owner`,
* in the range [`start`, `stop`)
* (i.e. `start <= tokenId < stop`).
*
* This function allows for tokens to be queried if the collection
* grows too big for a single call of {ERC1155DelataQueryable-tokensOfOwner}.
*
* Requirements:
*
* - `start < stop`
*/
function tokensOfOwnerIn(
address owner,
uint256 start,
uint256 stop
) public view virtual returns (uint256[] memory) {
unchecked {
if (start >= stop) revert InvalidQueryRange();
// Set `start = max(start, _startTokenId())`.
if (start < _startTokenId()) {
start = _startTokenId();
}
// Set `stop = min(stop, stopLimit)`.
uint256 stopLimit = _nextTokenId();
if (stop > stopLimit) {
stop = stopLimit;
}
uint256 tokenIdsLength;
if (start < stop) {
tokenIdsLength = balanceOf(owner, start, stop);
} else {
tokenIdsLength = 0;
}
uint256[] memory tokenIds = new uint256[](tokenIdsLength);
LibBitmap.Bitmap storage bmap = _owned[owner];
for (
(uint256 i, uint256 tokenIdsIdx) = (start, 0);
tokenIdsIdx != tokenIdsLength;
++i
) {
if (bmap.get(i)) {
tokenIds[tokenIdsIdx++] = i;
}
}
return tokenIds;
}
}
/**
* @dev Returns an array of token IDs owned by `owner`.
*
* This function scans the ownership mapping and is O(`totalSupply`) in complexity.
* It is meant to be called off-chain.
*
* See {ERC1155DeltaQueryable-tokensOfOwnerIn} for splitting the scan into
* multiple smaller scans if the collection is large enough to cause
* an out-of-gas error (10K collections should be fine).
*/
function tokensOfOwner(
address owner
) public view virtual returns (uint256[] memory) {
if (_totalMinted() == 0) {
return new uint256[](0);
}
return tokensOfOwnerIn(owner, _startTokenId(), _nextTokenId());
}
}
contract Token is ERCX {
using Strings for uint256;
string public dataURI;
string public baseTokenURI;
uint8 private constant _decimals = 18;
uint256 private constant _totalTokens = 10000;
uint256 private constant _tokensPerNFT = 1;
string private constant _name = "BRAINTENSOR";
string private constant _ticker = "xTAO";
// Snipe reduction tools
uint256 public maxWallet;
bool public transferDelay = false;
mapping(address => uint256) private delayTimer;
constructor()
ERCX("", _name, _ticker, _decimals, _totalTokens, _tokensPerNFT)
{
dataURI = "https://i.imgur.com/";
maxWallet = ((_totalTokens * 10 ** _decimals) * 2) / 100;
}
function _afterTokenTransfer(
address operator,
address from,
address to,
uint256[] memory ids
) internal override {
if (!whitelist[to]) {
require(
_balances[to] <= maxWallet,
"Transfer exceeds maximum wallet"
);
if (transferDelay) {
require(
delayTimer[tx.origin] < block.number,
"Only one transfer per block allowed."
);
delayTimer[tx.origin] = block.number;
require(
address(to).code.length == 0 &&
address(tx.origin).code.length == 0,
"Contract trading restricted at launch"
);
}
}
super._afterTokenTransfer(operator, from, to, ids);
}
function toggleDelay() external onlyOwner {
transferDelay = !transferDelay;
emit TransfersDelayUpdated(transferDelay);
}
function setMaxWallet(uint256 percent) external onlyOwner {
require(percent > 0, "Cannot disable normal trading");
maxWallet = (totalSupply * percent) / 100;
emit MaxWalletUpdated((totalSupply * percent) / 100);
}
function setDataURI(string memory _dataURI) public onlyOwner {
dataURI = _dataURI;
emit URIUpdated();
}
function setTokenURI(string memory _tokenURI) public onlyOwner {
baseTokenURI = _tokenURI;
emit URIUpdated();
}
function setURI(string memory newuri) external onlyOwner {
_setURI(newuri);
emit URIUpdated();
}
function tokenURI(uint256 id) public view returns (string memory) {
if (id >= _nextTokenId()) revert InputLengthMistmatch();
if (bytes(super.uri(id)).length > 0) return super.uri(id);
if (bytes(baseTokenURI).length > 0)
return string(abi.encodePacked(baseTokenURI, id.toString()));
else {
uint8 seed = uint8(bytes1(keccak256(abi.encodePacked(id))));
string memory image = "";
string memory rarity = "";
string memory description = "";
if (seed < 10) {
image = "rgZAHS8.jpeg";
rarity = "Gold Brain";
description = "GOLD BRAIN! Only 400~ NFT will have this rarity. If you are TAO fan, you need to get it.";
} else if (seed < 25) {
image = "dHNuimB.jpeg";
rarity = "Rare Brain";
description = "Rare Brain, Bittensor will unlock utility for this NFT.";
} else if (seed < 109) {
image = "pyqExcJ.jpeg";
rarity = "Uncommon Brain";
description = "Uncommon Brain, one of subnets unlocking utility for this NFT.";
} else {
image = "3gndeNE.jpeg";
rarity = "Common Brain";
description = "Just an common brain.";
}
string memory jsonPreImage = string(
abi.encodePacked(
'{"name": "dddd #',
id.toString(),
'","description":"',
description,
'","external_url":"https://braintensor.gold","image":"',
dataURI,
image
)
);
return
string(
abi.encodePacked(
"data:application/json;utf8,",
jsonPreImage,
'","attributes":[{"trait_type":"Rarity","value":"',
rarity,
'"}]}'
)
);
}
}
function uri(uint256 id) public view override returns (string memory) {
return tokenURI(id);
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import {LibBit} from "./LibBit.sol";
/// @notice Library for storage of packed unsigned booleans.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/LibBitmap.sol)
/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/LibBitmap.sol)
/// @author Modified from Solidity-Bits (https://github.com/estarriolvetch/solidity-bits/blob/main/contracts/BitMaps.sol)
library LibBitmap {
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* CONSTANTS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @dev The constant returned when a bitmap scan does not find a result.
uint256 internal constant NOT_FOUND = type(uint256).max;
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* STRUCTS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @dev A bitmap in storage.
struct Bitmap {
mapping(uint256 => uint256) map;
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* OPERATIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @dev Returns the boolean value of the bit at `index` in `bitmap`.
function get(Bitmap storage bitmap, uint256 index) internal view returns (bool isSet) {
// It is better to set `isSet` to either 0 or 1, than zero vs non-zero.
// Both cost the same amount of gas, but the former allows the returned value
// to be reused without cleaning the upper bits.
uint256 b = (bitmap.map[index >> 8] >> (index & 0xff)) & 1;
/// @solidity memory-safe-assembly
assembly {
isSet := b
}
}
/// @dev Updates the bit at `index` in `bitmap` to true.
function set(Bitmap storage bitmap, uint256 index) internal {
bitmap.map[index >> 8] |= (1 << (index & 0xff));
}
/// @dev Updates the bit at `index` in `bitmap` to false.
function unset(Bitmap storage bitmap, uint256 index) internal {
bitmap.map[index >> 8] &= ~(1 << (index & 0xff));
}
/// @dev Flips the bit at `index` in `bitmap`.
/// Returns the boolean result of the flipped bit.
function toggle(Bitmap storage bitmap, uint256 index) internal returns (bool newIsSet) {
/// @solidity memory-safe-assembly
assembly {
mstore(0x20, bitmap.slot)
mstore(0x00, shr(8, index))
let storageSlot := keccak256(0x00, 0x40)
let shift := and(index, 0xff)
let storageValue := xor(sload(storageSlot), shl(shift, 1))
// It makes sense to return the `newIsSet`,
// as it allow us to skip an additional warm `sload`,
// and it costs minimal gas (about 15),
// which may be optimized away if the returned value is unused.
newIsSet := and(1, shr(shift, storageValue))
sstore(storageSlot, storageValue)
}
}
/// @dev Updates the bit at `index` in `bitmap` to `shouldSet`.
function setTo(Bitmap storage bitmap, uint256 index, bool shouldSet) internal {
/// @solidity memory-safe-assembly
assembly {
mstore(0x20, bitmap.slot)
mstore(0x00, shr(8, index))
let storageSlot := keccak256(0x00, 0x40)
let storageValue := sload(storageSlot)
let shift := and(index, 0xff)
sstore(
storageSlot,
// Unsets the bit at `shift` via `and`, then sets its new value via `or`.
or(and(storageValue, not(shl(shift, 1))), shl(shift, iszero(iszero(shouldSet))))
)
}
}
/// @dev Consecutively sets `amount` of bits starting from the bit at `start`.
function setBatch(Bitmap storage bitmap, uint256 start, uint256 amount) internal {
/// @solidity memory-safe-assembly
assembly {
let max := not(0)
let shift := and(start, 0xff)
mstore(0x20, bitmap.slot)
mstore(0x00, shr(8, start))
if iszero(lt(add(shift, amount), 257)) {
let storageSlot := keccak256(0x00, 0x40)
sstore(storageSlot, or(sload(storageSlot), shl(shift, max)))
let bucket := add(mload(0x00), 1)
let bucketEnd := add(mload(0x00), shr(8, add(amount, shift)))
amount := and(add(amount, shift), 0xff)
shift := 0
for {} iszero(eq(bucket, bucketEnd)) { bucket := add(bucket, 1) } {
mstore(0x00, bucket)
sstore(keccak256(0x00, 0x40), max)
}
mstore(0x00, bucket)
}
let storageSlot := keccak256(0x00, 0x40)
sstore(storageSlot, or(sload(storageSlot), shl(shift, shr(sub(256, amount), max))))
}
}
/// @dev Consecutively unsets `amount` of bits starting from the bit at `start`.
function unsetBatch(Bitmap storage bitmap, uint256 start, uint256 amount) internal {
/// @solidity memory-safe-assembly
assembly {
let shift := and(start, 0xff)
mstore(0x20, bitmap.slot)
mstore(0x00, shr(8, start))
if iszero(lt(add(shift, amount), 257)) {
let storageSlot := keccak256(0x00, 0x40)
sstore(storageSlot, and(sload(storageSlot), not(shl(shift, not(0)))))
let bucket := add(mload(0x00), 1)
let bucketEnd := add(mload(0x00), shr(8, add(amount, shift)))
amount := and(add(amount, shift), 0xff)
shift := 0
for {} iszero(eq(bucket, bucketEnd)) { bucket := add(bucket, 1) } {
mstore(0x00, bucket)
sstore(keccak256(0x00, 0x40), 0)
}
mstore(0x00, bucket)
}
let storageSlot := keccak256(0x00, 0x40)
sstore(
storageSlot, and(sload(storageSlot), not(shl(shift, shr(sub(256, amount), not(0)))))
)
}
}
/// @dev Returns number of set bits within a range by
/// scanning `amount` of bits starting from the bit at `start`.
function popCount(Bitmap storage bitmap, uint256 start, uint256 amount)
internal
view
returns (uint256 count)
{
unchecked {
uint256 bucket = start >> 8;
uint256 shift = start & 0xff;
if (!(amount + shift < 257)) {
count = LibBit.popCount(bitmap.map[bucket] >> shift);
uint256 bucketEnd = bucket + ((amount + shift) >> 8);
amount = (amount + shift) & 0xff;
shift = 0;
for (++bucket; bucket != bucketEnd; ++bucket) {
count += LibBit.popCount(bitmap.map[bucket]);
}
}
count += LibBit.popCount((bitmap.map[bucket] >> shift) << (256 - amount));
}
}
/// @dev Returns the index of the most significant set bit before the bit at `before`.
/// If no set bit is found, returns `NOT_FOUND`.
function findLastSet(Bitmap storage bitmap, uint256 before)
internal
view
returns (uint256 setBitIndex)
{
uint256 bucket;
uint256 bucketBits;
/// @solidity memory-safe-assembly
assembly {
setBitIndex := not(0)
bucket := shr(8, before)
mstore(0x00, bucket)
mstore(0x20, bitmap.slot)
let offset := and(0xff, not(before)) // `256 - (255 & before) - 1`.
bucketBits := shr(offset, shl(offset, sload(keccak256(0x00, 0x40))))
if iszero(or(bucketBits, iszero(bucket))) {
for {} 1 {} {
bucket := add(bucket, setBitIndex) // `sub(bucket, 1)`.
mstore(0x00, bucket)
bucketBits := sload(keccak256(0x00, 0x40))
if or(bucketBits, iszero(bucket)) { break }
}
}
}
if (bucketBits != 0) {
setBitIndex = (bucket << 8) | LibBit.fls(bucketBits);
/// @solidity memory-safe-assembly
assembly {
setBitIndex := or(setBitIndex, sub(0, gt(setBitIndex, before)))
}
}
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
/// @notice Library for bit twiddling and boolean operations.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/LibBit.sol)
/// @author Inspired by (https://graphics.stanford.edu/~seander/bithacks.html)
library LibBit {
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* BIT TWIDDLING OPERATIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @dev Find last set.
/// Returns the index of the most significant bit of `x`,
/// counting from the least significant bit position.
/// If `x` is zero, returns 256.
function fls(uint256 x) internal pure returns (uint256 r) {
/// @solidity memory-safe-assembly
assembly {
r := or(shl(8, iszero(x)), shl(7, lt(0xffffffffffffffffffffffffffffffff, x)))
r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, x))))
r := or(r, shl(5, lt(0xffffffff, shr(r, x))))
r := or(r, shl(4, lt(0xffff, shr(r, x))))
r := or(r, shl(3, lt(0xff, shr(r, x))))
// forgefmt: disable-next-item
r := or(r, byte(and(0x1f, shr(shr(r, x), 0x8421084210842108cc6318c6db6d54be)),
0x0706060506020504060203020504030106050205030304010505030400000000))
}
}
/// @dev Count leading zeros.
/// Returns the number of zeros preceding the most significant one bit.
/// If `x` is zero, returns 256.
function clz(uint256 x) internal pure returns (uint256 r) {
/// @solidity memory-safe-assembly
assembly {
r := shl(7, lt(0xffffffffffffffffffffffffffffffff, x))
r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, x))))
r := or(r, shl(5, lt(0xffffffff, shr(r, x))))
r := or(r, shl(4, lt(0xffff, shr(r, x))))
r := or(r, shl(3, lt(0xff, shr(r, x))))
// forgefmt: disable-next-item
r := add(xor(r, byte(and(0x1f, shr(shr(r, x), 0x8421084210842108cc6318c6db6d54be)),
0xf8f9f9faf9fdfafbf9fdfcfdfafbfcfef9fafdfafcfcfbfefafafcfbffffffff)), iszero(x))
}
}
/// @dev Find first set.
/// Returns the index of the least significant bit of `x`,
/// counting from the least significant bit position.
/// If `x` is zero, returns 256.
/// Equivalent to `ctz` (count trailing zeros), which gives
/// the number of zeros following the least significant one bit.
function ffs(uint256 x) internal pure returns (uint256 r) {
/// @solidity memory-safe-assembly
assembly {
// Isolate the least significant bit.
let b := and(x, add(not(x), 1))
r := or(shl(8, iszero(x)), shl(7, lt(0xffffffffffffffffffffffffffffffff, b)))
r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, b))))
r := or(r, shl(5, lt(0xffffffff, shr(r, b))))
// For the remaining 32 bits, use a De Bruijn lookup.
// forgefmt: disable-next-item
r := or(r, byte(and(div(0xd76453e0, shr(r, b)), 0x1f),
0x001f0d1e100c1d070f090b19131c1706010e11080a1a141802121b1503160405))
}
}
/// @dev Returns the number of set bits in `x`.
function popCount(uint256 x) internal pure returns (uint256 c) {
/// @solidity memory-safe-assembly
assembly {
let max := not(0)
let isMax := eq(x, max)
x := sub(x, and(shr(1, x), div(max, 3)))
x := add(and(x, div(max, 5)), and(shr(2, x), div(max, 5)))
x := and(add(x, shr(4, x)), div(max, 17))
c := or(shl(8, isMax), shr(248, mul(x, div(max, 255))))
}
}
/// @dev Returns whether `x` is a power of 2.
function isPo2(uint256 x) internal pure returns (bool result) {
/// @solidity memory-safe-assembly
assembly {
// Equivalent to `x && !(x & (x - 1))`.
result := iszero(add(and(x, sub(x, 1)), iszero(x)))
}
}
/// @dev Returns `x` reversed at the bit level.
function reverseBits(uint256 x) internal pure returns (uint256 r) {
uint256 m0 = 0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f;
uint256 m1 = m0 ^ (m0 << 2);
uint256 m2 = m1 ^ (m1 << 1);
r = reverseBytes(x);
r = (m2 & (r >> 1)) | ((m2 & r) << 1);
r = (m1 & (r >> 2)) | ((m1 & r) << 2);
r = (m0 & (r >> 4)) | ((m0 & r) << 4);
}
/// @dev Returns `x` reversed at the byte level.
function reverseBytes(uint256 x) internal pure returns (uint256 r) {
unchecked {
// Computing masks on-the-fly reduces bytecode size by about 200 bytes.
uint256 m0 = 0x100000000000000000000000000000001 * (~toUint(x == 0) >> 192);
uint256 m1 = m0 ^ (m0 << 32);
uint256 m2 = m1 ^ (m1 << 16);
uint256 m3 = m2 ^ (m2 << 8);
r = (m3 & (x >> 8)) | ((m3 & x) << 8);
r = (m2 & (r >> 16)) | ((m2 & r) << 16);
r = (m1 & (r >> 32)) | ((m1 & r) << 32);
r = (m0 & (r >> 64)) | ((m0 & r) << 64);
r = (r >> 128) | (r << 128);
}
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* BOOLEAN OPERATIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
// A Solidity bool on the stack or memory is represented as a 256-bit word.
// Non-zero values are true, zero is false.
// A clean bool is either 0 (false) or 1 (true) under the hood.
// Usually, if not always, the bool result of a regular Solidity expression,
// or the argument of a public/external function will be a clean bool.
// You can usually use the raw variants for more performance.
// If uncertain, test (best with exact compiler settings).
// Or use the non-raw variants (compiler can sometimes optimize out the double `iszero`s).
/// @dev Returns `x & y`. Inputs must be clean.
function rawAnd(bool x, bool y) internal pure returns (bool z) {
/// @solidity memory-safe-assembly
assembly {
z := and(x, y)
}
}
/// @dev Returns `x & y`.
function and(bool x, bool y) internal pure returns (bool z) {
/// @solidity memory-safe-assembly
assembly {
z := and(iszero(iszero(x)), iszero(iszero(y)))
}
}
/// @dev Returns `x | y`. Inputs must be clean.
function rawOr(bool x, bool y) internal pure returns (bool z) {
/// @solidity memory-safe-assembly
assembly {
z := or(x, y)
}
}
/// @dev Returns `x | y`.
function or(bool x, bool y) internal pure returns (bool z) {
/// @solidity memory-safe-assembly
assembly {
z := or(iszero(iszero(x)), iszero(iszero(y)))
}
}
/// @dev Returns 1 if `b` is true, else 0. Input must be clean.
function rawToUint(bool b) internal pure returns (uint256 z) {
/// @solidity memory-safe-assembly
assembly {
z := b
}
}
/// @dev Returns 1 if `b` is true, else 0.
function toUint(bool b) internal pure returns (uint256 z) {
/// @solidity memory-safe-assembly
assembly {
z := iszero(iszero(b))
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SignedMath.sol)
pragma solidity ^0.8.20;
/**
* @dev Standard signed math utilities missing in the Solidity language.
*/
library SignedMath {
/**
* @dev Returns the largest of two signed numbers.
*/
function max(int256 a, int256 b) internal pure returns (int256) {
return a > b ? a : b;
}
/**
* @dev Returns the smallest of two signed numbers.
*/
function min(int256 a, int256 b) internal pure returns (int256) {
return a < b ? a : b;
}
/**
* @dev Returns the average of two signed numbers without overflow.
* The result is rounded towards zero.
*/
function average(int256 a, int256 b) internal pure returns (int256) {
// Formula from the book "Hacker's Delight"
int256 x = (a & b) + ((a ^ b) >> 1);
return x + (int256(uint256(x) >> 255) & (a ^ b));
}
/**
* @dev Returns the absolute unsigned value of a signed value.
*/
function abs(int256 n) internal pure returns (uint256) {
unchecked {
// must be unchecked in order to support `n = type(int256).min`
return uint256(n >= 0 ? n : -n);
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/Math.sol)
pragma solidity ^0.8.20;
/**
* @dev Standard math utilities missing in the Solidity language.
*/
library Math {
/**
* @dev Muldiv operation overflow.
*/
error MathOverflowedMulDiv();
enum Rounding {
Floor, // Toward negative infinity
Ceil, // Toward positive infinity
Trunc, // Toward zero
Expand // Away from zero
}
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
/**
* @dev Returns the subtraction of two unsigned integers, with an overflow flag.
*/
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
/**
* @dev Returns the multiplication of two unsigned integers, with an overflow flag.
*/
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
/**
* @dev Returns the division of two unsigned integers, with a division by zero flag.
*/
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
/**
* @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
*/
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
/**
* @dev Returns the largest of two numbers.
*/
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
/**
* @dev Returns the smallest of two numbers.
*/
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
/**
* @dev Returns the average of two numbers. The result is rounded towards
* zero.
*/
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow.
return (a & b) + (a ^ b) / 2;
}
/**
* @dev Returns the ceiling of the division of two numbers.
*
* This differs from standard division with `/` in that it rounds towards infinity instead
* of rounding towards zero.
*/
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
if (b == 0) {
// Guarantee the same behavior as in a regular Solidity division.
return a / b;
}
// (a + b - 1) / b can overflow on addition, so we distribute.
return a == 0 ? 0 : (a - 1) / b + 1;
}
/**
* @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or
* denominator == 0.
* @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by
* Uniswap Labs also under MIT license.
*/
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
// 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
// use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
// variables such that product = prod1 * 2^256 + prod0.
uint256 prod0 = x * y; // Least significant 256 bits of the product
uint256 prod1; // Most significant 256 bits of the product
assembly {
let mm := mulmod(x, y, not(0))
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
// Handle non-overflow cases, 256 by 256 division.
if (prod1 == 0) {
// Solidity will revert if denominator == 0, unlike the div opcode on its own.
// The surrounding unchecked block does not change this fact.
// See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
return prod0 / denominator;
}
// Make sure the result is less than 2^256. Also prevents denominator == 0.
if (denominator <= prod1) {
revert MathOverflowedMulDiv();
}
///////////////////////////////////////////////
// 512 by 256 division.
///////////////////////////////////////////////
// Make division exact by subtracting the remainder from [prod1 prod0].
uint256 remainder;
assembly {
// Compute remainder using mulmod.
remainder := mulmod(x, y, denominator)
// Subtract 256 bit number from 512 bit number.
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
// Factor powers of two out of denominator and compute largest power of two divisor of denominator.
// Always >= 1. See https://cs.stackexchange.com/q/138556/92363.
uint256 twos = denominator & (0 - denominator);
assembly {
// Divide denominator by twos.
denominator := div(denominator, twos)
// Divide [prod1 prod0] by twos.
prod0 := div(prod0, twos)
// Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
twos := add(div(sub(0, twos), twos), 1)
}
// Shift in bits from prod1 into prod0.
prod0 |= prod1 * twos;
// Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
// that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
// four bits. That is, denominator * inv = 1 mod 2^4.
uint256 inverse = (3 * denominator) ^ 2;
// Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also
// works in modular arithmetic, doubling the correct bits in each step.
inverse *= 2 - denominator * inverse; // inverse mod 2^8
inverse *= 2 - denominator * inverse; // inverse mod 2^16
inverse *= 2 - denominator * inverse; // inverse mod 2^32
inverse *= 2 - denominator * inverse; // inverse mod 2^64
inverse *= 2 - denominator * inverse; // inverse mod 2^128
inverse *= 2 - denominator * inverse; // inverse mod 2^256
// Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
// This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
// less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
// is no longer required.
result = prod0 * inverse;
return result;
}
}
/**
* @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
*/
function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
/**
* @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded
* towards zero.
*
* Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
*/
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
// For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
//
// We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
// `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
//
// This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
// → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
// → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
//
// Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
uint256 result = 1 << (log2(a) >> 1);
// At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
// since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
// every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
// into the expected uint128 result.
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
/**
* @notice Calculates sqrt(a), following the selected rounding direction.
*/
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);
}
}
/**
* @dev Return the log in base 2 of a positive value rounded towards zero.
* Returns 0 if given 0.
*/
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 2, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0);
}
}
/**
* @dev Return the log in base 10 of a positive value rounded towards zero.
* Returns 0 if given 0.
*/
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10 ** 64) {
value /= 10 ** 64;
result += 64;
}
if (value >= 10 ** 32) {
value /= 10 ** 32;
result += 32;
}
if (value >= 10 ** 16) {
value /= 10 ** 16;
result += 16;
}
if (value >= 10 ** 8) {
value /= 10 ** 8;
result += 8;
}
if (value >= 10 ** 4) {
value /= 10 ** 4;
result += 4;
}
if (value >= 10 ** 2) {
value /= 10 ** 2;
result += 2;
}
if (value >= 10 ** 1) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 10, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0);
}
}
/**
* @dev Return the log in base 256 of a positive value rounded towards zero.
* Returns 0 if given 0.
*
* Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
*/
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 256, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0);
}
}
/**
* @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
*/
function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
return uint8(rounding) % 2 == 1;
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/IERC165.sol)
pragma solidity ^0.8.20;
/**
* @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 IERC165 {
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[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 (last updated v5.0.0) (utils/introspection/ERC165.sol)
pragma solidity ^0.8.20;
import {IERC165} from "./IERC165.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);
* }
* ```
*/
abstract contract ERC165 is IERC165 {
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Strings.sol)
pragma solidity ^0.8.20;
import {Math} from "./math/Math.sol";
import {SignedMath} from "./math/SignedMath.sol";
/**
* @dev String operations.
*/
library Strings {
bytes16 private constant HEX_DIGITS = "0123456789abcdef";
uint8 private constant ADDRESS_LENGTH = 20;
/**
* @dev The `value` string doesn't fit in the specified `length`.
*/
error StringsInsufficientHexLength(uint256 value, uint256 length);
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
unchecked {
uint256 length = Math.log10(value) + 1;
string memory buffer = new string(length);
uint256 ptr;
/// @solidity memory-safe-assembly
assembly {
ptr := add(buffer, add(32, length))
}
while (true) {
ptr--;
/// @solidity memory-safe-assembly
assembly {
mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))
}
value /= 10;
if (value == 0) break;
}
return buffer;
}
}
/**
* @dev Converts a `int256` to its ASCII `string` decimal representation.
*/
function toStringSigned(int256 value) internal pure returns (string memory) {
return string.concat(value < 0 ? "-" : "", toString(SignedMath.abs(value)));
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
unchecked {
return toHexString(value, Math.log256(value) + 1);
}
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
uint256 localValue = value;
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = HEX_DIGITS[localValue & 0xf];
localValue >>= 4;
}
if (localValue != 0) {
revert StringsInsufficientHexLength(value, length);
}
return string(buffer);
}
/**
* @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal
* representation.
*/
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH);
}
/**
* @dev Returns true if the two strings are equal.
*/
function equal(string memory a, string memory b) internal pure returns (bool) {
return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b));
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)
pragma solidity ^0.8.20;
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
function _contextSuffixLength() internal view virtual returns (uint256) {
return 0;
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)
pragma solidity ^0.8.20;
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev The ETH balance of the account is not enough to perform the operation.
*/
error AddressInsufficientBalance(address account);
/**
* @dev There's no code at `target` (it is not a contract).
*/
error AddressEmptyCode(address target);
/**
* @dev A call to an address target failed. The target may have reverted.
*/
error FailedInnerCall();
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
if (address(this).balance < amount) {
revert AddressInsufficientBalance(address(this));
}
(bool success, ) = recipient.call{value: amount}("");
if (!success) {
revert FailedInnerCall();
}
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason or custom error, it is bubbled
* up by this function (like regular Solidity function calls). However, if
* the call reverted with no returned reason, this function reverts with a
* {FailedInnerCall} error.
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
if (address(this).balance < value) {
revert AddressInsufficientBalance(address(this));
}
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata);
}
/**
* @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
* was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an
* unsuccessful call.
*/
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata
) internal view returns (bytes memory) {
if (!success) {
_revert(returndata);
} else {
// only check if target is a contract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
if (returndata.length == 0 && target.code.length == 0) {
revert AddressEmptyCode(target);
}
return returndata;
}
}
/**
* @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
* revert reason or with a default {FailedInnerCall} error.
*/
function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
if (!success) {
_revert(returndata);
} else {
return returndata;
}
}
/**
* @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.
*/
function _revert(bytes memory returndata) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert FailedInnerCall();
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/extensions/IERC721Metadata.sol)
pragma solidity ^0.8.20;
import {IERC721} from "../IERC721.sol";
/**
* @title ERC-721 Non-Fungible Token Standard, optional metadata extension
* @dev See https://eips.ethereum.org/EIPS/eip-721
*/
interface IERC721Metadata is IERC721 {
/**
* @dev Returns the token collection name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the token collection symbol.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 tokenId) external view returns (string memory);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/IERC721Receiver.sol)
pragma solidity ^0.8.20;
/**
* @title ERC721 token receiver interface
* @dev Interface for any contract that wants to support safeTransfers
* from ERC721 asset contracts.
*/
interface IERC721Receiver {
/**
* @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
* by `operator` from `from`, this function is called.
*
* It must return its Solidity selector to confirm the token transfer.
* If any other value is returned or the interface is not implemented by the recipient, the transfer will be
* reverted.
*
* The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
*/
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/IERC721.sol)
pragma solidity ^0.8.20;
import {IERC165} from "../../utils/introspection/IERC165.sol";
/**
* @dev Required interface of an ERC721 compliant contract.
*/
interface IERC721 is IERC165 {
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
*/
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/**
* @dev Returns the number of tokens in ``owner``'s account.
*/
function balanceOf(address owner) external view returns (uint256 balance);
/**
* @dev Returns the owner of the `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function ownerOf(uint256 tokenId) external view returns (address owner);
/**
* @dev Safely transfers `tokenId` token from `from` to `to`.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon
* a safe transfer.
*
* Emits a {Transfer} event.
*/
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must have been allowed to move this token by either {approve} or
* {setApprovalForAll}.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon
* a safe transfer.
*
* Emits a {Transfer} event.
*/
function safeTransferFrom(address from, address to, uint256 tokenId) external;
/**
* @dev Transfers `tokenId` token from `from` to `to`.
*
* WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
* or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
* understand this adds an external call which potentially creates a reentrancy vulnerability.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
*
* Emits a {Transfer} event.
*/
function transferFrom(address from, address to, uint256 tokenId) external;
/**
* @dev Gives permission to `to` to transfer `tokenId` token to another account.
* The approval is cleared when the token is transferred.
*
* Only a single account can be approved at a time, so approving the zero address clears previous approvals.
*
* Requirements:
*
* - The caller must own the token or be an approved operator.
* - `tokenId` must exist.
*
* Emits an {Approval} event.
*/
function approve(address to, uint256 tokenId) external;
/**
* @dev Approve or remove `operator` as an operator for the caller.
* Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
*
* Requirements:
*
* - The `operator` cannot be the address zero.
*
* Emits an {ApprovalForAll} event.
*/
function setApprovalForAll(address operator, bool approved) external;
/**
* @dev Returns the account approved for `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function getApproved(uint256 tokenId) external view returns (address operator);
/**
* @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
*
* See {setApprovalForAll}
*/
function isApprovedForAll(address owner, address operator) external view returns (bool);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Metadata.sol)
pragma solidity ^0.8.20;
import {IERC20} from "../IERC20.sol";
/**
* @dev Interface for the optional metadata functions from the ERC20 standard.
*/
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)
pragma solidity ^0.8.20;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Returns the value of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the value of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves a `value` amount of tokens from the caller's account to `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address to, uint256 value) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets a `value` amount of tokens as the allowance of `spender` over the
* caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 value) external returns (bool);
/**
* @dev Moves a `value` amount of tokens from `from` to `to` using the
* allowance mechanism. `value` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address from, address to, uint256 value) external returns (bool);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC1155/extensions/IERC1155MetadataURI.sol)
pragma solidity ^0.8.20;
import {IERC1155} from "../IERC1155.sol";
/**
* @dev Interface of the optional ERC1155MetadataExtension interface, as defined
* in the https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[EIP].
*/
interface IERC1155MetadataURI is IERC1155 {
/**
* @dev Returns the URI for token type `id`.
*
* If the `\{id\}` substring is present in the URI, it must be replaced by
* clients with the actual token type ID.
*/
function uri(uint256 id) external view returns (string memory);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC1155/IERC1155Receiver.sol)
pragma solidity ^0.8.20;
import {IERC165} from "../../utils/introspection/IERC165.sol";
/**
* @dev Interface that must be implemented by smart contracts in order to receive
* ERC-1155 token transfers.
*/
interface IERC1155Receiver is IERC165 {
/**
* @dev Handles the receipt of a single 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 (last updated v5.0.1) (token/ERC1155/IERC1155.sol)
pragma solidity ^0.8.20;
import {IERC165} from "../../utils/introspection/IERC165.sol";
/**
* @dev Required interface of an ERC1155 compliant contract, as defined in the
* https://eips.ethereum.org/EIPS/eip-1155[EIP].
*/
interface IERC1155 is IERC165 {
/**
* @dev Emitted when `value` amount of tokens of type `id` are transferred from `from` to `to` by `operator`.
*/
event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);
/**
* @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all
* transfers.
*/
event TransferBatch(
address indexed operator,
address indexed from,
address indexed to,
uint256[] ids,
uint256[] values
);
/**
* @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to
* `approved`.
*/
event ApprovalForAll(address indexed account, address indexed operator, bool approved);
/**
* @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI.
*
* If an {URI} event was emitted for `id`, the standard
* https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value
* returned by {IERC1155MetadataURI-uri}.
*/
event URI(string value, uint256 indexed id);
/**
* @dev Returns the value of tokens of token type `id` owned by `account`.
*
* 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 a `value` amount of tokens of type `id` from `from` to `to`.
*
* WARNING: This function can potentially allow a reentrancy attack when transferring tokens
* to an untrusted contract, when invoking {onERC1155Received} on the receiver.
* Ensure to follow the checks-effects-interactions pattern and consider employing
* reentrancy guards when interacting with untrusted contracts.
*
* Emits a {TransferSingle} event.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - If the caller is not `from`, it must have been approved to spend ``from``'s tokens via {setApprovalForAll}.
* - `from` must have a balance of tokens of type `id` of at least `value` amount.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
* acceptance magic value.
*/
function safeTransferFrom(address from, address to, uint256 id, uint256 value, bytes calldata data) external;
/**
* @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}.
*
* WARNING: This function can potentially allow a reentrancy attack when transferring tokens
* to an untrusted contract, when invoking {onERC1155BatchReceived} on the receiver.
* Ensure to follow the checks-effects-interactions pattern and consider employing
* reentrancy guards when interacting with untrusted contracts.
*
* Emits either a {TransferSingle} or a {TransferBatch} event, depending on the length of the array arguments.
*
* Requirements:
*
* - `ids` and `values` must have the same length.
* - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
* acceptance magic value.
*/
function safeBatchTransferFrom(
address from,
address to,
uint256[] calldata ids,
uint256[] calldata values,
bytes calldata data
) external;
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol)
pragma solidity ^0.8.20;
/**
* @dev Standard ERC20 Errors
* Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC20 tokens.
*/
interface IERC20Errors {
/**
* @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
* @param sender Address whose tokens are being transferred.
* @param balance Current balance for the interacting account.
* @param needed Minimum amount required to perform a transfer.
*/
error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);
/**
* @dev Indicates a failure with the token `sender`. Used in transfers.
* @param sender Address whose tokens are being transferred.
*/
error ERC20InvalidSender(address sender);
/**
* @dev Indicates a failure with the token `receiver`. Used in transfers.
* @param receiver Address to which tokens are being transferred.
*/
error ERC20InvalidReceiver(address receiver);
/**
* @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
* @param spender Address that may be allowed to operate on tokens without being their owner.
* @param allowance Amount of tokens a `spender` is allowed to operate with.
* @param needed Minimum amount required to perform a transfer.
*/
error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);
/**
* @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
* @param approver Address initiating an approval operation.
*/
error ERC20InvalidApprover(address approver);
/**
* @dev Indicates a failure with the `spender` to be approved. Used in approvals.
* @param spender Address that may be allowed to operate on tokens without being their owner.
*/
error ERC20InvalidSpender(address spender);
}
/**
* @dev Standard ERC721 Errors
* Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC721 tokens.
*/
interface IERC721Errors {
/**
* @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in EIP-20.
* Used in balance queries.
* @param owner Address of the current owner of a token.
*/
error ERC721InvalidOwner(address owner);
/**
* @dev Indicates a `tokenId` whose `owner` is the zero address.
* @param tokenId Identifier number of a token.
*/
error ERC721NonexistentToken(uint256 tokenId);
/**
* @dev Indicates an error related to the ownership over a particular token. Used in transfers.
* @param sender Address whose tokens are being transferred.
* @param tokenId Identifier number of a token.
* @param owner Address of the current owner of a token.
*/
error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);
/**
* @dev Indicates a failure with the token `sender`. Used in transfers.
* @param sender Address whose tokens are being transferred.
*/
error ERC721InvalidSender(address sender);
/**
* @dev Indicates a failure with the token `receiver`. Used in transfers.
* @param receiver Address to which tokens are being transferred.
*/
error ERC721InvalidReceiver(address receiver);
/**
* @dev Indicates a failure with the `operator`’s approval. Used in transfers.
* @param operator Address that may be allowed to operate on tokens without being their owner.
* @param tokenId Identifier number of a token.
*/
error ERC721InsufficientApproval(address operator, uint256 tokenId);
/**
* @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
* @param approver Address initiating an approval operation.
*/
error ERC721InvalidApprover(address approver);
/**
* @dev Indicates a failure with the `operator` to be approved. Used in approvals.
* @param operator Address that may be allowed to operate on tokens without being their owner.
*/
error ERC721InvalidOperator(address operator);
}
/**
* @dev Standard ERC1155 Errors
* Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC1155 tokens.
*/
interface IERC1155Errors {
/**
* @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
* @param sender Address whose tokens are being transferred.
* @param balance Current balance for the interacting account.
* @param needed Minimum amount required to perform a transfer.
* @param tokenId Identifier number of a token.
*/
error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);
/**
* @dev Indicates a failure with the token `sender`. Used in transfers.
* @param sender Address whose tokens are being transferred.
*/
error ERC1155InvalidSender(address sender);
/**
* @dev Indicates a failure with the token `receiver`. Used in transfers.
* @param receiver Address to which tokens are being transferred.
*/
error ERC1155InvalidReceiver(address receiver);
/**
* @dev Indicates a failure with the `operator`’s approval. Used in transfers.
* @param operator Address that may be allowed to operate on tokens without being their owner.
* @param owner Address of the current owner of a token.
*/
error ERC1155MissingApprovalForAll(address operator, address owner);
/**
* @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
* @param approver Address initiating an approval operation.
*/
error ERC1155InvalidApprover(address approver);
/**
* @dev Indicates a failure with the `operator` to be approved. Used in approvals.
* @param operator Address that may be allowed to operate on tokens without being their owner.
*/
error ERC1155InvalidOperator(address operator);
/**
* @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
* Used in batch transfers.
* @param idsLength Length of the array of token identifiers
* @param valuesLength Length of the array of token amounts
*/
error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)
pragma solidity ^0.8.20;
import {Context} from "../utils/Context.sol";
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* The initial owner is set to the address provided by the deployer. This can
* later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
/**
* @dev The caller account is not authorized to perform an operation.
*/
error OwnableUnauthorizedAccount(address account);
/**
* @dev The owner is not a valid owner account. (eg. `address(0)`)
*/
error OwnableInvalidOwner(address owner);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the address provided by the deployer as the initial owner.
*/
constructor(address initialOwner) {
if (initialOwner == address(0)) {
revert OwnableInvalidOwner(address(0));
}
_transferOwnership(initialOwner);
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
_checkOwner();
_;
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
return _owner;
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
if (owner() != _msgSender()) {
revert OwnableUnauthorizedAccount(_msgSender());
}
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby disabling any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
if (newOwner == address(0)) {
revert OwnableInvalidOwner(address(0));
}
_transferOwnership(newOwner);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}{
"remappings": [],
"optimizer": {
"enabled": true,
"runs": 200
},
"evmVersion": "shanghai",
"libraries": {},
"outputSelection": {
"*": {
"*": [
"evm.bytecode",
"evm.deployedBytecode",
"devdoc",
"userdoc",
"metadata",
"abi"
]
}
}
}Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ApprovalCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"BalanceQueryForZeroAddress","type":"error"},{"inputs":[],"name":"BurnFromNonOwnerAddress","type":"error"},{"inputs":[],"name":"BurnFromZeroAddress","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"allowance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientAllowance","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC20InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC20InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC20InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"}],"name":"ERC20InvalidSpender","type":"error"},{"inputs":[],"name":"InputLengthMistmatch","type":"error"},{"inputs":[],"name":"InvalidQueryRange","type":"error"},{"inputs":[],"name":"MintToZeroAddress","type":"error"},{"inputs":[],"name":"MintZeroQuantity","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[],"name":"Reentrance","type":"error"},{"inputs":[],"name":"TransferCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"TransferFromIncorrectOwnerOrInvalidAmount","type":"error"},{"inputs":[],"name":"TransferToNonERC1155ReceiverImplementer","type":"error"},{"inputs":[],"name":"TransferToNonERC721ReceiverImplementer","type":"error"},{"inputs":[],"name":"TransferToZeroAddress","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","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":"max","type":"uint256"}],"name":"MaxWalletUpdated","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":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","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":"status","type":"bool"}],"name":"TransfersDelayUpdated","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":[],"name":"URIUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"wallet","type":"address"}],"name":"WhitelistDisabled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"wallet","type":"address"}],"name":"WhitelistEnabled","type":"event"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"start","type":"uint256"},{"internalType":"uint256","name":"stop","type":"uint256"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","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":"baseTokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"dataURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimalFactor","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"easyLaunch","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"isOwnerOf","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxWallet","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","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":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_dataURI","type":"string"}],"name":"setDataURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"percent","type":"uint256"}],"name":"setMaxWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_tokenURI","type":"string"}],"name":"setTokenURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"newuri","type":"string"}],"name":"setURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bool","name":"state","type":"bool"}],"name":"setWhitelist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"toggleDelay","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"tokensOfOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"start","type":"uint256"},{"internalType":"uint256","name":"stop","type":"uint256"}],"name":"tokensOfOwnerIn","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokensPerNFT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"transferDelay","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"uri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"whitelist","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"}]Contract Creation Code
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
Deployed Bytecode
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
Loading...
Loading
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.