Overview
POL Balance
0 POL
POL Value
$0.00More Info
Private Name Tags
ContractCreator
TokenTracker
Latest 1 from a total of 1 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Edit Contract | 51405505 | 358 days ago | IN | 0 POL | 0.00267207 |
Loading...
Loading
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 _owner initial owner of the token 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 _owner, 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 = msg.sender; 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(); owner.value = _owner; } 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, returndatasize())} 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":"_owner","type":"address"},{"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
0x6080604052600036818037808036817f0000000000000000000000000000000000f7a60f1c88f317f369e3d8679c66895af43d82803e15603d573d90f35b3d90fdfea264697066735822122070735439b0b1c67ba7e89f7fca82b9b6e11e5aade74a1ba8e691bfbd07af029364736f6c63430008140033
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
0000000000000000000000006ac32b97f7b6c8ff1335293becf6183d3fc786760000000000000000000000000000000000f7a60f1c88f317f369e3d8679c66890000000000000000000000000000000000000000000000000000000000000140000000000000000000000000000000000000000000000000000000000000018000000000000000000000000000000000000000000000000000000000000003e80000000000000000000000006ac32b97f7b6c8ff1335293becf6183d3fc786760000000000000000000000003cc6cdda760b79bafa08df41ecfa224f810dceb6000000000000000000000000000000000000d58696577347f78259bd376f1bec00000000000000000000000000000000000d351e7df55d1a7e8045daf6c998e200000000000000000000000000000000000000000000000000000000000001c000000000000000000000000000000000000000000000000000000000000000104d43424956206f6e20506f6c79676f6e0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000054d4342495600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000006ac32b97f7b6c8ff1335293becf6183d3fc78676
-----Decoded View---------------
Arg [0] : _owner (address): 0x6ac32B97F7b6c8Ff1335293becf6183d3fC78676
Arg [1] : _proxy (address): 0x0000000000F7A60F1C88F317f369e3D8679C6689
Arg [2] : _name (string): MCBIV on Polygon
Arg [3] : _symbol (string): MCBIV
Arg [4] : royaltyPct (uint96): 1000
Arg [5] : royaltyReceiver (address): 0x6ac32B97F7b6c8Ff1335293becf6183d3fC78676
Arg [6] : operatorFilterRegistry (address): 0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6
Arg [7] : _extension (address): 0x000000000000D58696577347F78259bD376F1BEC
Arg [8] : _renderer (address): 0x00000000000d351E7Df55d1A7E8045daf6C998E2
Arg [9] : _signers (address[]): 0x6ac32B97F7b6c8Ff1335293becf6183d3fC78676
-----Encoded View---------------
16 Constructor Arguments found :
Arg [0] : 0000000000000000000000006ac32b97f7b6c8ff1335293becf6183d3fc78676
Arg [1] : 0000000000000000000000000000000000f7a60f1c88f317f369e3d8679c6689
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000140
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000180
Arg [4] : 00000000000000000000000000000000000000000000000000000000000003e8
Arg [5] : 0000000000000000000000006ac32b97f7b6c8ff1335293becf6183d3fc78676
Arg [6] : 0000000000000000000000003cc6cdda760b79bafa08df41ecfa224f810dceb6
Arg [7] : 000000000000000000000000000000000000d58696577347f78259bd376f1bec
Arg [8] : 00000000000000000000000000000000000d351e7df55d1a7e8045daf6c998e2
Arg [9] : 00000000000000000000000000000000000000000000000000000000000001c0
Arg [10] : 0000000000000000000000000000000000000000000000000000000000000010
Arg [11] : 4d43424956206f6e20506f6c79676f6e00000000000000000000000000000000
Arg [12] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [13] : 4d43424956000000000000000000000000000000000000000000000000000000
Arg [14] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [15] : 0000000000000000000000006ac32b97f7b6c8ff1335293becf6183d3fc78676
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 30 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
[ Download: CSV Export ]
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.