creation_sourcecode: // Sources flattened with hardhat v2.14.0 https://hardhat.org
  
  // File @openzeppelin/contracts/utils/Context.sol@v4.9.6
  
  
  // OpenZeppelin Contracts (last updated v4.9.4) (utils/Context.sol)
  
  pragma solidity ^0.8.0;
  
  /**
   * @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;
      }
  }
  
  
  // File @openzeppelin/contracts/access/Ownable.sol@v4.9.6
  
  
  // OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)
  
  pragma solidity ^0.8.0;
  
  /**
   * @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.
   *
   * By default, the owner account will be the one that deploys the contract. 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;
  
      event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
  
      /**
       * @dev Initializes the contract setting the deployer as the initial owner.
       */
      constructor() {
          _transferOwnership(_msgSender());
      }
  
      /**
       * @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 {
          require(owner() == _msgSender(), "Ownable: caller is not the owner");
      }
  
      /**
       * @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 {
          require(newOwner != address(0), "Ownable: new owner is the zero address");
          _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);
      }
  }
  
  
  // File @openzeppelin/contracts/proxy/beacon/IBeacon.sol@v4.9.6
  
  
  // OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)
  
  pragma solidity ^0.8.0;
  
  /**
   * @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.
       *
       * {BeaconProxy} will check that this address is a contract.
       */
      function implementation() external view returns (address);
  }
  
  
  // File @openzeppelin/contracts/interfaces/draft-IERC1822.sol@v4.9.6
  
  
  // OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)
  
  pragma solidity ^0.8.0;
  
  /**
   * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified
   * proxy whose upgrades are fully controlled by the current implementation.
   */
  interface IERC1822Proxiable {
      /**
       * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation
       * address.
       *
       * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
       * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
       * function revert if invoked through a proxy.
       */
      function proxiableUUID() external view returns (bytes32);
  }
  
  
  // File @openzeppelin/contracts/interfaces/IERC1967.sol@v4.9.6
  
  
  // OpenZeppelin Contracts (last updated v4.9.0) (interfaces/IERC1967.sol)
  
  pragma solidity ^0.8.0;
  
  /**
   * @dev ERC-1967: Proxy Storage Slots. This interface contains the events defined in the ERC.
   *
   * _Available since v4.8.3._
   */
  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);
  }
  
  
  // File @openzeppelin/contracts/utils/Address.sol@v4.9.6
  
  
  // OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)
  
  pragma solidity ^0.8.1;
  
  /**
   * @dev Collection of functions related to the address type
   */
  library Address {
      /**
       * @dev Returns true if `account` is a contract.
       *
       * [IMPORTANT]
       * ====
       * It is unsafe to assume that an address for which this function returns
       * false is an externally-owned account (EOA) and not a contract.
       *
       * Among others, `isContract` will return false for the following
       * types of addresses:
       *
       *  - an externally-owned account
       *  - a contract in construction
       *  - an address where a contract will be created
       *  - an address where a contract lived, but was destroyed
       *
       * Furthermore, `isContract` will also return true if the target contract within
       * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
       * which only has an effect at the end of a transaction.
       * ====
       *
       * [IMPORTANT]
       * ====
       * You shouldn't rely on `isContract` to protect against flash loan attacks!
       *
       * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
       * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
       * constructor.
       * ====
       */
      function isContract(address account) internal view returns (bool) {
          // This method relies on extcodesize/address.code.length, which returns 0
          // for contracts in construction, since the code is only stored at the end
          // of the constructor execution.
  
          return account.code.length > 0;
      }
  
      /**
       * @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.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
       */
      function sendValue(address payable recipient, uint256 amount) internal {
          require(address(this).balance >= amount, "Address: insufficient balance");
  
          (bool success, ) = recipient.call{value: amount}("");
          require(success, "Address: unable to send value, recipient may have reverted");
      }
  
      /**
       * @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, it is bubbled up by this
       * function (like regular Solidity function calls).
       *
       * 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.
       *
       * _Available since v3.1._
       */
      function functionCall(address target, bytes memory data) internal returns (bytes memory) {
          return functionCallWithValue(target, data, 0, "Address: low-level call failed");
      }
  
      /**
       * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
       * `errorMessage` as a fallback revert reason when `target` reverts.
       *
       * _Available since v3.1._
       */
      function functionCall(
          address target,
          bytes memory data,
          string memory errorMessage
      ) internal returns (bytes memory) {
          return functionCallWithValue(target, data, 0, errorMessage);
      }
  
      /**
       * @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`.
       *
       * _Available since v3.1._
       */
      function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
          return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
      }
  
      /**
       * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
       * with `errorMessage` as a fallback revert reason when `target` reverts.
       *
       * _Available since v3.1._
       */
      function functionCallWithValue(
          address target,
          bytes memory data,
          uint256 value,
          string memory errorMessage
      ) internal returns (bytes memory) {
          require(address(this).balance >= value, "Address: insufficient balance for call");
          (bool success, bytes memory returndata) = target.call{value: value}(data);
          return verifyCallResultFromTarget(target, success, returndata, errorMessage);
      }
  
      /**
       * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
       * but performing a static call.
       *
       * _Available since v3.3._
       */
      function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
          return functionStaticCall(target, data, "Address: low-level static call failed");
      }
  
      /**
       * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
       * but performing a static call.
       *
       * _Available since v3.3._
       */
      function functionStaticCall(
          address target,
          bytes memory data,
          string memory errorMessage
      ) internal view returns (bytes memory) {
          (bool success, bytes memory returndata) = target.staticcall(data);
          return verifyCallResultFromTarget(target, success, returndata, errorMessage);
      }
  
      /**
       * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
       * but performing a delegate call.
       *
       * _Available since v3.4._
       */
      function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
          return functionDelegateCall(target, data, "Address: low-level delegate call failed");
      }
  
      /**
       * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
       * but performing a delegate call.
       *
       * _Available since v3.4._
       */
      function functionDelegateCall(
          address target,
          bytes memory data,
          string memory errorMessage
      ) internal returns (bytes memory) {
          (bool success, bytes memory returndata) = target.delegatecall(data);
          return verifyCallResultFromTarget(target, success, returndata, errorMessage);
      }
  
      /**
       * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
       * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
       *
       * _Available since v4.8._
       */
      function verifyCallResultFromTarget(
          address target,
          bool success,
          bytes memory returndata,
          string memory errorMessage
      ) internal view returns (bytes memory) {
          if (success) {
              if (returndata.length == 0) {
                  // only check isContract if the call was successful and the return data is empty
                  // otherwise we already know that it was a contract
                  require(isContract(target), "Address: call to non-contract");
              }
              return returndata;
          } else {
              _revert(returndata, errorMessage);
          }
      }
  
      /**
       * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
       * revert reason or using the provided one.
       *
       * _Available since v4.3._
       */
      function verifyCallResult(
          bool success,
          bytes memory returndata,
          string memory errorMessage
      ) internal pure returns (bytes memory) {
          if (success) {
              return returndata;
          } else {
              _revert(returndata, errorMessage);
          }
      }
  
      function _revert(bytes memory returndata, string memory errorMessage) private pure {
          // Look for revert reason and bubble it up if present
          if (returndata.length > 0) {
              // The easiest way to bubble the revert reason is using memory via assembly
              /// @solidity memory-safe-assembly
              assembly {
                  let returndata_size := mload(returndata)
                  revert(add(32, returndata), returndata_size)
              }
          } else {
              revert(errorMessage);
          }
      }
  }
  
  
  // File @openzeppelin/contracts/utils/StorageSlot.sol@v4.9.6
  
  
  // OpenZeppelin Contracts (last updated v4.9.0) (utils/StorageSlot.sol)
  // This file was procedurally generated from scripts/generate/templates/StorageSlot.js.
  
  pragma solidity ^0.8.0;
  
  /**
   * @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 ERC1967 implementation slot:
   * ```solidity
   * contract ERC1967 {
   *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
   *
   *     function _getImplementation() internal view returns (address) {
   *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
   *     }
   *
   *     function _setImplementation(address newImplementation) internal {
   *         require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
   *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
   *     }
   * }
   * ```
   *
   * _Available since v4.1 for `address`, `bool`, `bytes32`, `uint256`._
   * _Available since v4.9 for `string`, `bytes`._
   */
  library StorageSlot {
      struct AddressSlot {
          address value;
      }
  
      struct BooleanSlot {
          bool value;
      }
  
      struct Bytes32Slot {
          bytes32 value;
      }
  
      struct Uint256Slot {
          uint256 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) {
          /// @solidity memory-safe-assembly
          assembly {
              r.slot := slot
          }
      }
  
      /**
       * @dev Returns an `BooleanSlot` with member `value` located at `slot`.
       */
      function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
          /// @solidity memory-safe-assembly
          assembly {
              r.slot := slot
          }
      }
  
      /**
       * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
       */
      function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
          /// @solidity memory-safe-assembly
          assembly {
              r.slot := slot
          }
      }
  
      /**
       * @dev Returns an `Uint256Slot` with member `value` located at `slot`.
       */
      function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
          /// @solidity memory-safe-assembly
          assembly {
              r.slot := slot
          }
      }
  
      /**
       * @dev Returns an `StringSlot` with member `value` located at `slot`.
       */
      function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
          /// @solidity memory-safe-assembly
          assembly {
              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) {
          /// @solidity memory-safe-assembly
          assembly {
              r.slot := store.slot
          }
      }
  
      /**
       * @dev Returns an `BytesSlot` with member `value` located at `slot`.
       */
      function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
          /// @solidity memory-safe-assembly
          assembly {
              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) {
          /// @solidity memory-safe-assembly
          assembly {
              r.slot := store.slot
          }
      }
  }
  
  
  // File @openzeppelin/contracts/proxy/ERC1967/ERC1967Upgrade.sol@v4.9.6
  
  
  // OpenZeppelin Contracts (last updated v4.9.0) (proxy/ERC1967/ERC1967Upgrade.sol)
  
  pragma solidity ^0.8.2;
  
  
  
  
  
  /**
   * @dev This abstract contract provides getters and event emitting update functions for
   * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.
   *
   * _Available since v4.1._
   */
  abstract contract ERC1967Upgrade is IERC1967 {
      // This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1
      bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;
  
      /**
       * @dev Storage slot with the address of the current implementation.
       * This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is
       * validated in the constructor.
       */
      bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
  
      /**
       * @dev Returns the current implementation address.
       */
      function _getImplementation() internal view returns (address) {
          return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
      }
  
      /**
       * @dev Stores a new address in the EIP1967 implementation slot.
       */
      function _setImplementation(address newImplementation) private {
          require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
          StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
      }
  
      /**
       * @dev Perform implementation upgrade
       *
       * Emits an {Upgraded} event.
       */
      function _upgradeTo(address newImplementation) internal {
          _setImplementation(newImplementation);
          emit Upgraded(newImplementation);
      }
  
      /**
       * @dev Perform implementation upgrade with additional setup call.
       *
       * Emits an {Upgraded} event.
       */
      function _upgradeToAndCall(address newImplementation, bytes memory data, bool forceCall) internal {
          _upgradeTo(newImplementation);
          if (data.length > 0 || forceCall) {
              Address.functionDelegateCall(newImplementation, data);
          }
      }
  
      /**
       * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.
       *
       * Emits an {Upgraded} event.
       */
      function _upgradeToAndCallUUPS(address newImplementation, bytes memory data, bool forceCall) internal {
          // Upgrades from old implementations will perform a rollback test. This test requires the new
          // implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing
          // this special case will break upgrade paths from old UUPS implementation to new ones.
          if (StorageSlot.getBooleanSlot(_ROLLBACK_SLOT).value) {
              _setImplementation(newImplementation);
          } else {
              try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {
                  require(slot == _IMPLEMENTATION_SLOT, "ERC1967Upgrade: unsupported proxiableUUID");
              } catch {
                  revert("ERC1967Upgrade: new implementation is not UUPS");
              }
              _upgradeToAndCall(newImplementation, data, forceCall);
          }
      }
  
      /**
       * @dev Storage slot with the admin of the contract.
       * This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is
       * validated in the constructor.
       */
      bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
  
      /**
       * @dev Returns the current admin.
       */
      function _getAdmin() internal view returns (address) {
          return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;
      }
  
      /**
       * @dev Stores a new address in the EIP1967 admin slot.
       */
      function _setAdmin(address newAdmin) private {
          require(newAdmin != address(0), "ERC1967: new admin is the zero address");
          StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
      }
  
      /**
       * @dev Changes the admin of the proxy.
       *
       * Emits an {AdminChanged} event.
       */
      function _changeAdmin(address newAdmin) internal {
          emit AdminChanged(_getAdmin(), newAdmin);
          _setAdmin(newAdmin);
      }
  
      /**
       * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.
       * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.
       */
      bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;
  
      /**
       * @dev Returns the current beacon.
       */
      function _getBeacon() internal view returns (address) {
          return StorageSlot.getAddressSlot(_BEACON_SLOT).value;
      }
  
      /**
       * @dev Stores a new beacon in the EIP1967 beacon slot.
       */
      function _setBeacon(address newBeacon) private {
          require(Address.isContract(newBeacon), "ERC1967: new beacon is not a contract");
          require(
              Address.isContract(IBeacon(newBeacon).implementation()),
              "ERC1967: beacon implementation is not a contract"
          );
          StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;
      }
  
      /**
       * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does
       * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).
       *
       * Emits a {BeaconUpgraded} event.
       */
      function _upgradeBeaconToAndCall(address newBeacon, bytes memory data, bool forceCall) internal {
          _setBeacon(newBeacon);
          emit BeaconUpgraded(newBeacon);
          if (data.length > 0 || forceCall) {
              Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);
          }
      }
  }
  
  
  // File @openzeppelin/contracts/proxy/Proxy.sol@v4.9.6
  
  
  // OpenZeppelin Contracts (last updated v4.6.0) (proxy/Proxy.sol)
  
  pragma solidity ^0.8.0;
  
  /**
   * @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(0, 0, calldatasize())
  
              // Call the implementation.
              // out and outsize are 0 because we don't know the size yet.
              let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
  
              // Copy the returned data.
              returndatacopy(0, 0, returndatasize())
  
              switch result
              // delegatecall returns 0 on error.
              case 0 {
                  revert(0, returndatasize())
              }
              default {
                  return(0, 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 {
          _beforeFallback();
          _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();
      }
  
      /**
       * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data
       * is empty.
       */
      receive() external payable virtual {
          _fallback();
      }
  
      /**
       * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`
       * call, or as part of the Solidity `fallback` or `receive` functions.
       *
       * If overridden should call `super._beforeFallback()`.
       */
      function _beforeFallback() internal virtual {}
  }
  
  
  // File @openzeppelin/contracts/proxy/beacon/BeaconProxy.sol@v4.9.6
  
  
  // OpenZeppelin Contracts (last updated v4.7.0) (proxy/beacon/BeaconProxy.sol)
  
  pragma solidity ^0.8.0;
  
  
  
  /**
   * @dev This contract implements a proxy that gets the implementation address for each call from an {UpgradeableBeacon}.
   *
   * The beacon address is stored in storage slot `uint256(keccak256('eip1967.proxy.beacon')) - 1`, so that it doesn't
   * conflict with the storage layout of the implementation behind the proxy.
   *
   * _Available since v3.4._
   */
  contract BeaconProxy is Proxy, ERC1967Upgrade {
      /**
       * @dev Initializes the proxy with `beacon`.
       *
       * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon. This
       * will typically be an encoded function call, and allows initializing the storage of the proxy like a Solidity
       * constructor.
       *
       * Requirements:
       *
       * - `beacon` must be a contract with the interface {IBeacon}.
       */
      constructor(address beacon, bytes memory data) payable {
          _upgradeBeaconToAndCall(beacon, data, false);
      }
  
      /**
       * @dev Returns the current beacon address.
       */
      function _beacon() internal view virtual returns (address) {
          return _getBeacon();
      }
  
      /**
       * @dev Returns the current implementation address of the associated beacon.
       */
      function _implementation() internal view virtual override returns (address) {
          return IBeacon(_getBeacon()).implementation();
      }
  
      /**
       * @dev Changes the proxy to use a new beacon. Deprecated: see {_upgradeBeaconToAndCall}.
       *
       * If `data` is nonempty, it's used as data in a delegate call to the implementation returned by the beacon.
       *
       * Requirements:
       *
       * - `beacon` must be a contract.
       * - The implementation returned by `beacon` must be a contract.
       */
      function _setBeacon(address beacon, bytes memory data) internal virtual {
          _upgradeBeaconToAndCall(beacon, data, false);
      }
  }
  
  
  // File @openzeppelin/contracts/proxy/beacon/UpgradeableBeacon.sol@v4.9.6
  
  
  // OpenZeppelin Contracts v4.4.1 (proxy/beacon/UpgradeableBeacon.sol)
  
  pragma solidity ^0.8.0;
  
  
  
  /**
   * @dev This contract is used in conjunction with one or more instances of {BeaconProxy} to determine their
   * implementation contract, which is where they will delegate all function calls.
   *
   * An owner is able to change the implementation the beacon points to, thus upgrading the proxies that use this beacon.
   */
  contract UpgradeableBeacon is IBeacon, Ownable {
      address private _implementation;
  
      /**
       * @dev Emitted when the implementation returned by the beacon is changed.
       */
      event Upgraded(address indexed implementation);
  
      /**
       * @dev Sets the address of the initial implementation, and the deployer account as the owner who can upgrade the
       * beacon.
       */
      constructor(address implementation_) {
          _setImplementation(implementation_);
      }
  
      /**
       * @dev Returns the current implementation address.
       */
      function implementation() public view virtual override returns (address) {
          return _implementation;
      }
  
      /**
       * @dev Upgrades the beacon to a new implementation.
       *
       * Emits an {Upgraded} event.
       *
       * Requirements:
       *
       * - msg.sender must be the owner of the contract.
       * - `newImplementation` must be a contract.
       */
      function upgradeTo(address newImplementation) public virtual onlyOwner {
          _setImplementation(newImplementation);
          emit Upgraded(newImplementation);
      }
  
      /**
       * @dev Sets the implementation contract address for this beacon
       *
       * Requirements:
       *
       * - `newImplementation` must be a contract.
       */
      function _setImplementation(address newImplementation) private {
          require(Address.isContract(newImplementation), "UpgradeableBeacon: implementation is not a contract");
          _implementation = newImplementation;
      }
  }
  
  
  // File @openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol@v4.9.6
  
  
  // OpenZeppelin Contracts (last updated v4.7.0) (proxy/ERC1967/ERC1967Proxy.sol)
  
  pragma solidity ^0.8.0;
  
  
  /**
   * @dev This contract implements an upgradeable proxy. It is upgradeable because calls are delegated to an
   * implementation address that can be changed. This address is stored in storage in the location specified by
   * https://eips.ethereum.org/EIPS/eip-1967[EIP1967], so that it doesn't conflict with the storage layout of the
   * implementation behind the proxy.
   */
  contract ERC1967Proxy is Proxy, ERC1967Upgrade {
      /**
       * @dev Initializes the upgradeable proxy with an initial implementation specified by `_logic`.
       *
       * If `_data` is nonempty, it's used as data in a delegate call to `_logic`. This will typically be an encoded
       * function call, and allows initializing the storage of the proxy like a Solidity constructor.
       */
      constructor(address _logic, bytes memory _data) payable {
          _upgradeToAndCall(_logic, _data, false);
      }
  
      /**
       * @dev Returns the current implementation address.
       */
      function _implementation() internal view virtual override returns (address impl) {
          return ERC1967Upgrade._getImplementation();
      }
  }
  
  
  // File @openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol@v4.9.6
  
  
  // OpenZeppelin Contracts (last updated v4.9.0) (proxy/transparent/TransparentUpgradeableProxy.sol)
  
  pragma solidity ^0.8.0;
  
  /**
   * @dev Interface for {TransparentUpgradeableProxy}. In order to implement transparency, {TransparentUpgradeableProxy}
   * does not implement this interface directly, and some of its functions are implemented by an internal dispatch
   * mechanism. The compiler is unaware that these functions are implemented by {TransparentUpgradeableProxy} and will not
   * include them in the ABI so this interface must be used to interact with it.
   */
  interface ITransparentUpgradeableProxy is IERC1967 {
      function admin() external view returns (address);
  
      function implementation() external view returns (address);
  
      function changeAdmin(address) external;
  
      function upgradeTo(address) external;
  
      function upgradeToAndCall(address, bytes memory) external payable;
  }
  
  /**
   * @dev This contract implements a proxy that is upgradeable by an admin.
   *
   * To avoid https://medium.com/nomic-labs-blog/malicious-backdoors-in-ethereum-proxies-62629adf3357[proxy selector
   * clashing], which can potentially be used in an attack, this contract uses the
   * https://blog.openzeppelin.com/the-transparent-proxy-pattern/[transparent proxy pattern]. This pattern implies two
   * things that go hand in hand:
   *
   * 1. If any account other than the admin calls the proxy, the call will be forwarded to the implementation, even if
   * that call matches one of the admin functions exposed by the proxy itself.
   * 2. If the admin calls the proxy, it can access the admin functions, but its calls will never be forwarded to the
   * implementation. If the admin tries to call a function on the implementation it will fail with an error that says
   * "admin cannot fallback to proxy target".
   *
   * These properties mean that the admin account can only be used for admin actions like upgrading the proxy or changing
   * the admin, so it's best if it's a dedicated account that is not used for anything else. This will avoid headaches due
   * to sudden errors when trying to call a function from the proxy implementation.
   *
   * Our recommendation is for the dedicated account to be an instance of the {ProxyAdmin} contract. If set up this way,
   * you should think of the `ProxyAdmin` instance as the real administrative interface of your proxy.
   *
   * NOTE: The real interface of this proxy is that defined in `ITransparentUpgradeableProxy`. This contract does not
   * inherit from that interface, and instead the admin functions are implicitly implemented using a custom dispatch
   * mechanism in `_fallback`. Consequently, the compiler will not produce an ABI for this contract. This is necessary to
   * fully implement transparency without decoding reverts caused by selector clashes between the proxy and the
   * implementation.
   *
   * WARNING: It is not recommended to extend this contract to add additional external functions. If you do so, the compiler
   * will not check that there are no selector conflicts, due to the note above. A selector clash between any new function
   * and the functions declared in {ITransparentUpgradeableProxy} will be resolved in favor of the new one. This could
   * render the admin operations inaccessible, which could prevent upgradeability. Transparency may also be compromised.
   */
  contract TransparentUpgradeableProxy is ERC1967Proxy {
      /**
       * @dev Initializes an upgradeable proxy managed by `_admin`, backed by the implementation at `_logic`, and
       * optionally initialized with `_data` as explained in {ERC1967Proxy-constructor}.
       */
      constructor(address _logic, address admin_, bytes memory _data) payable ERC1967Proxy(_logic, _data) {
          _changeAdmin(admin_);
      }
  
      /**
       * @dev Modifier used internally that will delegate the call to the implementation unless the sender is the admin.
       *
       * CAUTION: This modifier is deprecated, as it could cause issues if the modified function has arguments, and the
       * implementation provides a function with the same selector.
       */
      modifier ifAdmin() {
          if (msg.sender == _getAdmin()) {
              _;
          } else {
              _fallback();
          }
      }
  
      /**
       * @dev If caller is the admin process the call internally, otherwise transparently fallback to the proxy behavior
       */
      function _fallback() internal virtual override {
          if (msg.sender == _getAdmin()) {
              bytes memory ret;
              bytes4 selector = msg.sig;
              if (selector == ITransparentUpgradeableProxy.upgradeTo.selector) {
                  ret = _dispatchUpgradeTo();
              } else if (selector == ITransparentUpgradeableProxy.upgradeToAndCall.selector) {
                  ret = _dispatchUpgradeToAndCall();
              } else if (selector == ITransparentUpgradeableProxy.changeAdmin.selector) {
                  ret = _dispatchChangeAdmin();
              } else if (selector == ITransparentUpgradeableProxy.admin.selector) {
                  ret = _dispatchAdmin();
              } else if (selector == ITransparentUpgradeableProxy.implementation.selector) {
                  ret = _dispatchImplementation();
              } else {
                  revert("TransparentUpgradeableProxy: admin cannot fallback to proxy target");
              }
              assembly {
                  return(add(ret, 0x20), mload(ret))
              }
          } else {
              super._fallback();
          }
      }
  
      /**
       * @dev Returns the current admin.
       *
       * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the
       * https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.
       * `0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103`
       */
      function _dispatchAdmin() private returns (bytes memory) {
          _requireZeroValue();
  
          address admin = _getAdmin();
          return abi.encode(admin);
      }
  
      /**
       * @dev Returns the current implementation.
       *
       * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the
       * https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.
       * `0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc`
       */
      function _dispatchImplementation() private returns (bytes memory) {
          _requireZeroValue();
  
          address implementation = _implementation();
          return abi.encode(implementation);
      }
  
      /**
       * @dev Changes the admin of the proxy.
       *
       * Emits an {AdminChanged} event.
       */
      function _dispatchChangeAdmin() private returns (bytes memory) {
          _requireZeroValue();
  
          address newAdmin = abi.decode(msg.data[4:], (address));
          _changeAdmin(newAdmin);
  
          return "";
      }
  
      /**
       * @dev Upgrade the implementation of the proxy.
       */
      function _dispatchUpgradeTo() private returns (bytes memory) {
          _requireZeroValue();
  
          address newImplementation = abi.decode(msg.data[4:], (address));
          _upgradeToAndCall(newImplementation, bytes(""), false);
  
          return "";
      }
  
      /**
       * @dev Upgrade the implementation of the proxy, and then call a function from the new implementation as specified
       * by `data`, which should be an encoded function call. This is useful to initialize new storage variables in the
       * proxied contract.
       */
      function _dispatchUpgradeToAndCall() private returns (bytes memory) {
          (address newImplementation, bytes memory data) = abi.decode(msg.data[4:], (address, bytes));
          _upgradeToAndCall(newImplementation, data, true);
  
          return "";
      }
  
      /**
       * @dev Returns the current admin.
       *
       * CAUTION: This function is deprecated. Use {ERC1967Upgrade-_getAdmin} instead.
       */
      function _admin() internal view virtual returns (address) {
          return _getAdmin();
      }
  
      /**
       * @dev To keep this contract fully transparent, all `ifAdmin` functions must be payable. This helper is here to
       * emulate some proxy functions being non-payable while still allowing value to pass through.
       */
      function _requireZeroValue() private {
          require(msg.value == 0);
      }
  }
  
  
  // File @openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol@v4.9.6
  
  
  // OpenZeppelin Contracts (last updated v4.8.3) (proxy/transparent/ProxyAdmin.sol)
  
  pragma solidity ^0.8.0;
  
  
  /**
   * @dev This is an auxiliary contract meant to be assigned as the admin of a {TransparentUpgradeableProxy}. For an
   * explanation of why you would want to use this see the documentation for {TransparentUpgradeableProxy}.
   */
  contract ProxyAdmin is Ownable {
      /**
       * @dev Returns the current implementation of `proxy`.
       *
       * Requirements:
       *
       * - This contract must be the admin of `proxy`.
       */
      function getProxyImplementation(ITransparentUpgradeableProxy proxy) public view virtual returns (address) {
          // We need to manually run the static call since the getter cannot be flagged as view
          // bytes4(keccak256("implementation()")) == 0x5c60da1b
          (bool success, bytes memory returndata) = address(proxy).staticcall(hex"5c60da1b");
          require(success);
          return abi.decode(returndata, (address));
      }
  
      /**
       * @dev Returns the current admin of `proxy`.
       *
       * Requirements:
       *
       * - This contract must be the admin of `proxy`.
       */
      function getProxyAdmin(ITransparentUpgradeableProxy proxy) public view virtual returns (address) {
          // We need to manually run the static call since the getter cannot be flagged as view
          // bytes4(keccak256("admin()")) == 0xf851a440
          (bool success, bytes memory returndata) = address(proxy).staticcall(hex"f851a440");
          require(success);
          return abi.decode(returndata, (address));
      }
  
      /**
       * @dev Changes the admin of `proxy` to `newAdmin`.
       *
       * Requirements:
       *
       * - This contract must be the current admin of `proxy`.
       */
      function changeProxyAdmin(ITransparentUpgradeableProxy proxy, address newAdmin) public virtual onlyOwner {
          proxy.changeAdmin(newAdmin);
      }
  
      /**
       * @dev Upgrades `proxy` to `implementation`. See {TransparentUpgradeableProxy-upgradeTo}.
       *
       * Requirements:
       *
       * - This contract must be the admin of `proxy`.
       */
      function upgrade(ITransparentUpgradeableProxy proxy, address implementation) public virtual onlyOwner {
          proxy.upgradeTo(implementation);
      }
  
      /**
       * @dev Upgrades `proxy` to `implementation` and calls a function on the new implementation. See
       * {TransparentUpgradeableProxy-upgradeToAndCall}.
       *
       * Requirements:
       *
       * - This contract must be the admin of `proxy`.
       */
      function upgradeAndCall(
          ITransparentUpgradeableProxy proxy,
          address implementation,
          bytes memory data
      ) public payable virtual onlyOwner {
          proxy.upgradeToAndCall{value: msg.value}(implementation, data);
      }
  }
  
  
  // File @openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol@v4.9.6
  
  
  // OpenZeppelin Contracts (last updated v4.9.4) (token/ERC20/extensions/IERC20Permit.sol)
  
  pragma solidity ^0.8.0;
  
  /**
   * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
   * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
   *
   * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
   * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
   * need to send a transaction, and thus is not required to hold Ether at all.
   *
   * ==== Security Considerations
   *
   * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
   * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
   * considered as an intention to spend the allowance in any specific way. The second is that because permits have
   * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
   * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
   * generally recommended is:
   *
   * ```solidity
   * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
   *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
   *     doThing(..., value);
   * }
   *
   * function doThing(..., uint256 value) public {
   *     token.safeTransferFrom(msg.sender, address(this), value);
   *     ...
   * }
   * ```
   *
   * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
   * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
   * {SafeERC20-safeTransferFrom}).
   *
   * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
   * contracts should have entry points that don't rely on permit.
   */
  interface IERC20Permit {
      /**
       * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
       * given ``owner``'s signed approval.
       *
       * IMPORTANT: The same issues {IERC20-approve} has related to transaction
       * ordering also apply here.
       *
       * Emits an {Approval} event.
       *
       * Requirements:
       *
       * - `spender` cannot be the zero address.
       * - `deadline` must be a timestamp in the future.
       * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
       * over the EIP712-formatted function arguments.
       * - the signature must use ``owner``'s current nonce (see {nonces}).
       *
       * For more information on the signature format, see the
       * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
       * section].
       *
       * CAUTION: See Security Considerations above.
       */
      function permit(
          address owner,
          address spender,
          uint256 value,
          uint256 deadline,
          uint8 v,
          bytes32 r,
          bytes32 s
      ) external;
  
      /**
       * @dev Returns the current nonce for `owner`. This value must be
       * included whenever a signature is generated for {permit}.
       *
       * Every successful call to {permit} increases ``owner``'s nonce by one. This
       * prevents a signature from being used multiple times.
       */
      function nonces(address owner) external view returns (uint256);
  
      /**
       * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
       */
      // solhint-disable-next-line func-name-mixedcase
      function DOMAIN_SEPARATOR() external view returns (bytes32);
  }
  
  
  // File @openzeppelin/contracts/token/ERC20/IERC20.sol@v4.9.6
  
  
  // OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)
  
  pragma solidity ^0.8.0;
  
  /**
   * @dev Interface of the ERC20 standard as defined in the EIP.
   */
  interface IERC20 {
      /**
       * @dev Emitted when `value` tokens are moved from one account (`from`) to
       * another (`to`).
       *
       * Note that `value` may be zero.
       */
      event Transfer(address indexed from, address indexed to, uint256 value);
  
      /**
       * @dev Emitted when the allowance of a `spender` for an `owner` is set by
       * a call to {approve}. `value` is the new allowance.
       */
      event Approval(address indexed owner, address indexed spender, uint256 value);
  
      /**
       * @dev Returns the amount of tokens in existence.
       */
      function totalSupply() external view returns (uint256);
  
      /**
       * @dev Returns the amount of tokens owned by `account`.
       */
      function balanceOf(address account) external view returns (uint256);
  
      /**
       * @dev Moves `amount` tokens from the caller's account to `to`.
       *
       * Returns a boolean value indicating whether the operation succeeded.
       *
       * Emits a {Transfer} event.
       */
      function transfer(address to, uint256 amount) external returns (bool);
  
      /**
       * @dev Returns the remaining number of tokens that `spender` will be
       * allowed to spend on behalf of `owner` through {transferFrom}. This is
       * zero by default.
       *
       * This value changes when {approve} or {transferFrom} are called.
       */
      function allowance(address owner, address spender) external view returns (uint256);
  
      /**
       * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
       *
       * Returns a boolean value indicating whether the operation succeeded.
       *
       * IMPORTANT: Beware that changing an allowance with this method brings the risk
       * that someone may use both the old and the new allowance by unfortunate
       * transaction ordering. One possible solution to mitigate this race
       * condition is to first reduce the spender's allowance to 0 and set the
       * desired value afterwards:
       * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
       *
       * Emits an {Approval} event.
       */
      function approve(address spender, uint256 amount) external returns (bool);
  
      /**
       * @dev Moves `amount` tokens from `from` to `to` using the
       * allowance mechanism. `amount` is then deducted from the caller's
       * allowance.
       *
       * Returns a boolean value indicating whether the operation succeeded.
       *
       * Emits a {Transfer} event.
       */
      function transferFrom(address from, address to, uint256 amount) external returns (bool);
  }
  
  
  // File @openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol@v4.9.6
  
  
  // OpenZeppelin Contracts (last updated v4.9.3) (token/ERC20/utils/SafeERC20.sol)
  
  pragma solidity ^0.8.0;
  
  
  
  /**
   * @title SafeERC20
   * @dev Wrappers around ERC20 operations that throw on failure (when the token
   * contract returns false). Tokens that return no value (and instead revert or
   * throw on failure) are also supported, non-reverting calls are assumed to be
   * successful.
   * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
   * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
   */
  library SafeERC20 {
      using Address for address;
  
      /**
       * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
       * non-reverting calls are assumed to be successful.
       */
      function safeTransfer(IERC20 token, address to, uint256 value) internal {
          _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
      }
  
      /**
       * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
       * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
       */
      function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
          _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
      }
  
      /**
       * @dev Deprecated. This function has issues similar to the ones found in
       * {IERC20-approve}, and its usage is discouraged.
       *
       * Whenever possible, use {safeIncreaseAllowance} and
       * {safeDecreaseAllowance} instead.
       */
      function safeApprove(IERC20 token, address spender, uint256 value) internal {
          // safeApprove should only be called when setting an initial allowance,
          // or when resetting it to zero. To increase and decrease it, use
          // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
          require(
              (value == 0) || (token.allowance(address(this), spender) == 0),
              "SafeERC20: approve from non-zero to non-zero allowance"
          );
          _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
      }
  
      /**
       * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
       * non-reverting calls are assumed to be successful.
       */
      function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
          uint256 oldAllowance = token.allowance(address(this), spender);
          _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));
      }
  
      /**
       * @dev Decrease the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
       * non-reverting calls are assumed to be successful.
       */
      function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
          unchecked {
              uint256 oldAllowance = token.allowance(address(this), spender);
              require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
              _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));
          }
      }
  
      /**
       * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
       * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
       * to be set to zero before setting it to a non-zero value, such as USDT.
       */
      function forceApprove(IERC20 token, address spender, uint256 value) internal {
          bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);
  
          if (!_callOptionalReturnBool(token, approvalCall)) {
              _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));
              _callOptionalReturn(token, approvalCall);
          }
      }
  
      /**
       * @dev Use a ERC-2612 signature to set the `owner` approval toward `spender` on `token`.
       * Revert on invalid signature.
       */
      function safePermit(
          IERC20Permit token,
          address owner,
          address spender,
          uint256 value,
          uint256 deadline,
          uint8 v,
          bytes32 r,
          bytes32 s
      ) internal {
          uint256 nonceBefore = token.nonces(owner);
          token.permit(owner, spender, value, deadline, v, r, s);
          uint256 nonceAfter = token.nonces(owner);
          require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
      }
  
      /**
       * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
       * on the return value: the return value is optional (but if data is returned, it must not be false).
       * @param token The token targeted by the call.
       * @param data The call data (encoded using abi.encode or one of its variants).
       */
      function _callOptionalReturn(IERC20 token, bytes memory data) private {
          // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
          // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
          // the target address contains contract code and also asserts for success in the low-level call.
  
          bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
          require(returndata.length == 0 || abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
      }
  
      /**
       * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
       * on the return value: the return value is optional (but if data is returned, it must not be false).
       * @param token The token targeted by the call.
       * @param data The call data (encoded using abi.encode or one of its variants).
       *
       * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
       */
      function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
          // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
          // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false
          // and not revert is the subcall reverts.
  
          (bool success, bytes memory returndata) = address(token).call(data);
          return
              success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token));
      }
  }
  
  
  // File contracts/chain-adapters/interfaces/AdapterInterface.sol
  
  
  pragma solidity ^0.8.0;
  
  /**
   * @notice Sends cross chain messages and tokens to contracts on a specific L2 network.
   * This interface is implemented by an adapter contract that is deployed on L1.
   */
  
  interface AdapterInterface {
      event MessageRelayed(address target, bytes message);
  
      event TokensRelayed(address l1Token, address l2Token, uint256 amount, address to);
  
      /**
       * @notice Send message to `target` on L2.
       * @dev This method is marked payable because relaying the message might require a fee
       * to be paid by the sender to forward the message to L2. However, it will not send msg.value
       * to the target contract on L2.
       * @param target L2 address to send message to.
       * @param message Message to send to `target`.
       */
      function relayMessage(address target, bytes calldata message) external payable;
  
      /**
       * @notice Send `amount` of `l1Token` to `to` on L2. `l2Token` is the L2 address equivalent of `l1Token`.
       * @dev This method is marked payable because relaying the message might require a fee
       * to be paid by the sender to forward the message to L2. However, it will not send msg.value
       * to the target contract on L2.
       * @param l1Token L1 token to bridge.
       * @param l2Token L2 token to receive.
       * @param amount Amount of `l1Token` to bridge.
       * @param to Bridge recipient.
       */
      function relayTokens(
          address l1Token,
          address l2Token,
          uint256 amount,
          address to
      ) external payable;
  }
  
  
  // File contracts/external/interfaces/CCTPInterfaces.sol
  
  /**
   * Copyright (C) 2015, 2016, 2017 Dapphub
   *
   * This program is free software: you can redistribute it and/or modify
   * it under the terms of the GNU General Public License as published by
   * the Free Software Foundation, either version 3 of the License, or
   * (at your option) any later version.
   *
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU General Public License for more details.
   *
   * You should have received a copy of the GNU General Public License
   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
   */
  
  // SPDX-License-Identifier: GPL-3.0-or-later
  pragma solidity ^0.8.0;
  
  /**
   * Imported as-is from commit 139d8d0ce3b5531d3c7ec284f89d946dfb720016 of:
   *   * https://github.com/walkerq/evm-cctp-contracts/blob/139d8d0ce3b5531d3c7ec284f89d946dfb720016/src/TokenMessenger.sol
   * Changes applied post-import:
   *   * Removed a majority of code from this contract and converted the needed function signatures in this interface.
   */
  interface ITokenMessenger {
      /**
       * @notice Deposits and burns tokens from sender to be minted on destination domain.
       * Emits a `DepositForBurn` event.
       * @dev reverts if:
       * - given burnToken is not supported
       * - given destinationDomain has no TokenMessenger registered
       * - transferFrom() reverts. For example, if sender's burnToken balance or approved allowance
       * to this contract is less than `amount`.
       * - burn() reverts. For example, if `amount` is 0.
       * - MessageTransmitter returns false or reverts.
       * @param amount amount of tokens to burn
       * @param destinationDomain destination domain
       * @param mintRecipient address of mint recipient on destination domain
       * @param burnToken address of contract to burn deposited tokens, on local domain
       * @return _nonce unique nonce reserved by message
       */
      function depositForBurn(
          uint256 amount,
          uint32 destinationDomain,
          bytes32 mintRecipient,
          address burnToken
      ) external returns (uint64 _nonce);
  }
  
  
  // File contracts/libraries/CircleCCTPAdapter.sol
  
  
  pragma solidity ^0.8.0;
  
  
  
  library CircleDomainIds {
      uint32 public constant Ethereum = 0;
      uint32 public constant Optimism = 2;
      uint32 public constant Arbitrum = 3;
      uint32 public constant Base = 6;
      uint32 public constant Polygon = 7;
  }
  
  abstract contract CircleCCTPAdapter {
      using SafeERC20 for IERC20;
  
      /**
       * @notice The domain ID that CCTP will transfer funds to.
       * @dev This identifier is assigned by Circle and is not related to a chain ID.
       * @dev Official domain list can be found here: https://developers.circle.com/stablecoins/docs/supported-domains
       */
      /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
      uint32 public immutable recipientCircleDomainId;
  
      /**
       * @notice The official USDC contract address on this chain.
       * @dev Posted officially here: https://developers.circle.com/stablecoins/docs/usdc-on-main-networks
       */
      /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
      IERC20 public immutable usdcToken;
  
      /**
       * @notice The official Circle CCTP token bridge contract endpoint.
       * @dev Posted officially here: https://developers.circle.com/stablecoins/docs/evm-smart-contracts
       */
      /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
      ITokenMessenger public immutable cctpTokenMessenger;
  
      /**
       * @notice intiailizes the CircleCCTPAdapter contract.
       * @param _usdcToken USDC address on the current chain.
       * @param _cctpTokenMessenger TokenMessenger contract to bridge via CCTP. If the zero address is passed, CCTP bridging will be disabled.
       * @param _recipientCircleDomainId The domain ID that CCTP will transfer funds to.
       */
      /// @custom:oz-upgrades-unsafe-allow constructor
      constructor(
          IERC20 _usdcToken,
          ITokenMessenger _cctpTokenMessenger,
          uint32 _recipientCircleDomainId
      ) {
          usdcToken = _usdcToken;
          cctpTokenMessenger = _cctpTokenMessenger;
          recipientCircleDomainId = _recipientCircleDomainId;
      }
  
      /**
       * @notice converts address to bytes32 (alignment preserving cast.)
       * @param addr the address to convert to bytes32
       * @dev Sourced from the official CCTP repo: https://github.com/walkerq/evm-cctp-contracts/blob/139d8d0ce3b5531d3c7ec284f89d946dfb720016/src/messages/Message.sol#L142C1-L148C6
       */
      function _addressToBytes32(address addr) internal pure returns (bytes32) {
          return bytes32(uint256(uint160(addr)));
      }
  
      /**
       * @notice Returns whether or not the CCTP bridge is enabled.
       * @dev If the CCTPTokenMessenger is the zero address, CCTP bridging is disabled.
       */
      function _isCCTPEnabled() internal view returns (bool) {
          return address(cctpTokenMessenger) != address(0);
      }
  
      /**
       * @notice Transfers USDC from the current domain to the given address on the new domain.
       * @dev This function will revert if the CCTP bridge is disabled. I.e. if the zero address is passed to the constructor for the cctpTokenMessenger.
       * @param to Address to receive USDC on the new domain.
       * @param amount Amount of USDC to transfer.
       */
      function _transferUsdc(address to, uint256 amount) internal {
          // Only approve the exact amount to be transferred
          usdcToken.safeIncreaseAllowance(address(cctpTokenMessenger), amount);
          // Submit the amount to be transferred to bridged via the TokenMessenger
          cctpTokenMessenger.depositForBurn(amount, recipientCircleDomainId, _addressToBytes32(to), address(usdcToken));
      }
  }
  
  
  // File contracts/chain-adapters/Arbitrum_Adapter.sol
  
  
  pragma solidity ^0.8.0;
  
  
  
  
  /**
   * @notice Interface for Arbitrum's L1 Inbox contract used to send messages to Arbitrum.
   */
  interface ArbitrumL1InboxLike {
      /**
       * @notice Put a message in the L2 inbox that can be reexecuted for some fixed amount of time if it reverts
       * @dev Gas limit and maxFeePerGas should not be set to 1 as that is used to trigger the RetryableData error
       * @dev Caller must set msg.value equal to at least `maxSubmissionCost + maxGas * gasPriceBid`.
       *      all msg.value will deposited to callValueRefundAddress on L2
       * @dev More details can be found here: https://developer.arbitrum.io/arbos/l1-to-l2-messaging
       * @param to destination L2 contract address
       * @param l2CallValue call value for retryable L2 message
       * @param maxSubmissionCost Max gas deducted from user's L2 balance to cover base submission fee
       * @param excessFeeRefundAddress gasLimit x maxFeePerGas - execution cost gets credited here on L2 balance
       * @param callValueRefundAddress l2Callvalue gets credited here on L2 if retryable txn times out or gets cancelled
       * @param gasLimit Max gas deducted from user's L2 balance to cover L2 execution. Should not be set to 1 (magic value used to trigger the RetryableData error)
       * @param maxFeePerGas price bid for L2 execution. Should not be set to 1 (magic value used to trigger the RetryableData error)
       * @param data ABI encoded data of L2 message
       * @return unique message number of the retryable transaction
       */
      function createRetryableTicket(
          address to,
          uint256 l2CallValue,
          uint256 maxSubmissionCost,
          address excessFeeRefundAddress,
          address callValueRefundAddress,
          uint256 gasLimit,
          uint256 maxFeePerGas,
          bytes calldata data
      ) external payable returns (uint256);
  
      /**
       * @notice Put a message in the L2 inbox that can be reexecuted for some fixed amount of time if it reverts
       * @dev Same as createRetryableTicket, but does not guarantee that submission will succeed by requiring the needed
       * funds come from the deposit alone, rather than falling back on the user's L2 balance
       * @dev Advanced usage only (does not rewrite aliases for excessFeeRefundAddress and callValueRefundAddress).
       * createRetryableTicket method is the recommended standard.
       * @dev Gas limit and maxFeePerGas should not be set to 1 as that is used to trigger the RetryableData error
       * @param to destination L2 contract address
       * @param l2CallValue call value for retryable L2 message
       * @param maxSubmissionCost Max gas deducted from user's L2 balance to cover base submission fee
       * @param excessFeeRefundAddress gasLimit x maxFeePerGas - execution cost gets credited here on L2 balance
       * @param callValueRefundAddress l2Callvalue gets credited here on L2 if retryable txn times out or gets cancelled
       * @param gasLimit Max gas deducted from user's L2 balance to cover L2 execution. Should not be set to 1 (magic value used to trigger the RetryableData error)
       * @param maxFeePerGas price bid for L2 execution. Should not be set to 1 (magic value used to trigger the RetryableData error)
       * @param data ABI encoded data of L2 message
       * @return unique message number of the retryable transaction
       */
      function unsafeCreateRetryableTicket(
          address to,
          uint256 l2CallValue,
          uint256 maxSubmissionCost,
          address excessFeeRefundAddress,
          address callValueRefundAddress,
          uint256 gasLimit,
          uint256 maxFeePerGas,
          bytes calldata data
      ) external payable returns (uint256);
  }
  
  /**
   * @notice Layer 1 Gateway contract for bridging standard ERC20s to Arbitrum.
   */
  interface ArbitrumL1ERC20GatewayLike {
      /**
       * @notice Deprecated in favor of outboundTransferCustomRefund but still used in custom bridges
       * like the DAI bridge.
       * @dev Refunded to aliased L2 address of sender if sender has code on L1, otherwise to to sender's EOA on L2.
       * @param _l1Token L1 address of ERC20
       * @param _to Account to be credited with the tokens in the L2 (can be the user's L2 account or a contract),
       * not subject to L2 aliasing. This account, or its L2 alias if it have code in L1, will also be able to
       * cancel the retryable ticket and receive callvalue refund
       * @param _amount Token Amount
       * @param _maxGas Max gas deducted from user's L2 balance to cover L2 execution
       * @param _gasPriceBid Gas price for L2 execution
       * @param _data encoded data from router and user
       * @return res abi encoded inbox sequence number
       */
      function outboundTransfer(
          address _l1Token,
          address _to,
          uint256 _amount,
          uint256 _maxGas,
          uint256 _gasPriceBid,
          bytes calldata _data
      ) external payable returns (bytes memory);
  
      /**
       * @notice Deposit ERC20 token from Ethereum into Arbitrum.
       * @dev L2 address alias will not be applied to the following types of addresses on L1:
       *      - an externally-owned account
       *      - a contract in construction
       *      - an address where a contract will be created
       *      - an address where a contract lived, but was destroyed
       * @param _l1Token L1 address of ERC20
       * @param _refundTo Account, or its L2 alias if it have code in L1, to be credited with excess gas refund in L2
       * @param _to Account to be credited with the tokens in the L2 (can be the user's L2 account or a contract),
       * not subject to L2 aliasing. This account, or its L2 alias if it have code in L1, will also be able to
       * cancel the retryable ticket and receive callvalue refund
       * @param _amount Token Amount
       * @param _maxGas Max gas deducted from user's L2 balance to cover L2 execution
       * @param _gasPriceBid Gas price for L2 execution
       * @param _data encoded data from router and user
       * @return res abi encoded inbox sequence number
       */
      function outboundTransferCustomRefund(
          address _l1Token,
          address _refundTo,
          address _to,
          uint256 _amount,
          uint256 _maxGas,
          uint256 _gasPriceBid,
          bytes calldata _data
      ) external payable returns (bytes memory);
  
      /**
       * @notice get ERC20 gateway for token.
       * @param _token ERC20 address.
       * @return address of ERC20 gateway.
       */
      function getGateway(address _token) external view returns (address);
  }
  
  /**
   * @notice Contract containing logic to send messages from L1 to Arbitrum.
   * @dev Public functions calling external contracts do not guard against reentrancy because they are expected to be
   * called via delegatecall, which will execute this contract's logic within the context of the originating contract.
   * For example, the HubPool will delegatecall these functions, therefore its only necessary that the HubPool's methods
   * that call this contract's logic guard against reentrancy.
   */
  
  // solhint-disable-next-line contract-name-camelcase
  contract Arbitrum_Adapter is AdapterInterface, CircleCCTPAdapter {
      using SafeERC20 for IERC20;
  
      // Amount of ETH allocated to pay for the base submission fee. The base submission fee is a parameter unique to
      // retryable transactions; the user is charged the base submission fee to cover the storage costs of keeping their
      // ticket’s calldata in the retry buffer. (current base submission fee is queryable via
      // ArbRetryableTx.getSubmissionPrice). ArbRetryableTicket precompile interface exists at L2 address
      // 0x000000000000000000000000000000000000006E.
      uint256 public constant L2_MAX_SUBMISSION_COST = 0.01e18;
  
      // L2 Gas price bid for immediate L2 execution attempt (queryable via standard eth*gasPrice RPC)
      uint256 public constant L2_GAS_PRICE = 5e9; // 5 gWei
  
      uint256 public constant L2_CALL_VALUE = 0;
  
      uint32 public constant RELAY_TOKENS_L2_GAS_LIMIT = 300_000;
      uint32 public constant RELAY_MESSAGE_L2_GAS_LIMIT = 2_000_000;
  
      address public constant L1_DAI = 0x6B175474E89094C44Da98b954EedeAC495271d0F;
  
      // This address on L2 receives extra ETH that is left over after relaying a message via the inbox.
      address public immutable L2_REFUND_L2_ADDRESS;
  
      ArbitrumL1InboxLike public immutable L1_INBOX;
  
      ArbitrumL1ERC20GatewayLike public immutable L1_ERC20_GATEWAY_ROUTER;
  
      /**
       * @notice Constructs new Adapter.
       * @param _l1ArbitrumInbox Inbox helper contract to send messages to Arbitrum.
       * @param _l1ERC20GatewayRouter ERC20 gateway router contract to send tokens to Arbitrum.
       * @param _l2RefundL2Address L2 address to receive gas refunds on after a message is relayed.
       * @param _l1Usdc USDC address on L1.
       * @param _cctpTokenMessenger TokenMessenger contract to bridge via CCTP.
       */
      constructor(
          ArbitrumL1InboxLike _l1ArbitrumInbox,
          ArbitrumL1ERC20GatewayLike _l1ERC20GatewayRouter,
          address _l2RefundL2Address,
          IERC20 _l1Usdc,
          ITokenMessenger _cctpTokenMessenger
      ) CircleCCTPAdapter(_l1Usdc, _cctpTokenMessenger, CircleDomainIds.Arbitrum) {
          L1_INBOX = _l1ArbitrumInbox;
          L1_ERC20_GATEWAY_ROUTER = _l1ERC20GatewayRouter;
          L2_REFUND_L2_ADDRESS = _l2RefundL2Address;
      }
  
      /**
       * @notice Send cross-chain message to target on Arbitrum.
       * @notice This contract must hold at least getL1CallValue() amount of ETH to send a message via the Inbox
       * successfully, or the message will get stuck.
       * @param target Contract on Arbitrum that will receive message.
       * @param message Data to send to target.
       */
      function relayMessage(address target, bytes memory message) external payable override {
          uint256 requiredL1CallValue = _contractHasSufficientEthBalance(RELAY_MESSAGE_L2_GAS_LIMIT);
  
          L1_INBOX.createRetryableTicket{ value: requiredL1CallValue }(
              target, // destAddr destination L2 contract address
              L2_CALL_VALUE, // l2CallValue call value for retryable L2 message
              L2_MAX_SUBMISSION_COST, // maxSubmissionCost Max gas deducted from user's L2 balance to cover base fee
              L2_REFUND_L2_ADDRESS, // excessFeeRefundAddress maxgas * gasprice - execution cost gets credited here on L2
              L2_REFUND_L2_ADDRESS, // callValueRefundAddress l2Callvalue gets credited here on L2 if retryable txn times out or gets cancelled
              RELAY_MESSAGE_L2_GAS_LIMIT, // maxGas Max gas deducted from user's L2 balance to cover L2 execution
              L2_GAS_PRICE, // gasPriceBid price bid for L2 execution
              message // data ABI encoded data of L2 message
          );
  
          emit MessageRelayed(target, message);
      }
  
      /**
       * @notice Bridge tokens to Arbitrum.
       * @notice This contract must hold at least getL1CallValue() amount of ETH to send a message via the Inbox
       * successfully, or the message will get stuck.
       * @param l1Token L1 token to deposit.
       * @param l2Token L2 token to receive.
       * @param amount Amount of L1 tokens to deposit and L2 tokens to receive.
       * @param to Bridge recipient.
       */
      function relayTokens(
          address l1Token,
          address l2Token, // l2Token is unused for Arbitrum.
          uint256 amount,
          address to
      ) external payable override {
          // Check if this token is USDC, which requires a custom bridge via CCTP.
          if (_isCCTPEnabled() && l1Token == address(usdcToken)) {
              _transferUsdc(to, amount);
          }
          // If not, we can use the Arbitrum gateway
          else {
              uint256 requiredL1CallValue = _contractHasSufficientEthBalance(RELAY_TOKENS_L2_GAS_LIMIT);
  
              // Approve the gateway, not the router, to spend the hub pool's balance. The gateway, which is different
              // per L1 token, will temporarily escrow the tokens to be bridged and pull them from this contract.
              address erc20Gateway = L1_ERC20_GATEWAY_ROUTER.getGateway(l1Token);
              IERC20(l1Token).safeIncreaseAllowance(erc20Gateway, amount);
  
              // `outboundTransfer` expects that the caller includes a bytes message as the last param that includes the
              // maxSubmissionCost to use when creating an L2 retryable ticket: https://github.com/OffchainLabs/arbitrum/blob/e98d14873dd77513b569771f47b5e05b72402c5e/packages/arb-bridge-peripherals/contracts/tokenbridge/ethereum/gateway/L1GatewayRouter.sol#L232
              bytes memory data = abi.encode(L2_MAX_SUBMISSION_COST, "");
  
              // Note: Legacy routers don't have the outboundTransferCustomRefund method, so default to using
              // outboundTransfer(). Legacy routers are used for the following tokens that are currently enabled:
              // - DAI: the implementation of `outboundTransfer` at the current DAI custom gateway
              //        (https://etherscan.io/address/0xD3B5b60020504bc3489D6949d545893982BA3011#writeContract) sets the
              //        sender as the refund address so the aliased HubPool should receive excess funds. Implementation here:
              //        https://github.com/makerdao/arbitrum-dai-bridge/blob/11a80385e2622968069c34d401b3d54a59060e87/contracts/l1/L1DaiGateway.sol#L109
              if (l1Token == L1_DAI) {
                  // This means that the excess ETH to pay for the L2 transaction will be sent to the aliased
                  // contract address on L2, which we'd have to retrieve via a custom adapter, the Arbitrum_RescueAdapter.
                  // To do so, in a single transaction: 1) setCrossChainContracts to Arbitrum_RescueAdapter, 2) relayMessage
                  // with function data = abi.encode(amountToRescue), 3) setCrossChainContracts back to this adapter.
                  L1_ERC20_GATEWAY_ROUTER.outboundTransfer{ value: requiredL1CallValue }(
                      l1Token,
                      to,
                      amount,
                      RELAY_TOKENS_L2_GAS_LIMIT,
                      L2_GAS_PRICE,
                      data
                  );
              } else {
                  L1_ERC20_GATEWAY_ROUTER.outboundTransferCustomRefund{ value: requiredL1CallValue }(
                      l1Token,
                      L2_REFUND_L2_ADDRESS,
                      to,
                      amount,
                      RELAY_TOKENS_L2_GAS_LIMIT,
                      L2_GAS_PRICE,
                      data
                  );
              }
          }
          emit TokensRelayed(l1Token, l2Token, amount, to);
      }
  
      /**
       * @notice Returns required amount of ETH to send a message via the Inbox.
       * @return amount of ETH that this contract needs to hold in order for relayMessage to succeed.
       */
      function getL1CallValue(uint32 l2GasLimit) public pure returns (uint256) {
          return L2_MAX_SUBMISSION_COST + L2_GAS_PRICE * l2GasLimit;
      }
  
      function _contractHasSufficientEthBalance(uint32 l2GasLimit) internal view returns (uint256) {
          uint256 requiredL1CallValue = getL1CallValue(l2GasLimit);
          require(address(this).balance >= requiredL1CallValue, "Insufficient ETH balance");
          return requiredL1CallValue;
      }
  }