Source Code
Overview
S Balance
0 SMore Info
ContractCreator
Loading...
Loading
This contract may be a proxy contract. Click on More Options and select Is this a proxy? to confirm and enable the "Read as Proxy" & "Write as Proxy" tabs.
Contract Source Code Verified (Exact Match)
Contract Name:
RabbitU
Compiler Version
v0.8.24+commit.e11b9ed9
Optimization Enabled:
Yes with 200 runs
Other Settings:
paris EvmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./EIP712VerifierU.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
contract RabbitU is EIP712VerifierU, UUPSUpgradeable, OwnableUpgradeable {
uint256 constant UNLOCKED = 1;
uint256 constant LOCKED = 2;
string constant DEPOSIT_PREFIX = "d_";
string constant CONTRACT_SUFFIX = "_rbx";
address public timelock;
address public defaultToken;
mapping(uint256 => bool) public processedWithdrawals;
mapping(address => bool) public supportedTokens;
mapping(address => uint256) public minDeposits;
uint256 nextDepositNum;
uint256 reentryLockStatus;
event Deposit(
string id,
address indexed trader,
uint256 amount,
address indexed token
);
event WithdrawalReceipt(
uint256 indexed id,
address indexed trader,
uint256 amount,
address indexed token
);
event SetOwner(address indexed owner);
event SetSigner(address indexed signer);
event SupportToken(address indexed token, uint256 minDeposit);
event UnsupportToken(address indexed token);
modifier onlyTimelock() {
require(msg.sender == timelock, "ONLY_TIMELOCK");
_;
}
modifier nonReentrant() {
require(reentryLockStatus == UNLOCKED, "NO_REENTRY");
reentryLockStatus = LOCKED;
_;
reentryLockStatus = UNLOCKED;
}
/// @custom:oz-upgrades-unsafe-allow constructor
constructor() {
_disableInitializers();
}
function initialize(
address _timelock,
address _owner,
address _signer,
address _defaultToken,
uint256 _minDeposit,
address[] memory _otherTokens,
uint256[] memory _minDeposits
) public initializer {
__Ownable_init(_owner);
__UUPSUpgradeable_init();
EIP712VerifierU.__EIP712VerifierU_init("RabbitXWithdrawal", "1", _signer);
timelock = _timelock;
defaultToken = _defaultToken;
supportedTokens[_defaultToken] = true;
minDeposits[_defaultToken] = _minDeposit;
for (uint256 i = 0; i < _otherTokens.length; i++) {
address token = _otherTokens[i];
supportedTokens[token] = true;
minDeposits[token] = _minDeposits[i];
}
nextDepositNum = 1000;
reentryLockStatus = UNLOCKED;
}
function withdraw(
uint256 id,
address trader,
uint256 amount,
uint8 v,
bytes32 r,
bytes32 s
) external nonReentrant {
require(amount > 0, "WRONG_AMOUNT");
require(processedWithdrawals[id] == false, "ALREADY_PROCESSED");
processedWithdrawals[id] = true;
bytes32 digest = getDigest(id, trader, amount, defaultToken, false);
bool valid = verify(digest, v, r, s);
require(valid, "INVALID_SIGNATURE");
emit WithdrawalReceipt(id, trader, amount, defaultToken);
bool success = makeTransfer(trader, amount, defaultToken);
require(success, "TRANSFER_FAILED");
}
function withdrawToken(
uint256 id,
address trader,
uint256 amount,
address token,
uint8 v,
bytes32 r,
bytes32 s
) external nonReentrant {
require(amount > 0, "WRONG_AMOUNT");
require(processedWithdrawals[id] == false, "ALREADY_PROCESSED");
processedWithdrawals[id] = true;
bytes32 digest = getDigest(id, trader, amount, token, true);
bool valid = verify(digest, v, r, s);
require(valid, "INVALID_SIGNATURE");
emit WithdrawalReceipt(id, trader, amount, token);
bool success = makeTransfer(trader, amount, token);
require(success, "TRANSFER_FAILED");
}
function withdrawNative(
uint256 id,
address trader,
uint256 amount,
uint8 v,
bytes32 r,
bytes32 s
) external nonReentrant {
require(amount > 0, "WRONG_AMOUNT");
require(processedWithdrawals[id] == false, "ALREADY_PROCESSED");
processedWithdrawals[id] = true;
address native = address(0);
bytes32 digest = getDigest(id, trader, amount, native, true);
bool valid = verify(digest, v, r, s);
require(valid, "INVALID_SIGNATURE");
emit WithdrawalReceipt(id, trader, amount, native);
(bool success, ) = msg.sender.call{value: amount}("");
require(success, "TRANSFER_FAILED");
}
function getDigest(
uint256 id,
address trader,
uint256 amount,
address token,
bool includeToken
) private view returns (bytes32 digest) {
bytes memory encoded;
if (includeToken) {
encoded = abi.encode(
keccak256(
"Withdrawal(uint256 id,address token,address trader,uint256 amount)"
),
id,
token,
trader,
amount
);
} else {
encoded = abi.encode(
keccak256(
"withdrawal(uint256 id,address trader,uint256 amount)"
),
id,
trader,
amount
);
}
digest = _hashTypedDataV4(keccak256(encoded));
}
function _authorizeUpgrade(address newImplementation) internal override onlyTimelock {
}
function supportToken(address token, uint256 minDeposit) external onlyOwner {
supportedTokens[token] = true;
minDeposits[token] = minDeposit;
emit SupportToken(token, minDeposit);
}
function unsupportToken(address token) external onlyOwner {
supportedTokens[token] = false;
emit UnsupportToken(token);
}
function allocateDepositId() private returns (string memory depositId) {
uint256 depositNum = nextDepositNum;
nextDepositNum++;
return string(
abi.encodePacked(
DEPOSIT_PREFIX,
Strings.toString(depositNum),
CONTRACT_SUFFIX
)
);
}
function deposit(uint256 amount) external nonReentrant{
handleDeposit(amount, defaultToken);
}
function depositToken(uint256 amount, address token) external nonReentrant {
handleDeposit(amount, token);
}
function handleDeposit(uint256 amount, address token) internal {
require(supportedTokens[token], "UNSUPPORTED_TOKEN");
require(amount >= minDeposits[token], "AMOUNT_TOO_SMALL");
string memory depositId = allocateDepositId();
emit Deposit(depositId, msg.sender, amount, token);
uint256 prevBalance = IERC20(token).balanceOf(address(this));
bool success = makeTransferFrom(msg.sender, address(this), amount, token);
require(success, "TRANSFER_FAILED");
uint256 newBalance = IERC20(token).balanceOf(address(this));
require(newBalance == amount + prevBalance, "NOT_ENOUGH_TRANSFERRED");
}
receive() external payable {
handleReceivedNative();
}
function depositNative() external payable {
handleReceivedNative();
}
function handleReceivedNative() internal {
address native = address(0);
require(supportedTokens[native], "UNSUPPORTED_TOKEN");
uint256 minDeposit = minDeposits[native];
require(msg.value >= minDeposit, "AMOUNT_TOO_SMALL");
string memory depositId = allocateDepositId();
emit Deposit(depositId, msg.sender, msg.value, native);
}
function transferOwnership(address newOwner) public virtual override onlyTimelock {
require(newOwner != address(0), "ZERO_OWNER");
_transferOwnership(newOwner);
}
function changeSigner(address new_signer) external onlyTimelock {
require(new_signer != address(0), "ZERO_SIGNER");
external_signer = new_signer;
emit SetSigner(new_signer);
}
function makeTransfer(
address to,
uint256 amount,
address token
) private returns (bool success) {
return
tokenCall(
token,
abi.encodeWithSelector(
IERC20(token).transfer.selector,
to,
amount
)
);
}
function makeTransferFrom(
address from,
address to,
uint256 amount,
address token
) private returns (bool success) {
return
tokenCall(
token,
abi.encodeWithSelector(
IERC20(token).transferFrom.selector,
from,
to,
amount
)
);
}
function tokenCall(address token, bytes memory data) private returns (bool) {
(bool success, bytes memory returndata) = token.call(
data
);
if (success) {
if (returndata.length > 0) {
success = abi.decode(returndata, (bool));
} else {
success = token.code.length > 0;
}
}
return success;
}
function getVersion() public pure returns (uint256) {
return 21;
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)
pragma solidity ^0.8.20;
import {ContextUpgradeable} from "../utils/ContextUpgradeable.sol";
import {Initializable} from "../proxy/utils/Initializable.sol";
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* The initial owner is set to the address provided by the deployer. This can
* later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
/// @custom:storage-location erc7201:openzeppelin.storage.Ownable
struct OwnableStorage {
address _owner;
}
// keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Ownable")) - 1)) & ~bytes32(uint256(0xff))
bytes32 private constant OwnableStorageLocation = 0x9016d09d72d40fdae2fd8ceac6b6234c7706214fd39c1cd1e609a0528c199300;
function _getOwnableStorage() private pure returns (OwnableStorage storage $) {
assembly {
$.slot := OwnableStorageLocation
}
}
/**
* @dev The caller account is not authorized to perform an operation.
*/
error OwnableUnauthorizedAccount(address account);
/**
* @dev The owner is not a valid owner account. (eg. `address(0)`)
*/
error OwnableInvalidOwner(address owner);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the address provided by the deployer as the initial owner.
*/
function __Ownable_init(address initialOwner) internal onlyInitializing {
__Ownable_init_unchained(initialOwner);
}
function __Ownable_init_unchained(address initialOwner) internal onlyInitializing {
if (initialOwner == address(0)) {
revert OwnableInvalidOwner(address(0));
}
_transferOwnership(initialOwner);
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
_checkOwner();
_;
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
OwnableStorage storage $ = _getOwnableStorage();
return $._owner;
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
if (owner() != _msgSender()) {
revert OwnableUnauthorizedAccount(_msgSender());
}
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby disabling any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
if (newOwner == address(0)) {
revert OwnableInvalidOwner(address(0));
}
_transferOwnership(newOwner);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
OwnableStorage storage $ = _getOwnableStorage();
address oldOwner = $._owner;
$._owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (proxy/utils/Initializable.sol)
pragma solidity ^0.8.20;
/**
* @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
* behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
* external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
* function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
*
* The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
* reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
* case an upgrade adds a module that needs to be initialized.
*
* For example:
*
* [.hljs-theme-light.nopadding]
* ```solidity
* contract MyToken is ERC20Upgradeable {
* function initialize() initializer public {
* __ERC20_init("MyToken", "MTK");
* }
* }
*
* contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
* function initializeV2() reinitializer(2) public {
* __ERC20Permit_init("MyToken");
* }
* }
* ```
*
* TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
* possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
*
* CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
* that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
*
* [CAUTION]
* ====
* Avoid leaving a contract uninitialized.
*
* An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
* contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
* the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
*
* [.hljs-theme-light.nopadding]
* ```
* /// @custom:oz-upgrades-unsafe-allow constructor
* constructor() {
* _disableInitializers();
* }
* ```
* ====
*/
abstract contract Initializable {
/**
* @dev Storage of the initializable contract.
*
* It's implemented on a custom ERC-7201 namespace to reduce the risk of storage collisions
* when using with upgradeable contracts.
*
* @custom:storage-location erc7201:openzeppelin.storage.Initializable
*/
struct InitializableStorage {
/**
* @dev Indicates that the contract has been initialized.
*/
uint64 _initialized;
/**
* @dev Indicates that the contract is in the process of being initialized.
*/
bool _initializing;
}
// keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Initializable")) - 1)) & ~bytes32(uint256(0xff))
bytes32 private constant INITIALIZABLE_STORAGE = 0xf0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a00;
/**
* @dev The contract is already initialized.
*/
error InvalidInitialization();
/**
* @dev The contract is not initializing.
*/
error NotInitializing();
/**
* @dev Triggered when the contract has been initialized or reinitialized.
*/
event Initialized(uint64 version);
/**
* @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
* `onlyInitializing` functions can be used to initialize parent contracts.
*
* Similar to `reinitializer(1)`, except that in the context of a constructor an `initializer` may be invoked any
* number of times. This behavior in the constructor can be useful during testing and is not expected to be used in
* production.
*
* Emits an {Initialized} event.
*/
modifier initializer() {
// solhint-disable-next-line var-name-mixedcase
InitializableStorage storage $ = _getInitializableStorage();
// Cache values to avoid duplicated sloads
bool isTopLevelCall = !$._initializing;
uint64 initialized = $._initialized;
// Allowed calls:
// - initialSetup: the contract is not in the initializing state and no previous version was
// initialized
// - construction: the contract is initialized at version 1 (no reininitialization) and the
// current contract is just being deployed
bool initialSetup = initialized == 0 && isTopLevelCall;
bool construction = initialized == 1 && address(this).code.length == 0;
if (!initialSetup && !construction) {
revert InvalidInitialization();
}
$._initialized = 1;
if (isTopLevelCall) {
$._initializing = true;
}
_;
if (isTopLevelCall) {
$._initializing = false;
emit Initialized(1);
}
}
/**
* @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
* contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
* used to initialize parent contracts.
*
* A reinitializer may be used after the original initialization step. This is essential to configure modules that
* are added through upgrades and that require initialization.
*
* When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`
* cannot be nested. If one is invoked in the context of another, execution will revert.
*
* Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
* a contract, executing them in the right order is up to the developer or operator.
*
* WARNING: Setting the version to 2**64 - 1 will prevent any future reinitialization.
*
* Emits an {Initialized} event.
*/
modifier reinitializer(uint64 version) {
// solhint-disable-next-line var-name-mixedcase
InitializableStorage storage $ = _getInitializableStorage();
if ($._initializing || $._initialized >= version) {
revert InvalidInitialization();
}
$._initialized = version;
$._initializing = true;
_;
$._initializing = false;
emit Initialized(version);
}
/**
* @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
* {initializer} and {reinitializer} modifiers, directly or indirectly.
*/
modifier onlyInitializing() {
_checkInitializing();
_;
}
/**
* @dev Reverts if the contract is not in an initializing state. See {onlyInitializing}.
*/
function _checkInitializing() internal view virtual {
if (!_isInitializing()) {
revert NotInitializing();
}
}
/**
* @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
* Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
* to any version. It is recommended to use this to lock implementation contracts that are designed to be called
* through proxies.
*
* Emits an {Initialized} event the first time it is successfully executed.
*/
function _disableInitializers() internal virtual {
// solhint-disable-next-line var-name-mixedcase
InitializableStorage storage $ = _getInitializableStorage();
if ($._initializing) {
revert InvalidInitialization();
}
if ($._initialized != type(uint64).max) {
$._initialized = type(uint64).max;
emit Initialized(type(uint64).max);
}
}
/**
* @dev Returns the highest version that has been initialized. See {reinitializer}.
*/
function _getInitializedVersion() internal view returns (uint64) {
return _getInitializableStorage()._initialized;
}
/**
* @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.
*/
function _isInitializing() internal view returns (bool) {
return _getInitializableStorage()._initializing;
}
/**
* @dev Returns a pointer to the storage namespace.
*/
// solhint-disable-next-line var-name-mixedcase
function _getInitializableStorage() private pure returns (InitializableStorage storage $) {
assembly {
$.slot := INITIALIZABLE_STORAGE
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (proxy/utils/UUPSUpgradeable.sol)
pragma solidity ^0.8.20;
import {IERC1822Proxiable} from "@openzeppelin/contracts/interfaces/draft-IERC1822.sol";
import {ERC1967Utils} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Utils.sol";
import {Initializable} from "./Initializable.sol";
/**
* @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an
* {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy.
*
* A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is
* reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing
* `UUPSUpgradeable` with a custom implementation of upgrades.
*
* The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism.
*/
abstract contract UUPSUpgradeable is Initializable, IERC1822Proxiable {
/// @custom:oz-upgrades-unsafe-allow state-variable-immutable
address private immutable __self = address(this);
/**
* @dev The version of the upgrade interface of the contract. If this getter is missing, both `upgradeTo(address)`
* and `upgradeToAndCall(address,bytes)` are present, and `upgradeTo` must be used if no function should be called,
* while `upgradeToAndCall` will invoke the `receive` function if the second argument is the empty byte string.
* If the getter returns `"5.0.0"`, only `upgradeToAndCall(address,bytes)` is present, and the second argument must
* be the empty byte string if no function should be called, making it impossible to invoke the `receive` function
* during an upgrade.
*/
string public constant UPGRADE_INTERFACE_VERSION = "5.0.0";
/**
* @dev The call is from an unauthorized context.
*/
error UUPSUnauthorizedCallContext();
/**
* @dev The storage `slot` is unsupported as a UUID.
*/
error UUPSUnsupportedProxiableUUID(bytes32 slot);
/**
* @dev Check that the execution is being performed through a delegatecall call and that the execution context is
* a proxy contract with an implementation (as defined in ERC1967) pointing to self. This should only be the case
* for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a
* function through ERC1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to
* fail.
*/
modifier onlyProxy() {
_checkProxy();
_;
}
/**
* @dev Check that the execution is not being performed through a delegate call. This allows a function to be
* callable on the implementing contract but not through proxies.
*/
modifier notDelegated() {
_checkNotDelegated();
_;
}
function __UUPSUpgradeable_init() internal onlyInitializing {
}
function __UUPSUpgradeable_init_unchained() internal onlyInitializing {
}
/**
* @dev Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the
* implementation. It is used to validate the implementation's compatibility when performing an upgrade.
*
* 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. This is guaranteed by the `notDelegated` modifier.
*/
function proxiableUUID() external view virtual notDelegated returns (bytes32) {
return ERC1967Utils.IMPLEMENTATION_SLOT;
}
/**
* @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call
* encoded in `data`.
*
* Calls {_authorizeUpgrade}.
*
* Emits an {Upgraded} event.
*
* @custom:oz-upgrades-unsafe-allow-reachable delegatecall
*/
function upgradeToAndCall(address newImplementation, bytes memory data) public payable virtual onlyProxy {
_authorizeUpgrade(newImplementation);
_upgradeToAndCallUUPS(newImplementation, data);
}
/**
* @dev Reverts if the execution is not performed via delegatecall or the execution
* context is not of a proxy with an ERC1967-compliant implementation pointing to self.
* See {_onlyProxy}.
*/
function _checkProxy() internal view virtual {
if (
address(this) == __self || // Must be called through delegatecall
ERC1967Utils.getImplementation() != __self // Must be called through an active proxy
) {
revert UUPSUnauthorizedCallContext();
}
}
/**
* @dev Reverts if the execution is performed via delegatecall.
* See {notDelegated}.
*/
function _checkNotDelegated() internal view virtual {
if (address(this) != __self) {
// Must not be called through delegatecall
revert UUPSUnauthorizedCallContext();
}
}
/**
* @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by
* {upgradeToAndCall}.
*
* Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}.
*
* ```solidity
* function _authorizeUpgrade(address) internal onlyOwner {}
* ```
*/
function _authorizeUpgrade(address newImplementation) internal virtual;
/**
* @dev Performs an implementation upgrade with a security check for UUPS proxies, and additional setup call.
*
* As a security check, {proxiableUUID} is invoked in the new implementation, and the return value
* is expected to be the implementation slot in ERC1967.
*
* Emits an {IERC1967-Upgraded} event.
*/
function _upgradeToAndCallUUPS(address newImplementation, bytes memory data) private {
try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {
if (slot != ERC1967Utils.IMPLEMENTATION_SLOT) {
revert UUPSUnsupportedProxiableUUID(slot);
}
ERC1967Utils.upgradeToAndCall(newImplementation, data);
} catch {
// The implementation is not UUPS
revert ERC1967Utils.ERC1967InvalidImplementation(newImplementation);
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)
pragma solidity ^0.8.20;
import {Initializable} from "../proxy/utils/Initializable.sol";
/**
* @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 ContextUpgradeable is Initializable {
function __Context_init() internal onlyInitializing {
}
function __Context_init_unchained() internal onlyInitializing {
}
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
function _contextSuffixLength() internal view virtual returns (uint256) {
return 0;
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/EIP712.sol)
pragma solidity ^0.8.20;
import {MessageHashUtils} from "@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol";
import {IERC5267} from "@openzeppelin/contracts/interfaces/IERC5267.sol";
import {Initializable} from "../../proxy/utils/Initializable.sol";
/**
* @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.
*
* The encoding scheme specified in the EIP requires a domain separator and a hash of the typed structured data, whose
* encoding is very generic and therefore its implementation in Solidity is not feasible, thus this contract
* does not implement the encoding itself. Protocols need to implement the type-specific encoding they need in order to
* produce the hash of their typed data using a combination of `abi.encode` and `keccak256`.
*
* This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding
* scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA
* ({_hashTypedDataV4}).
*
* The implementation of the domain separator was designed to be as efficient as possible while still properly updating
* the chain id to protect against replay attacks on an eventual fork of the chain.
*
* NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method
* https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].
*
* NOTE: In the upgradeable version of this contract, the cached values will correspond to the address, and the domain
* separator of the implementation contract. This will cause the {_domainSeparatorV4} function to always rebuild the
* separator from the immutable values, which is cheaper than accessing a cached version in cold storage.
*/
abstract contract EIP712Upgradeable is Initializable, IERC5267 {
bytes32 private constant TYPE_HASH =
keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
/// @custom:storage-location erc7201:openzeppelin.storage.EIP712
struct EIP712Storage {
/// @custom:oz-renamed-from _HASHED_NAME
bytes32 _hashedName;
/// @custom:oz-renamed-from _HASHED_VERSION
bytes32 _hashedVersion;
string _name;
string _version;
}
// keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.EIP712")) - 1)) & ~bytes32(uint256(0xff))
bytes32 private constant EIP712StorageLocation = 0xa16a46d94261c7517cc8ff89f61c0ce93598e3c849801011dee649a6a557d100;
function _getEIP712Storage() private pure returns (EIP712Storage storage $) {
assembly {
$.slot := EIP712StorageLocation
}
}
/**
* @dev Initializes the domain separator and parameter caches.
*
* The meaning of `name` and `version` is specified in
* https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]:
*
* - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.
* - `version`: the current major version of the signing domain.
*
* NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart
* contract upgrade].
*/
function __EIP712_init(string memory name, string memory version) internal onlyInitializing {
__EIP712_init_unchained(name, version);
}
function __EIP712_init_unchained(string memory name, string memory version) internal onlyInitializing {
EIP712Storage storage $ = _getEIP712Storage();
$._name = name;
$._version = version;
// Reset prior values in storage if upgrading
$._hashedName = 0;
$._hashedVersion = 0;
}
/**
* @dev Returns the domain separator for the current chain.
*/
function _domainSeparatorV4() internal view returns (bytes32) {
return _buildDomainSeparator();
}
function _buildDomainSeparator() private view returns (bytes32) {
return keccak256(abi.encode(TYPE_HASH, _EIP712NameHash(), _EIP712VersionHash(), block.chainid, address(this)));
}
/**
* @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this
* function returns the hash of the fully encoded EIP712 message for this domain.
*
* This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:
*
* ```solidity
* bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(
* keccak256("Mail(address to,string contents)"),
* mailTo,
* keccak256(bytes(mailContents))
* )));
* address signer = ECDSA.recover(digest, signature);
* ```
*/
function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
return MessageHashUtils.toTypedDataHash(_domainSeparatorV4(), structHash);
}
/**
* @dev See {IERC-5267}.
*/
function eip712Domain()
public
view
virtual
returns (
bytes1 fields,
string memory name,
string memory version,
uint256 chainId,
address verifyingContract,
bytes32 salt,
uint256[] memory extensions
)
{
EIP712Storage storage $ = _getEIP712Storage();
// If the hashed name and version in storage are non-zero, the contract hasn't been properly initialized
// and the EIP712 domain is not reliable, as it will be missing name and version.
require($._hashedName == 0 && $._hashedVersion == 0, "EIP712: Uninitialized");
return (
hex"0f", // 01111
_EIP712Name(),
_EIP712Version(),
block.chainid,
address(this),
bytes32(0),
new uint256[](0)
);
}
/**
* @dev The name parameter for the EIP712 domain.
*
* NOTE: This function reads from storage by default, but can be redefined to return a constant value if gas costs
* are a concern.
*/
function _EIP712Name() internal view virtual returns (string memory) {
EIP712Storage storage $ = _getEIP712Storage();
return $._name;
}
/**
* @dev The version parameter for the EIP712 domain.
*
* NOTE: This function reads from storage by default, but can be redefined to return a constant value if gas costs
* are a concern.
*/
function _EIP712Version() internal view virtual returns (string memory) {
EIP712Storage storage $ = _getEIP712Storage();
return $._version;
}
/**
* @dev The hash of the name parameter for the EIP712 domain.
*
* NOTE: In previous versions this function was virtual. In this version you should override `_EIP712Name` instead.
*/
function _EIP712NameHash() internal view returns (bytes32) {
EIP712Storage storage $ = _getEIP712Storage();
string memory name = _EIP712Name();
if (bytes(name).length > 0) {
return keccak256(bytes(name));
} else {
// If the name is empty, the contract may have been upgraded without initializing the new storage.
// We return the name hash in storage if non-zero, otherwise we assume the name is empty by design.
bytes32 hashedName = $._hashedName;
if (hashedName != 0) {
return hashedName;
} else {
return keccak256("");
}
}
}
/**
* @dev The hash of the version parameter for the EIP712 domain.
*
* NOTE: In previous versions this function was virtual. In this version you should override `_EIP712Version` instead.
*/
function _EIP712VersionHash() internal view returns (bytes32) {
EIP712Storage storage $ = _getEIP712Storage();
string memory version = _EIP712Version();
if (bytes(version).length > 0) {
return keccak256(bytes(version));
} else {
// If the version is empty, the contract may have been upgraded without initializing the new storage.
// We return the version hash in storage if non-zero, otherwise we assume the version is empty by design.
bytes32 hashedVersion = $._hashedVersion;
if (hashedVersion != 0) {
return hashedVersion;
} else {
return keccak256("");
}
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC1822.sol)
pragma solidity ^0.8.20;
/**
* @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);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC5267.sol)
pragma solidity ^0.8.20;
interface IERC5267 {
/**
* @dev MAY be emitted to signal that the domain could have changed.
*/
event EIP712DomainChanged();
/**
* @dev returns the fields and values that describe the domain separator used by this contract for EIP-712
* signature.
*/
function eip712Domain()
external
view
returns (
bytes1 fields,
string memory name,
string memory version,
uint256 chainId,
address verifyingContract,
bytes32 salt,
uint256[] memory extensions
);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (proxy/beacon/IBeacon.sol)
pragma solidity ^0.8.20;
/**
* @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.0.0) (proxy/ERC1967/ERC1967Utils.sol)
pragma solidity ^0.8.20;
import {IBeacon} from "../beacon/IBeacon.sol";
import {Address} from "../../utils/Address.sol";
import {StorageSlot} from "../../utils/StorageSlot.sol";
/**
* @dev This abstract contract provides getters and event emitting update functions for
* https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.
*/
library ERC1967Utils {
// We re-declare ERC-1967 events here because they can't be used directly from IERC1967.
// This will be fixed in Solidity 0.8.21. At that point we should remove these events.
/**
* @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);
/**
* @dev Storage slot with the address of the current implementation.
* This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1.
*/
// solhint-disable-next-line private-vars-leading-underscore
bytes32 internal constant IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
/**
* @dev The `implementation` of the proxy is invalid.
*/
error ERC1967InvalidImplementation(address implementation);
/**
* @dev The `admin` of the proxy is invalid.
*/
error ERC1967InvalidAdmin(address admin);
/**
* @dev The `beacon` of the proxy is invalid.
*/
error ERC1967InvalidBeacon(address beacon);
/**
* @dev An upgrade function sees `msg.value > 0` that may be lost.
*/
error ERC1967NonPayable();
/**
* @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 {
if (newImplementation.code.length == 0) {
revert ERC1967InvalidImplementation(newImplementation);
}
StorageSlot.getAddressSlot(IMPLEMENTATION_SLOT).value = newImplementation;
}
/**
* @dev Performs implementation upgrade with additional setup call if data is nonempty.
* This function is payable only if the setup call is performed, otherwise `msg.value` is rejected
* to avoid stuck value in the contract.
*
* Emits an {IERC1967-Upgraded} event.
*/
function upgradeToAndCall(address newImplementation, bytes memory data) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
if (data.length > 0) {
Address.functionDelegateCall(newImplementation, data);
} else {
_checkNonPayable();
}
}
/**
* @dev Storage slot with the admin of the contract.
* This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1.
*/
// solhint-disable-next-line private-vars-leading-underscore
bytes32 internal constant ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
/**
* @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 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 {
if (newAdmin == address(0)) {
revert ERC1967InvalidAdmin(address(0));
}
StorageSlot.getAddressSlot(ADMIN_SLOT).value = newAdmin;
}
/**
* @dev Changes the admin of the proxy.
*
* Emits an {IERC1967-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 the keccak-256 hash of "eip1967.proxy.beacon" subtracted by 1.
*/
// solhint-disable-next-line private-vars-leading-underscore
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 {
if (newBeacon.code.length == 0) {
revert ERC1967InvalidBeacon(newBeacon);
}
StorageSlot.getAddressSlot(BEACON_SLOT).value = newBeacon;
address beaconImplementation = IBeacon(newBeacon).implementation();
if (beaconImplementation.code.length == 0) {
revert ERC1967InvalidImplementation(beaconImplementation);
}
}
/**
* @dev Change the beacon and trigger a setup call if data is nonempty.
* This function is payable only if the setup call is performed, otherwise `msg.value` is rejected
* to avoid stuck value in the contract.
*
* Emits an {IERC1967-BeaconUpgraded} event.
*
* CAUTION: Invoking this function has no effect on an instance of {BeaconProxy} since v5, since
* it uses an immutable beacon without looking at the value of the ERC-1967 beacon slot for
* efficiency.
*/
function upgradeBeaconToAndCall(address newBeacon, bytes memory data) internal {
_setBeacon(newBeacon);
emit BeaconUpgraded(newBeacon);
if (data.length > 0) {
Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);
} else {
_checkNonPayable();
}
}
/**
* @dev Reverts if `msg.value` is not zero. It can be used to avoid `msg.value` stuck in the contract
* if an upgrade doesn't perform an initialization call.
*/
function _checkNonPayable() private {
if (msg.value > 0) {
revert ERC1967NonPayable();
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)
pragma solidity ^0.8.20;
/**
* @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 value of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the value of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves a `value` amount of 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 value) 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 a `value` amount of tokens 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 value) external returns (bool);
/**
* @dev Moves a `value` amount of tokens from `from` to `to` using the
* allowance mechanism. `value` 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 value) external returns (bool);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)
pragma solidity ^0.8.20;
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev The ETH balance of the account is not enough to perform the operation.
*/
error AddressInsufficientBalance(address account);
/**
* @dev There's no code at `target` (it is not a contract).
*/
error AddressEmptyCode(address target);
/**
* @dev A call to an address target failed. The target may have reverted.
*/
error FailedInnerCall();
/**
* @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 AddressInsufficientBalance(address(this));
}
(bool success, ) = recipient.call{value: amount}("");
if (!success) {
revert FailedInnerCall();
}
}
/**
* @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
* {FailedInnerCall} 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 AddressInsufficientBalance(address(this));
}
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata);
}
/**
* @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, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata);
}
/**
* @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, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata);
}
/**
* @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 {FailedInnerCall}) in case of an
* unsuccessful call.
*/
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata
) internal view returns (bytes memory) {
if (!success) {
_revert(returndata);
} else {
// 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 (returndata.length == 0 && target.code.length == 0) {
revert AddressEmptyCode(target);
}
return returndata;
}
}
/**
* @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 {FailedInnerCall} error.
*/
function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
if (!success) {
_revert(returndata);
} else {
return returndata;
}
}
/**
* @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.
*/
function _revert(bytes memory returndata) 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 FailedInnerCall();
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/ECDSA.sol)
pragma solidity ^0.8.20;
/**
* @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
*
* These functions can be used to verify that a message was signed by the holder
* of the private keys of a given address.
*/
library ECDSA {
enum RecoverError {
NoError,
InvalidSignature,
InvalidSignatureLength,
InvalidSignatureS
}
/**
* @dev The signature derives the `address(0)`.
*/
error ECDSAInvalidSignature();
/**
* @dev The signature has an invalid length.
*/
error ECDSAInvalidSignatureLength(uint256 length);
/**
* @dev The signature has an S value that is in the upper half order.
*/
error ECDSAInvalidSignatureS(bytes32 s);
/**
* @dev Returns the address that signed a hashed message (`hash`) with `signature` or an error. This will not
* return address(0) without also returning an error description. Errors are documented using an enum (error type)
* and a bytes32 providing additional information about the error.
*
* If no error is returned, then the address can be used for verification purposes.
*
* The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:
* this function rejects them by requiring the `s` value to be in the lower
* half order, and the `v` value to be either 27 or 28.
*
* IMPORTANT: `hash` _must_ be the result of a hash operation for the
* verification to be secure: it is possible to craft signatures that
* recover to arbitrary addresses for non-hashed data. A safe way to ensure
* this is by receiving a hash of the original message (which may otherwise
* be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.
*
* Documentation for signature generation:
* - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
* - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
*/
function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError, bytes32) {
if (signature.length == 65) {
bytes32 r;
bytes32 s;
uint8 v;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
/// @solidity memory-safe-assembly
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return tryRecover(hash, v, r, s);
} else {
return (address(0), RecoverError.InvalidSignatureLength, bytes32(signature.length));
}
}
/**
* @dev Returns the address that signed a hashed message (`hash`) with
* `signature`. This address can then be used for verification purposes.
*
* The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:
* this function rejects them by requiring the `s` value to be in the lower
* half order, and the `v` value to be either 27 or 28.
*
* IMPORTANT: `hash` _must_ be the result of a hash operation for the
* verification to be secure: it is possible to craft signatures that
* recover to arbitrary addresses for non-hashed data. A safe way to ensure
* this is by receiving a hash of the original message (which may otherwise
* be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.
*/
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
(address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, signature);
_throwError(error, errorArg);
return recovered;
}
/**
* @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
*
* See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
*/
function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError, bytes32) {
unchecked {
bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
// We do not check for an overflow here since the shift operation results in 0 or 1.
uint8 v = uint8((uint256(vs) >> 255) + 27);
return tryRecover(hash, v, r, s);
}
}
/**
* @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
*/
function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {
(address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, r, vs);
_throwError(error, errorArg);
return recovered;
}
/**
* @dev Overload of {ECDSA-tryRecover} that receives the `v`,
* `r` and `s` signature fields separately.
*/
function tryRecover(
bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s
) internal pure returns (address, RecoverError, bytes32) {
// EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
// unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
// the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
// signatures from current libraries generate a unique signature with an s-value in the lower half order.
//
// If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
// with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
// vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
// these malleable signatures as well.
if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
return (address(0), RecoverError.InvalidSignatureS, s);
}
// If the signature is valid (and not malleable), return the signer address
address signer = ecrecover(hash, v, r, s);
if (signer == address(0)) {
return (address(0), RecoverError.InvalidSignature, bytes32(0));
}
return (signer, RecoverError.NoError, bytes32(0));
}
/**
* @dev Overload of {ECDSA-recover} that receives the `v`,
* `r` and `s` signature fields separately.
*/
function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
(address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, v, r, s);
_throwError(error, errorArg);
return recovered;
}
/**
* @dev Optionally reverts with the corresponding custom error according to the `error` argument provided.
*/
function _throwError(RecoverError error, bytes32 errorArg) private pure {
if (error == RecoverError.NoError) {
return; // no error: do nothing
} else if (error == RecoverError.InvalidSignature) {
revert ECDSAInvalidSignature();
} else if (error == RecoverError.InvalidSignatureLength) {
revert ECDSAInvalidSignatureLength(uint256(errorArg));
} else if (error == RecoverError.InvalidSignatureS) {
revert ECDSAInvalidSignatureS(errorArg);
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/MessageHashUtils.sol)
pragma solidity ^0.8.20;
import {Strings} from "../Strings.sol";
/**
* @dev Signature message hash utilities for producing digests to be consumed by {ECDSA} recovery or signing.
*
* The library provides methods for generating a hash of a message that conforms to the
* https://eips.ethereum.org/EIPS/eip-191[EIP 191] and https://eips.ethereum.org/EIPS/eip-712[EIP 712]
* specifications.
*/
library MessageHashUtils {
/**
* @dev Returns the keccak256 digest of an EIP-191 signed data with version
* `0x45` (`personal_sign` messages).
*
* The digest is calculated by prefixing a bytes32 `messageHash` with
* `"\x19Ethereum Signed Message:\n32"` and hashing the result. It corresponds with the
* hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method.
*
* NOTE: The `messageHash` parameter is intended to be the result of hashing a raw message with
* keccak256, although any bytes32 value can be safely used because the final digest will
* be re-hashed.
*
* See {ECDSA-recover}.
*/
function toEthSignedMessageHash(bytes32 messageHash) internal pure returns (bytes32 digest) {
/// @solidity memory-safe-assembly
assembly {
mstore(0x00, "\x19Ethereum Signed Message:\n32") // 32 is the bytes-length of messageHash
mstore(0x1c, messageHash) // 0x1c (28) is the length of the prefix
digest := keccak256(0x00, 0x3c) // 0x3c is the length of the prefix (0x1c) + messageHash (0x20)
}
}
/**
* @dev Returns the keccak256 digest of an EIP-191 signed data with version
* `0x45` (`personal_sign` messages).
*
* The digest is calculated by prefixing an arbitrary `message` with
* `"\x19Ethereum Signed Message:\n" + len(message)` and hashing the result. It corresponds with the
* hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method.
*
* See {ECDSA-recover}.
*/
function toEthSignedMessageHash(bytes memory message) internal pure returns (bytes32) {
return
keccak256(bytes.concat("\x19Ethereum Signed Message:\n", bytes(Strings.toString(message.length)), message));
}
/**
* @dev Returns the keccak256 digest of an EIP-191 signed data with version
* `0x00` (data with intended validator).
*
* The digest is calculated by prefixing an arbitrary `data` with `"\x19\x00"` and the intended
* `validator` address. Then hashing the result.
*
* See {ECDSA-recover}.
*/
function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {
return keccak256(abi.encodePacked(hex"19_00", validator, data));
}
/**
* @dev Returns the keccak256 digest of an EIP-712 typed data (EIP-191 version `0x01`).
*
* The digest is calculated from a `domainSeparator` and a `structHash`, by prefixing them with
* `\x19\x01` and hashing the result. It corresponds to the hash signed by the
* https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`] JSON-RPC method as part of EIP-712.
*
* See {ECDSA-recover}.
*/
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 digest) {
/// @solidity memory-safe-assembly
assembly {
let ptr := mload(0x40)
mstore(ptr, hex"19_01")
mstore(add(ptr, 0x02), domainSeparator)
mstore(add(ptr, 0x22), structHash)
digest := keccak256(ptr, 0x42)
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/Math.sol)
pragma solidity ^0.8.20;
/**
* @dev Standard math utilities missing in the Solidity language.
*/
library Math {
/**
* @dev Muldiv operation overflow.
*/
error MathOverflowedMulDiv();
enum Rounding {
Floor, // Toward negative infinity
Ceil, // Toward positive infinity
Trunc, // Toward zero
Expand // Away from zero
}
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
/**
* @dev Returns the subtraction of two unsigned integers, with an overflow flag.
*/
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
/**
* @dev Returns the multiplication of two unsigned integers, with an overflow flag.
*/
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
/**
* @dev Returns the division of two unsigned integers, with a division by zero flag.
*/
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
/**
* @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
*/
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
/**
* @dev Returns the largest of two numbers.
*/
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
/**
* @dev Returns the smallest of two numbers.
*/
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
/**
* @dev Returns the average of two numbers. The result is rounded towards
* zero.
*/
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow.
return (a & b) + (a ^ b) / 2;
}
/**
* @dev Returns the ceiling of the division of two numbers.
*
* This differs from standard division with `/` in that it rounds towards infinity instead
* of rounding towards zero.
*/
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
if (b == 0) {
// Guarantee the same behavior as in a regular Solidity division.
return a / b;
}
// (a + b - 1) / b can overflow on addition, so we distribute.
return a == 0 ? 0 : (a - 1) / b + 1;
}
/**
* @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or
* denominator == 0.
* @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by
* Uniswap Labs also under MIT license.
*/
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
// 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
// use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
// variables such that product = prod1 * 2^256 + prod0.
uint256 prod0 = x * y; // Least significant 256 bits of the product
uint256 prod1; // Most significant 256 bits of the product
assembly {
let mm := mulmod(x, y, not(0))
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
// Handle non-overflow cases, 256 by 256 division.
if (prod1 == 0) {
// Solidity will revert if denominator == 0, unlike the div opcode on its own.
// The surrounding unchecked block does not change this fact.
// See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
return prod0 / denominator;
}
// Make sure the result is less than 2^256. Also prevents denominator == 0.
if (denominator <= prod1) {
revert MathOverflowedMulDiv();
}
///////////////////////////////////////////////
// 512 by 256 division.
///////////////////////////////////////////////
// Make division exact by subtracting the remainder from [prod1 prod0].
uint256 remainder;
assembly {
// Compute remainder using mulmod.
remainder := mulmod(x, y, denominator)
// Subtract 256 bit number from 512 bit number.
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
// Factor powers of two out of denominator and compute largest power of two divisor of denominator.
// Always >= 1. See https://cs.stackexchange.com/q/138556/92363.
uint256 twos = denominator & (0 - denominator);
assembly {
// Divide denominator by twos.
denominator := div(denominator, twos)
// Divide [prod1 prod0] by twos.
prod0 := div(prod0, twos)
// Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
twos := add(div(sub(0, twos), twos), 1)
}
// Shift in bits from prod1 into prod0.
prod0 |= prod1 * twos;
// Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
// that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
// four bits. That is, denominator * inv = 1 mod 2^4.
uint256 inverse = (3 * denominator) ^ 2;
// Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also
// works in modular arithmetic, doubling the correct bits in each step.
inverse *= 2 - denominator * inverse; // inverse mod 2^8
inverse *= 2 - denominator * inverse; // inverse mod 2^16
inverse *= 2 - denominator * inverse; // inverse mod 2^32
inverse *= 2 - denominator * inverse; // inverse mod 2^64
inverse *= 2 - denominator * inverse; // inverse mod 2^128
inverse *= 2 - denominator * inverse; // inverse mod 2^256
// Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
// This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
// less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
// is no longer required.
result = prod0 * inverse;
return result;
}
}
/**
* @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
*/
function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
/**
* @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded
* towards zero.
*
* Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
*/
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
// For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
//
// We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
// `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
//
// This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
// → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
// → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
//
// Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
uint256 result = 1 << (log2(a) >> 1);
// At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
// since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
// every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
// into the expected uint128 result.
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
/**
* @notice Calculates sqrt(a), following the selected rounding direction.
*/
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);
}
}
/**
* @dev Return the log in base 2 of a positive value rounded towards zero.
* Returns 0 if given 0.
*/
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 2, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0);
}
}
/**
* @dev Return the log in base 10 of a positive value rounded towards zero.
* Returns 0 if given 0.
*/
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10 ** 64) {
value /= 10 ** 64;
result += 64;
}
if (value >= 10 ** 32) {
value /= 10 ** 32;
result += 32;
}
if (value >= 10 ** 16) {
value /= 10 ** 16;
result += 16;
}
if (value >= 10 ** 8) {
value /= 10 ** 8;
result += 8;
}
if (value >= 10 ** 4) {
value /= 10 ** 4;
result += 4;
}
if (value >= 10 ** 2) {
value /= 10 ** 2;
result += 2;
}
if (value >= 10 ** 1) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 10, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0);
}
}
/**
* @dev Return the log in base 256 of a positive value rounded towards zero.
* Returns 0 if given 0.
*
* Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
*/
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 256, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0);
}
}
/**
* @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
*/
function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
return uint8(rounding) % 2 == 1;
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SignedMath.sol)
pragma solidity ^0.8.20;
/**
* @dev Standard signed math utilities missing in the Solidity language.
*/
library SignedMath {
/**
* @dev Returns the largest of two signed numbers.
*/
function max(int256 a, int256 b) internal pure returns (int256) {
return a > b ? a : b;
}
/**
* @dev Returns the smallest of two signed numbers.
*/
function min(int256 a, int256 b) internal pure returns (int256) {
return a < b ? a : b;
}
/**
* @dev Returns the average of two signed numbers without overflow.
* The result is rounded towards zero.
*/
function average(int256 a, int256 b) internal pure returns (int256) {
// Formula from the book "Hacker's Delight"
int256 x = (a & b) + ((a ^ b) >> 1);
return x + (int256(uint256(x) >> 255) & (a ^ b));
}
/**
* @dev Returns the absolute unsigned value of a signed value.
*/
function abs(int256 n) internal pure returns (uint256) {
unchecked {
// must be unchecked in order to support `n = type(int256).min`
return uint256(n >= 0 ? n : -n);
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.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 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(newImplementation.code.length > 0);
* StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
* }
* }
* ```
*/
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
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Strings.sol)
pragma solidity ^0.8.20;
import {Math} from "./math/Math.sol";
import {SignedMath} from "./math/SignedMath.sol";
/**
* @dev String operations.
*/
library Strings {
bytes16 private constant HEX_DIGITS = "0123456789abcdef";
uint8 private constant ADDRESS_LENGTH = 20;
/**
* @dev The `value` string doesn't fit in the specified `length`.
*/
error StringsInsufficientHexLength(uint256 value, uint256 length);
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
unchecked {
uint256 length = Math.log10(value) + 1;
string memory buffer = new string(length);
uint256 ptr;
/// @solidity memory-safe-assembly
assembly {
ptr := add(buffer, add(32, length))
}
while (true) {
ptr--;
/// @solidity memory-safe-assembly
assembly {
mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))
}
value /= 10;
if (value == 0) break;
}
return buffer;
}
}
/**
* @dev Converts a `int256` to its ASCII `string` decimal representation.
*/
function toStringSigned(int256 value) internal pure returns (string memory) {
return string.concat(value < 0 ? "-" : "", toString(SignedMath.abs(value)));
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
unchecked {
return toHexString(value, Math.log256(value) + 1);
}
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
uint256 localValue = value;
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = HEX_DIGITS[localValue & 0xf];
localValue >>= 4;
}
if (localValue != 0) {
revert StringsInsufficientHexLength(value, length);
}
return string(buffer);
}
/**
* @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal
* representation.
*/
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH);
}
/**
* @dev Returns true if the two strings are equal.
*/
function equal(string memory a, string memory b) internal pure returns (bool) {
return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b));
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts-upgradeable/utils/cryptography/EIP712Upgradeable.sol";
contract EIP712VerifierU is EIP712Upgradeable {
address public external_signer;
uint256[50] private __gap;
function __EIP712VerifierU_init(string memory domainName, string memory version, address signer) internal initializer {
require(signer != address(0), "ZERO_SIGNER");
__EIP712_init(domainName, version);
external_signer = signer;
}
/*
Standard EIP712 verifier but with different v combinations
*/
function verify(bytes32 digest, uint8 v, bytes32 r, bytes32 s) internal view returns (bool) {
address recovered_signer = ecrecover(digest, v, r, s);
if (recovered_signer != external_signer) {
uint8 other_v = 27;
if (other_v == v) {
other_v = 28;
}
recovered_signer = ecrecover(digest, other_v, r, s);
}
if (recovered_signer != external_signer) {
return false;
}
return true;
}
}{
"viaIR": true,
"optimizer": {
"enabled": true,
"runs": 200,
"details": {
"yulDetails": {
"optimizerSteps": "u"
}
}
},
"evmVersion": "paris",
"outputSelection": {
"*": {
"*": [
"evm.bytecode",
"evm.deployedBytecode",
"devdoc",
"userdoc",
"metadata",
"abi"
]
}
},
"libraries": {}
}[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"AddressEmptyCode","type":"error"},{"inputs":[{"internalType":"address","name":"implementation","type":"address"}],"name":"ERC1967InvalidImplementation","type":"error"},{"inputs":[],"name":"ERC1967NonPayable","type":"error"},{"inputs":[],"name":"FailedInnerCall","type":"error"},{"inputs":[],"name":"InvalidInitialization","type":"error"},{"inputs":[],"name":"NotInitializing","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[],"name":"UUPSUnauthorizedCallContext","type":"error"},{"inputs":[{"internalType":"bytes32","name":"slot","type":"bytes32"}],"name":"UUPSUnsupportedProxiableUUID","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"id","type":"string"},{"indexed":true,"internalType":"address","name":"trader","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":true,"internalType":"address","name":"token","type":"address"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[],"name":"EIP712DomainChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint64","name":"version","type":"uint64"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"}],"name":"SetOwner","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"signer","type":"address"}],"name":"SetSigner","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"minDeposit","type":"uint256"}],"name":"SupportToken","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token","type":"address"}],"name":"UnsupportToken","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"implementation","type":"address"}],"name":"Upgraded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":true,"internalType":"address","name":"trader","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":true,"internalType":"address","name":"token","type":"address"}],"name":"WithdrawalReceipt","type":"event"},{"inputs":[],"name":"UPGRADE_INTERFACE_VERSION","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"new_signer","type":"address"}],"name":"changeSigner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"defaultToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"depositNative","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"token","type":"address"}],"name":"depositToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"eip712Domain","outputs":[{"internalType":"bytes1","name":"fields","type":"bytes1"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"version","type":"string"},{"internalType":"uint256","name":"chainId","type":"uint256"},{"internalType":"address","name":"verifyingContract","type":"address"},{"internalType":"bytes32","name":"salt","type":"bytes32"},{"internalType":"uint256[]","name":"extensions","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"external_signer","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getVersion","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"_timelock","type":"address"},{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address","name":"_signer","type":"address"},{"internalType":"address","name":"_defaultToken","type":"address"},{"internalType":"uint256","name":"_minDeposit","type":"uint256"},{"internalType":"address[]","name":"_otherTokens","type":"address[]"},{"internalType":"uint256[]","name":"_minDeposits","type":"uint256[]"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"minDeposits","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"processedWithdrawals","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"proxiableUUID","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"minDeposit","type":"uint256"}],"name":"supportToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"supportedTokens","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"timelock","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"unsupportToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newImplementation","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"upgradeToAndCall","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"address","name":"trader","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"address","name":"trader","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"withdrawNative","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"address","name":"trader","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"withdrawToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]Contract Creation Code
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
Deployed Bytecode
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
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 30 Chains
| Chain | Token | Portfolio % | Price | Amount | Value |
|---|
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.