Forkchoice Ethereum Mainnet

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)

pragma solidity ^0.8.20;

import {Context} from "../utils/Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * The initial owner is set to the address provided by the deployer. This can
 * later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// 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/Create2.sol)

pragma solidity ^0.8.20;

/**
 * @dev Helper to make usage of the `CREATE2` EVM opcode easier and safer.
 * `CREATE2` can be used to compute in advance the address where a smart
 * contract will be deployed, which allows for interesting new mechanisms known
 * as 'counterfactual interactions'.
 *
 * See the https://eips.ethereum.org/EIPS/eip-1014#motivation[EIP] for more
 * information.
 */
library Create2 {
    /**
     * @dev Not enough balance for performing a CREATE2 deploy.
     */
    error Create2InsufficientBalance(uint256 balance, uint256 needed);

    /**
     * @dev There's no code to deploy.
     */
    error Create2EmptyBytecode();

    /**
     * @dev The deployment failed.
     */
    error Create2FailedDeployment();

    /**
     * @dev Deploys a contract using `CREATE2`. The address where the contract
     * will be deployed can be known in advance via {computeAddress}.
     *
     * The bytecode for a contract can be obtained from Solidity with
     * `type(contractName).creationCode`.
     *
     * Requirements:
     *
     * - `bytecode` must not be empty.
     * - `salt` must have not been used for `bytecode` already.
     * - the factory must have a balance of at least `amount`.
     * - if `amount` is non-zero, `bytecode` must have a `payable` constructor.
     */
    function deploy(uint256 amount, bytes32 salt, bytes memory bytecode) internal returns (address addr) {
        if (address(this).balance < amount) {
            revert Create2InsufficientBalance(address(this).balance, amount);
        }
        if (bytecode.length == 0) {
            revert Create2EmptyBytecode();
        }
        /// @solidity memory-safe-assembly
        assembly {
            addr := create2(amount, add(bytecode, 0x20), mload(bytecode), salt)
        }
        if (addr == address(0)) {
            revert Create2FailedDeployment();
        }
    }

    /**
     * @dev Returns the address where a contract will be stored if deployed via {deploy}. Any change in the
     * `bytecodeHash` or `salt` will result in a new destination address.
     */
    function computeAddress(bytes32 salt, bytes32 bytecodeHash) internal view returns (address) {
        return computeAddress(salt, bytecodeHash, address(this));
    }

    /**
     * @dev Returns the address where a contract will be stored if deployed via {deploy} from a contract located at
     * `deployer`. If `deployer` is this contract's address, returns the same value as {computeAddress}.
     */
    function computeAddress(bytes32 salt, bytes32 bytecodeHash, address deployer) internal pure returns (address addr) {
        /// @solidity memory-safe-assembly
        assembly {
            let ptr := mload(0x40) // Get free memory pointer

            // |                   | ↓ ptr ...  ↓ ptr + 0x0B (start) ...  ↓ ptr + 0x20 ...  ↓ ptr + 0x40 ...   |
            // |-------------------|---------------------------------------------------------------------------|
            // | bytecodeHash      |                                                        CCCCCCCCCCCCC...CC |
            // | salt              |                                      BBBBBBBBBBBBB...BB                   |
            // | deployer          | 000000...0000AAAAAAAAAAAAAAAAAAA...AA                                     |
            // | 0xFF              |            FF                                                             |
            // |-------------------|---------------------------------------------------------------------------|
            // | memory            | 000000...00FFAAAAAAAAAAAAAAAAAAA...AABBBBBBBBBBBBB...BBCCCCCCCCCCCCC...CC |
            // | keccak(start, 85) |            ↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑ |

            mstore(add(ptr, 0x40), bytecodeHash)
            mstore(add(ptr, 0x20), salt)
            mstore(ptr, deployer) // Right-aligned with 12 preceding garbage bytes
            let start := add(ptr, 0x0b) // The hashed data starts at the final garbage byte which we will set to 0xff
            mstore8(start, 0xff)
            addr := keccak256(start, 85)
        }
    }
}

// SPDX-License-Identifier: BSD-3-Clause
pragma solidity ^0.8.20;

import {Create2} from "@openzeppelin/contracts/utils/Create2.sol";
import {Context} from "@openzeppelin/contracts/utils/Context.sol";
import {Storage} from "../storage/Storage.sol";

