ERC-721
Overview
Max Total Supply
618 HELL
Holders
135
Market
Volume (24H)
N/A
Min Price (24H)
N/A
Max Price (24H)
N/A
Other Info
Token Contract
Balance
1 HELLLoading...
Loading
Loading...
Loading
Loading...
Loading
# | Exchange | Pair | Price | 24H Volume | % Volume |
---|
Contract Name:
LayerrProxy
Compiler Version
v0.8.20+commit.a1b79de6
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: BUSL-1.1 pragma solidity ^0.8.20; import {StringValue} from "./lib/StorageTypes.sol"; import {AddressValue} from "./lib/StorageTypes.sol"; import {ILayerrMinter} from "./interfaces/ILayerrMinter.sol"; import {LAYERROWNABLE_OWNER_SLOT, LAYERRTOKEN_NAME_SLOT, LAYERRTOKEN_SYMBOL_SLOT, LAYERRTOKEN_RENDERER_SLOT} from "./common/LayerrStorage.sol"; /** * @title LayerrProxy * @author 0xth0mas (Layerr) * @notice A proxy contract that serves as an interface for interacting with * Layerr tokens. At deployment it sets token properties and contract * ownership, initializes signers and mint extensions, and configures * royalties. */ contract LayerrProxy { /// @dev the implementation address for the proxy contract address immutable proxy; /// @dev this is included as a hint for block explorers bytes32 private constant PROXY_IMPLEMENTATION_REFERENCE = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc; /// @dev Thrown when a required initialization call fails error DeploymentFailed(); /** * @notice Initializes the proxy contract * @param _proxy implementation address for the proxy contract * @param _name token contract name * @param _symbol token contract symbol * @param royaltyPct default royalty percentage in BPS * @param royaltyReceiver default royalty receiver * @param operatorFilterRegistry address of the operator filter registry to subscribe to * @param _extension minting extension to use with the token contract * @param _renderer renderer to use with the token contract * @param _signers array of allowed signers for the mint extension */ constructor( address _proxy, string memory _name, string memory _symbol, uint96 royaltyPct, address royaltyReceiver, address operatorFilterRegistry, address _extension, address _renderer, address[] memory _signers ) { proxy = _proxy; StringValue storage name; StringValue storage symbol; AddressValue storage renderer; AddressValue storage owner; AddressValue storage explorerProxy; /// @solidity memory-safe-assembly assembly { name.slot := LAYERRTOKEN_NAME_SLOT symbol.slot := LAYERRTOKEN_SYMBOL_SLOT renderer.slot := LAYERRTOKEN_RENDERER_SLOT owner.slot := LAYERROWNABLE_OWNER_SLOT explorerProxy.slot := PROXY_IMPLEMENTATION_REFERENCE } name.value = _name; symbol.value = _symbol; renderer.value = _renderer; owner.value = tx.origin; explorerProxy.value = _proxy; uint256 signersLength = _signers.length; for(uint256 signerIndex;signerIndex < signersLength;) { ILayerrMinter(_extension).setContractAllowedSigner(_signers[signerIndex], true); unchecked { ++signerIndex; } } (bool success, ) = _proxy.delegatecall(abi.encodeWithSignature("setRoyalty(uint96,address)", royaltyPct, royaltyReceiver)); if(!success) revert DeploymentFailed(); (success, ) = _proxy.delegatecall(abi.encodeWithSignature("setOperatorFilter(address)", operatorFilterRegistry)); //this item may fail if deploying a contract that does not use an operator filter (success, ) = _proxy.delegatecall(abi.encodeWithSignature("setMintExtension(address,bool)", _extension, true)); if(!success) revert DeploymentFailed(); (success, ) = _proxy.delegatecall(abi.encodeWithSignature("initialize()")); if(!success) revert DeploymentFailed(); } fallback() external payable { address _proxy = proxy; assembly { calldatacopy(0x0, 0x0, calldatasize()) let result := delegatecall(gas(), _proxy, 0x0, calldatasize(), 0x0, 0) returndatacopy(0x0, 0x0, returndatasize()) switch result case 0 {revert(0, 0)} default {return (0, returndatasize())} } } }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity ^0.8.20; /// @dev Storage slot for current owner calculated from keccak256('Layerr.LayerrOwnable.owner') bytes32 constant LAYERROWNABLE_OWNER_SLOT = 0xedc628ad38a73ae7d50600532f1bf21da1bfb1390b4f8174f361aca54d4c6b66; /// @dev Storage slot for pending ownership transfer calculated from keccak256('Layerr.LayerrOwnable.newOwner') bytes32 constant LAYERROWNABLE_NEW_OWNER_SLOT = 0x15c115ab76de082272ae65126522082d4aad634b6478097549f84086af3b84bc; /// @dev Storage slot for token name calculated from keccak256('Layerr.LayerrToken.name') bytes32 constant LAYERRTOKEN_NAME_SLOT = 0x7f84c61ed30727f282b62cab23f49ac7f4d263f04a4948416b7b9ba7f34a20dc; /// @dev Storage slot for token symbol calculated from keccak256('Layerr.LayerrToken.symbol') bytes32 constant LAYERRTOKEN_SYMBOL_SLOT = 0xdc0f2363b26c589c72caecd2357dae5fee235863060295a057e8d69d61a96d8a; /// @dev Storage slot for URI renderer calculated from keccak256('Layerr.LayerrToken.renderer') bytes32 constant LAYERRTOKEN_RENDERER_SLOT = 0x395b7021d979c3dbed0f5d530785632316942232113ba3dbe325dc167550e320;
// SPDX-License-Identifier: MIT pragma solidity ^0.8.20; import {MintOrder, MintParameters, MintToken, BurnToken, PaymentToken} from "../lib/MinterStructs.sol"; /** * @title ILayerrMinter * @author 0xth0mas (Layerr) * @notice ILayerrMinter interface defines functions required in the LayerrMinter to be callable by token contracts */ interface ILayerrMinter { /// @dev Event emitted when a mint order is fulfilled event MintOrderFulfilled( bytes32 indexed mintParametersDigest, address indexed minter, uint256 indexed quantity ); /// @dev Event emitted when a token contract updates an allowed signer for EIP712 signatures event ContractAllowedSignerUpdate( address indexed _contract, address indexed _signer, bool indexed _allowed ); /// @dev Event emitted when a token contract updates an allowed oracle signer for offchain authorization of a wallet to use a signature event ContractOracleUpdated( address indexed _contract, address indexed _oracle, bool indexed _allowed ); /// @dev Event emitted when a signer updates their nonce with LayerrMinter. Updating a nonce invalidates all previously signed EIP712 signatures. event SignerNonceIncremented( address indexed _signer, uint256 indexed _nonce ); /// @dev Event emitted when a specific signature's validity is updated with the LayerrMinter contract. event SignatureValidityUpdated( address indexed _contract, bool indexed invalid, bytes32 mintParametersDigests ); /// @dev Thrown when the amount of native tokens supplied in msg.value is insufficient for the mint order error InsufficientPayment(); /// @dev Thrown when a payment fails to be forwarded to the intended recipient error PaymentFailed(); /// @dev Thrown when a MintParameters payment token uses a token type value other than native or ERC20 error InvalidPaymentTokenType(); /// @dev Thrown when a MintParameters burn token uses a token type value other than ERC20, ERC721 or ERC1155 error InvalidBurnTokenType(); /// @dev Thrown when a MintParameters mint token uses a token type value other than ERC20, ERC721 or ERC1155 error InvalidMintTokenType(); /// @dev Thrown when a MintParameters burn token uses a burn type value other than contract burn or send to dead error InvalidBurnType(); /// @dev Thrown when a MintParameters burn token requires a specific burn token id and the tokenId supplied does not match error InvalidBurnTokenId(); /// @dev Thrown when a MintParameters burn token requires a specific ERC721 token and the burn amount is greater than 1 error CannotBurnMultipleERC721WithSameId(); /// @dev Thrown when attempting to mint with MintParameters that have a start time greater than the current block time error MintHasNotStarted(); /// @dev Thrown when attempting to mint with MintParameters that have an end time less than the current block time error MintHasEnded(); /// @dev Thrown when a MintParameters has a merkleroot set but the supplied merkle proof is invalid error InvalidMerkleProof(); /// @dev Thrown when a MintOrder will cause a token's minted supply to exceed the defined maximum supply in MintParameters error MintExceedsMaxSupply(); /// @dev Thrown when a MintOrder will cause a minter's minted amount to exceed the defined max per wallet in MintParameters error MintExceedsMaxPerWallet(); /// @dev Thrown when a MintParameters mint token has a specific ERC721 token and the mint amount is greater than 1 error CannotMintMultipleERC721WithSameId(); /// @dev Thrown when the recovered signer for the MintParameters is not an allowed signer for the mint token error NotAllowedSigner(); /// @dev Thrown when the recovered signer's nonce does not match the current nonce in LayerrMinter error SignerNonceInvalid(); /// @dev Thrown when a signature has been marked as invalid for a mint token contract error SignatureInvalid(); /// @dev Thrown when MintParameters requires an oracle signature and the recovered signer is not an allowed oracle for the contract error InvalidOracleSignature(); /// @dev Thrown when MintParameters has a max signature use set and the MintOrder will exceed the maximum uses error ExceedsMaxSignatureUsage(); /// @dev Thrown when attempting to increment nonce on behalf of another account and the signature is invalid error InvalidSignatureToIncrementNonce(); /** * @notice This function is called by token contracts to update allowed signers for minting * @param _signer address of the EIP712 signer * @param _allowed if the `_signer` is allowed to sign for minting */ function setContractAllowedSigner(address _signer, bool _allowed) external; /** * @notice This function is called by token contracts to update allowed oracles for offchain authorizations * @param _oracle address of the oracle * @param _allowed if the `_oracle` is allowed to sign offchain authorizations */ function setContractAllowedOracle(address _oracle, bool _allowed) external; /** * @notice This function is called by token contracts to update validity of signatures for the LayerrMinter contract * @dev `invalid` should be true to invalidate signatures, the default state of `invalid` being false means * a signature is valid for a contract assuming all other conditions are met * @param mintParametersDigests an array of message digests for MintParameters to update validity of * @param invalid if the supplied digests will be marked as valid or invalid */ function setSignatureValidity( bytes32[] calldata mintParametersDigests, bool invalid ) external; /** * @notice Increments the nonce for a signer to invalidate all previous signed MintParameters */ function incrementSignerNonce() external; /** * @notice Increments the nonce on behalf of another account by validating a signature from that account * @dev The signature is an eth personal sign message of the current signer nonce plus the chain id * ex. current nonce 0 on chain 5 would be a signature of \x19Ethereum Signed Message:\n15 * current nonce 50 on chain 1 would be a signature of \x19Ethereum Signed Message:\n251 * @param signer account to increment nonce for * @param signature signature proof that the request is coming from the account */ function incrementNonceFor(address signer, bytes calldata signature) external; /** * @notice Validates and processes a single MintOrder, tokens are minted to msg.sender * @param mintOrder struct containing the details of the mint order */ function mint( MintOrder calldata mintOrder ) external payable; /** * @notice Validates and processes an array of MintOrders, tokens are minted to msg.sender * @param mintOrders array of structs containing the details of the mint orders */ function mintBatch( MintOrder[] calldata mintOrders ) external payable; /** * @notice Validates and processes a single MintOrder, tokens are minted to `mintToWallet` * @param mintToWallet the address tokens will be minted to * @param mintOrder struct containing the details of the mint order * @param paymentContext Contextual information related to the payment process * (Note: This parameter is required for integration with * the payment processor and does not impact the behavior * of the function) */ function mintTo( address mintToWallet, MintOrder calldata mintOrder, uint256 paymentContext ) external payable; /** * @notice Validates and processes an array of MintOrders, tokens are minted to `mintToWallet` * @param mintToWallet the address tokens will be minted to * @param mintOrders array of structs containing the details of the mint orders * @param paymentContext Contextual information related to the payment process * (Note: This parameter is required for integration with * the payment processor and does not impact the behavior * of the function) */ function mintBatchTo( address mintToWallet, MintOrder[] calldata mintOrders, uint256 paymentContext ) external payable; }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity ^0.8.20; /** * @dev EIP712 Domain for signature verification */ struct EIP712Domain { string name; string version; uint256 chainId; address verifyingContract; } /** * @dev MintOrders contain MintParameters as defined by a token creator * along with proofs required to validate the MintParameters and * parameters specific to the mint being performed. * * `mintParameters` are the parameters signed by the token creator * `quantity` is a multiplier for mintTokens, burnTokens and paymentTokens * defined in mintParameters * `mintParametersSignature` is the signature from the token creator * `oracleSignature` is a signature of the hash of the mintParameters digest * and msg.sender. The recovered signer must be an allowed oracle for * the token contract if oracleSignatureRequired is true for mintParameters. * `merkleProof` is the proof that is checked if merkleRoot is not bytes(0) in * mintParameters * `suppliedBurnTokenIds` is an array of tokenIds to be used when processing * burnTokens. There must be one item in the array for each ERC1155 burnToken * regardless of `quantity` and `quantity` items in the array for each ERC721 * burnToken. * `referrer` is the address that will receive a portion of a paymentToken if * not address(0) and paymentToken's referralBPS is greater than 0 * `vaultWallet` is used for allowlist mints if the msg.sender address it not on * the allowlist but their delegate.cash vault wallet is. * */ struct MintOrder { MintParameters mintParameters; uint256 quantity; bytes mintParametersSignature; bytes oracleSignature; bytes32[] merkleProof; uint256[] suppliedBurnTokenIds; address referrer; address vaultWallet; } /** * @dev MintParameters define the tokens to be minted and conditions that must be met * for the mint to be successfully processed. * * `mintTokens` is an array of tokens that will be minted * `burnTokens` is an array of tokens required to be burned * `paymentTokens` is an array of tokens required as payment * `startTime` is the UTC timestamp of when the mint will start * `endTime` is the UTC timestamp of when the mint will end * `signatureMaxUses` limits the number of mints that can be performed with the * specific mintParameters/signature * `merkleRoot` is the root of the merkletree for allowlist minting * `nonce` is the signer nonce that can be incremented on the LayerrMinter * contract to invalidate all previous signatures * `oracleSignatureRequired` if true requires a secondary signature to process the mint */ struct MintParameters { MintToken[] mintTokens; BurnToken[] burnTokens; PaymentToken[] paymentTokens; uint256 startTime; uint256 endTime; uint256 signatureMaxUses; bytes32 merkleRoot; uint256 nonce; bool oracleSignatureRequired; } /** * @dev Defines the token that will be minted * * `contractAddress` address of contract to mint tokens from * `specificTokenId` used for ERC721 - * if true, mint is non-sequential ERC721 * if false, mint is sequential ERC721A * `tokenType` is the type of token being minted defined in TokenTypes.sol * `tokenId` the tokenId to mint if specificTokenId is true * `mintAmount` is the quantity to be minted * `maxSupply` is checked against the total minted amount at time of mint * minting reverts if `mintAmount` * `quantity` will cause total minted to * exceed `maxSupply` * `maxMintPerWallet` is checked against the number minted for the wallet * minting reverts if `mintAmount` * `quantity` will cause wallet minted to * exceed `maxMintPerWallet` */ struct MintToken { address contractAddress; bool specificTokenId; uint256 tokenType; uint256 tokenId; uint256 mintAmount; uint256 maxSupply; uint256 maxMintPerWallet; } /** * @dev Defines the token that will be burned * * `contractAddress` address of contract to burn tokens from * `specificTokenId` specifies if the user has the option of choosing any token * from the contract or if they must burn a specific token * `tokenType` is the type of token being burned, defined in TokenTypes.sol * `burnType` is the type of burn to perform, burn function call or transfer to * dead address, defined in BurnType.sol * `tokenId` the tokenId to burn if specificTokenId is true * `burnAmount` is the quantity to be burned */ struct BurnToken { address contractAddress; bool specificTokenId; uint256 tokenType; uint256 burnType; uint256 tokenId; uint256 burnAmount; } /** * @dev Defines the token that will be used for payment * * `contractAddress` address of contract to for payment if ERC20 * if tokenType is native token then this should be set to 0x000...000 * to save calldata gas units * `tokenType` is the type of token being used for payment, defined in TokenTypes.sol * `payTo` the address that will receive the payment * `paymentAmount` the amount for the payment in base units for the token * ex. a native payment on Ethereum for 1 ETH would be specified in wei * which would be 1**18 wei * `referralBPS` is the percentage of the payment in BPS that will be sent to the * `referrer` on the MintOrder if `referralBPS` is greater than 0 and `referrer` * is not address(0) */ struct PaymentToken { address contractAddress; uint256 tokenType; address payTo; uint256 paymentAmount; uint256 referralBPS; }
// SPDX-License-Identifier: BUSL-1.1 pragma solidity ^0.8.20; /// @dev Simple struct to store a string value in a custom storage slot struct StringValue { string value; } /// @dev Simple struct to store an address value in a custom storage slot struct AddressValue { address value; }
{ "optimizer": { "enabled": true, "runs": 33333 }, "evmVersion": "paris", "viaIR": true, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"address","name":"_proxy","type":"address"},{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"},{"internalType":"uint96","name":"royaltyPct","type":"uint96"},{"internalType":"address","name":"royaltyReceiver","type":"address"},{"internalType":"address","name":"operatorFilterRegistry","type":"address"},{"internalType":"address","name":"_extension","type":"address"},{"internalType":"address","name":"_renderer","type":"address"},{"internalType":"address[]","name":"_signers","type":"address[]"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"DeploymentFailed","type":"error"},{"stateMutability":"payable","type":"fallback"}]
Contract Creation Code
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
Deployed Bytecode
0x6080604052600036818037808036817f0000000000000000000000000000000000ca814ae01460b2f4797d0f34d38a7d5af43d82803e15603d573d90f35b80fdfea2646970667358221220fd5afa91e5ef53d78f21df2cfa554a17e52607624d10edcca268d264a28ce40764736f6c63430008140033
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
0000000000000000000000000000000000ca814ae01460b2f4797d0f34d38a7d0000000000000000000000000000000000000000000000000000000000000120000000000000000000000000000000000000000000000000000000000000016000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000116d4c19d23b22cea9d78911d05cbc3871365990000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000d58696577347f78259bd376f1bec00000000000000000000000000000000000d351e7df55d1a7e8045daf6c998e200000000000000000000000000000000000000000000000000000000000001a0000000000000000000000000000000000000000000000000000000000000000848454c4c494f4e5a000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000448454c4c000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000f57e485905f5f7de581a1dcae0411f9b86da8f51
-----Decoded View---------------
Arg [0] : _proxy (address): 0x0000000000cA814AE01460b2f4797D0F34d38A7d
Arg [1] : _name (string): HELLIONZ
Arg [2] : _symbol (string): HELL
Arg [3] : royaltyPct (uint96): 0
Arg [4] : royaltyReceiver (address): 0x0116D4c19d23B22CEa9d78911D05CBc387136599
Arg [5] : operatorFilterRegistry (address): 0x0000000000000000000000000000000000000000
Arg [6] : _extension (address): 0x000000000000D58696577347F78259bD376F1BEC
Arg [7] : _renderer (address): 0x00000000000d351E7Df55d1A7E8045daf6C998E2
Arg [8] : _signers (address[]): 0xF57e485905f5F7De581A1DcAE0411F9B86da8F51
-----Encoded View---------------
15 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000ca814ae01460b2f4797d0f34d38a7d
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000120
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000160
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [4] : 0000000000000000000000000116d4c19d23b22cea9d78911d05cbc387136599
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [6] : 000000000000000000000000000000000000d58696577347f78259bd376f1bec
Arg [7] : 00000000000000000000000000000000000d351e7df55d1a7e8045daf6c998e2
Arg [8] : 00000000000000000000000000000000000000000000000000000000000001a0
Arg [9] : 0000000000000000000000000000000000000000000000000000000000000008
Arg [10] : 48454c4c494f4e5a000000000000000000000000000000000000000000000000
Arg [11] : 0000000000000000000000000000000000000000000000000000000000000004
Arg [12] : 48454c4c00000000000000000000000000000000000000000000000000000000
Arg [13] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [14] : 000000000000000000000000f57e485905f5f7de581a1dcae0411f9b86da8f51
Loading...
Loading
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.