// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1967.sol) pragma solidity >=0.4.11; /** * @dev ERC-1967: Proxy Storage Slots. This interface contains the events defined in the ERC. */ interface IERC1967 { /** * @dev Emitted when the implementation is upgraded. */ event Upgraded(address indexed implementation); /** * @dev Emitted when the admin account has changed. */ event AdminChanged(address previousAdmin, address newAdmin); /** * @dev Emitted when the beacon is changed. */ event BeaconUpgraded(address indexed beacon); }

// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.5.0) (proxy/Proxy.sol) pragma solidity ^0.8.20; /** * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to * be specified by overriding the virtual {_implementation} function. * * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a * different contract through the {_delegate} function. * * The success and return data of the delegated call will be returned back to the caller of the proxy. */ abstract contract Proxy { /** * @dev Delegates the current call to `implementation`. * * This function does not return to its internal call site, it will return directly to the external caller. */ function _delegate(address implementation) internal virtual { assembly { // Copy msg.data. We take full control of memory in this inline assembly // block because it will not return to Solidity code. We overwrite the // Solidity scratch pad at memory position 0. calldatacopy(0x00, 0x00, calldatasize()) // Call the implementation. // out and outsize are 0 because we don't know the size yet. let result := delegatecall(gas(), implementation, 0x00, calldatasize(), 0x00, 0x00) // Copy the returned data. returndatacopy(0x00, 0x00, returndatasize()) switch result // delegatecall returns 0 on error. case 0 { revert(0x00, returndatasize()) } default { return(0x00, returndatasize()) } } } /** * @dev This is a virtual function that should be overridden so it returns the address to which the fallback * function and {_fallback} should delegate. */ function _implementation() internal view virtual returns (address); /** * @dev Delegates the current call to the address returned by `_implementation()`. * * This function does not return to its internal call site, it will return directly to the external caller. */ function _fallback() internal virtual { _delegate(_implementation()); } /** * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other * function in the contract matches the call data. */ fallback() external payable virtual { _fallback(); } }

// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.4.0) (proxy/beacon/IBeacon.sol) pragma solidity >=0.4.16; /** * @dev This is the interface that {BeaconProxy} expects of its beacon. */ interface IBeacon { /** * @dev Must return an address that can be used as a delegate call target. * * {UpgradeableBeacon} will check that this address is a contract. */ function implementation() external view returns (address); }

// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.5.0) (utils/Address.sol) pragma solidity ^0.8.20; import {Errors} from "./Errors.sol"; import {LowLevelCall} from "./LowLevelCall.sol"; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev There's no code at `target` (it is not a contract). */ error AddressEmptyCode(address target); /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { if (address(this).balance < amount) { revert Errors.InsufficientBalance(address(this).balance, amount); } if (LowLevelCall.callNoReturn(recipient, amount, "")) { // call successful, nothing to do return; } else if (LowLevelCall.returnDataSize() > 0) { LowLevelCall.bubbleRevert(); } else { revert Errors.FailedCall(); } } /** * @dev Performs a Solidity function call using a low level `call`. A * plain `call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason or custom error, it is bubbled * up by this function (like regular Solidity function calls). However, if * the call reverted with no returned reason, this function reverts with a * {Errors.FailedCall} error. * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCallWithValue(target, data, 0); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. */ function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { if (address(this).balance < value) { revert Errors.InsufficientBalance(address(this).balance, value); } bool success = LowLevelCall.callNoReturn(target, value, data); if (success && (LowLevelCall.returnDataSize() > 0 || target.code.length > 0)) { return LowLevelCall.returnData(); } else if (success) { revert AddressEmptyCode(target); } else if (LowLevelCall.returnDataSize() > 0) { LowLevelCall.bubbleRevert(); } else { revert Errors.FailedCall(); } } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { bool success = LowLevelCall.staticcallNoReturn(target, data); if (success && (LowLevelCall.returnDataSize() > 0 || target.code.length > 0)) { return LowLevelCall.returnData(); } else if (success) { revert AddressEmptyCode(target); } else if (LowLevelCall.returnDataSize() > 0) { LowLevelCall.bubbleRevert(); } else { revert Errors.FailedCall(); } } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { bool success = LowLevelCall.delegatecallNoReturn(target, data); if (success && (LowLevelCall.returnDataSize() > 0 || target.code.length > 0)) { return LowLevelCall.returnData(); } else if (success) { revert AddressEmptyCode(target); } else if (LowLevelCall.returnDataSize() > 0) { LowLevelCall.bubbleRevert(); } else { revert Errors.FailedCall(); } } /** * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target * was not a contract or bubbling up the revert reason (falling back to {Errors.FailedCall}) in case * of an unsuccessful call. * * NOTE: This function is DEPRECATED and may be removed in the next major release. */ function verifyCallResultFromTarget( address target, bool success, bytes memory returndata ) internal view returns (bytes memory) { // only check if target is a contract if the call was successful and the return data is empty // otherwise we already know that it was a contract if (success && (returndata.length > 0 || target.code.length > 0)) { return returndata; } else if (success) { revert AddressEmptyCode(target); } else if (returndata.length > 0) { LowLevelCall.bubbleRevert(returndata); } else { revert Errors.FailedCall(); } } /** * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the * revert reason or with a default {Errors.FailedCall} error. */ function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) { if (success) { return returndata; } else if (returndata.length > 0) { LowLevelCall.bubbleRevert(returndata); } else { revert Errors.FailedCall(); } } }

// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.1.0) (utils/Errors.sol) pragma solidity ^0.8.20; /** * @dev Collection of common custom errors used in multiple contracts * * IMPORTANT: Backwards compatibility is not guaranteed in future versions of the library. * It is recommended to avoid relying on the error API for critical functionality. * * _Available since v5.1._ */ library Errors { /** * @dev The ETH balance of the account is not enough to perform the operation. */ error InsufficientBalance(uint256 balance, uint256 needed); /** * @dev A call to an address target failed. The target may have reverted. */ error FailedCall(); /** * @dev The deployment failed. */ error FailedDeployment(); /** * @dev A necessary precompile is missing. */ error MissingPrecompile(address); }

// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.5.0) (utils/LowLevelCall.sol) pragma solidity ^0.8.20; /** * @dev Library of low level call functions that implement different calling strategies to deal with the return data. * * WARNING: Using this library requires an advanced understanding of Solidity and how the EVM works. It is recommended * to use the {Address} library instead. */ library LowLevelCall { /// @dev Performs a Solidity function call using a low level `call` and ignoring the return data. function callNoReturn(address target, bytes memory data) internal returns (bool success) { return callNoReturn(target, 0, data); } /// @dev Same as {callNoReturn}, but allows to specify the value to be sent in the call. function callNoReturn(address target, uint256 value, bytes memory data) internal returns (bool success) { assembly ("memory-safe") { success := call(gas(), target, value, add(data, 0x20), mload(data), 0x00, 0x00) } } /// @dev Performs a Solidity function call using a low level `call` and returns the first 64 bytes of the result /// in the scratch space of memory. Useful for functions that return a tuple of single-word values. /// /// WARNING: Do not assume that the results are zero if `success` is false. Memory can be already allocated /// and this function doesn't zero it out. function callReturn64Bytes( address target, bytes memory data ) internal returns (bool success, bytes32 result1, bytes32 result2) { return callReturn64Bytes(target, 0, data); } /// @dev Same as {callReturnBytes32Pair}, but allows to specify the value to be sent in the call. function callReturn64Bytes( address target, uint256 value, bytes memory data ) internal returns (bool success, bytes32 result1, bytes32 result2) { assembly ("memory-safe") { success := call(gas(), target, value, add(data, 0x20), mload(data), 0x00, 0x40) result1 := mload(0x00) result2 := mload(0x20) } } /// @dev Performs a Solidity function call using a low level `staticcall` and ignoring the return data. function staticcallNoReturn(address target, bytes memory data) internal view returns (bool success) { assembly ("memory-safe") { success := staticcall(gas(), target, add(data, 0x20), mload(data), 0x00, 0x00) } } /// @dev Performs a Solidity function call using a low level `staticcall` and returns the first 64 bytes of the result /// in the scratch space of memory. Useful for functions that return a tuple of single-word values. /// /// WARNING: Do not assume that the results are zero if `success` is false. Memory can be already allocated /// and this function doesn't zero it out. function staticcallReturn64Bytes( address target, bytes memory data ) internal view returns (bool success, bytes32 result1, bytes32 result2) { assembly ("memory-safe") { success := staticcall(gas(), target, add(data, 0x20), mload(data), 0x00, 0x40) result1 := mload(0x00) result2 := mload(0x20) } } /// @dev Performs a Solidity function call using a low level `delegatecall` and ignoring the return data. function delegatecallNoReturn(address target, bytes memory data) internal returns (bool success) { assembly ("memory-safe") { success := delegatecall(gas(), target, add(data, 0x20), mload(data), 0x00, 0x00) } } /// @dev Performs a Solidity function call using a low level `delegatecall` and returns the first 64 bytes of the result /// in the scratch space of memory. Useful for functions that return a tuple of single-word values. /// /// WARNING: Do not assume that the results are zero if `success` is false. Memory can be already allocated /// and this function doesn't zero it out. function delegatecallReturn64Bytes( address target, bytes memory data ) internal returns (bool success, bytes32 result1, bytes32 result2) { assembly ("memory-safe") { success := delegatecall(gas(), target, add(data, 0x20), mload(data), 0x00, 0x40) result1 := mload(0x00) result2 := mload(0x20) } } /// @dev Returns the size of the return data buffer. function returnDataSize() internal pure returns (uint256 size) { assembly ("memory-safe") { size := returndatasize() } } /// @dev Returns a buffer containing the return data from the last call. function returnData() internal pure returns (bytes memory result) { assembly ("memory-safe") { result := mload(0x40) mstore(result, returndatasize()) returndatacopy(add(result, 0x20), 0x00, returndatasize()) mstore(0x40, add(result, add(0x20, returndatasize()))) } } /// @dev Revert with the return data from the last call. function bubbleRevert() internal pure { assembly ("memory-safe") { let fmp := mload(0x40) returndatacopy(fmp, 0x00, returndatasize()) revert(fmp, returndatasize()) } } function bubbleRevert(bytes memory returndata) internal pure { assembly ("memory-safe") { revert(add(returndata, 0x20), mload(returndata)) } } }

// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v5.1.0) (utils/StorageSlot.sol) // This file was procedurally generated from scripts/generate/templates/StorageSlot.js. pragma solidity ^0.8.20; /** * @dev Library for reading and writing primitive types to specific storage slots. * * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts. * This library helps with reading and writing to such slots without the need for inline assembly. * * The functions in this library return Slot structs that contain a `value` member that can be used to read or write. * * Example usage to set ERC-1967 implementation slot: * ```solidity * contract ERC1967 { * // Define the slot. Alternatively, use the SlotDerivation library to derive the slot. * bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc; * * function _getImplementation() internal view returns (address) { * return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value; * } * * function _setImplementation(address newImplementation) internal { * require(newImplementation.code.length > 0); * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation; * } * } * ``` * * TIP: Consider using this library along with {SlotDerivation}. */ library StorageSlot { struct AddressSlot { address value; } struct BooleanSlot { bool value; } struct Bytes32Slot { bytes32 value; } struct Uint256Slot { uint256 value; } struct Int256Slot { int256 value; } struct StringSlot { string value; } struct BytesSlot { bytes value; } /** * @dev Returns an `AddressSlot` with member `value` located at `slot`. */ function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) { assembly ("memory-safe") { r.slot := slot } } /** * @dev Returns a `BooleanSlot` with member `value` located at `slot`. */ function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) { assembly ("memory-safe") { r.slot := slot } } /** * @dev Returns a `Bytes32Slot` with member `value` located at `slot`. */ function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) { assembly ("memory-safe") { r.slot := slot } } /** * @dev Returns a `Uint256Slot` with member `value` located at `slot`. */ function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) { assembly ("memory-safe") { r.slot := slot } } /** * @dev Returns a `Int256Slot` with member `value` located at `slot`. */ function getInt256Slot(bytes32 slot) internal pure returns (Int256Slot storage r) { assembly ("memory-safe") { r.slot := slot } } /** * @dev Returns a `StringSlot` with member `value` located at `slot`. */ function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) { assembly ("memory-safe") { r.slot := slot } } /** * @dev Returns an `StringSlot` representation of the string storage pointer `store`. */ function getStringSlot(string storage store) internal pure returns (StringSlot storage r) { assembly ("memory-safe") { r.slot := store.slot } } /** * @dev Returns a `BytesSlot` with member `value` located at `slot`. */ function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) { assembly ("memory-safe") { r.slot := slot } } /** * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`. */ function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) { assembly ("memory-safe") { r.slot := store.slot } } }