Feature Tip: Add private address tag to any address under My Name Tag !
Overview
TokenID
3772
Total Transfers
-
Market
Onchain Market Cap
$0.00
Circulating Supply Market Cap
-
Other Info
Token Contract
Loading...
Loading
Loading...
Loading
Loading...
Loading
# | Exchange | Pair | Price | 24H Volume | % Volume |
---|
Contract Source Code Verified (Exact Match)
Contract Name:
PairedCollection
Compiler Version
v0.8.24+commit.e11b9ed9
Optimization Enabled:
Yes with 200 runs
Other Settings:
paris EvmVersion
Contract Source Code (Solidity Standard Json-Input format)
pragma solidity ^0.8.20; import {ERC20} from "./ERC20.sol"; import {TokenCollection} from "./TokenCollection.sol"; import {Escrow} from "./Escrow.sol"; contract PairedToken is ERC20 { error TokenNotLive(); error RestrictedOperation(); enum State { NEW, READY, LIVE } address internal $owner; PairedCollection internal $collection; State internal $state; constructor(string memory _name, string memory _symbol, uint256 _supply, uint8 _decimals, address owner) ERC20(_name, _symbol, _supply, _decimals) { $state = State.NEW; $owner = owner; } function initialize(address _collection) public { require($state == State.NEW, "Can only be called on new contract!"); require(msg.sender == $owner, "Can only be called by owner!"); require(PairedCollection(_collection).maxSupply() == maxSupply() / $erc20.unit, "Invalid Collection!"); $collection = PairedCollection(_collection); $state = State.READY; } function launch() public { require(msg.sender == address($collection) && $state == State.READY, "Launch must be done by paired collection on ready contract!"); $state = State.LIVE; } function pause() public { require($state == State.LIVE, "Can only be called on live contract!"); require(msg.sender == address($collection), "Can only be called by owner!"); $state = State.READY; } function renounce() public { require($state == State.LIVE, "Cannot renounce contract because its not live!"); require(msg.sender == address($collection), "Can only be renounced by collection!"); $owner = address(0); } function transferFrom(address from, address to, uint256 atoms) public override returns (bool) { if ($state != State.LIVE) { revert TokenNotLive(); } else if (atoms > $erc20.users[from].balance) { revert ERC20InsufficientBalance(from, $erc20.users[from].balance, atoms); } uint256 loss = ($erc20.users[from].balance / $erc20.unit) - (($erc20.users[from].balance - atoms) / $erc20.unit); uint256 gain = (($erc20.users[to].balance + atoms) / $erc20.unit) - ($erc20.users[to].balance / $erc20.unit); $collection._sudoTransferNext(from, to, loss > gain ? gain : loss); $collection._sudoTransferNext(address($collection), to, gain > loss ? 1 : 0); $collection._sudoTransferNext(from, address($collection), gain < loss ? 1 : 0); super.transferFrom(from, to, atoms); return true; } function _sudoTransferFrom(address from, address to, uint256 atoms) public returns (bool) { if (msg.sender != address($collection)) { revert RestrictedOperation(); } return _sudoTransferERC20(from, to, atoms); } } contract PairedCollection is TokenCollection, Escrow { error TokenNotLive(); error RestrictedOperation(); error MintableMaxExceeded(uint256 limit); error MintableUnderfunded(uint256 cost); event Minted(address indexed recipient, uint256 amount); enum State { NEW, READY, LIVE } struct Mint { uint256 price; uint256 limit; } PairedToken internal $token; State internal $state; Mint internal $mint; address internal $owner; address internal $team; address internal $treasury; constructor(string memory _name, uint256 _supply, address owner, address team, address treasury) TokenCollection(_name, _supply, "") { $owner = owner; $team = team; $treasury = treasury; $state = State.NEW; } function symbol() public view returns (string memory) { return $token.symbol(); } function initialize(address _token, uint256 teamGrant, uint256 treasuryGrant) public { require($state == State.NEW, "Can only be called on new contract!"); require(msg.sender == $owner, "Can only be called by owner!"); require(teamGrant < $collection.maxSupply, "Grant cannot exceed supply!"); require(treasuryGrant < $collection.maxSupply, "Grant cannot exceed supply!"); $token = PairedToken(_token); $state = State.READY; $token._sudoTransferFrom(_token, $team, teamGrant * $token.unit()); $token._sudoTransferFrom(_token, $treasury, treasuryGrant * $token.unit()); // NOTE: This is unsafe to call if any state has changed since construction! uint256 treasuryFullBlocks = treasuryGrant / 256; for (uint256 index; index < treasuryFullBlocks; index++) { $collection.users[address(this)].held[index] = uint256(0); $collection.users[$treasury].held[index] = type(uint256).max; } uint256 treasuryLastBlockMask = (1 << (treasuryGrant % 256)) - 1; $collection.users[$treasury].held[treasuryFullBlocks] = treasuryLastBlockMask; $collection.users[address(this)].held[treasuryFullBlocks] = ~treasuryLastBlockMask; $collection.users[$treasury].heldCount = treasuryGrant; $collection.users[address(this)].heldCount -= treasuryGrant; $collection.supply += treasuryGrant; // TODO: Dedup uint256 teamFullBlocks = teamGrant / 256; uint256 usedSlots = (treasuryGrant + 255) / 256; for (uint256 index = usedSlots; index < usedSlots + teamFullBlocks; index++) { $collection.users[address(this)].held[index] = uint256(0); $collection.users[$team].held[index] = type(uint256).max; } uint256 teamLastBlockMask = (1 << (teamGrant % 256)) - 1; $collection.users[$team].held[usedSlots + teamFullBlocks] = teamLastBlockMask; $collection.users[address(this)].held[usedSlots + teamFullBlocks] = ~teamLastBlockMask; $collection.users[$team].heldCount = teamGrant; $collection.users[address(this)].heldCount -= teamGrant; $collection.supply += teamGrant; } //function _transferBlock(address from, address to, function launch(uint256 _mintCost, uint256 _mintLimit, string memory _uri) public { require($state == State.READY, "Can only be called on ready contract!"); require(msg.sender == $owner, "Can only be called by owner!"); $state = State.LIVE; $mint.price = _mintCost; $mint.limit = _mintLimit; _setURI(_uri); $token.launch(); } function pause() public { require($state == State.LIVE, "Can only be called on live contract!"); require(msg.sender == $owner, "Can only be called by owner!"); $state = State.READY; $token.pause(); } function price() public view returns (uint256) { return $mint.price; } function setMintLimit(uint256 _limit) public { require(msg.sender == $owner, "Can only be called by owner!"); $mint.limit = _limit; } function setMintPrice(uint256 _price) public { require(msg.sender == $owner, "Can only be called by owner!"); $mint.price = _price; } function renounce() public { require($state == State.LIVE, "Cannot renounce contract because its not live!"); require(msg.sender == $owner, "Can only be renounced by owner!"); $token.renounce(); $owner = address(0); } function setURI(string memory _uri) public { require(msg.sender == $owner, "Can only be set by owner!"); _setURI(_uri); } function mint(uint256 count) public payable { if ($state != State.LIVE) { revert TokenNotLive(); } uint256 cost = count * $mint.price; if (count > $mint.limit) { revert MintableMaxExceeded($mint.limit); } else if (msg.value < cost) { revert MintableUnderfunded(count * $mint.price); } else { deposit($treasury, cost); deposit(msg.sender, msg.value - cost); _updateNext(address(this), msg.sender, count); $token._sudoTransferFrom(address($token), msg.sender, count * $token.unit()); } } function _sudoTransferNext(address from, address to, uint256 count) public { if (msg.sender != address($token)) { revert RestrictedOperation(); } _updateNext(from, to, count); } function safeTransferFrom(address from, address to, uint256 id, uint256 value, bytes memory data) public override { if ($state != State.LIVE) { revert TokenNotLive(); } super.safeTransferFrom(from, to, id, value, data); $token._sudoTransferFrom(from, to, $token.unit()); } function safeBatchTransferFrom(address from, address to, uint256[] memory ids, uint256[] memory values, bytes memory data) public override { if ($state != State.LIVE) { revert TokenNotLive(); } super.safeBatchTransferFrom(from, to, ids, values, data); $token._sudoTransferFrom(from, to, ids.length * $token.unit()); } }
// https://docs.openzeppelin.com/contracts/5.x/api/token/erc20#IERC20 pragma solidity ^0.8.20; abstract contract ERC20 { event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); // event Approval(address owner, address spender, uint256 atoms); // Errors from https://eips.ethereum.org/EIPS/eip-6093 error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed); error ERC20InvalidSender(address sender); // error ERC20InvalidReceiver(address receiver); error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed); // error ERC20InvalidApprover(address approver); // error ERC20InvalidSpender(address spender); struct ERC20User { uint256 balance; mapping(address delegate => uint256) allowances; } struct ERC20Info { string name; string symbol; uint8 decimals; uint256 unit; uint256 supply; uint256 maxSupply; mapping(address => ERC20User) users; } ERC20Info internal $erc20; // TODO: Switch to using precision instead of decimals constructor(string memory _name, string memory _symbol, uint256 _supply, uint8 _decimals) { $erc20.name = _name; $erc20.symbol = _symbol; $erc20.supply = 0; $erc20.maxSupply = _supply; $erc20.users[address(this)].balance = _supply; $erc20.decimals = _decimals; $erc20.unit = 10 ** _decimals; } function transferFrom(address from, address to, uint256 atoms) public virtual returns (bool) { _spendAllowance(from, msg.sender, atoms); _sudoTransferERC20(from, to, atoms); return true; } function transfer(address to, uint256 atoms) public returns (bool) { return transferFrom(msg.sender, to, atoms); } function _sudoTransferERC20(address from, address to, uint256 atoms) internal virtual returns (bool) { if (atoms > $erc20.users[from].balance) { revert ERC20InsufficientBalance(from, $erc20.users[from].balance, atoms); } else if (from == address(0)) { revert ERC20InvalidSender(from); } $erc20.users[from].balance -= atoms; $erc20.users[to].balance += atoms; if (to == address(0) || to == address(this)) { $erc20.supply -= atoms; } if (from == address(this)) { $erc20.supply += atoms; } emit Transfer(from, to, atoms); return true; } function approve(address delegate, uint256 atoms) public returns (bool) { return _sudoApproveERC20(msg.sender, delegate, atoms); } function _sudoApproveERC20(address principal, address delegate, uint256 atoms) internal returns (bool) { $erc20.users[principal].allowances[delegate] = atoms; return true; } function allowance(address principal, address delegate) public view virtual returns (uint256) { return principal == delegate ? type(uint256).max : $erc20.users[principal].allowances[delegate]; } function _spendAllowance(address principal, address delegate, uint256 atoms) internal { uint256 currentAllowance = allowance(principal, delegate); if (currentAllowance != type(uint256).max) { if (currentAllowance < atoms) { revert ERC20InsufficientAllowance(delegate, currentAllowance, atoms); } unchecked { _sudoApproveERC20(principal, delegate, currentAllowance - atoms); } } } function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) { return interfaceId == 0x01ffc9a7 // ERC165 || interfaceId == 0x36372b07 // ERC20 || interfaceId == 0x06fdde03 // ERC20 name || interfaceId == 0x95d89b41 // ERC20 symbol || interfaceId == 0x313ce567; // ERC20 decimals } function balanceOf(address account) public view returns (uint256) { return $erc20.users[account].balance; } function totalSupply() public virtual view returns (uint256) { return $erc20.supply; } function maxSupply() public virtual view returns (uint256) { return $erc20.maxSupply; } function name() public virtual view returns (string memory) { return $erc20.name; } function symbol() public view returns (string memory) { return $erc20.symbol; } function decimals() public view returns (uint8) { return $erc20.decimals; } function unit() public view returns (uint256) { return $erc20.unit; } }
// https://docs.openzeppelin.com/contracts/5.x/api/token/erc20#IERC20 pragma solidity ^0.8.20; import {ERC1155} from "@openzeppelin/contracts/token/ERC1155/ERC1155.sol"; import {ERC1155Utils} from "@openzeppelin/contracts/token/ERC1155/utils/ERC1155Utils.sol"; import {Arrays} from "@openzeppelin/contracts/utils/Arrays.sol"; abstract contract TokenCollection is ERC1155 { using Arrays for uint256[]; using Arrays for address[]; error CollectionInvalidID(uint256 id); struct CollectionUser { mapping(address delegate => bool) delegates; uint256[40] held; uint256 heldCount; } struct CollectionInfo { string name; uint256 supply; uint256 maxSupply; string uri; mapping(address => CollectionUser) users; } CollectionInfo internal $collection; constructor(string memory _name, uint256 _supply, string memory _uri) ERC1155(_uri) { require(_supply <= 10000, "Currently only supports 10k supply!"); $collection.name = _name; $collection.supply = 0; $collection.maxSupply = _supply; $collection.uri = _uri; $collection.users[address(this)].heldCount = _supply; for (uint256 index; index < 40; index++) { $collection.users[address(this)].held[index] = type(uint256).max; } } function _changeHolder(address current, address next, uint256 id) internal { require(isHeldBy(id, current), "Incorrect holder!"); _markHeld(id, current, false); _markHeld(id, next, true); } function name() public virtual view returns (string memory) { return $collection.name; } function _markHeld(uint256 id, address holder, bool held) internal { uint256 index = (id - 1) / 256; uint256 offset = (id - 1) % 256; bool previouslyHeld = isHeldBy(id, holder); if (previouslyHeld == held) { // Do nothing } else if (held) { $collection.users[holder].heldCount += 1; $collection.users[holder].held[index] = $collection.users[holder].held[index] | (1 << offset); } else { $collection.users[holder].heldCount -= 1; $collection.users[holder].held[index] = $collection.users[holder].held[index] & ~(1 << offset); } } function maxSupply() public virtual view returns (uint256) { return $collection.maxSupply; } function totalSupply() public virtual view returns (uint256) { return $collection.supply; } function isHeldBy(uint256 id, address holder) public view returns (bool) { require(id != 0 && id <= $collection.maxSupply, "Invalid ID!"); uint256 index = (id - 1) / 256; uint256 offset = (id - 1) % 256; return ($collection.users[holder].held[index] & (1 << offset)) != 0; } function quantityHeldBy(address account) public view returns (uint256) { return $collection.users[account].heldCount; } function allHeldBy(address account) public view returns (uint256[] memory) { heldBy(account, $collection.maxSupply); return heldBy(account, $collection.maxSupply); } function heldBy(address account, uint256 max) public view returns (uint256[] memory) { uint256 available = quantityHeldBy(account); // Assuming this is optimized uint256[] memory ids = new uint256[](available > max ? max : available); uint256 found = 0; uint256 slots = $collection.users[account].held.length; for (uint256 index = 0; (index < slots) && (found < ids.length); index++) { uint256 slot = $collection.users[account].held[index]; if (slot == 0) continue; // Skip if no IDs in this slot are owned for (uint256 offset = 0; (offset < 256) && (found < ids.length); offset++) { uint256 id = index * 256 + offset + 1; if (id > $collection.maxSupply) break; if ((slot & (1 << offset)) != 0) { ids[found] = id; found += 1; if (found == max) break; } } } require(found == available || found == max, "Inconsistent internal state!"); return ids; } function uri(uint256 /* id */) public view override returns (string memory) { return $collection.uri; } function _setURI(string memory _uri) internal override { $collection.uri = _uri; } function balanceOf(address account, uint256 id) public view override returns (uint256) { if (id == 0 || id > $collection.maxSupply) { revert CollectionInvalidID(id); } return isHeldBy(id, account) ? 1 : 0; } function safeTransferFrom(address from, address to, uint256 id, uint256 value, bytes memory data) public virtual override { address sender = _msgSender(); if (from != sender && !isApprovedForAll(from, sender)) { revert ERC1155MissingApprovalForAll(sender, from); } (uint256[] memory ids, uint256[] memory values) = _asSingleElementArrays(id, value); _updateWithAcceptanceCheck(from, to, ids, values, data); } function safeBatchTransferFrom(address from, address to, uint256[] memory ids, uint256[] memory values, bytes memory data) public virtual override { address sender = _msgSender(); if (from != sender && !isApprovedForAll(from, sender)) { revert ERC1155MissingApprovalForAll(sender, from); } _updateWithAcceptanceCheck(from, to, ids, values, data); } // Copied from ERC1155 implementation, because it's private there function _asSingleElementArrays(uint256 element1, uint256 element2) internal pure returns (uint256[] memory array1, uint256[] memory array2) { /// @solidity memory-safe-assembly assembly { // Load the free memory pointer array1 := mload(0x40) // Set array length to 1 mstore(array1, 1) // Store the single element at the next word after the length (where content starts) mstore(add(array1, 0x20), element1) // Repeat for next array locating it right after the first array array2 := add(array1, 0x40) mstore(array2, 1) mstore(add(array2, 0x20), element2) // Update the free memory pointer by pointing after the second array mstore(0x40, add(array2, 0x40)) } } function setApprovalForAll(address delegate, bool approved) public override { $collection.users[msg.sender].delegates[delegate] = approved; emit ApprovalForAll(msg.sender, delegate, approved); } function isApprovedForAll(address principal, address operator) public view virtual override returns (bool) { return $collection.users[principal].delegates[operator]; } function _update(address from, address to, uint256[] memory ids, uint256[] memory values) internal virtual override { require(from != address(0), "ERC1155: transfer from the zero address"); require(ids.length == values.length, "ERC1155: ids and values length mismatch"); uint256[] memory transferredIds = new uint256[](ids.length); uint256[] memory transferredValues = new uint256[](ids.length); uint256 transferredCount = 0; for (uint256 i = 0; i < ids.length; i++) { if (values[i] != 1) { revert("ERC1155: invalid value, can only transfer 1 of each ID"); } if (isHeldBy(ids[i], from)) { _changeHolder(from, to, ids[i]); transferredIds[transferredCount] = ids[i]; transferredValues[transferredCount] = values[i]; transferredCount++; } else { revert("ERC1155: attempting to transfer an ID not held by the sender"); } } if (transferredCount > 0) { uint256[] memory actualTransferredIds = new uint256[](transferredCount); uint256[] memory actualTransferredValues = new uint256[](transferredCount); for (uint256 i = 0; i < transferredCount; i++) { actualTransferredIds[i] = transferredIds[i]; actualTransferredValues[i] = transferredValues[i]; } emit TransferBatch(msg.sender, from, to, actualTransferredIds, actualTransferredValues); } if (from == address(this)) { $collection.supply += transferredCount; } if (to == address(0) || to == address(this)) { $collection.supply -= transferredCount; } } function _updateNext(address from, address to, uint256 count) internal { uint256 transferred = 0; uint256[] memory ids = new uint256[](count); uint256[] memory values = new uint256[](count); // Assuming each transfer is of quantity 1 for (uint256 index = 0; index < $collection.users[from].held.length && transferred < count; index++) { uint256 fromSlot = $collection.users[from].held[index]; if (fromSlot == 0) continue; // Skip if no owned IDs in this slot for (uint256 offset = 0; offset < 256 && transferred < count; offset++) { uint256 bitMask = (1 << offset); if (fromSlot & bitMask != 0) { uint256 id = 256 * index + offset + 1; ids[transferred] = id; values[transferred] = 1; $collection.users[from].held[index] &= ~bitMask; $collection.users[to].held[index] |= bitMask; transferred++; } } } require(transferred == count, "Not enough elements owned by sender to transfer"); // Update the held counts for both parties $collection.users[from].heldCount -= transferred; $collection.users[to].heldCount += transferred; if (from == address(this)) { $collection.supply += transferred; } if (to == address(0) || to == address(this)) { $collection.supply -= transferred; } if (transferred == 1) { emit TransferSingle(msg.sender, from, to, ids[0], 1); } else if (transferred > 1) { emit TransferBatch(msg.sender, from, to, ids, values); } } function _createOnesArray(uint256 length) internal pure returns (uint256[] memory) { uint[] memory onesArray = new uint[](length); for (uint256 index; index < length; index++) { onesArray[index] = 1; } return onesArray; } function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == 0x01ffc9a7 // ERC165 || interfaceId == 0xd9b67a26 // ERC1155 || interfaceId == 0x0e89341c; // ERC1155MetadataURI } function _updateWithAcceptanceCheck(address from, address to, uint256[] memory ids, uint256[] memory values, bytes memory /*data*/) internal virtual override { _update(from, to, ids, values); } function onERC1155Received(address /*operator*/, address /*from*/, uint256 /*id*/, uint256 /*value*/, bytes calldata /*data*/) external pure returns (bytes4) { return 0xf23a6e61; } function onERC1155BatchReceived(address /*operator*/, address /*from*/, uint256[] calldata /*ids*/, uint256[] calldata /*values*/, bytes calldata /*data*/) external pure returns (bytes4) { return 0xbc197c81; } }
pragma solidity ^0.8.20; import {Owned} from "./Owned.sol"; contract Escrow { error EscrowDepositUnderfunded(); error EscrowWithdrawalFailed(); event Deposit(address sender, uint256 amount); event Withdrawal(address receiver, uint256 amount); mapping(address => uint256) internal $escrow; function escrowed(address beneficiary) public view returns (uint256) { return $escrow[beneficiary]; } function deposit(address beneficiary, uint256 amount) public payable { if (amount > msg.value) { revert EscrowDepositUnderfunded(); } $escrow[beneficiary] += amount; } function withdraw(address payable beneficiary) public { uint256 payment = $escrow[beneficiary]; $escrow[beneficiary] = 0; (bool success,) = payable(beneficiary).call{value: payment}(""); if (success != true) { revert EscrowWithdrawalFailed(); } } function withdraw(address payable beneficiary, uint256 amount) public { uint256 max = $escrow[beneficiary]; require(amount <= max, "Can't withdraw more than maximum amount!"); $escrow[beneficiary] = max - amount; (bool success,) = payable(beneficiary).call{value: amount}(""); if (success != true) { revert EscrowWithdrawalFailed(); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC1155/ERC1155.sol) pragma solidity ^0.8.20; import {IERC1155} from "./IERC1155.sol"; import {IERC1155MetadataURI} from "./extensions/IERC1155MetadataURI.sol"; import {ERC1155Utils} from "./utils/ERC1155Utils.sol"; import {Context} from "../../utils/Context.sol"; import {IERC165, ERC165} from "../../utils/introspection/ERC165.sol"; import {Arrays} from "../../utils/Arrays.sol"; import {IERC1155Errors} from "../../interfaces/draft-IERC6093.sol"; /** * @dev Implementation of the basic standard multi-token. * See https://eips.ethereum.org/EIPS/eip-1155 * Originally based on code by Enjin: https://github.com/enjin/erc-1155 */ abstract contract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI, IERC1155Errors { using Arrays for uint256[]; using Arrays for address[]; mapping(uint256 id => mapping(address account => uint256)) private _balances; mapping(address account => mapping(address operator => bool)) private _operatorApprovals; // Used as the URI for all token types by relying on ID substitution, e.g. https://token-cdn-domain/{id}.json string private _uri; /** * @dev See {_setURI}. */ constructor(string memory uri_) { _setURI(uri_); } /** * @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 || super.supportsInterface(interfaceId); } /** * @dev See {IERC1155MetadataURI-uri}. * * This implementation returns the same URI for *all* token types. It relies * on the token type ID substitution mechanism * https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the ERC]. * * Clients calling this function must replace the `\{id\}` substring with the * actual token type ID. */ function uri(uint256 /* id */) public view virtual returns (string memory) { return _uri; } /** * @dev See {IERC1155-balanceOf}. */ function balanceOf(address account, uint256 id) public view virtual returns (uint256) { return _balances[id][account]; } /** * @dev See {IERC1155-balanceOfBatch}. * * Requirements: * * - `accounts` and `ids` must have the same length. */ function balanceOfBatch( address[] memory accounts, uint256[] memory ids ) public view virtual returns (uint256[] memory) { if (accounts.length != ids.length) { revert ERC1155InvalidArrayLength(ids.length, accounts.length); } uint256[] memory batchBalances = new uint256[](accounts.length); for (uint256 i = 0; i < accounts.length; ++i) { batchBalances[i] = balanceOf(accounts.unsafeMemoryAccess(i), ids.unsafeMemoryAccess(i)); } return batchBalances; } /** * @dev See {IERC1155-setApprovalForAll}. */ function setApprovalForAll(address operator, bool approved) public virtual { _setApprovalForAll(_msgSender(), operator, approved); } /** * @dev See {IERC1155-isApprovedForAll}. */ function isApprovedForAll(address account, address operator) public view virtual returns (bool) { return _operatorApprovals[account][operator]; } /** * @dev See {IERC1155-safeTransferFrom}. */ function safeTransferFrom(address from, address to, uint256 id, uint256 value, bytes memory data) public virtual { address sender = _msgSender(); if (from != sender && !isApprovedForAll(from, sender)) { revert ERC1155MissingApprovalForAll(sender, from); } _safeTransferFrom(from, to, id, value, data); } /** * @dev See {IERC1155-safeBatchTransferFrom}. */ function safeBatchTransferFrom( address from, address to, uint256[] memory ids, uint256[] memory values, bytes memory data ) public virtual { address sender = _msgSender(); if (from != sender && !isApprovedForAll(from, sender)) { revert ERC1155MissingApprovalForAll(sender, from); } _safeBatchTransferFrom(from, to, ids, values, data); } /** * @dev Transfers a `value` amount of tokens of type `id` from `from` to `to`. Will mint (or burn) if `from` * (or `to`) is the zero address. * * Emits a {TransferSingle} event if the arrays contain one element, and {TransferBatch} otherwise. * * Requirements: * * - If `to` refers to a smart contract, it must implement either {IERC1155Receiver-onERC1155Received} * or {IERC1155Receiver-onERC1155BatchReceived} and return the acceptance magic value. * - `ids` and `values` must have the same length. * * NOTE: The ERC-1155 acceptance check is not performed in this function. See {_updateWithAcceptanceCheck} instead. */ function _update(address from, address to, uint256[] memory ids, uint256[] memory values) internal virtual { if (ids.length != values.length) { revert ERC1155InvalidArrayLength(ids.length, values.length); } address operator = _msgSender(); for (uint256 i = 0; i < ids.length; ++i) { uint256 id = ids.unsafeMemoryAccess(i); uint256 value = values.unsafeMemoryAccess(i); if (from != address(0)) { uint256 fromBalance = _balances[id][from]; if (fromBalance < value) { revert ERC1155InsufficientBalance(from, fromBalance, value, id); } unchecked { // Overflow not possible: value <= fromBalance _balances[id][from] = fromBalance - value; } } if (to != address(0)) { _balances[id][to] += value; } } if (ids.length == 1) { uint256 id = ids.unsafeMemoryAccess(0); uint256 value = values.unsafeMemoryAccess(0); emit TransferSingle(operator, from, to, id, value); } else { emit TransferBatch(operator, from, to, ids, values); } } /** * @dev Version of {_update} that performs the token acceptance check by calling * {IERC1155Receiver-onERC1155Received} or {IERC1155Receiver-onERC1155BatchReceived} on the receiver address if it * contains code (eg. is a smart contract at the moment of execution). * * IMPORTANT: Overriding this function is discouraged because it poses a reentrancy risk from the receiver. So any * update to the contract state after this function would break the check-effect-interaction pattern. Consider * overriding {_update} instead. */ function _updateWithAcceptanceCheck( address from, address to, uint256[] memory ids, uint256[] memory values, bytes memory data ) internal virtual { _update(from, to, ids, values); if (to != address(0)) { address operator = _msgSender(); if (ids.length == 1) { uint256 id = ids.unsafeMemoryAccess(0); uint256 value = values.unsafeMemoryAccess(0); ERC1155Utils.checkOnERC1155Received(operator, from, to, id, value, data); } else { ERC1155Utils.checkOnERC1155BatchReceived(operator, from, to, ids, values, data); } } } /** * @dev Transfers a `value` tokens of token type `id` from `from` to `to`. * * Emits a {TransferSingle} event. * * Requirements: * * - `to` cannot be the zero address. * - `from` must have a balance of tokens of type `id` of at least `value` amount. * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the * acceptance magic value. */ function _safeTransferFrom(address from, address to, uint256 id, uint256 value, bytes memory data) internal { if (to == address(0)) { revert ERC1155InvalidReceiver(address(0)); } if (from == address(0)) { revert ERC1155InvalidSender(address(0)); } (uint256[] memory ids, uint256[] memory values) = _asSingletonArrays(id, value); _updateWithAcceptanceCheck(from, to, ids, values, data); } /** * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_safeTransferFrom}. * * Emits a {TransferBatch} event. * * Requirements: * * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the * acceptance magic value. * - `ids` and `values` must have the same length. */ function _safeBatchTransferFrom( address from, address to, uint256[] memory ids, uint256[] memory values, bytes memory data ) internal { if (to == address(0)) { revert ERC1155InvalidReceiver(address(0)); } if (from == address(0)) { revert ERC1155InvalidSender(address(0)); } _updateWithAcceptanceCheck(from, to, ids, values, data); } /** * @dev Sets a new URI for all token types, by relying on the token type ID * substitution mechanism * https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the ERC]. * * By this mechanism, any occurrence of the `\{id\}` substring in either the * URI or any of the values in the JSON file at said URI will be replaced by * clients with the token type ID. * * For example, the `https://token-cdn-domain/\{id\}.json` URI would be * interpreted by clients as * `https://token-cdn-domain/000000000000000000000000000000000000000000000000000000000004cce0.json` * for token type ID 0x4cce0. * * See {uri}. * * Because these URIs cannot be meaningfully represented by the {URI} event, * this function emits no events. */ function _setURI(string memory newuri) internal virtual { _uri = newuri; } /** * @dev Creates a `value` amount of tokens of type `id`, and assigns them to `to`. * * Emits a {TransferSingle} event. * * Requirements: * * - `to` cannot be the zero address. * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the * acceptance magic value. */ function _mint(address to, uint256 id, uint256 value, bytes memory data) internal { if (to == address(0)) { revert ERC1155InvalidReceiver(address(0)); } (uint256[] memory ids, uint256[] memory values) = _asSingletonArrays(id, value); _updateWithAcceptanceCheck(address(0), to, ids, values, data); } /** * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_mint}. * * Emits a {TransferBatch} event. * * Requirements: * * - `ids` and `values` must have the same length. * - `to` cannot be the zero address. * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the * acceptance magic value. */ function _mintBatch(address to, uint256[] memory ids, uint256[] memory values, bytes memory data) internal { if (to == address(0)) { revert ERC1155InvalidReceiver(address(0)); } _updateWithAcceptanceCheck(address(0), to, ids, values, data); } /** * @dev Destroys a `value` amount of tokens of type `id` from `from` * * Emits a {TransferSingle} event. * * Requirements: * * - `from` cannot be the zero address. * - `from` must have at least `value` amount of tokens of type `id`. */ function _burn(address from, uint256 id, uint256 value) internal { if (from == address(0)) { revert ERC1155InvalidSender(address(0)); } (uint256[] memory ids, uint256[] memory values) = _asSingletonArrays(id, value); _updateWithAcceptanceCheck(from, address(0), ids, values, ""); } /** * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_burn}. * * Emits a {TransferBatch} event. * * Requirements: * * - `from` cannot be the zero address. * - `from` must have at least `value` amount of tokens of type `id`. * - `ids` and `values` must have the same length. */ function _burnBatch(address from, uint256[] memory ids, uint256[] memory values) internal { if (from == address(0)) { revert ERC1155InvalidSender(address(0)); } _updateWithAcceptanceCheck(from, address(0), ids, values, ""); } /** * @dev Approve `operator` to operate on all of `owner` tokens * * Emits an {ApprovalForAll} event. * * Requirements: * * - `operator` cannot be the zero address. */ function _setApprovalForAll(address owner, address operator, bool approved) internal virtual { if (operator == address(0)) { revert ERC1155InvalidOperator(address(0)); } _operatorApprovals[owner][operator] = approved; emit ApprovalForAll(owner, operator, approved); } /** * @dev Creates an array in memory with only one value for each of the elements provided. */ function _asSingletonArrays( uint256 element1, uint256 element2 ) private pure returns (uint256[] memory array1, uint256[] memory array2) { /// @solidity memory-safe-assembly assembly { // Load the free memory pointer array1 := mload(0x40) // Set array length to 1 mstore(array1, 1) // Store the single element at the next word after the length (where content starts) mstore(add(array1, 0x20), element1) // Repeat for next array locating it right after the first array array2 := add(array1, 0x40) mstore(array2, 1) mstore(add(array2, 0x20), element2) // Update the free memory pointer by pointing after the second array mstore(0x40, add(array2, 0x40)) } } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.20; import {IERC1155Receiver} from "../IERC1155Receiver.sol"; import {IERC1155Errors} from "../../../interfaces/draft-IERC6093.sol"; /** * @dev Library that provide common ERC-1155 utility functions. * * See https://eips.ethereum.org/EIPS/eip-1155[ERC-1155]. */ library ERC1155Utils { /** * @dev Performs an acceptance check for the provided `operator` by calling {IERC1155-onERC1155Received} * on the `to` address. The `operator` is generally the address that initiated the token transfer (i.e. `msg.sender`). * * The acceptance call is not executed and treated as a no-op if the target address is doesn't contain code (i.e. an EOA). * Otherwise, the recipient must implement {IERC1155Receiver-onERC1155Received} and return the acceptance magic value to accept * the transfer. */ function checkOnERC1155Received( address operator, address from, address to, uint256 id, uint256 value, bytes memory data ) internal { if (to.code.length > 0) { try IERC1155Receiver(to).onERC1155Received(operator, from, id, value, data) returns (bytes4 response) { if (response != IERC1155Receiver.onERC1155Received.selector) { // Tokens rejected revert IERC1155Errors.ERC1155InvalidReceiver(to); } } catch (bytes memory reason) { if (reason.length == 0) { // non-IERC1155Receiver implementer revert IERC1155Errors.ERC1155InvalidReceiver(to); } else { /// @solidity memory-safe-assembly assembly { revert(add(32, reason), mload(reason)) } } } } } /** * @dev Performs a batch acceptance check for the provided `operator` by calling {IERC1155-onERC1155BatchReceived} * on the `to` address. The `operator` is generally the address that initiated the token transfer (i.e. `msg.sender`). * * The acceptance call is not executed and treated as a no-op if the target address is doesn't contain code (i.e. an EOA). * Otherwise, the recipient must implement {IERC1155Receiver-onERC1155Received} and return the acceptance magic value to accept * the transfer. */ function checkOnERC1155BatchReceived( address operator, address from, address to, uint256[] memory ids, uint256[] memory values, bytes memory data ) internal { if (to.code.length > 0) { try IERC1155Receiver(to).onERC1155BatchReceived(operator, from, ids, values, data) returns ( bytes4 response ) { if (response != IERC1155Receiver.onERC1155BatchReceived.selector) { // Tokens rejected revert IERC1155Errors.ERC1155InvalidReceiver(to); } } catch (bytes memory reason) { if (reason.length == 0) { // non-IERC1155Receiver implementer revert IERC1155Errors.ERC1155InvalidReceiver(to); } else { /// @solidity memory-safe-assembly assembly { revert(add(32, reason), mload(reason)) } } } } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (utils/Arrays.sol) pragma solidity ^0.8.20; import {StorageSlot} from "./StorageSlot.sol"; import {Math} from "./math/Math.sol"; /** * @dev Collection of functions related to array types. */ library Arrays { using StorageSlot for bytes32; /** * @dev Sort an array (in memory) in increasing order. * * This function does the sorting "in place", meaning that it overrides the input. The object is returned for * convenience, but that returned value can be discarded safely if the caller has a memory pointer to the array. * * NOTE: this function's cost is `O(n · log(n))` in average and `O(n²)` in the worst case, with n the length of the * array. Using it in view functions that are executed through `eth_call` is safe, but one should be very careful * when executing this as part of a transaction. If the array being sorted is too large, the sort operation may * consume more gas than is available in a block, leading to potential DoS. */ function sort(uint256[] memory array) internal pure returns (uint256[] memory) { _quickSort(array, 0, array.length); return array; } /** * @dev Performs a quick sort on an array in memory. The array is sorted in increasing order. * * Invariant: `i <= j <= array.length`. This is the case when initially called by {sort} and is preserved in * subcalls. */ function _quickSort(uint256[] memory array, uint256 i, uint256 j) private pure { unchecked { // Can't overflow given `i <= j` if (j - i < 2) return; // Use first element as pivot uint256 pivot = unsafeMemoryAccess(array, i); // Position where the pivot should be at the end of the loop uint256 index = i; for (uint256 k = i + 1; k < j; ++k) { // Unsafe access is safe given `k < j <= array.length`. if (unsafeMemoryAccess(array, k) < pivot) { // If array[k] is smaller than the pivot, we increment the index and move array[k] there. _swap(array, ++index, k); } } // Swap pivot into place _swap(array, i, index); _quickSort(array, i, index); // Sort the left side of the pivot _quickSort(array, index + 1, j); // Sort the right side of the pivot } } /** * @dev Swaps the elements at positions `i` and `j` in the `arr` array. */ function _swap(uint256[] memory arr, uint256 i, uint256 j) private pure { assembly { let start := add(arr, 0x20) // Pointer to the first element of the array let pos_i := add(start, mul(i, 0x20)) let pos_j := add(start, mul(j, 0x20)) let val_i := mload(pos_i) let val_j := mload(pos_j) mstore(pos_i, val_j) mstore(pos_j, val_i) } } /** * @dev Searches a sorted `array` and returns the first index that contains * a value greater or equal to `element`. If no such index exists (i.e. all * values in the array are strictly less than `element`), the array length is * returned. Time complexity O(log n). * * NOTE: The `array` is expected to be sorted in ascending order, and to * contain no repeated elements. * * IMPORTANT: Deprecated. This implementation behaves as {lowerBound} but lacks * support for repeated elements in the array. The {lowerBound} function should * be used instead. */ function findUpperBound(uint256[] storage array, uint256 element) internal view returns (uint256) { uint256 low = 0; uint256 high = array.length; if (high == 0) { return 0; } while (low < high) { uint256 mid = Math.average(low, high); // Note that mid will always be strictly less than high (i.e. it will be a valid array index) // because Math.average rounds towards zero (it does integer division with truncation). if (unsafeAccess(array, mid).value > element) { high = mid; } else { low = mid + 1; } } // At this point `low` is the exclusive upper bound. We will return the inclusive upper bound. if (low > 0 && unsafeAccess(array, low - 1).value == element) { return low - 1; } else { return low; } } /** * @dev Searches an `array` sorted in ascending order and returns the first * index that contains a value greater or equal than `element`. If no such index * exists (i.e. all values in the array are strictly less than `element`), the array * length is returned. Time complexity O(log n). * * See C++'s https://en.cppreference.com/w/cpp/algorithm/lower_bound[lower_bound]. */ function lowerBound(uint256[] storage array, uint256 element) internal view returns (uint256) { uint256 low = 0; uint256 high = array.length; if (high == 0) { return 0; } while (low < high) { uint256 mid = Math.average(low, high); // Note that mid will always be strictly less than high (i.e. it will be a valid array index) // because Math.average rounds towards zero (it does integer division with truncation). if (unsafeAccess(array, mid).value < element) { // this cannot overflow because mid < high unchecked { low = mid + 1; } } else { high = mid; } } return low; } /** * @dev Searches an `array` sorted in ascending order and returns the first * index that contains a value strictly greater than `element`. If no such index * exists (i.e. all values in the array are strictly less than `element`), the array * length is returned. Time complexity O(log n). * * See C++'s https://en.cppreference.com/w/cpp/algorithm/upper_bound[upper_bound]. */ function upperBound(uint256[] storage array, uint256 element) internal view returns (uint256) { uint256 low = 0; uint256 high = array.length; if (high == 0) { return 0; } while (low < high) { uint256 mid = Math.average(low, high); // Note that mid will always be strictly less than high (i.e. it will be a valid array index) // because Math.average rounds towards zero (it does integer division with truncation). if (unsafeAccess(array, mid).value > element) { high = mid; } else { // this cannot overflow because mid < high unchecked { low = mid + 1; } } } return low; } /** * @dev Same as {lowerBound}, but with an array in memory. */ function lowerBoundMemory(uint256[] memory array, uint256 element) internal pure returns (uint256) { uint256 low = 0; uint256 high = array.length; if (high == 0) { return 0; } while (low < high) { uint256 mid = Math.average(low, high); // Note that mid will always be strictly less than high (i.e. it will be a valid array index) // because Math.average rounds towards zero (it does integer division with truncation). if (unsafeMemoryAccess(array, mid) < element) { // this cannot overflow because mid < high unchecked { low = mid + 1; } } else { high = mid; } } return low; } /** * @dev Same as {upperBound}, but with an array in memory. */ function upperBoundMemory(uint256[] memory array, uint256 element) internal pure returns (uint256) { uint256 low = 0; uint256 high = array.length; if (high == 0) { return 0; } while (low < high) { uint256 mid = Math.average(low, high); // Note that mid will always be strictly less than high (i.e. it will be a valid array index) // because Math.average rounds towards zero (it does integer division with truncation). if (unsafeMemoryAccess(array, mid) > element) { high = mid; } else { // this cannot overflow because mid < high unchecked { low = mid + 1; } } } return low; } /** * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check. * * WARNING: Only use if you are certain `pos` is lower than the array length. */ function unsafeAccess(address[] storage arr, uint256 pos) internal pure returns (StorageSlot.AddressSlot storage) { bytes32 slot; // We use assembly to calculate the storage slot of the element at index `pos` of the dynamic array `arr` // following https://docs.soliditylang.org/en/v0.8.20/internals/layout_in_storage.html#mappings-and-dynamic-arrays. /// @solidity memory-safe-assembly assembly { mstore(0, arr.slot) slot := add(keccak256(0, 0x20), pos) } return slot.getAddressSlot(); } /** * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check. * * WARNING: Only use if you are certain `pos` is lower than the array length. */ function unsafeAccess(bytes32[] storage arr, uint256 pos) internal pure returns (StorageSlot.Bytes32Slot storage) { bytes32 slot; // We use assembly to calculate the storage slot of the element at index `pos` of the dynamic array `arr` // following https://docs.soliditylang.org/en/v0.8.20/internals/layout_in_storage.html#mappings-and-dynamic-arrays. /// @solidity memory-safe-assembly assembly { mstore(0, arr.slot) slot := add(keccak256(0, 0x20), pos) } return slot.getBytes32Slot(); } /** * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check. * * WARNING: Only use if you are certain `pos` is lower than the array length. */ function unsafeAccess(uint256[] storage arr, uint256 pos) internal pure returns (StorageSlot.Uint256Slot storage) { bytes32 slot; // We use assembly to calculate the storage slot of the element at index `pos` of the dynamic array `arr` // following https://docs.soliditylang.org/en/v0.8.20/internals/layout_in_storage.html#mappings-and-dynamic-arrays. /// @solidity memory-safe-assembly assembly { mstore(0, arr.slot) slot := add(keccak256(0, 0x20), pos) } return slot.getUint256Slot(); } /** * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check. * * WARNING: Only use if you are certain `pos` is lower than the array length. */ function unsafeMemoryAccess(address[] memory arr, uint256 pos) internal pure returns (address res) { assembly { res := mload(add(add(arr, 0x20), mul(pos, 0x20))) } } /** * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check. * * WARNING: Only use if you are certain `pos` is lower than the array length. */ function unsafeMemoryAccess(bytes32[] memory arr, uint256 pos) internal pure returns (bytes32 res) { assembly { res := mload(add(add(arr, 0x20), mul(pos, 0x20))) } } /** * @dev Access an array in an "unsafe" way. Skips solidity "index-out-of-range" check. * * WARNING: Only use if you are certain `pos` is lower than the array length. */ function unsafeMemoryAccess(uint256[] memory arr, uint256 pos) internal pure returns (uint256 res) { assembly { res := mload(add(add(arr, 0x20), mul(pos, 0x20))) } } }
pragma solidity ^0.8.20; abstract contract Owned { error OwnableUnauthorizedAccount(address account); event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); modifier onlyOwner() { _checkOwner(); _; } function transferOwnership(address newOwner) public virtual onlyOwner { _transferOwnership(newOwner); } function _checkOwner() internal view virtual { if (owner() != msg.sender) { revert OwnableUnauthorizedAccount(msg.sender); } } function owner() public view virtual returns (address); function _transferOwnership(address newOwner) internal virtual; }
// 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 ERC-1155 compliant contract, as defined in the * https://eips.ethereum.org/EIPS/eip-1155[ERC]. */ interface IERC1155 is IERC165 { /** * @dev Emitted when `value` amount of tokens of type `id` are transferred from `from` to `to` by `operator`. */ event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value); /** * @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all * transfers. */ event TransferBatch( address indexed operator, address indexed from, address indexed to, uint256[] ids, uint256[] values ); /** * @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to * `approved`. */ event ApprovalForAll(address indexed account, address indexed operator, bool approved); /** * @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI. * * If an {URI} event was emitted for `id`, the standard * https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value * returned by {IERC1155MetadataURI-uri}. */ event URI(string value, uint256 indexed id); /** * @dev Returns the value of tokens of token type `id` owned by `account`. */ function balanceOf(address account, uint256 id) external view returns (uint256); /** * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}. * * Requirements: * * - `accounts` and `ids` must have the same length. */ function balanceOfBatch( address[] calldata accounts, uint256[] calldata ids ) external view returns (uint256[] memory); /** * @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`, * * Emits an {ApprovalForAll} event. * * Requirements: * * - `operator` cannot be the zero address. */ function setApprovalForAll(address operator, bool approved) external; /** * @dev Returns true if `operator` is approved to transfer ``account``'s tokens. * * See {setApprovalForAll}. */ function isApprovedForAll(address account, address operator) external view returns (bool); /** * @dev Transfers a `value` amount of tokens of type `id` from `from` to `to`. * * WARNING: This function can potentially allow a reentrancy attack when transferring tokens * to an untrusted contract, when invoking {onERC1155Received} on the receiver. * Ensure to follow the checks-effects-interactions pattern and consider employing * reentrancy guards when interacting with untrusted contracts. * * Emits a {TransferSingle} event. * * Requirements: * * - `to` cannot be the zero address. * - If the caller is not `from`, it must have been approved to spend ``from``'s tokens via {setApprovalForAll}. * - `from` must have a balance of tokens of type `id` of at least `value` amount. * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the * acceptance magic value. */ function safeTransferFrom(address from, address to, uint256 id, uint256 value, bytes calldata data) external; /** * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}. * * WARNING: This function can potentially allow a reentrancy attack when transferring tokens * to an untrusted contract, when invoking {onERC1155BatchReceived} on the receiver. * Ensure to follow the checks-effects-interactions pattern and consider employing * reentrancy guards when interacting with untrusted contracts. * * Emits either a {TransferSingle} or a {TransferBatch} event, depending on the length of the array arguments. * * Requirements: * * - `ids` and `values` must have the same length. * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the * acceptance magic value. */ function safeBatchTransferFrom( address from, address to, uint256[] calldata ids, uint256[] calldata values, bytes calldata data ) external; }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.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[ERC]. */ interface IERC1155MetadataURI is IERC1155 { /** * @dev Returns the URI for token type `id`. * * If the `\{id\}` substring is present in the URI, it must be replaced by * clients with the actual token type ID. */ function uri(uint256 id) external view returns (string memory); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.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/introspection/ERC165.sol) pragma solidity ^0.8.20; import {IERC165} from "./IERC165.sol"; /** * @dev Implementation of the {IERC165} interface. * * Contracts that want to implement ERC-165 should inherit from this contract and override {supportsInterface} to check * for the additional interface id that will be supported. For example: * * ```solidity * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId); * } * ``` */ abstract contract 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) (interfaces/draft-IERC6093.sol) pragma solidity ^0.8.20; /** * @dev Standard ERC-20 Errors * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-20 tokens. */ interface IERC20Errors { /** * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers. * @param sender Address whose tokens are being transferred. * @param balance Current balance for the interacting account. * @param needed Minimum amount required to perform a transfer. */ error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed); /** * @dev Indicates a failure with the token `sender`. Used in transfers. * @param sender Address whose tokens are being transferred. */ error ERC20InvalidSender(address sender); /** * @dev Indicates a failure with the token `receiver`. Used in transfers. * @param receiver Address to which tokens are being transferred. */ error ERC20InvalidReceiver(address receiver); /** * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers. * @param spender Address that may be allowed to operate on tokens without being their owner. * @param allowance Amount of tokens a `spender` is allowed to operate with. * @param needed Minimum amount required to perform a transfer. */ error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed); /** * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals. * @param approver Address initiating an approval operation. */ error ERC20InvalidApprover(address approver); /** * @dev Indicates a failure with the `spender` to be approved. Used in approvals. * @param spender Address that may be allowed to operate on tokens without being their owner. */ error ERC20InvalidSpender(address spender); } /** * @dev Standard ERC-721 Errors * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-721 tokens. */ interface IERC721Errors { /** * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-20. * Used in balance queries. * @param owner Address of the current owner of a token. */ error ERC721InvalidOwner(address owner); /** * @dev Indicates a `tokenId` whose `owner` is the zero address. * @param tokenId Identifier number of a token. */ error ERC721NonexistentToken(uint256 tokenId); /** * @dev Indicates an error related to the ownership over a particular token. Used in transfers. * @param sender Address whose tokens are being transferred. * @param tokenId Identifier number of a token. * @param owner Address of the current owner of a token. */ error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner); /** * @dev Indicates a failure with the token `sender`. Used in transfers. * @param sender Address whose tokens are being transferred. */ error ERC721InvalidSender(address sender); /** * @dev Indicates a failure with the token `receiver`. Used in transfers. * @param receiver Address to which tokens are being transferred. */ error ERC721InvalidReceiver(address receiver); /** * @dev Indicates a failure with the `operator`’s approval. Used in transfers. * @param operator Address that may be allowed to operate on tokens without being their owner. * @param tokenId Identifier number of a token. */ error ERC721InsufficientApproval(address operator, uint256 tokenId); /** * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals. * @param approver Address initiating an approval operation. */ error ERC721InvalidApprover(address approver); /** * @dev Indicates a failure with the `operator` to be approved. Used in approvals. * @param operator Address that may be allowed to operate on tokens without being their owner. */ error ERC721InvalidOperator(address operator); } /** * @dev Standard ERC-1155 Errors * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-1155 tokens. */ interface IERC1155Errors { /** * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers. * @param sender Address whose tokens are being transferred. * @param balance Current balance for the interacting account. * @param needed Minimum amount required to perform a transfer. * @param tokenId Identifier number of a token. */ error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId); /** * @dev Indicates a failure with the token `sender`. Used in transfers. * @param sender Address whose tokens are being transferred. */ error ERC1155InvalidSender(address sender); /** * @dev Indicates a failure with the token `receiver`. Used in transfers. * @param receiver Address to which tokens are being transferred. */ error ERC1155InvalidReceiver(address receiver); /** * @dev Indicates a failure with the `operator`’s approval. Used in transfers. * @param operator Address that may be allowed to operate on tokens without being their owner. * @param owner Address of the current owner of a token. */ error ERC1155MissingApprovalForAll(address operator, address owner); /** * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals. * @param approver Address initiating an approval operation. */ error ERC1155InvalidApprover(address approver); /** * @dev Indicates a failure with the `operator` to be approved. Used in approvals. * @param operator Address that may be allowed to operate on tokens without being their owner. */ error ERC1155InvalidOperator(address operator); /** * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation. * Used in batch transfers. * @param idsLength Length of the array of token identifiers * @param valuesLength Length of the array of token amounts */ error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (token/ERC1155/IERC1155Receiver.sol) pragma solidity ^0.8.20; import {IERC165} from "../../utils/introspection/IERC165.sol"; /** * @dev Interface that must be implemented by smart contracts in order to receive * ERC-1155 token transfers. */ interface IERC1155Receiver is IERC165 { /** * @dev Handles the receipt of a single ERC-1155 token type. This function is * called at the end of a `safeTransferFrom` after the balance has been updated. * * NOTE: To accept the transfer, this must return * `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` * (i.e. 0xf23a6e61, or its own function selector). * * @param operator The address which initiated the transfer (i.e. msg.sender) * @param from The address which previously owned the token * @param id The ID of the token being transferred * @param value The amount of tokens being transferred * @param data Additional data with no specified format * @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed */ function onERC1155Received( address operator, address from, uint256 id, uint256 value, bytes calldata data ) external returns (bytes4); /** * @dev Handles the receipt of a multiple ERC-1155 token types. This function * is called at the end of a `safeBatchTransferFrom` after the balances have * been updated. * * NOTE: To accept the transfer(s), this must return * `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` * (i.e. 0xbc197c81, or its own function selector). * * @param operator The address which initiated the batch transfer (i.e. msg.sender) * @param from The address which previously owned the token * @param ids An array containing ids of each token being transferred (order and length must match values array) * @param values An array containing amounts of each token being transferred (order and length must match ids array) * @param data Additional data with no specified format * @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed */ function onERC1155BatchReceived( address operator, address from, uint256[] calldata ids, uint256[] calldata values, bytes calldata data ) external returns (bytes4); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (utils/StorageSlot.sol) // This file was procedurally generated from scripts/generate/templates/StorageSlot.js. pragma solidity ^0.8.20; /** * @dev Library for reading and writing primitive types to specific storage slots. * * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts. * This library helps with reading and writing to such slots without the need for inline assembly. * * The functions in this library return Slot structs that contain a `value` member that can be used to read or write. * * Example usage to set ERC-1967 implementation slot: * ```solidity * contract ERC1967 { * bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc; * * function _getImplementation() internal view returns (address) { * return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value; * } * * function _setImplementation(address newImplementation) internal { * require(newImplementation.code.length > 0); * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation; * } * } * ``` */ library StorageSlot { struct AddressSlot { address value; } struct BooleanSlot { bool value; } struct Bytes32Slot { bytes32 value; } struct Uint256Slot { uint256 value; } struct StringSlot { string value; } struct BytesSlot { bytes value; } /** * @dev Returns an `AddressSlot` with member `value` located at `slot`. */ function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `BooleanSlot` with member `value` located at `slot`. */ function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `Bytes32Slot` with member `value` located at `slot`. */ function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `Uint256Slot` with member `value` located at `slot`. */ function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `StringSlot` with member `value` located at `slot`. */ function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `StringSlot` representation of the string storage pointer `store`. */ function getStringSlot(string storage store) internal pure returns (StringSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := store.slot } } /** * @dev Returns an `BytesSlot` with member `value` located at `slot`. */ function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := slot } } /** * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`. */ function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) { /// @solidity memory-safe-assembly assembly { r.slot := store.slot } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (utils/math/Math.sol) pragma solidity ^0.8.20; import {Address} from "../Address.sol"; import {Panic} from "../Panic.sol"; import {SafeCast} from "./SafeCast.sol"; /** * @dev Standard math utilities missing in the Solidity language. */ library Math { enum Rounding { Floor, // Toward negative infinity Ceil, // Toward positive infinity Trunc, // Toward zero Expand // Away from zero } /** * @dev Returns the addition of two unsigned integers, with an success flag (no overflow). */ function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) { unchecked { uint256 c = a + b; if (c < a) return (false, 0); return (true, c); } } /** * @dev Returns the subtraction of two unsigned integers, with an success flag (no overflow). */ function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) { unchecked { if (b > a) return (false, 0); return (true, a - b); } } /** * @dev Returns the multiplication of two unsigned integers, with an success flag (no overflow). */ function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) { unchecked { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) return (true, 0); uint256 c = a * b; if (c / a != b) return (false, 0); return (true, c); } } /** * @dev Returns the division of two unsigned integers, with a success flag (no division by zero). */ function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) { unchecked { if (b == 0) return (false, 0); return (true, a / b); } } /** * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero). */ function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) { unchecked { if (b == 0) return (false, 0); return (true, a % b); } } /** * @dev 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. Panic.panic(Panic.DIVISION_BY_ZERO); } // The following calculation ensures accurate ceiling division without overflow. // Since a is non-zero, (a - 1) / b will not overflow. // The largest possible result occurs when (a - 1) / b is type(uint256).max, // but the largest value we can obtain is type(uint256).max - 1, which happens // when a = type(uint256).max and b = 1. unchecked { return a == 0 ? 0 : (a - 1) / b + 1; } } /** * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or * denominator == 0. * * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by * Uniswap Labs also under MIT license. */ function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) { unchecked { // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^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) { Panic.panic(denominator == 0 ? Panic.DIVISION_BY_ZERO : Panic.UNDER_OVERFLOW); } /////////////////////////////////////////////// // 512 by 256 division. /////////////////////////////////////////////// // Make division exact by subtracting the remainder from [prod1 prod0]. uint256 remainder; assembly { // Compute remainder using mulmod. remainder := mulmod(x, y, denominator) // Subtract 256 bit number from 512 bit number. prod1 := sub(prod1, gt(remainder, prod0)) prod0 := sub(prod0, remainder) } // Factor powers of two out of denominator and compute largest power of two divisor of denominator. // Always >= 1. See https://cs.stackexchange.com/q/138556/92363. uint256 twos = denominator & (0 - denominator); assembly { // Divide denominator by twos. denominator := div(denominator, twos) // Divide [prod1 prod0] by twos. prod0 := div(prod0, twos) // Flip twos such that it is 2^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; } } /** * @dev Calculates x * y / denominator with full precision, following the selected rounding direction. */ function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) { return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0); } /** * @dev Calculate the modular multiplicative inverse of a number in Z/nZ. * * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, expect 0. * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible. * * If the input value is not inversible, 0 is returned. * * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Ferma's little theorem and get the * inverse using `Math.modExp(a, n - 2, n)`. */ function invMod(uint256 a, uint256 n) internal pure returns (uint256) { unchecked { if (n == 0) return 0; // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version) // Used to compute integers x and y such that: ax + ny = gcd(a, n). // When the gcd is 1, then the inverse of a modulo n exists and it's x. // ax + ny = 1 // ax = 1 + (-y)n // ax ≡ 1 (mod n) # x is the inverse of a modulo n // If the remainder is 0 the gcd is n right away. uint256 remainder = a % n; uint256 gcd = n; // Therefore the initial coefficients are: // ax + ny = gcd(a, n) = n // 0a + 1n = n int256 x = 0; int256 y = 1; while (remainder != 0) { uint256 quotient = gcd / remainder; (gcd, remainder) = ( // The old remainder is the next gcd to try. remainder, // Compute the next remainder. // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd // where gcd is at most n (capped to type(uint256).max) gcd - remainder * quotient ); (x, y) = ( // Increment the coefficient of a. y, // Decrement the coefficient of n. // Can overflow, but the result is casted to uint256 so that the // next value of y is "wrapped around" to a value between 0 and n - 1. x - y * int256(quotient) ); } if (gcd != 1) return 0; // No inverse exists. return x < 0 ? (n - uint256(-x)) : uint256(x); // Wrap the result if it's negative. } } /** * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m) * * Requirements: * - modulus can't be zero * - underlying staticcall to precompile must succeed * * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make * sure the chain you're using it on supports the precompiled contract for modular exponentiation * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, * the underlying function will succeed given the lack of a revert, but the result may be incorrectly * interpreted as 0. */ function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) { (bool success, uint256 result) = tryModExp(b, e, m); if (!success) { if (m == 0) { Panic.panic(Panic.DIVISION_BY_ZERO); } else { revert Address.FailedInnerCall(); } } return result; } /** * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m). * It includes a success flag indicating if the operation succeeded. Operation will be marked has failed if trying * to operate modulo 0 or if the underlying precompile reverted. * * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack * of a revert, but the result may be incorrectly interpreted as 0. */ function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) { if (m == 0) return (false, 0); /// @solidity memory-safe-assembly assembly { let ptr := mload(0x40) // | Offset | Content | Content (Hex) | // |-----------|------------|--------------------------------------------------------------------| // | 0x00:0x1f | size of b | 0x0000000000000000000000000000000000000000000000000000000000000020 | // | 0x20:0x3f | size of e | 0x0000000000000000000000000000000000000000000000000000000000000020 | // | 0x40:0x5f | size of m | 0x0000000000000000000000000000000000000000000000000000000000000020 | // | 0x60:0x7f | value of b | 0x<.............................................................b> | // | 0x80:0x9f | value of e | 0x<.............................................................e> | // | 0xa0:0xbf | value of m | 0x<.............................................................m> | mstore(ptr, 0x20) mstore(add(ptr, 0x20), 0x20) mstore(add(ptr, 0x40), 0x20) mstore(add(ptr, 0x60), b) mstore(add(ptr, 0x80), e) mstore(add(ptr, 0xa0), m) // Given the result < m, it's guaranteed to fit in 32 bytes, // so we can use the memory scratch space located at offset 0. success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20) result := mload(0x00) } } /** * @dev 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); } } /** * @dev Calculates sqrt(a), following the selected rounding direction. */ function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = sqrt(a); return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a); } } /** * @dev Return the log in base 2 of a positive value rounded towards zero. * Returns 0 if given 0. */ function log2(uint256 value) internal pure returns (uint256) { uint256 result = 0; uint256 exp; unchecked { exp = 128 * SafeCast.toUint(value > (1 << 128) - 1); value >>= exp; result += exp; exp = 64 * SafeCast.toUint(value > (1 << 64) - 1); value >>= exp; result += exp; exp = 32 * SafeCast.toUint(value > (1 << 32) - 1); value >>= exp; result += exp; exp = 16 * SafeCast.toUint(value > (1 << 16) - 1); value >>= exp; result += exp; exp = 8 * SafeCast.toUint(value > (1 << 8) - 1); value >>= exp; result += exp; exp = 4 * SafeCast.toUint(value > (1 << 4) - 1); value >>= exp; result += exp; exp = 2 * SafeCast.toUint(value > (1 << 2) - 1); value >>= exp; result += exp; result += SafeCast.toUint(value > 1); } return result; } /** * @dev Return the log in base 2, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log2(value); return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value); } } /** * @dev Return the log in base 10 of a positive value rounded towards zero. * Returns 0 if given 0. */ function log10(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >= 10 ** 64) { value /= 10 ** 64; result += 64; } if (value >= 10 ** 32) { value /= 10 ** 32; result += 32; } if (value >= 10 ** 16) { value /= 10 ** 16; result += 16; } if (value >= 10 ** 8) { value /= 10 ** 8; result += 8; } if (value >= 10 ** 4) { value /= 10 ** 4; result += 4; } if (value >= 10 ** 2) { value /= 10 ** 2; result += 2; } if (value >= 10 ** 1) { result += 1; } } return result; } /** * @dev Return the log in base 10, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log10(value); return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value); } } /** * @dev Return the log in base 256 of a positive value rounded towards zero. * Returns 0 if given 0. * * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string. */ function log256(uint256 value) internal pure returns (uint256) { uint256 result = 0; uint256 isGt; unchecked { isGt = SafeCast.toUint(value > (1 << 128) - 1); value >>= isGt * 128; result += isGt * 16; isGt = SafeCast.toUint(value > (1 << 64) - 1); value >>= isGt * 64; result += isGt * 8; isGt = SafeCast.toUint(value > (1 << 32) - 1); value >>= isGt * 32; result += isGt * 4; isGt = SafeCast.toUint(value > (1 << 16) - 1); value >>= isGt * 16; result += isGt * 2; result += SafeCast.toUint(value > (1 << 8) - 1); } return result; } /** * @dev Return the log in base 256, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log256(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log256(value); return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value); } } /** * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers. */ function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) { return uint8(rounding) % 2 == 1; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/IERC165.sol) pragma solidity ^0.8.20; /** * @dev Interface of the ERC-165 standard, as defined in the * https://eips.ethereum.org/EIPS/eip-165[ERC]. * * Implementers can declare support of contract interfaces, which can then be * queried by others ({ERC165Checker}). * * For an implementation, see {ERC165}. */ interface IERC165 { /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section] * to learn more about how these ids are created. * * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.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 pragma solidity ^0.8.20; /** * @dev Helper library for emitting standardized panic codes. * * ```solidity * contract Example { * using Panic for uint256; * * // Use any of the declared internal constants * function foo() { Panic.GENERIC.panic(); } * * // Alternatively * function foo() { Panic.panic(Panic.GENERIC); } * } * ``` * * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil]. */ // slither-disable-next-line unused-state library Panic { /// @dev generic / unspecified error uint256 internal constant GENERIC = 0x00; /// @dev used by the assert() builtin uint256 internal constant ASSERT = 0x01; /// @dev arithmetic underflow or overflow uint256 internal constant UNDER_OVERFLOW = 0x11; /// @dev division or modulo by zero uint256 internal constant DIVISION_BY_ZERO = 0x12; /// @dev enum conversion error uint256 internal constant ENUM_CONVERSION_ERROR = 0x21; /// @dev invalid encoding in storage uint256 internal constant STORAGE_ENCODING_ERROR = 0x22; /// @dev empty array pop uint256 internal constant EMPTY_ARRAY_POP = 0x31; /// @dev array out of bounds access uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32; /// @dev resource error (too large allocation or too large array) uint256 internal constant RESOURCE_ERROR = 0x41; /// @dev calling invalid internal function uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51; /// @dev Reverts with a panic code. Recommended to use with /// the internal constants with predefined codes. function panic(uint256 code) internal pure { /// @solidity memory-safe-assembly assembly { mstore(0x00, shl(0xe0, 0x4e487b71)) mstore(0x04, code) revert(0x00, 0x24) } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SafeCast.sol) // This file was procedurally generated from scripts/generate/templates/SafeCast.js. pragma solidity ^0.8.20; /** * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow * checks. * * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can * easily result in undesired exploitation or bugs, since developers usually * assume that overflows raise errors. `SafeCast` restores this intuition by * reverting the transaction when such an operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. */ library SafeCast { /** * @dev Value doesn't fit in an uint of `bits` size. */ error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value); /** * @dev An int value doesn't fit in an uint of `bits` size. */ error SafeCastOverflowedIntToUint(int256 value); /** * @dev Value doesn't fit in an int of `bits` size. */ error SafeCastOverflowedIntDowncast(uint8 bits, int256 value); /** * @dev An uint value doesn't fit in an int of `bits` size. */ error SafeCastOverflowedUintToInt(uint256 value); /** * @dev Returns the downcasted uint248 from uint256, reverting on * overflow (when the input is greater than largest uint248). * * Counterpart to Solidity's `uint248` operator. * * Requirements: * * - input must fit into 248 bits */ function toUint248(uint256 value) internal pure returns (uint248) { if (value > type(uint248).max) { revert SafeCastOverflowedUintDowncast(248, value); } return uint248(value); } /** * @dev Returns the downcasted uint240 from uint256, reverting on * overflow (when the input is greater than largest uint240). * * Counterpart to Solidity's `uint240` operator. * * Requirements: * * - input must fit into 240 bits */ function toUint240(uint256 value) internal pure returns (uint240) { if (value > type(uint240).max) { revert SafeCastOverflowedUintDowncast(240, value); } return uint240(value); } /** * @dev Returns the downcasted uint232 from uint256, reverting on * overflow (when the input is greater than largest uint232). * * Counterpart to Solidity's `uint232` operator. * * Requirements: * * - input must fit into 232 bits */ function toUint232(uint256 value) internal pure returns (uint232) { if (value > type(uint232).max) { revert SafeCastOverflowedUintDowncast(232, value); } return uint232(value); } /** * @dev Returns the downcasted uint224 from uint256, reverting on * overflow (when the input is greater than largest uint224). * * Counterpart to Solidity's `uint224` operator. * * Requirements: * * - input must fit into 224 bits */ function toUint224(uint256 value) internal pure returns (uint224) { if (value > type(uint224).max) { revert SafeCastOverflowedUintDowncast(224, value); } return uint224(value); } /** * @dev Returns the downcasted uint216 from uint256, reverting on * overflow (when the input is greater than largest uint216). * * Counterpart to Solidity's `uint216` operator. * * Requirements: * * - input must fit into 216 bits */ function toUint216(uint256 value) internal pure returns (uint216) { if (value > type(uint216).max) { revert SafeCastOverflowedUintDowncast(216, value); } return uint216(value); } /** * @dev Returns the downcasted uint208 from uint256, reverting on * overflow (when the input is greater than largest uint208). * * Counterpart to Solidity's `uint208` operator. * * Requirements: * * - input must fit into 208 bits */ function toUint208(uint256 value) internal pure returns (uint208) { if (value > type(uint208).max) { revert SafeCastOverflowedUintDowncast(208, value); } return uint208(value); } /** * @dev Returns the downcasted uint200 from uint256, reverting on * overflow (when the input is greater than largest uint200). * * Counterpart to Solidity's `uint200` operator. * * Requirements: * * - input must fit into 200 bits */ function toUint200(uint256 value) internal pure returns (uint200) { if (value > type(uint200).max) { revert SafeCastOverflowedUintDowncast(200, value); } return uint200(value); } /** * @dev Returns the downcasted uint192 from uint256, reverting on * overflow (when the input is greater than largest uint192). * * Counterpart to Solidity's `uint192` operator. * * Requirements: * * - input must fit into 192 bits */ function toUint192(uint256 value) internal pure returns (uint192) { if (value > type(uint192).max) { revert SafeCastOverflowedUintDowncast(192, value); } return uint192(value); } /** * @dev Returns the downcasted uint184 from uint256, reverting on * overflow (when the input is greater than largest uint184). * * Counterpart to Solidity's `uint184` operator. * * Requirements: * * - input must fit into 184 bits */ function toUint184(uint256 value) internal pure returns (uint184) { if (value > type(uint184).max) { revert SafeCastOverflowedUintDowncast(184, value); } return uint184(value); } /** * @dev Returns the downcasted uint176 from uint256, reverting on * overflow (when the input is greater than largest uint176). * * Counterpart to Solidity's `uint176` operator. * * Requirements: * * - input must fit into 176 bits */ function toUint176(uint256 value) internal pure returns (uint176) { if (value > type(uint176).max) { revert SafeCastOverflowedUintDowncast(176, value); } return uint176(value); } /** * @dev Returns the downcasted uint168 from uint256, reverting on * overflow (when the input is greater than largest uint168). * * Counterpart to Solidity's `uint168` operator. * * Requirements: * * - input must fit into 168 bits */ function toUint168(uint256 value) internal pure returns (uint168) { if (value > type(uint168).max) { revert SafeCastOverflowedUintDowncast(168, value); } return uint168(value); } /** * @dev Returns the downcasted uint160 from uint256, reverting on * overflow (when the input is greater than largest uint160). * * Counterpart to Solidity's `uint160` operator. * * Requirements: * * - input must fit into 160 bits */ function toUint160(uint256 value) internal pure returns (uint160) { if (value > type(uint160).max) { revert SafeCastOverflowedUintDowncast(160, value); } return uint160(value); } /** * @dev Returns the downcasted uint152 from uint256, reverting on * overflow (when the input is greater than largest uint152). * * Counterpart to Solidity's `uint152` operator. * * Requirements: * * - input must fit into 152 bits */ function toUint152(uint256 value) internal pure returns (uint152) { if (value > type(uint152).max) { revert SafeCastOverflowedUintDowncast(152, value); } return uint152(value); } /** * @dev Returns the downcasted uint144 from uint256, reverting on * overflow (when the input is greater than largest uint144). * * Counterpart to Solidity's `uint144` operator. * * Requirements: * * - input must fit into 144 bits */ function toUint144(uint256 value) internal pure returns (uint144) { if (value > type(uint144).max) { revert SafeCastOverflowedUintDowncast(144, value); } return uint144(value); } /** * @dev Returns the downcasted uint136 from uint256, reverting on * overflow (when the input is greater than largest uint136). * * Counterpart to Solidity's `uint136` operator. * * Requirements: * * - input must fit into 136 bits */ function toUint136(uint256 value) internal pure returns (uint136) { if (value > type(uint136).max) { revert SafeCastOverflowedUintDowncast(136, value); } return uint136(value); } /** * @dev Returns the downcasted uint128 from uint256, reverting on * overflow (when the input is greater than largest uint128). * * Counterpart to Solidity's `uint128` operator. * * Requirements: * * - input must fit into 128 bits */ function toUint128(uint256 value) internal pure returns (uint128) { if (value > type(uint128).max) { revert SafeCastOverflowedUintDowncast(128, value); } return uint128(value); } /** * @dev Returns the downcasted uint120 from uint256, reverting on * overflow (when the input is greater than largest uint120). * * Counterpart to Solidity's `uint120` operator. * * Requirements: * * - input must fit into 120 bits */ function toUint120(uint256 value) internal pure returns (uint120) { if (value > type(uint120).max) { revert SafeCastOverflowedUintDowncast(120, value); } return uint120(value); } /** * @dev Returns the downcasted uint112 from uint256, reverting on * overflow (when the input is greater than largest uint112). * * Counterpart to Solidity's `uint112` operator. * * Requirements: * * - input must fit into 112 bits */ function toUint112(uint256 value) internal pure returns (uint112) { if (value > type(uint112).max) { revert SafeCastOverflowedUintDowncast(112, value); } return uint112(value); } /** * @dev Returns the downcasted uint104 from uint256, reverting on * overflow (when the input is greater than largest uint104). * * Counterpart to Solidity's `uint104` operator. * * Requirements: * * - input must fit into 104 bits */ function toUint104(uint256 value) internal pure returns (uint104) { if (value > type(uint104).max) { revert SafeCastOverflowedUintDowncast(104, value); } return uint104(value); } /** * @dev Returns the downcasted uint96 from uint256, reverting on * overflow (when the input is greater than largest uint96). * * Counterpart to Solidity's `uint96` operator. * * Requirements: * * - input must fit into 96 bits */ function toUint96(uint256 value) internal pure returns (uint96) { if (value > type(uint96).max) { revert SafeCastOverflowedUintDowncast(96, value); } return uint96(value); } /** * @dev Returns the downcasted uint88 from uint256, reverting on * overflow (when the input is greater than largest uint88). * * Counterpart to Solidity's `uint88` operator. * * Requirements: * * - input must fit into 88 bits */ function toUint88(uint256 value) internal pure returns (uint88) { if (value > type(uint88).max) { revert SafeCastOverflowedUintDowncast(88, value); } return uint88(value); } /** * @dev Returns the downcasted uint80 from uint256, reverting on * overflow (when the input is greater than largest uint80). * * Counterpart to Solidity's `uint80` operator. * * Requirements: * * - input must fit into 80 bits */ function toUint80(uint256 value) internal pure returns (uint80) { if (value > type(uint80).max) { revert SafeCastOverflowedUintDowncast(80, value); } return uint80(value); } /** * @dev Returns the downcasted uint72 from uint256, reverting on * overflow (when the input is greater than largest uint72). * * Counterpart to Solidity's `uint72` operator. * * Requirements: * * - input must fit into 72 bits */ function toUint72(uint256 value) internal pure returns (uint72) { if (value > type(uint72).max) { revert SafeCastOverflowedUintDowncast(72, value); } return uint72(value); } /** * @dev Returns the downcasted uint64 from uint256, reverting on * overflow (when the input is greater than largest uint64). * * Counterpart to Solidity's `uint64` operator. * * Requirements: * * - input must fit into 64 bits */ function toUint64(uint256 value) internal pure returns (uint64) { if (value > type(uint64).max) { revert SafeCastOverflowedUintDowncast(64, value); } return uint64(value); } /** * @dev Returns the downcasted uint56 from uint256, reverting on * overflow (when the input is greater than largest uint56). * * Counterpart to Solidity's `uint56` operator. * * Requirements: * * - input must fit into 56 bits */ function toUint56(uint256 value) internal pure returns (uint56) { if (value > type(uint56).max) { revert SafeCastOverflowedUintDowncast(56, value); } return uint56(value); } /** * @dev Returns the downcasted uint48 from uint256, reverting on * overflow (when the input is greater than largest uint48). * * Counterpart to Solidity's `uint48` operator. * * Requirements: * * - input must fit into 48 bits */ function toUint48(uint256 value) internal pure returns (uint48) { if (value > type(uint48).max) { revert SafeCastOverflowedUintDowncast(48, value); } return uint48(value); } /** * @dev Returns the downcasted uint40 from uint256, reverting on * overflow (when the input is greater than largest uint40). * * Counterpart to Solidity's `uint40` operator. * * Requirements: * * - input must fit into 40 bits */ function toUint40(uint256 value) internal pure returns (uint40) { if (value > type(uint40).max) { revert SafeCastOverflowedUintDowncast(40, value); } return uint40(value); } /** * @dev Returns the downcasted uint32 from uint256, reverting on * overflow (when the input is greater than largest uint32). * * Counterpart to Solidity's `uint32` operator. * * Requirements: * * - input must fit into 32 bits */ function toUint32(uint256 value) internal pure returns (uint32) { if (value > type(uint32).max) { revert SafeCastOverflowedUintDowncast(32, value); } return uint32(value); } /** * @dev Returns the downcasted uint24 from uint256, reverting on * overflow (when the input is greater than largest uint24). * * Counterpart to Solidity's `uint24` operator. * * Requirements: * * - input must fit into 24 bits */ function toUint24(uint256 value) internal pure returns (uint24) { if (value > type(uint24).max) { revert SafeCastOverflowedUintDowncast(24, value); } return uint24(value); } /** * @dev Returns the downcasted uint16 from uint256, reverting on * overflow (when the input is greater than largest uint16). * * Counterpart to Solidity's `uint16` operator. * * Requirements: * * - input must fit into 16 bits */ function toUint16(uint256 value) internal pure returns (uint16) { if (value > type(uint16).max) { revert SafeCastOverflowedUintDowncast(16, value); } return uint16(value); } /** * @dev Returns the downcasted uint8 from uint256, reverting on * overflow (when the input is greater than largest uint8). * * Counterpart to Solidity's `uint8` operator. * * Requirements: * * - input must fit into 8 bits */ function toUint8(uint256 value) internal pure returns (uint8) { if (value > type(uint8).max) { revert SafeCastOverflowedUintDowncast(8, value); } return uint8(value); } /** * @dev Converts a signed int256 into an unsigned uint256. * * Requirements: * * - input must be greater than or equal to 0. */ function toUint256(int256 value) internal pure returns (uint256) { if (value < 0) { revert SafeCastOverflowedIntToUint(value); } return uint256(value); } /** * @dev Returns the downcasted int248 from int256, reverting on * overflow (when the input is less than smallest int248 or * greater than largest int248). * * Counterpart to Solidity's `int248` operator. * * Requirements: * * - input must fit into 248 bits */ function toInt248(int256 value) internal pure returns (int248 downcasted) { downcasted = int248(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(248, value); } } /** * @dev Returns the downcasted int240 from int256, reverting on * overflow (when the input is less than smallest int240 or * greater than largest int240). * * Counterpart to Solidity's `int240` operator. * * Requirements: * * - input must fit into 240 bits */ function toInt240(int256 value) internal pure returns (int240 downcasted) { downcasted = int240(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(240, value); } } /** * @dev Returns the downcasted int232 from int256, reverting on * overflow (when the input is less than smallest int232 or * greater than largest int232). * * Counterpart to Solidity's `int232` operator. * * Requirements: * * - input must fit into 232 bits */ function toInt232(int256 value) internal pure returns (int232 downcasted) { downcasted = int232(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(232, value); } } /** * @dev Returns the downcasted int224 from int256, reverting on * overflow (when the input is less than smallest int224 or * greater than largest int224). * * Counterpart to Solidity's `int224` operator. * * Requirements: * * - input must fit into 224 bits */ function toInt224(int256 value) internal pure returns (int224 downcasted) { downcasted = int224(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(224, value); } } /** * @dev Returns the downcasted int216 from int256, reverting on * overflow (when the input is less than smallest int216 or * greater than largest int216). * * Counterpart to Solidity's `int216` operator. * * Requirements: * * - input must fit into 216 bits */ function toInt216(int256 value) internal pure returns (int216 downcasted) { downcasted = int216(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(216, value); } } /** * @dev Returns the downcasted int208 from int256, reverting on * overflow (when the input is less than smallest int208 or * greater than largest int208). * * Counterpart to Solidity's `int208` operator. * * Requirements: * * - input must fit into 208 bits */ function toInt208(int256 value) internal pure returns (int208 downcasted) { downcasted = int208(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(208, value); } } /** * @dev Returns the downcasted int200 from int256, reverting on * overflow (when the input is less than smallest int200 or * greater than largest int200). * * Counterpart to Solidity's `int200` operator. * * Requirements: * * - input must fit into 200 bits */ function toInt200(int256 value) internal pure returns (int200 downcasted) { downcasted = int200(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(200, value); } } /** * @dev Returns the downcasted int192 from int256, reverting on * overflow (when the input is less than smallest int192 or * greater than largest int192). * * Counterpart to Solidity's `int192` operator. * * Requirements: * * - input must fit into 192 bits */ function toInt192(int256 value) internal pure returns (int192 downcasted) { downcasted = int192(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(192, value); } } /** * @dev Returns the downcasted int184 from int256, reverting on * overflow (when the input is less than smallest int184 or * greater than largest int184). * * Counterpart to Solidity's `int184` operator. * * Requirements: * * - input must fit into 184 bits */ function toInt184(int256 value) internal pure returns (int184 downcasted) { downcasted = int184(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(184, value); } } /** * @dev Returns the downcasted int176 from int256, reverting on * overflow (when the input is less than smallest int176 or * greater than largest int176). * * Counterpart to Solidity's `int176` operator. * * Requirements: * * - input must fit into 176 bits */ function toInt176(int256 value) internal pure returns (int176 downcasted) { downcasted = int176(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(176, value); } } /** * @dev Returns the downcasted int168 from int256, reverting on * overflow (when the input is less than smallest int168 or * greater than largest int168). * * Counterpart to Solidity's `int168` operator. * * Requirements: * * - input must fit into 168 bits */ function toInt168(int256 value) internal pure returns (int168 downcasted) { downcasted = int168(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(168, value); } } /** * @dev Returns the downcasted int160 from int256, reverting on * overflow (when the input is less than smallest int160 or * greater than largest int160). * * Counterpart to Solidity's `int160` operator. * * Requirements: * * - input must fit into 160 bits */ function toInt160(int256 value) internal pure returns (int160 downcasted) { downcasted = int160(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(160, value); } } /** * @dev Returns the downcasted int152 from int256, reverting on * overflow (when the input is less than smallest int152 or * greater than largest int152). * * Counterpart to Solidity's `int152` operator. * * Requirements: * * - input must fit into 152 bits */ function toInt152(int256 value) internal pure returns (int152 downcasted) { downcasted = int152(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(152, value); } } /** * @dev Returns the downcasted int144 from int256, reverting on * overflow (when the input is less than smallest int144 or * greater than largest int144). * * Counterpart to Solidity's `int144` operator. * * Requirements: * * - input must fit into 144 bits */ function toInt144(int256 value) internal pure returns (int144 downcasted) { downcasted = int144(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(144, value); } } /** * @dev Returns the downcasted int136 from int256, reverting on * overflow (when the input is less than smallest int136 or * greater than largest int136). * * Counterpart to Solidity's `int136` operator. * * Requirements: * * - input must fit into 136 bits */ function toInt136(int256 value) internal pure returns (int136 downcasted) { downcasted = int136(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(136, value); } } /** * @dev Returns the downcasted int128 from int256, reverting on * overflow (when the input is less than smallest int128 or * greater than largest int128). * * Counterpart to Solidity's `int128` operator. * * Requirements: * * - input must fit into 128 bits */ function toInt128(int256 value) internal pure returns (int128 downcasted) { downcasted = int128(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(128, value); } } /** * @dev Returns the downcasted int120 from int256, reverting on * overflow (when the input is less than smallest int120 or * greater than largest int120). * * Counterpart to Solidity's `int120` operator. * * Requirements: * * - input must fit into 120 bits */ function toInt120(int256 value) internal pure returns (int120 downcasted) { downcasted = int120(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(120, value); } } /** * @dev Returns the downcasted int112 from int256, reverting on * overflow (when the input is less than smallest int112 or * greater than largest int112). * * Counterpart to Solidity's `int112` operator. * * Requirements: * * - input must fit into 112 bits */ function toInt112(int256 value) internal pure returns (int112 downcasted) { downcasted = int112(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(112, value); } } /** * @dev Returns the downcasted int104 from int256, reverting on * overflow (when the input is less than smallest int104 or * greater than largest int104). * * Counterpart to Solidity's `int104` operator. * * Requirements: * * - input must fit into 104 bits */ function toInt104(int256 value) internal pure returns (int104 downcasted) { downcasted = int104(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(104, value); } } /** * @dev Returns the downcasted int96 from int256, reverting on * overflow (when the input is less than smallest int96 or * greater than largest int96). * * Counterpart to Solidity's `int96` operator. * * Requirements: * * - input must fit into 96 bits */ function toInt96(int256 value) internal pure returns (int96 downcasted) { downcasted = int96(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(96, value); } } /** * @dev Returns the downcasted int88 from int256, reverting on * overflow (when the input is less than smallest int88 or * greater than largest int88). * * Counterpart to Solidity's `int88` operator. * * Requirements: * * - input must fit into 88 bits */ function toInt88(int256 value) internal pure returns (int88 downcasted) { downcasted = int88(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(88, value); } } /** * @dev Returns the downcasted int80 from int256, reverting on * overflow (when the input is less than smallest int80 or * greater than largest int80). * * Counterpart to Solidity's `int80` operator. * * Requirements: * * - input must fit into 80 bits */ function toInt80(int256 value) internal pure returns (int80 downcasted) { downcasted = int80(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(80, value); } } /** * @dev Returns the downcasted int72 from int256, reverting on * overflow (when the input is less than smallest int72 or * greater than largest int72). * * Counterpart to Solidity's `int72` operator. * * Requirements: * * - input must fit into 72 bits */ function toInt72(int256 value) internal pure returns (int72 downcasted) { downcasted = int72(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(72, value); } } /** * @dev Returns the downcasted int64 from int256, reverting on * overflow (when the input is less than smallest int64 or * greater than largest int64). * * Counterpart to Solidity's `int64` operator. * * Requirements: * * - input must fit into 64 bits */ function toInt64(int256 value) internal pure returns (int64 downcasted) { downcasted = int64(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(64, value); } } /** * @dev Returns the downcasted int56 from int256, reverting on * overflow (when the input is less than smallest int56 or * greater than largest int56). * * Counterpart to Solidity's `int56` operator. * * Requirements: * * - input must fit into 56 bits */ function toInt56(int256 value) internal pure returns (int56 downcasted) { downcasted = int56(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(56, value); } } /** * @dev Returns the downcasted int48 from int256, reverting on * overflow (when the input is less than smallest int48 or * greater than largest int48). * * Counterpart to Solidity's `int48` operator. * * Requirements: * * - input must fit into 48 bits */ function toInt48(int256 value) internal pure returns (int48 downcasted) { downcasted = int48(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(48, value); } } /** * @dev Returns the downcasted int40 from int256, reverting on * overflow (when the input is less than smallest int40 or * greater than largest int40). * * Counterpart to Solidity's `int40` operator. * * Requirements: * * - input must fit into 40 bits */ function toInt40(int256 value) internal pure returns (int40 downcasted) { downcasted = int40(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(40, value); } } /** * @dev Returns the downcasted int32 from int256, reverting on * overflow (when the input is less than smallest int32 or * greater than largest int32). * * Counterpart to Solidity's `int32` operator. * * Requirements: * * - input must fit into 32 bits */ function toInt32(int256 value) internal pure returns (int32 downcasted) { downcasted = int32(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(32, value); } } /** * @dev Returns the downcasted int24 from int256, reverting on * overflow (when the input is less than smallest int24 or * greater than largest int24). * * Counterpart to Solidity's `int24` operator. * * Requirements: * * - input must fit into 24 bits */ function toInt24(int256 value) internal pure returns (int24 downcasted) { downcasted = int24(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(24, value); } } /** * @dev Returns the downcasted int16 from int256, reverting on * overflow (when the input is less than smallest int16 or * greater than largest int16). * * Counterpart to Solidity's `int16` operator. * * Requirements: * * - input must fit into 16 bits */ function toInt16(int256 value) internal pure returns (int16 downcasted) { downcasted = int16(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(16, value); } } /** * @dev Returns the downcasted int8 from int256, reverting on * overflow (when the input is less than smallest int8 or * greater than largest int8). * * Counterpart to Solidity's `int8` operator. * * Requirements: * * - input must fit into 8 bits */ function toInt8(int256 value) internal pure returns (int8 downcasted) { downcasted = int8(value); if (downcasted != value) { revert SafeCastOverflowedIntDowncast(8, value); } } /** * @dev Converts an unsigned uint256 into a signed int256. * * Requirements: * * - input must be less than or equal to maxInt256. */ function toInt256(uint256 value) internal pure returns (int256) { // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive if (value > uint256(type(int256).max)) { revert SafeCastOverflowedUintToInt(value); } return int256(value); } /** * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump. */ function toUint(bool b) internal pure returns (uint256 u) { /// @solidity memory-safe-assembly assembly { u := iszero(iszero(b)) } } }
{ "remappings": [ "@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/", "ERC404/=lib/ERC404/src/", "ds-test/=lib/forge-std/lib/ds-test/src/", "erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/", "forge-std/=lib/forge-std/src/", "openzeppelin-contracts/=lib/openzeppelin-contracts/", "solidity-linked-list/=lib/solidity-linked-list/" ], "optimizer": { "enabled": true, "runs": 200 }, "metadata": { "useLiteralContent": false, "bytecodeHash": "ipfs", "appendCBOR": true }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } }, "evmVersion": "paris", "libraries": {} }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"string","name":"_name","type":"string"},{"internalType":"uint256","name":"_supply","type":"uint256"},{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"team","type":"address"},{"internalType":"address","name":"treasury","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"CollectionInvalidID","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ERC1155InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC1155InvalidApprover","type":"error"},{"inputs":[{"internalType":"uint256","name":"idsLength","type":"uint256"},{"internalType":"uint256","name":"valuesLength","type":"uint256"}],"name":"ERC1155InvalidArrayLength","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"ERC1155InvalidOperator","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC1155InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC1155InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"address","name":"owner","type":"address"}],"name":"ERC1155MissingApprovalForAll","type":"error"},{"inputs":[],"name":"EscrowDepositUnderfunded","type":"error"},{"inputs":[],"name":"EscrowWithdrawalFailed","type":"error"},{"inputs":[{"internalType":"uint256","name":"limit","type":"uint256"}],"name":"MintableMaxExceeded","type":"error"},{"inputs":[{"internalType":"uint256","name":"cost","type":"uint256"}],"name":"MintableUnderfunded","type":"error"},{"inputs":[],"name":"RestrictedOperation","type":"error"},{"inputs":[],"name":"TokenNotLive","type":"error"},{"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":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Minted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"indexed":false,"internalType":"uint256[]","name":"values","type":"uint256[]"}],"name":"TransferBatch","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"TransferSingle","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"value","type":"string"},{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"}],"name":"URI","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"receiver","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdrawal","type":"event"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"count","type":"uint256"}],"name":"_sudoTransferNext","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"allHeldBy","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"accounts","type":"address[]"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"}],"name":"balanceOfBatch","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"beneficiary","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"beneficiary","type":"address"}],"name":"escrowed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"max","type":"uint256"}],"name":"heldBy","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"uint256","name":"teamGrant","type":"uint256"},{"internalType":"uint256","name":"treasuryGrant","type":"uint256"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"principal","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"address","name":"holder","type":"address"}],"name":"isHeldBy","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_mintCost","type":"uint256"},{"internalType":"uint256","name":"_mintLimit","type":"uint256"},{"internalType":"string","name":"_uri","type":"string"}],"name":"launch","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"count","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC1155BatchReceived","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC1155Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"price","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"quantityHeldBy","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounce","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":"values","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":"value","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"delegate","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_limit","type":"uint256"}],"name":"setMintLimit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_price","type":"uint256"}],"name":"setMintPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_uri","type":"string"}],"name":"setURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"uri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address payable","name":"beneficiary","type":"address"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"beneficiary","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
60806040523480156200001157600080fd5b506040516200392a3803806200392a8339810160408190526200003491620001d4565b8484604051806020016040528060008152508062000058816200018f60201b60201c565b50612710821115620000bc5760405162461bcd60e51b815260206004820152602360248201527f43757272656e746c79206f6e6c7920737570706f7274732031306b20737570706044820152626c792160e81b606482015260840160405180910390fd5b6003620000ca84826200037c565b50600060045560058290556006620000e382826200037c565b503060009081526007602052604081206029018390555b602881101562000139573060009081526007602052604090206000199060010182602881106200012e576200012e62000448565b0155600101620000fa565b5050600c80546001600160a01b039687166001600160a01b031991821617909155600d8054958716958216959095179094555050600e805491909316911617905550506009805460ff60a01b191690556200045e565b60066200019d82826200037c565b5050565b634e487b7160e01b600052604160045260246000fd5b80516001600160a01b0381168114620001cf57600080fd5b919050565b600080600080600060a08688031215620001ed57600080fd5b85516001600160401b03808211156200020557600080fd5b818801915088601f8301126200021a57600080fd5b8151818111156200022f576200022f620001a1565b604051601f8201601f19908116603f011681019083821181831017156200025a576200025a620001a1565b81604052828152602093508b848487010111156200027757600080fd5b600091505b828210156200029b57848201840151818301850152908301906200027c565b60008484830101528099505050508088015195505050620002bf60408701620001b7565b9250620002cf60608701620001b7565b9150620002df60808701620001b7565b90509295509295909350565b600181811c908216806200030057607f821691505b6020821081036200032157634e487b7160e01b600052602260045260246000fd5b50919050565b601f82111562000377576000816000526020600020601f850160051c81016020861015620003525750805b601f850160051c820191505b8181101562000373578281556001016200035e565b5050505b505050565b81516001600160401b03811115620003985762000398620001a1565b620003b081620003a98454620002eb565b8462000327565b602080601f831160018114620003e85760008415620003cf5750858301515b600019600386901b1c1916600185901b17855562000373565b600085815260208120601f198616915b828110156200041957888601518255948401946001909101908401620003f8565b5085821015620004385787850151600019600388901b60f8161c191681555b5050505050600190811b01905550565b634e487b7160e01b600052603260045260246000fd5b6134bc806200046e6000396000f3fe6080604052600436106101e25760003560e01c80639c7b390111610102578063d01242f911610095578063f23a6e6111610064578063f23a6e6114610596578063f242432a146105c3578063f3fef3a3146105e3578063f4a0a5281461060357600080fd5b8063d01242f91461050b578063d5abeb0114610541578063e985e9c514610556578063f0a57e711461057657600080fd5b8063a22cb465116100d1578063a22cb46514610455578063a81119a114610475578063b15be2f5146104ae578063bc197c81146104c357600080fd5b80639c7b3901146103ed5780639e6a1d7d1461040d578063a035b1fe1461042d578063a0712d681461044257600080fd5b80634e1273f41161017a5780637d55cd92116101495780637d55cd92146103835780638456cb59146103a3578063915aeb7c146103b857806395d89b41146103d857600080fd5b80634e1273f4146102f657806351cff8d9146103235780636435a753146103435780637a1ac61e1461036357600080fd5b80630e89341c116101b65780630e89341c1461028e57806318160ddd146102ae5780632eb2c2d6146102c357806347e7ef24146102e357600080fd5b8062fdd58e146101e757806301ffc9a71461021a57806302fe53051461024a57806306fdde031461026c575b600080fd5b3480156101f357600080fd5b50610207610202366004612984565b610623565b6040519081526020015b60405180910390f35b34801561022657600080fd5b5061023a6102353660046129b0565b61067d565b6040519015158152602001610211565b34801561025657600080fd5b5061026a610265366004612aa4565b6106cb565b005b34801561027857600080fd5b50610281610731565b6040516102119190612b04565b34801561029a57600080fd5b506102816102a9366004612b37565b6107c6565b3480156102ba57600080fd5b50600454610207565b3480156102cf57600080fd5b5061026a6102de366004612bdd565b61085c565b61026a6102f1366004612984565b610996565b34801561030257600080fd5b50610316610311366004612c8a565b6109e8565b6040516102119190612d87565b34801561032f57600080fd5b5061026a61033e366004612d9a565b610ab4565b34801561034f57600080fd5b5061031661035e366004612d9a565b610b44565b34801561036f57600080fd5b5061026a61037e366004612db7565b610b65565b34801561038f57600080fd5b5061026a61039e366004612dec565b61117d565b3480156103af57600080fd5b5061026a6112b5565b3480156103c457600080fd5b506103166103d3366004612984565b6113ca565b3480156103e457600080fd5b506102816115d1565b3480156103f957600080fd5b5061023a610408366004612e3b565b611648565b34801561041957600080fd5b5061026a610428366004612b37565b61170c565b34801561043957600080fd5b50600a54610207565b61026a610450366004612b37565b61173b565b34801561046157600080fd5b5061026a610470366004612e79565b6118ff565b34801561048157600080fd5b50610207610490366004612d9a565b6001600160a01b031660009081526007602052604090206029015490565b3480156104ba57600080fd5b5061026a61196b565b3480156104cf57600080fd5b506104f26104de366004612f33565b63bc197c8160e01b98975050505050505050565b6040516001600160e01b03199091168152602001610211565b34801561051757600080fd5b50610207610526366004612d9a565b6001600160a01b031660009081526008602052604090205490565b34801561054d57600080fd5b50600554610207565b34801561056257600080fd5b5061023a610571366004612ff1565b611ac3565b34801561058257600080fd5b5061026a61059136600461301f565b611af1565b3480156105a257600080fd5b506104f26105b1366004613060565b63f23a6e6160e01b9695505050505050565b3480156105cf57600080fd5b5061026a6105de3660046130db565b611b27565b3480156105ef57600080fd5b5061026a6105fe366004612984565b611bec565b34801561060f57600080fd5b5061026a61061e366004612b37565b611cf6565b6000811580610633575060055482115b1561065957604051637e70ea5b60e01b8152600481018390526024015b60405180910390fd5b6106638284611648565b61066e576000610671565b60015b60ff1690505b92915050565b60006301ffc9a760e01b6001600160e01b0319831614806106ae5750636cdb3d1360e11b6001600160e01b03198316145b806106775750506001600160e01b0319166303a24d0760e21b1490565b600c546001600160a01b031633146107255760405162461bcd60e51b815260206004820152601960248201527f43616e206f6e6c7920626520736574206279206f776e657221000000000000006044820152606401610650565b61072e81611d25565b50565b60606003600001805461074390613143565b80601f016020809104026020016040519081016040528092919081815260200182805461076f90613143565b80156107bc5780601f10610791576101008083540402835291602001916107bc565b820191906000526020600020905b81548152906001019060200180831161079f57829003601f168201915b5050505050905090565b60606003800180546107d790613143565b80601f016020809104026020016040519081016040528092919081815260200182805461080390613143565b80156108505780601f1061082557610100808354040283529160200191610850565b820191906000526020600020905b81548152906001019060200180831161083357829003601f168201915b50505050509050919050565b6002600954600160a01b900460ff16600281111561087c5761087c61317d565b1461089a5760405163c0d2241560e01b815260040160405180910390fd5b6108a78585858585611d31565b60095460408051630241ebdb60e61b815290516001600160a01b039092169163b81bf8fc9188918891859163907af6c0916004808201926020929091908290030181865afa1580156108fd573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906109219190613193565b875161092d91906131c2565b6040518463ffffffff1660e01b815260040161094b939291906131d9565b6020604051808303816000875af115801561096a573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061098e91906131fd565b505050505050565b348111156109b7576040516384b018ed60e01b815260040160405180910390fd5b6001600160a01b038216600090815260086020526040812080548392906109df90849061321a565b90915550505050565b60608151835114610a195781518351604051635b05999160e01b815260048101929092526024820152604401610650565b600083516001600160401b03811115610a3457610a346129e1565b604051908082528060200260200182016040528015610a5d578160200160208202803683370190505b50905060005b8451811015610aac57602080820286010151610a8790602080840287010151610623565b828281518110610a9957610a9961322d565b6020908102919091010152600101610a63565b509392505050565b6001600160a01b038116600081815260086020526040808220805490839055905190929083908381818185875af1925050503d8060008114610b12576040519150601f19603f3d011682016040523d82523d6000602084013e610b17565b606091505b5090915050600181151514610b3f57604051632333c24d60e01b815260040160405180910390fd5b505050565b6060610b55826003600201546113ca565b50610677826003600201546113ca565b6000600954600160a01b900460ff166002811115610b8557610b8561317d565b14610bde5760405162461bcd60e51b815260206004820152602360248201527f43616e206f6e6c792062652063616c6c6564206f6e206e657720636f6e74726160448201526263742160e81b6064820152608401610650565b600c546001600160a01b03163314610c085760405162461bcd60e51b815260040161065090613243565b6005548210610c595760405162461bcd60e51b815260206004820152601b60248201527f4772616e742063616e6e6f742065786365656420737570706c792100000000006044820152606401610650565b6005548110610caa5760405162461bcd60e51b815260206004820152601b60248201527f4772616e742063616e6e6f742065786365656420737570706c792100000000006044820152606401610650565b600980546001600160a01b038581166001600160a81b031990921691909117600160a01b1791829055600d5460408051630241ebdb60e61b815290519383169363b81bf8fc9388931691859163907af6c0916004808201926020929091908290030181865afa158015610d21573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610d459190613193565b610d4f90876131c2565b6040518463ffffffff1660e01b8152600401610d6d939291906131d9565b6020604051808303816000875af1158015610d8c573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610db091906131fd565b50600954600e5460408051630241ebdb60e61b815290516001600160a01b039384169363b81bf8fc938893911691859163907af6c09160048083019260209291908290030181865afa158015610e0a573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610e2e9190613193565b610e3890866131c2565b6040518463ffffffff1660e01b8152600401610e56939291906131d9565b6020604051808303816000875af1158015610e75573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610e9991906131fd565b506000610ea861010083613290565b905060005b81811015610f16573060009081526007602052604081206001018260288110610ed857610ed861322d565b0155600e546001600160a01b03166000908152600760205260409020600019906001018260288110610f0c57610f0c61322d565b0155600101610ead565b5060006001610f27610100856132a4565b6001901b610f3591906132b8565b600e546001600160a01b0316600090815260076020526040902090915081906001018360288110610f6857610f6861322d565b01553060009081526007602052604090208119906001018360288110610f9057610f9061322d565b0155600e546001600160a01b03166000908152600760205260408082206029908101869055308352908220018054859290610fcc9084906132b8565b909155505060048054849190600090610fe690849061321a565b9091555060009050610ffa61010086613290565b9050600061010061100c8660ff61321a565b6110169190613290565b9050805b611024838361321a565b81101561108c57306000908152600760205260408120600101826028811061104e5761104e61322d565b0155600d546001600160a01b031660009081526007602052604090206000199060010182602881106110825761108261322d565b015560010161101a565b506000600161109d610100896132a4565b6001901b6110ab91906132b8565b600d546001600160a01b0316600090815260076020526040902090915081906001016110d7858561321a565b602881106110e7576110e761322d565b0155306000908152600760205260409020811990600101611108858561321a565b602881106111185761111861322d565b0155600d546001600160a01b031660009081526007602052604080822060299081018a90553083529082200180548992906111549084906132b8565b90915550506004805488919060009061116e90849061321a565b90915550505050505050505050565b6001600954600160a01b900460ff16600281111561119d5761119d61317d565b146111f85760405162461bcd60e51b815260206004820152602560248201527f43616e206f6e6c792062652063616c6c6564206f6e20726561647920636f6e74604482015264726163742160d81b6064820152608401610650565b600c546001600160a01b031633146112225760405162461bcd60e51b815260040161065090613243565b6009805460ff60a01b1916600160a11b179055600a839055600b82905561124881611d25565b600960009054906101000a90046001600160a01b03166001600160a01b03166301339c216040518163ffffffff1660e01b8152600401600060405180830381600087803b15801561129857600080fd5b505af11580156112ac573d6000803e3d6000fd5b50505050505050565b6002600954600160a01b900460ff1660028111156112d5576112d561317d565b1461132e5760405162461bcd60e51b8152602060048201526024808201527f43616e206f6e6c792062652063616c6c6564206f6e206c69766520636f6e74726044820152636163742160e01b6064820152608401610650565b600c546001600160a01b031633146113585760405162461bcd60e51b815260040161065090613243565b60098054600160a01b60ff60a01b1982161790915560408051638456cb5960e01b815290516001600160a01b0390921691638456cb599160048082019260009290919082900301818387803b1580156113b057600080fd5b505af11580156113c4573d6000803e3d6000fd5b50505050565b606060006113f0846001600160a01b031660009081526007602052604090206029015490565b905060008382116114015781611403565b835b6001600160401b0381111561141a5761141a6129e1565b604051908082528060200260200182016040528015611443578160200160208202803683370190505b506001600160a01b038616600090815260076020529091506028815b818110801561146e5750835183105b1561156c576001600160a01b0388166000908152600760205260408120600101826028811061149f5761149f61322d565b01549050806000036114b1575061155a565b60005b610100811080156114c55750855185105b15611557576000816114d9856101006131c2565b6114e3919061321a565b6114ee90600161321a565b6005549091508111156115015750611557565b6001821b831615611544578087878151811061151f5761151f61322d565b602090810291909101015261153560018761321a565b95508986036115445750611557565b508061154f816132cb565b9150506114b4565b50505b80611564816132cb565b91505061145f565b508382148061157a57508582145b6115c65760405162461bcd60e51b815260206004820152601c60248201527f496e636f6e73697374656e7420696e7465726e616c20737461746521000000006044820152606401610650565b509095945050505050565b600954604080516395d89b4160e01b815290516060926001600160a01b0316916395d89b419160048083019260009291908290030181865afa15801561161b573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f1916820160405261164391908101906132e4565b905090565b6000821580159061165b57506005548311155b6116955760405162461bcd60e51b815260206004820152600b60248201526a496e76616c69642049442160a81b6044820152606401610650565b60006101006116a56001866132b8565b6116af9190613290565b905060006101006116c16001876132b8565b6116cb91906132a4565b6001600160a01b0385166000908152600760205260409020909150600180831b910183602881106116fe576116fe61322d565b015416151595945050505050565b600c546001600160a01b031633146117365760405162461bcd60e51b815260040161065090613243565b600b55565b6002600954600160a01b900460ff16600281111561175b5761175b61317d565b146117795760405163c0d2241560e01b815260040160405180910390fd5b600a5460009061178990836131c2565b600b549091508211156117b657600b54604051634712163160e01b81526004810191909152602401610650565b803410156117e757600a546117cb90836131c2565b6040516385cfa67760e01b815260040161065091815260200190565b600e546117fd906001600160a01b031682610996565b61180b336102f183346132b8565b611816303384611d90565b60095460408051630241ebdb60e61b815290516001600160a01b039092169163b81bf8fc9183913391839163907af6c0916004808201926020929091908290030181865afa15801561186c573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906118909190613193565b61189a90876131c2565b6040518463ffffffff1660e01b81526004016118b8939291906131d9565b6020604051808303816000875af11580156118d7573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610b3f91906131fd565b5050565b3360008181526007602090815260408083206001600160a01b03871680855290835292819020805460ff191686151590811790915590519081529192917f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31910160405180910390a35050565b6002600954600160a01b900460ff16600281111561198b5761198b61317d565b146119ef5760405162461bcd60e51b815260206004820152602e60248201527f43616e6e6f742072656e6f756e636520636f6e7472616374206265636175736560448201526d20697473206e6f74206c6976652160901b6064820152608401610650565b600c546001600160a01b03163314611a495760405162461bcd60e51b815260206004820152601f60248201527f43616e206f6e6c792062652072656e6f756e636564206279206f776e657221006044820152606401610650565b600960009054906101000a90046001600160a01b03166001600160a01b031663b15be2f56040518163ffffffff1660e01b8152600401600060405180830381600087803b158015611a9957600080fd5b505af1158015611aad573d6000803e3d6000fd5b5050600c80546001600160a01b03191690555050565b6001600160a01b03918216600090815260076020908152604080832093909416825291909152205460ff1690565b6009546001600160a01b03163314611b1c576040516309e7447960e11b815260040160405180910390fd5b610b3f838383611d90565b6002600954600160a01b900460ff166002811115611b4757611b4761317d565b14611b655760405163c0d2241560e01b815260040160405180910390fd5b611b7285858585856121d5565b60095460408051630241ebdb60e61b815290516001600160a01b039092169163b81bf8fc9188918891859163907af6c0916004808201926020929091908290030181865afa158015611bc8573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061092d9190613193565b6001600160a01b03821660009081526008602052604090205480821115611c665760405162461bcd60e51b815260206004820152602860248201527f43616e2774207769746864726177206d6f7265207468616e206d6178696d756d60448201526720616d6f756e742160c01b6064820152608401610650565b611c7082826132b8565b6001600160a01b03841660008181526008602052604080822093909355915184908381818185875af1925050503d8060008114611cc9576040519150601f19603f3d011682016040523d82523d6000602084013e611cce565b606091505b50909150506001811515146113c457604051632333c24d60e01b815260040160405180910390fd5b600c546001600160a01b03163314611d205760405162461bcd60e51b815260040161065090613243565b600a55565b60066118fb82826133a2565b336001600160a01b0386168114801590611d525750611d508682611ac3565b155b15611d835760405163711bec9160e11b81526001600160a01b03808316600483015287166024820152604401610650565b61098e8686868686612263565b600080826001600160401b03811115611dab57611dab6129e1565b604051908082528060200260200182016040528015611dd4578160200160208202803683370190505b5090506000836001600160401b03811115611df157611df16129e1565b604051908082528060200260200182016040528015611e1a578160200160208202803683370190505b50905060005b6001600160a01b0387166000526007602052602881108015611e4157508484105b15611fb4576001600160a01b03871660009081526007602052604081206001018260288110611e7257611e7261322d565b0154905080600003611e845750611fa2565b60005b61010081108015611e9757508686105b15611f9f576001811b82811615611f8c57600082611eb7866101006131c2565b611ec1919061321a565b611ecc90600161321a565b905080878981518110611ee157611ee161322d565b6020026020010181815250506001868981518110611f0157611f0161322d565b6020908102919091018101919091526001600160a01b038c1660009081526007909152604090208219906001018660288110611f3f57611f3f61322d565b01805490911690556001600160a01b038a16600090815260076020526040902082906001018660288110611f7557611f7561322d565b018054909117905587611f87816132cb565b985050505b5080611f97816132cb565b915050611e87565b50505b80611fac816132cb565b915050611e20565b5083831461201c5760405162461bcd60e51b815260206004820152602f60248201527f4e6f7420656e6f75676820656c656d656e7473206f776e65642062792073656e60448201526e3232b9103a37903a3930b739b332b960891b6064820152608401610650565b6001600160a01b038616600090815260076020526040812060290180548592906120479084906132b8565b90915550506001600160a01b0385166000908152600760205260408120602901805485929061207790849061321a565b9091555050306001600160a01b038716036120a75782600360010160008282546120a1919061321a565b90915550505b6001600160a01b03851615806120c557506001600160a01b03851630145b156120e55782600360010160008282546120df91906132b8565b90915550505b8260010361216d57846001600160a01b0316866001600160a01b0316336001600160a01b03167fc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f628560008151811061213f5761213f61322d565b60200260200101516001604051612160929190918252602082015260400190565b60405180910390a461098e565b600183111561098e57846001600160a01b0316866001600160a01b0316336001600160a01b03167f4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb85856040516121c5929190613461565b60405180910390a4505050505050565b336001600160a01b03861681148015906121f657506121f48682611ac3565b155b156122275760405163711bec9160e11b81526001600160a01b03808316600483015287166024820152604401610650565b604080516001808252602082018790528183019081526060820186905260808201909252906122598888848488612263565b5050505050505050565b61226f85858585612276565b5050505050565b6001600160a01b0384166122dc5760405162461bcd60e51b815260206004820152602760248201527f455243313135353a207472616e736665722066726f6d20746865207a65726f206044820152666164647265737360c81b6064820152608401610650565b805182511461233d5760405162461bcd60e51b815260206004820152602760248201527f455243313135353a2069647320616e642076616c756573206c656e677468206d6044820152660d2e6dac2e8c6d60cb1b6064820152608401610650565b600082516001600160401b03811115612358576123586129e1565b604051908082528060200260200182016040528015612381578160200160208202803683370190505b509050600083516001600160401b0381111561239f5761239f6129e1565b6040519080825280602002602001820160405280156123c8578160200160208202803683370190505b5090506000805b85518110156125a3578481815181106123ea576123ea61322d565b60200260200101516001146124605760405162461bcd60e51b815260206004820152603660248201527f455243313135353a20696e76616c69642076616c75652c2063616e206f6e6c79604482015275081d1c985b9cd9995c880c481bd988195858da08125160521b6064820152608401610650565b6124838682815181106124755761247561322d565b602002602001015189611648565b1561252d576124ac888888848151811061249f5761249f61322d565b6020026020010151612784565b8581815181106124be576124be61322d565b60200260200101518483815181106124d8576124d861322d565b6020026020010181815250508481815181106124f6576124f661322d565b60200260200101518383815181106125105761251061322d565b602090810291909101015281612525816132cb565b92505061259b565b60405162461bcd60e51b815260206004820152603c60248201527f455243313135353a20617474656d7074696e6720746f207472616e736665722060448201527f616e204944206e6f742068656c64206279207468652073656e646572000000006064820152608401610650565b6001016123cf565b508015612713576000816001600160401b038111156125c4576125c46129e1565b6040519080825280602002602001820160405280156125ed578160200160208202803683370190505b5090506000826001600160401b0381111561260a5761260a6129e1565b604051908082528060200260200182016040528015612633578160200160208202803683370190505b50905060005b838110156126b8578581815181106126535761265361322d565b602002602001015183828151811061266d5761266d61322d565b60200260200101818152505084818151811061268b5761268b61322d565b60200260200101518282815181106126a5576126a561322d565b6020908102919091010152600101612639565b50876001600160a01b0316896001600160a01b0316336001600160a01b03167f4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb8585604051612708929190613461565b60405180910390a450505b306001600160a01b0388160361273e578060036001016000828254612738919061321a565b90915550505b6001600160a01b038616158061275c57506001600160a01b03861630145b156112ac57806003600101600082825461277691906132b8565b909155505050505050505050565b61278e8184611648565b6127ce5760405162461bcd60e51b8152602060048201526011602482015270496e636f727265637420686f6c6465722160781b6044820152606401610650565b6127da818460006127e2565b610b3f818360015b60006101006127f26001866132b8565b6127fc9190613290565b9050600061010061280e6001876132b8565b61281891906132a4565b905060006128268686611648565b90508015158415151461098e5783156128d2576001600160a01b038516600090815260076020526040812060290180546001929061286590849061321a565b90915550506001600160a01b0385166000908152600760205260409020600180841b9101846028811061289a5761289a61322d565b01546001600160a01b038716600090815260076020526040902091179060010184602881106128cb576128cb61322d565b015561098e565b6001600160a01b03851660009081526007602052604081206029018054600192906128fe9084906132b8565b90915550506001600160a01b0385166000908152600760205260409020600180841b19910184602881106129345761293461322d565b01546001600160a01b038716600090815260076020526040902091169060010184602881106129655761296561322d565b0155505050505050565b6001600160a01b038116811461072e57600080fd5b6000806040838503121561299757600080fd5b82356129a28161296f565b946020939093013593505050565b6000602082840312156129c257600080fd5b81356001600160e01b0319811681146129da57600080fd5b9392505050565b634e487b7160e01b600052604160045260246000fd5b604051601f8201601f191681016001600160401b0381118282101715612a1f57612a1f6129e1565b604052919050565b60006001600160401b03821115612a4057612a406129e1565b50601f01601f191660200190565b600082601f830112612a5f57600080fd5b8135612a72612a6d82612a27565b6129f7565b818152846020838601011115612a8757600080fd5b816020850160208301376000918101602001919091529392505050565b600060208284031215612ab657600080fd5b81356001600160401b03811115612acc57600080fd5b612ad884828501612a4e565b949350505050565b60005b83811015612afb578181015183820152602001612ae3565b50506000910152565b6020815260008251806020840152612b23816040850160208701612ae0565b601f01601f19169190910160400192915050565b600060208284031215612b4957600080fd5b5035919050565b60006001600160401b03821115612b6957612b696129e1565b5060051b60200190565b600082601f830112612b8457600080fd5b81356020612b94612a6d83612b50565b8083825260208201915060208460051b870101935086841115612bb657600080fd5b602086015b84811015612bd25780358352918301918301612bbb565b509695505050505050565b600080600080600060a08688031215612bf557600080fd5b8535612c008161296f565b94506020860135612c108161296f565b935060408601356001600160401b0380821115612c2c57600080fd5b612c3889838a01612b73565b94506060880135915080821115612c4e57600080fd5b612c5a89838a01612b73565b93506080880135915080821115612c7057600080fd5b50612c7d88828901612a4e565b9150509295509295909350565b60008060408385031215612c9d57600080fd5b82356001600160401b0380821115612cb457600080fd5b818501915085601f830112612cc857600080fd5b81356020612cd8612a6d83612b50565b82815260059290921b84018101918181019089841115612cf757600080fd5b948201945b83861015612d1e578535612d0f8161296f565b82529482019490820190612cfc565b96505086013592505080821115612d3457600080fd5b50612d4185828601612b73565b9150509250929050565b60008151808452602080850194506020840160005b83811015612d7c57815187529582019590820190600101612d60565b509495945050505050565b6020815260006129da6020830184612d4b565b600060208284031215612dac57600080fd5b81356129da8161296f565b600080600060608486031215612dcc57600080fd5b8335612dd78161296f565b95602085013595506040909401359392505050565b600080600060608486031215612e0157600080fd5b833592506020840135915060408401356001600160401b03811115612e2557600080fd5b612e3186828701612a4e565b9150509250925092565b60008060408385031215612e4e57600080fd5b823591506020830135612e608161296f565b809150509250929050565b801515811461072e57600080fd5b60008060408385031215612e8c57600080fd5b8235612e978161296f565b91506020830135612e6081612e6b565b60008083601f840112612eb957600080fd5b5081356001600160401b03811115612ed057600080fd5b6020830191508360208260051b8501011115612eeb57600080fd5b9250929050565b60008083601f840112612f0457600080fd5b5081356001600160401b03811115612f1b57600080fd5b602083019150836020828501011115612eeb57600080fd5b60008060008060008060008060a0898b031215612f4f57600080fd5b8835612f5a8161296f565b97506020890135612f6a8161296f565b965060408901356001600160401b0380821115612f8657600080fd5b612f928c838d01612ea7565b909850965060608b0135915080821115612fab57600080fd5b612fb78c838d01612ea7565b909650945060808b0135915080821115612fd057600080fd5b50612fdd8b828c01612ef2565b999c989b5096995094979396929594505050565b6000806040838503121561300457600080fd5b823561300f8161296f565b91506020830135612e608161296f565b60008060006060848603121561303457600080fd5b833561303f8161296f565b9250602084013561304f8161296f565b929592945050506040919091013590565b60008060008060008060a0878903121561307957600080fd5b86356130848161296f565b955060208701356130948161296f565b9450604087013593506060870135925060808701356001600160401b038111156130bd57600080fd5b6130c989828a01612ef2565b979a9699509497509295939492505050565b600080600080600060a086880312156130f357600080fd5b85356130fe8161296f565b9450602086013561310e8161296f565b9350604086013592506060860135915060808601356001600160401b0381111561313757600080fd5b612c7d88828901612a4e565b600181811c9082168061315757607f821691505b60208210810361317757634e487b7160e01b600052602260045260246000fd5b50919050565b634e487b7160e01b600052602160045260246000fd5b6000602082840312156131a557600080fd5b5051919050565b634e487b7160e01b600052601160045260246000fd5b8082028115828204841417610677576106776131ac565b6001600160a01b039384168152919092166020820152604081019190915260600190565b60006020828403121561320f57600080fd5b81516129da81612e6b565b80820180821115610677576106776131ac565b634e487b7160e01b600052603260045260246000fd5b6020808252601c908201527f43616e206f6e6c792062652063616c6c6564206279206f776e65722100000000604082015260600190565b634e487b7160e01b600052601260045260246000fd5b60008261329f5761329f61327a565b500490565b6000826132b3576132b361327a565b500690565b81810381811115610677576106776131ac565b6000600182016132dd576132dd6131ac565b5060010190565b6000602082840312156132f657600080fd5b81516001600160401b0381111561330c57600080fd5b8201601f8101841361331d57600080fd5b805161332b612a6d82612a27565b81815285602083850101111561334057600080fd5b613351826020830160208601612ae0565b95945050505050565b601f821115610b3f576000816000526020600020601f850160051c810160208610156133835750805b601f850160051c820191505b8181101561098e5782815560010161338f565b81516001600160401b038111156133bb576133bb6129e1565b6133cf816133c98454613143565b8461335a565b602080601f83116001811461340457600084156133ec5750858301515b600019600386901b1c1916600185901b17855561098e565b600085815260208120601f198616915b8281101561343357888601518255948401946001909101908401613414565b50858210156134515787850151600019600388901b60f8161c191681555b5050505050600190811b01905550565b6040815260006134746040830185612d4b565b82810360208401526133518185612d4b56fea2646970667358221220acb3c47f67c4f5dc62275cb254b7faebb74ef7a0a0525933adc448c24c8bd69e64736f6c6343000818003300000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000027100000000000000000000000005976f7859f93901c5b1227ef5cded8efb1927fa20000000000000000000000008a5f749de59eb6d2c39cf2e54332ea95ab1882fa00000000000000000000000059a6f1498bc045f415f10269670d8d06d7e92ecd000000000000000000000000000000000000000000000000000000000000000b53686964647950756e6b73000000000000000000000000000000000000000000
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
00000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000027100000000000000000000000005976f7859f93901c5b1227ef5cded8efb1927fa20000000000000000000000008a5f749de59eb6d2c39cf2e54332ea95ab1882fa00000000000000000000000059a6f1498bc045f415f10269670d8d06d7e92ecd000000000000000000000000000000000000000000000000000000000000000b53686964647950756e6b73000000000000000000000000000000000000000000
-----Decoded View---------------
Arg [0] : _name (string): ShiddyPunks
Arg [1] : _supply (uint256): 10000
Arg [2] : owner (address): 0x5976f7859f93901C5B1227EF5cDED8efB1927Fa2
Arg [3] : team (address): 0x8a5F749dE59eb6D2C39cf2e54332eA95Ab1882fa
Arg [4] : treasury (address): 0x59A6F1498bC045F415F10269670d8D06D7E92EcD
-----Encoded View---------------
7 Constructor Arguments found :
Arg [0] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [1] : 0000000000000000000000000000000000000000000000000000000000002710
Arg [2] : 0000000000000000000000005976f7859f93901c5b1227ef5cded8efb1927fa2
Arg [3] : 0000000000000000000000008a5f749de59eb6d2c39cf2e54332ea95ab1882fa
Arg [4] : 00000000000000000000000059a6f1498bc045f415f10269670d8d06d7e92ecd
Arg [5] : 000000000000000000000000000000000000000000000000000000000000000b
Arg [6] : 53686964647950756e6b73000000000000000000000000000000000000000000
Loading...
Loading
Loading...
Loading
[ 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.