Forkchoice Ethereum Mainnet

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

import "../interfaces/IDiamondLoupe.sol";
import "../libraries/DiamondLib.sol";

/**
 * @title DiamondLoupeFacet
 * @notice Facet for diamond loupe functionality
 * @dev Implements EIP-2535 Diamond Standard loupe operations
 */
contract DiamondLoupeFacet is IDiamondLoupe {
    /**
     * @notice Gets all facet addresses and their four byte function selectors
     * @return facets_ Array of Facet structs
     */
    function facets() external view override returns (Facet[] memory facets_) {
        DiamondLib.DiamondStorage storage ds = DiamondLib.diamondStorage();
        uint256 selectorCount = ds.selectors.length;
        // Create an array to store facet selector counts
        uint256[] memory facetSelectorCounts = new uint256[](ds.facetAddresses.length);

        // Count selectors for each facet
        for (uint256 selectorIndex; selectorIndex < selectorCount; selectorIndex++) {
            bytes4 selector = ds.selectors[selectorIndex];
            address facet = ds.facetAddressAndSelectorPosition[selector].facetAddress;
            for (uint256 facetIndex; facetIndex < ds.facetAddresses.length; facetIndex++) {
                if (ds.facetAddresses[facetIndex] == facet) {
                    facetSelectorCounts[facetIndex]++;
                    break;
                }
            }
        }

        // Create facets array
        facets_ = new Facet[](ds.facetAddresses.length);
        for (uint256 facetIndex; facetIndex < ds.facetAddresses.length; facetIndex++) {
            facets_[facetIndex].facetAddress = ds.facetAddresses[facetIndex];
            facets_[facetIndex].functionSelectors = new bytes4[](facetSelectorCounts[facetIndex]);

            uint256 currentSelectorIndex = 0;
            for (uint256 selectorIndex; selectorIndex < selectorCount; selectorIndex++) {
                bytes4 selector = ds.selectors[selectorIndex];
                address facet = ds.facetAddressAndSelectorPosition[selector].facetAddress;
                if (facet == ds.facetAddresses[facetIndex]) {
                    facets_[facetIndex].functionSelectors[currentSelectorIndex] = selector;
                    currentSelectorIndex++;
                }
            }
        }
    }

    /**
     * @notice Gets all the function selectors supported by a specific facet
     * @param facet_ The facet address
     * @return facetFunctionSelectors_ Array of function selectors
     */
    function facetFunctionSelectors(
        address facet_
    ) external view override returns (bytes4[] memory facetFunctionSelectors_) {
        DiamondLib.DiamondStorage storage ds = DiamondLib.diamondStorage();
        uint256 selectorCount = ds.selectors.length;
        uint256 facetSelectorCount = 0;

        // Count selectors for this facet
        for (uint256 selectorIndex; selectorIndex < selectorCount; selectorIndex++) {
            if (facet_ == ds.facetAddressAndSelectorPosition[ds.selectors[selectorIndex]].facetAddress) {
                facetSelectorCount++;
            }
        }

        // Create array and populate
        facetFunctionSelectors_ = new bytes4[](facetSelectorCount);
        uint256 currentIndex = 0;
        for (uint256 selectorIndex; selectorIndex < selectorCount; selectorIndex++) {
            bytes4 selector = ds.selectors[selectorIndex];
            if (facet_ == ds.facetAddressAndSelectorPosition[selector].facetAddress) {
                facetFunctionSelectors_[currentIndex] = selector;
                currentIndex++;
            }
        }
    }

    /**
     * @notice Get all the facet addresses used by a diamond
     * @return facetAddresses_ Array of facet addresses
     */
    function facetAddresses() external view override returns (address[] memory facetAddresses_) {
        DiamondLib.DiamondStorage storage ds = DiamondLib.diamondStorage();
        facetAddresses_ = ds.facetAddresses;
    }

    /**
     * @notice Gets the facet that supports the given selector
     * @param functionSelector_ The function selector
     * @return facetAddress_ The facet address that supports the selector
     */
    function facetAddress(bytes4 functionSelector_) external view override returns (address facetAddress_) {
        DiamondLib.DiamondStorage storage ds = DiamondLib.diamondStorage();
        facetAddress_ = ds.facetAddressAndSelectorPosition[functionSelector_].facetAddress;
    }
}

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

/**
 * @title IDiamondCut
 * @notice Interface for diamond cut functionality
 * @dev EIP-2535 Diamond Standard interface
 */
interface IDiamondCut {
    enum FacetCutAction {
        Add,
        Replace,
        Remove
    }

    struct FacetCut {
        address facetAddress;
        FacetCutAction action;
        bytes4[] functionSelectors;
    }

    /**
     * @notice Add/replace/remove any number of functions and optionally execute a function with delegatecall
     * @param diamondCut Contains the facet addresses and function selectors
     * @param init The address of the contract or facet to execute initCalldata
     * @param initCalldata A function call, including function selector and arguments executed with delegatecall on init
     */
    function diamondCut(FacetCut[] calldata diamondCut, address init, bytes calldata initCalldata) external;