contract MinimalProxyFactory is Context {
  address public info;

  event MinimalProxyCreated(address minimalProxy);

  error ProxyInitializationFailed();

  error Forbidden();

  constructor(address _info) {
    info = _info;
  }

  function _getContractCreationCode(address logic) internal pure returns (bytes memory) {
    bytes10 creation = 0x3d602d80600a3d3981f3;
    bytes10 prefix = 0x363d3d373d3d3d363d73;
    bytes20 targetBytes = bytes20(logic);
    bytes15 suffix = 0x5af43d82803e903d91602b57fd5bf3;

    return abi.encodePacked(creation, prefix, targetBytes, suffix);
  }

  /**
   * @notice Calculates proxy contract address for salt.
   * @param salt CREATE2 opcode salt.
   * @param implementation Proxy implementation contract address.
   * @return Proxy contract address.
   */
  function computeAddress(bytes32 salt, address implementation) external view returns (address) {
    return Create2.computeAddress(salt, keccak256(_getContractCreationCode(implementation)), address(this));
  }

  /**
   * @notice Deploy and initialize minimal proxy contract for salt.
   * @param salt CREATE2 opcode salt.
   * @param implementation Proxy implementation contract address.
   * @param data Initialize method data.
   * @return Proxy contract address.
   */
  function deploy(bytes32 salt, address implementation, bytes memory data) external returns (address) {
    bool isCallAllowed = Storage(info).getBool(
      keccak256(abi.encodePacked("EH:MinimalProxyFactory:Deployer:", _msgSender()))
    );
    if (!isCallAllowed) revert Forbidden();

    address minimalProxy = Create2.deploy(0, salt, _getContractCreationCode(implementation));
    if (data.length > 0) {
      // solhint-disable-next-line avoid-low-level-calls
      (bool success, ) = minimalProxy.call(data);
      if (!success) revert ProxyInitializationFailed();
    }

    emit MinimalProxyCreated(minimalProxy);

    return minimalProxy;
  }
}

// SPDX-License-Identifier: BSD-3-Clause
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/access/Ownable.sol";

contract Storage is Ownable {
  /// @dev Bytes storage.
  mapping(bytes32 => bytes) private _bytes;

  /// @dev Bool storage.
  mapping(bytes32 => bool) private _bool;

  /// @dev Uint storage.
  mapping(bytes32 => uint256) private _uint;

  /// @dev Int storage.
  mapping(bytes32 => int256) private _int;

  /// @dev Address storage.
  mapping(bytes32 => address) private _address;

  /// @dev String storage.
  mapping(bytes32 => string) private _string;

  event Updated(bytes32 indexed key);

  constructor() Ownable(_msgSender()) {}

  /**
   * @param key The key for the record
   */
  function getBytes(bytes32 key) external view returns (bytes memory) {
    return _bytes[key];
  }

  /**
   * @param key The key for the record
   */
  function getBool(bytes32 key) external view returns (bool) {
    return _bool[key];
  }

  /**
   * @param key The key for the record
   */
  function getUint(bytes32 key) external view returns (uint256) {
    return _uint[key];
  }

  /**
   * @param key The key for the record
   */
  function getInt(bytes32 key) external view returns (int256) {
    return _int[key];
  }

  /**
   * @param key The key for the record
   */
  function getAddress(bytes32 key) external view returns (address) {
    return _address[key];
  }

  /**
   * @param key The key for the record
   */
  function getString(bytes32 key) external view returns (string memory) {
    return _string[key];
  }

  /**
   * @param key The key for the record
   * @param value The value to set.
   */
  function setBytes(bytes32 key, bytes calldata value) external onlyOwner {
    _bytes[key] = value;
    emit Updated(key);
  }

  /**
   * @param key The key for the record
   * @param value The value to set.
   */
  function setBool(bytes32 key, bool value) external onlyOwner {
    _bool[key] = value;
    emit Updated(key);
  }

  /**
   * @param key The key for the record
   * @param value The value to set.
   */
  function setUint(bytes32 key, uint256 value) external onlyOwner {
    _uint[key] = value;
    emit Updated(key);
  }

  /**
   * @param key The key for the record
   * @param value The value to set.
   */
  function setInt(bytes32 key, int256 value) external onlyOwner {
    _int[key] = value;
    emit Updated(key);
  }

  /**
   * @param key The key for the record
   * @param value The value to set.
   */
  function setAddress(bytes32 key, address value) external onlyOwner {
    _address[key] = value;
    emit Updated(key);
  }

  /**
   * @param key The key for the record
   * @param value The value to set.
   */
  function setString(bytes32 key, string calldata value) external onlyOwner {
    _string[key] = value;
    emit Updated(key);
  }

  /**
   * @param key The key for the record
   */
  function deleteBytes(bytes32 key) external onlyOwner {
    delete _bytes[key];
    emit Updated(key);
  }

  /**
   * @param key The key for the record
   */
  function deleteBool(bytes32 key) external onlyOwner {
    delete _bool[key];
    emit Updated(key);
  }

  /**
   * @param key The key for the record
   */
  function deleteUint(bytes32 key) external onlyOwner {
    delete _uint[key];
    emit Updated(key);
  }

  /**
   * @param key The key for the record
   */
  function deleteInt(bytes32 key) external onlyOwner {
    delete _int[key];
    emit Updated(key);
  }

  /**
   * @param key The key for the record
   */
  function deleteAddress(bytes32 key) external onlyOwner {
    delete _address[key];
    emit Updated(key);
  }

  /**
   * @param key The key for the record
   */
  function deleteString(bytes32 key) external onlyOwner {
    delete _string[key];
    emit Updated(key);
  }
}