New Solidity Smart Contract Verification

Contract Address

Is Yul contract

Yes

Contract Name

Include nightly builds

Yes

Compiler

EVM Version

Optimization

Yes

Optimization runs

Enter the Solidity Contract Code

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

// Adapted from the Diamond 3 reference implementation by Nick Mudge:
// https://github.com/mudgen/diamond-3-hardhat

import {IDiamondCut} from '../interfaces/IDiamondCut.sol';
import {LibContractOwner} from '../libraries/LibContractOwner.sol';
import {LibDiamond} from '../libraries/LibDiamond.sol';

contract Diamond {
    error FunctionDoesNotExist(bytes4 methodSelector);
    error DiamondAlreadyInitialized();

constructor(address diamondCutFacet) payable {
        initializeDiamond(diamondCutFacet);
    }

// Find facet for function that is called and execute the
    // function if a facet is found and return any value.
    fallback() external payable {
        /* solhint-disable no-inline-assembly */
        // get facet from function selector
        address facet = LibDiamond.diamondStorage().selectorToFacetAndPosition[msg.sig].facetAddress;
        if (facet == address(0)) revert FunctionDoesNotExist(msg.sig);
        // Execute external function from facet using delegatecall and return any value.
        assembly {
            // copy function selector and any arguments
            calldatacopy(0, 0, calldatasize())
            // execute function call using the facet
            let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)
            // get any return value
            returndatacopy(0, 0, returndatasize())
            // return any return value or error back to the caller
            switch result
            case 0 {
                revert(0, returndatasize())
            }
            default {
                return(0, returndatasize())
            }
        }
        /* solhint-enable no-inline-assembly */
    }

/// @notice Initializes the diamond, by adding the `diamondCut` method and setting the owner.
    /// @dev This function is automatically called by the constructor.
    /// @dev The code is separated out to facilitate on-chain copying utilities.
    function initializeDiamond(address diamondCutFacet) public {
        LibDiamond.DiamondStorage storage ds = LibDiamond.diamondStorage();
        if (ds.initialized) revert DiamondAlreadyInitialized();

// Attach the diamondCut function from the diamondCutFacet
        IDiamondCut.FacetCut[] memory cut = new IDiamondCut.FacetCut[](1);
        cut[0] = IDiamondCut.FacetCut({
            facetAddress: diamondCutFacet,
            action: IDiamondCut.FacetCutAction.Add,
            functionSelectors: new bytes4[](1)
        });
        cut[0].functionSelectors[0] = IDiamondCut.diamondCut.selector;

LibDiamond.diamondCut(cut);

//  When deployed from an EOA this will be the owner wallet,
        //  when deployed from the clone function, the copier contract will be the owner.
        LibContractOwner.setContractOwner(msg.sender);

ds.initialized = true;
    }

receive() external payable {}
}

Try to fetch constructor arguments automatically

Yes

Add Contract Libraries

Contract Libraries

Library 1 Name

Library 1 Address

Library 2 Name

Library 2 Address

Library 3 Name

Library 3 Address

Library 4 Name

Library 4 Address

Library 5 Name

Library 5 Address

Library 6 Name

Library 6 Address

Library 7 Name

Library 7 Address

Library 8 Name

Library 8 Address

Library 9 Name

Library 9 Address

Library 10 Name

Library 10 Address

Add Library

Cancel