    event DiamondCut(FacetCut[] diamondCut, address init, bytes initCalldata);
}

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

/**
 * @title IDiamondLoupe
 * @notice Interface for diamond loupe functionality
 * @dev EIP-2535 Diamond Standard loupe interface
 */
interface IDiamondLoupe {
    struct Facet {
        address facetAddress;
        bytes4[] functionSelectors;
    }

    /**
     * @notice Gets all facet addresses and their four byte function selectors
     * @return facets_ Array of Facet structs
     */
    function facets() external view returns (Facet[] memory facets_);

    /**
     * @notice Gets all the function selectors supported by a specific facet
     * @param facet The facet address
     * @return facetFunctionSelectors_ Array of function selectors
     */
    function facetFunctionSelectors(address facet) external view returns (bytes4[] memory facetFunctionSelectors_);

    /**
     * @notice Get all the facet addresses used by a diamond
     * @return facetAddresses_ Array of facet addresses
     */
    function facetAddresses() external view returns (address[] memory facetAddresses_);

    /**
     * @notice Gets the facet that supports the given selector
     * @param functionSelector The function selector
     * @return facetAddress_ The facet address that supports the selector
     */
    function facetAddress(bytes4 functionSelector) external view returns (address facetAddress_);
}

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

import "../interfaces/IDiamondCut.sol";

/**
 * @title DiamondLib
 * @notice Core library for diamond functionality
 * @dev Implements EIP-2535 Diamond Standard core logic
 */
library DiamondLib {
    bytes32 constant DIAMOND_STORAGE_POSITION = bytes32(uint256(keccak256("diamond.standard.diamond.storage")) - 1);

    struct FacetAddressAndSelectorPosition {
        address facetAddress;
        uint16 selectorPosition;
    }

    struct DiamondStorage {
        // Maps function selectors to the facet that executes the functions
        mapping(bytes4 => FacetAddressAndSelectorPosition) facetAddressAndSelectorPosition;
        bytes4[] selectors;
        mapping(address => uint256) facetAddressToSelectorCount;
        address[] facetAddresses;
        // Owner of the diamond
        address contractOwner;
    }

    function diamondStorage() internal pure returns (DiamondStorage storage ds) {
        bytes32 position = DIAMOND_STORAGE_POSITION;
        assembly {
            ds.slot := position
        }
    }

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    event DiamondCut(IDiamondCut.FacetCut[] diamondCut, address init, bytes initCalldata);

    function setContractOwner(address newOwner) internal {
        DiamondStorage storage ds = diamondStorage();
        address previousOwner = ds.contractOwner;
        ds.contractOwner = newOwner;
        emit OwnershipTransferred(previousOwner, newOwner);
    }

    function contractOwner() internal view returns (address contractOwner_) {
        contractOwner_ = diamondStorage().contractOwner;
    }

    function enforceIsContractOwner() internal view {
        require(msg.sender == diamondStorage().contractOwner, "DiamondLib: Must be contract owner");
    }

    function diamondCut(IDiamondCut.FacetCut[] memory diamondCut_, address init, bytes memory initCalldata) internal {
        for (uint256 facetIndex; facetIndex < diamondCut_.length; facetIndex++) {
            IDiamondCut.FacetCutAction action = diamondCut_[facetIndex].action;
            if (action == IDiamondCut.FacetCutAction.Add) {
                addFunctions(diamondCut_[facetIndex].facetAddress, diamondCut_[facetIndex].functionSelectors);
            } else if (action == IDiamondCut.FacetCutAction.Replace) {
                replaceFunctions(diamondCut_[facetIndex].facetAddress, diamondCut_[facetIndex].functionSelectors);
            } else if (action == IDiamondCut.FacetCutAction.Remove) {
                removeFunctions(diamondCut_[facetIndex].facetAddress, diamondCut_[facetIndex].functionSelectors);
            } else {
                revert("DiamondCutFacet: Incorrect FacetCutAction");
            }
        }
        emit DiamondCut(diamondCut_, init, initCalldata);
        initializeDiamondCut(init, initCalldata);
    }

    function addFunctions(address facetAddress, bytes4[] memory functionSelectors) internal {
        require(functionSelectors.length > 0, "DiamondLib: No selectors in facet to cut");
        DiamondStorage storage ds = diamondStorage();
        uint16 selectorCount = uint16(ds.selectors.length);
        require(facetAddress != address(0), "DiamondLib: Add facet can't be address(0)");
        enforceHasContractCode(facetAddress, "DiamondLib: Add facet has no code");
        for (uint256 selectorIndex; selectorIndex < functionSelectors.length; selectorIndex++) {
            bytes4 selector = functionSelectors[selectorIndex];
            address oldFacetAddress = ds.facetAddressAndSelectorPosition[selector].facetAddress;
            require(oldFacetAddress == address(0), "DiamondLib: Can't add function that already exists");
            ds.facetAddressAndSelectorPosition[selector] = FacetAddressAndSelectorPosition(facetAddress, selectorCount);
            ds.selectors.push(selector);
            selectorCount++;
        }
        if (ds.facetAddressToSelectorCount[facetAddress] == 0) {
            ds.facetAddresses.push(facetAddress);
        }
        ds.facetAddressToSelectorCount[facetAddress] += functionSelectors.length;
    }

    function replaceFunctions(address facetAddress, bytes4[] memory functionSelectors) internal {
        require(functionSelectors.length > 0, "DiamondLib: No selectors in facet to cut");
        DiamondStorage storage ds = diamondStorage();
        require(facetAddress != address(0), "DiamondLib: Replace facet can't be address(0)");
        enforceHasContractCode(facetAddress, "DiamondLib: Replace facet has no code");
        for (uint256 selectorIndex; selectorIndex < functionSelectors.length; selectorIndex++) {
            bytes4 selector = functionSelectors[selectorIndex];
            address oldFacetAddress = ds.facetAddressAndSelectorPosition[selector].facetAddress;
            require(oldFacetAddress != facetAddress, "DiamondLib: Can't replace function with same function");
            require(oldFacetAddress != address(0), "DiamondLib: Can't replace function that doesn't exist");
            // Replace old facet address
            ds.facetAddressAndSelectorPosition[selector].facetAddress = facetAddress;
            if (ds.facetAddressToSelectorCount[facetAddress] == 0) {
                ds.facetAddresses.push(facetAddress);
            }
            ds.facetAddressToSelectorCount[facetAddress]++;
            ds.facetAddressToSelectorCount[oldFacetAddress]--;
            if (ds.facetAddressToSelectorCount[oldFacetAddress] == 0) {
                removeFacetAddress(ds, oldFacetAddress);
            }
        }
    }

    function removeFunctions(address facetAddress, bytes4[] memory functionSelectors) internal {
        require(functionSelectors.length > 0, "DiamondLib: No selectors in facet to cut");
        DiamondStorage storage ds = diamondStorage();
        require(facetAddress == address(0), "DiamondLib: Remove facet address must be address(0)");
        for (uint256 selectorIndex; selectorIndex < functionSelectors.length; selectorIndex++) {
            bytes4 selector = functionSelectors[selectorIndex];
            FacetAddressAndSelectorPosition memory oldFacetAddressAndSelectorPosition = ds
                .facetAddressAndSelectorPosition[selector];
            require(
                oldFacetAddressAndSelectorPosition.facetAddress != address(0),
                "DiamondLib: Can't remove function that doesn't exist"
            );
            // Replace selector with last selector
            uint256 selectorPosition = oldFacetAddressAndSelectorPosition.selectorPosition;
            uint256 lastSelectorPosition = ds.selectors.length - 1;
            // If not the same then replace selector with last selector
            if (selectorPosition != lastSelectorPosition) {
                bytes4 lastSelector = ds.selectors[lastSelectorPosition];
                ds.selectors[selectorPosition] = lastSelector;
                ds.facetAddressAndSelectorPosition[lastSelector].selectorPosition = uint16(selectorPosition);
            }
            // Delete the last selector
            ds.selectors.pop();
            delete ds.facetAddressAndSelectorPosition[selector];
            address oldFacetAddress = oldFacetAddressAndSelectorPosition.facetAddress;
            ds.facetAddressToSelectorCount[oldFacetAddress]--;
            if (ds.facetAddressToSelectorCount[oldFacetAddress] == 0) {
                removeFacetAddress(ds, oldFacetAddress);
            }
        }
    }

    function removeFacetAddress(DiamondStorage storage ds, address facetAddress) internal {
        uint256 facetAddressCount = ds.facetAddresses.length;
        for (uint256 i; i < facetAddressCount; i++) {
            if (ds.facetAddresses[i] == facetAddress) {
                ds.facetAddresses[i] = ds.facetAddresses[facetAddressCount - 1];
                ds.facetAddresses.pop();
                break;
            }
        }
    }

    function initializeDiamondCut(address init, bytes memory initCalldata) internal {
        if (init == address(0)) {
            require(initCalldata.length == 0, "DiamondLib: init is address(0) but initCalldata is not empty");
        } else {
            require(initCalldata.length > 0, "DiamondLib: initCalldata is empty but init is not address(0)");
            if (init != address(this)) {
                enforceHasContractCode(init, "DiamondLib: init address has no code");
            }
            (bool success, bytes memory error) = init.delegatecall(initCalldata);
            if (!success) {
                if (error.length > 0) {
                    // bubble up the error
                    revert(string(error));
                } else {
                    revert("DiamondLib: initializeDiamondCut failed");
                }
            }
        }
    }

    function enforceHasContractCode(address facet, string memory errorMessage) internal view {
        uint256 contractSize;
        assembly {
            contractSize := extcodesize(facet)
        }
        require(contractSize > 0, errorMessage);
    }
}