Contract Name:
EverclearSpoke
Contract Source Code:
// SPDX-License-Identifier: MIT
pragma solidity 0.8.23;
/*
Coded for Everclear with ♥ by
░██╗░░░░░░░██╗░█████╗░███╗░░██╗██████╗░███████╗██████╗░██╗░░░░░░█████╗░███╗░░██╗██████╗░
░██║░░██╗░░██║██╔══██╗████╗░██║██╔══██╗██╔════╝██╔══██╗██║░░░░░██╔══██╗████╗░██║██╔══██╗
░╚██╗████╗██╔╝██║░░██║██╔██╗██║██║░░██║█████╗░░██████╔╝██║░░░░░███████║██╔██╗██║██║░░██║
░░████╔═████║░██║░░██║██║╚████║██║░░██║██╔══╝░░██╔══██╗██║░░░░░██╔══██║██║╚████║██║░░██║
░░╚██╔╝░╚██╔╝░╚█████╔╝██║░╚███║██████╔╝███████╗██║░░██║███████╗██║░░██║██║░╚███║██████╔╝
░░░╚═╝░░░╚═╝░░░╚════╝░╚═╝░░╚══╝╚═════╝░╚══════╝╚═╝░░╚═╝╚══════╝╚═╝░░╚═╝╚═╝░░╚══╝╚═════╝░
https://defi.sucks
*/
import {OwnableUpgradeable} from '@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol';
import {UUPSUpgradeable} from '@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol';
import {NoncesUpgradeable} from '@openzeppelin/contracts-upgradeable/utils/NoncesUpgradeable.sol';
import {ERC20} from '@openzeppelin/contracts/token/ERC20/ERC20.sol';
import {IERC20} from '@openzeppelin/contracts/token/ERC20/IERC20.sol';
import {SafeERC20} from '@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol';
import {ECDSA} from '@openzeppelin/contracts/utils/cryptography/ECDSA.sol';
import {MessageHashUtils} from '@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol';
import {AssetUtils} from 'contracts/common/AssetUtils.sol';
import {Constants as Common} from 'contracts/common/Constants.sol';
import {MessageLib} from 'contracts/common/MessageLib.sol';
import {QueueLib} from 'contracts/common/QueueLib.sol';
import {TypeCasts} from 'contracts/common/TypeCasts.sol';
import {Constants} from 'contracts/intent/lib/Constants.sol';
import {IEverclear} from 'interfaces/common/IEverclear.sol';
import {IMessageReceiver} from 'interfaces/common/IMessageReceiver.sol';
import {IPermit2} from 'interfaces/common/IPermit2.sol';
import {ISettlementModule} from 'interfaces/common/ISettlementModule.sol';
import {IEverclearSpoke} from 'interfaces/intent/IEverclearSpoke.sol';
import {ISpokeGateway} from 'interfaces/intent/ISpokeGateway.sol';
import {SpokeStorage} from 'contracts/intent/SpokeStorage.sol';
/**
* @title EverclearSpoke
* @notice Spoke contract for Everclear
*/
contract EverclearSpoke is
SpokeStorage,
UUPSUpgradeable,
OwnableUpgradeable,
NoncesUpgradeable,
IEverclearSpoke,
IMessageReceiver
{
using QueueLib for QueueLib.IntentQueue;
using QueueLib for QueueLib.FillQueue;
using SafeERC20 for IERC20;
using TypeCasts for address;
using TypeCasts for bytes32;
constructor() {
_disableInitializers();
}
/*///////////////////////////////////////////////////////////////
EXTERNAL FUNCTIONS
//////////////////////////////////////////////////////////////*/
/// @inheritdoc IEverclearSpoke
function pause() external hasPauseAccess {
paused = true;
emit Paused();
}
/// @inheritdoc IEverclearSpoke
function unpause() external hasPauseAccess {
paused = false;
emit Unpaused();
}
/// @inheritdoc IEverclearSpoke
function setStrategyForAsset(address _asset, IEverclear.Strategy _strategy) external onlyOwner {
strategies[_asset] = _strategy;
emit StrategySetForAsset(_asset, _strategy);
}
/// @inheritdoc IEverclearSpoke
function setModuleForStrategy(IEverclear.Strategy _strategy, ISettlementModule _module) external onlyOwner {
modules[_strategy] = _module;
emit ModuleSetForStrategy(_strategy, _module);
}
/// @inheritdoc IEverclearSpoke
function updateSecurityModule(
address _newSecurityModule
) external onlyOwner {
gateway.updateSecurityModule(_newSecurityModule);
}
/// @inheritdoc IMessageReceiver
function receiveMessage(
bytes calldata
) external {
_delegate(messageReceiver);
}
/// @inheritdoc IEverclearSpoke
function newIntent(
uint32[] memory _destinations,
address _receiver,
address _inputAsset,
address _outputAsset,
uint256 _amount,
uint24 _maxFee,
uint48 _ttl,
bytes calldata _data
) external whenNotPaused returns (bytes32 _intentId, Intent memory _intent) {
if (_destinations.length > 10) revert EverclearSpoke_NewIntent_InvalidIntent();
(_intentId, _intent) = _newIntent({
_destinations: _destinations,
_receiver: _receiver,
_inputAsset: _inputAsset,
_outputAsset: _outputAsset,
_amount: _amount,
_maxFee: _maxFee,
_ttl: _ttl,
_data: _data,
_usesPermit2: false
});
}
/// @inheritdoc IEverclearSpoke
function newIntent(
uint32[] memory _destinations,
address _receiver,
address _inputAsset,
address _outputAsset,
uint256 _amount,
uint24 _maxFee,
uint48 _ttl,
bytes calldata _data,
Permit2Params calldata _permit2Params
) external whenNotPaused returns (bytes32 _intentId, Intent memory _intent) {
if (_destinations.length > 10) revert EverclearSpoke_NewIntent_InvalidIntent();
PERMIT2.permitTransferFrom(
IPermit2.PermitTransferFrom({
permitted: IPermit2.TokenPermissions({token: IERC20(_inputAsset), amount: _amount}),
nonce: _permit2Params.nonce,
deadline: _permit2Params.deadline
}),
IPermit2.SignatureTransferDetails({to: address(this), requestedAmount: _amount}),
msg.sender,
_permit2Params.signature
);
(_intentId, _intent) = _newIntent({
_destinations: _destinations,
_receiver: _receiver,
_inputAsset: _inputAsset,
_outputAsset: _outputAsset,
_amount: _amount,
_maxFee: _maxFee,
_ttl: _ttl,
_data: _data,
_usesPermit2: true
});
}
/// @inheritdoc IEverclearSpoke
function fillIntent(
Intent calldata _intent,
uint24 _fee
) external whenNotPaused returns (FillMessage memory _fillMessage) {
_fillMessage = _fillIntent(_intent, msg.sender, _fee);
}
/// @inheritdoc IEverclearSpoke
function fillIntentForSolver(
address _solver,
Intent calldata _intent,
uint256 _nonce,
uint24 _fee,
bytes calldata _signature
) external whenNotPaused returns (FillMessage memory _fillMessage) {
bytes memory _data = abi.encode(FILL_INTENT_FOR_SOLVER_TYPEHASH, _intent, _nonce, _fee);
_verifySignature(_solver, _data, _nonce, _signature);
_fillMessage = _fillIntent(_intent, _solver, _fee);
}
/// @inheritdoc IEverclearSpoke
function processIntentQueue(
Intent[] calldata _intents
) external payable whenNotPaused {
(bytes memory _batchIntentmessage, uint256 _firstIdx) = _processIntentQueue(_intents);
(bytes32 _messageId, uint256 _feeSpent) =
gateway.sendMessage{value: msg.value}(EVERCLEAR, _batchIntentmessage, messageGasLimit);
emit IntentQueueProcessed(_messageId, _firstIdx, _firstIdx + _intents.length, _feeSpent);
}
/// @inheritdoc IEverclearSpoke
function processFillQueue(
uint32 _amount
) external payable whenNotPaused {
(bytes memory _batchFillMessage, uint256 _firstIdx) = _processFillQueue(_amount);
(bytes32 _messageId, uint256 _feeSpent) =
gateway.sendMessage{value: msg.value}(EVERCLEAR, _batchFillMessage, messageGasLimit);
emit FillQueueProcessed(_messageId, _firstIdx, _firstIdx + _amount, _feeSpent);
}
/// @inheritdoc IEverclearSpoke
function processIntentQueueViaRelayer(
uint32 _domain,
Intent[] calldata _intents,
address _relayer,
uint256 _ttl,
uint256 _nonce,
uint256 _bufferDBPS,
bytes calldata _signature
) external whenNotPaused {
uint32 _amount = uint32(_intents.length);
bytes memory _data =
abi.encode(PROCESS_INTENT_QUEUE_VIA_RELAYER_TYPEHASH, _domain, _amount, _relayer, _ttl, _nonce, _bufferDBPS);
_verifySignature(lighthouse, _data, _nonce, _signature);
_processQueueChecks(_domain, _relayer, _ttl);
(bytes memory _batchIntentmessage, uint256 _firstIdx) = _processIntentQueue(_intents);
uint256 _fee = gateway.quoteMessage(EVERCLEAR, _batchIntentmessage, messageGasLimit);
(bytes32 _messageId, uint256 _feeSpent) = gateway.sendMessage(
EVERCLEAR, _batchIntentmessage, _fee + ((_fee * _bufferDBPS) / Common.DBPS_DENOMINATOR), messageGasLimit
);
emit IntentQueueProcessed(_messageId, _firstIdx, _firstIdx + _amount, _feeSpent);
}
/// @inheritdoc IEverclearSpoke
function processFillQueueViaRelayer(
uint32 _domain,
uint32 _amount,
address _relayer,
uint256 _ttl,
uint256 _nonce,
uint256 _bufferDBPS,
bytes calldata _signature
) external whenNotPaused {
bytes memory _data =
abi.encode(PROCESS_FILL_QUEUE_VIA_RELAYER_TYPEHASH, _domain, _amount, _relayer, _ttl, _nonce, _bufferDBPS);
_verifySignature(lighthouse, _data, _nonce, _signature);
_processQueueChecks(_domain, _relayer, _ttl);
(bytes memory _batchFillMessage, uint256 _firstIdx) = _processFillQueue(_amount);
uint256 _fee = gateway.quoteMessage(EVERCLEAR, _batchFillMessage, messageGasLimit);
(bytes32 _messageId, uint256 _feeSpent) = gateway.sendMessage(
EVERCLEAR, _batchFillMessage, _fee + ((_fee * _bufferDBPS) / Common.DBPS_DENOMINATOR), messageGasLimit
);
emit FillQueueProcessed(_messageId, _firstIdx, _firstIdx + _amount, _feeSpent);
}
/// @inheritdoc IEverclearSpoke
function deposit(address _asset, uint256 _amount) external whenNotPaused {
_pullTokens(msg.sender, _asset, _amount);
balances[_asset.toBytes32()][msg.sender.toBytes32()] += _amount;
emit Deposited(msg.sender, _asset, _amount);
}
/// @inheritdoc IEverclearSpoke
function withdraw(address _asset, uint256 _amount) external whenNotPaused {
balances[_asset.toBytes32()][msg.sender.toBytes32()] -= _amount;
_pushTokens(msg.sender, _asset, _amount);
emit Withdrawn(msg.sender, _asset, _amount);
}
/// @inheritdoc IEverclearSpoke
function updateGateway(
address _newGateway
) external onlyOwner {
address _oldGateway = address(gateway);
gateway = ISpokeGateway(_newGateway);
emit GatewayUpdated(_oldGateway, _newGateway);
}
/// @inheritdoc IEverclearSpoke
function updateMessageReceiver(
address _newMessageReceiver
) external onlyOwner {
address _oldMessageReceiver = messageReceiver;
messageReceiver = _newMessageReceiver;
emit MessageReceiverUpdated(_oldMessageReceiver, _newMessageReceiver);
}
/// @inheritdoc IEverclearSpoke
function updateMessageGasLimit(
uint256 _newGasLimit
) external onlyOwner {
uint256 _oldGasLimit = messageGasLimit;
messageGasLimit = _newGasLimit;
emit MessageGasLimitUpdated(_oldGasLimit, _newGasLimit);
}
/// @inheritdoc IEverclearSpoke
function executeIntentCalldata(
Intent calldata _intent
) external whenNotPaused validDestination(_intent) {
bytes32 _intentId = keccak256(abi.encode(_intent));
if (status[_intentId] != IntentStatus.SETTLED) {
revert EverclearSpoke_ExecuteIntentCalldata_InvalidStatus(_intentId);
}
// internal method will revert if it fails
_executeCalldata(_intentId, _intent.data);
status[_intentId] = IntentStatus.SETTLED_AND_MANUALLY_EXECUTED;
}
/*///////////////////////////////////////////////////////////////
INITIALIZER
//////////////////////////////////////////////////////////////*/
/// @inheritdoc IEverclearSpoke
function initialize(
SpokeInitializationParams calldata _init
) public initializer {
DOMAIN = uint32(block.chainid);
gateway = _init.gateway;
messageReceiver = _init.messageReceiver;
lighthouse = _init.lighthouse;
watchtower = _init.watchtower;
callExecutor = _init.callExecutor;
EVERCLEAR = _init.hubDomain;
messageGasLimit = 20_000_000;
__Ownable_init(_init.owner);
// Intialize the queues
intentQueue.first = 1;
fillQueue.first = 1;
}
/*///////////////////////////////////////////////////////////////
INTERNAL FUNCTIONS
//////////////////////////////////////////////////////////////*/
/**
* @notice Creates a new intent
* @param _destinations The destination chains of the intent
* @param _receiver The destinantion address of the intent
* @param _inputAsset The asset address on origin
* @param _outputAsset The asset address on destination
* @param _amount The amount of the asset
* @param _maxFee The maximum fee that can be taken by solvers
* @param _ttl The time to live of the intent
* @param _data The data of the intent
* @param _usesPermit2 If the intent uses permit2
* @return _intentId The ID of the intent
* @return _intent The intent structure
*/
function _newIntent(
uint32[] memory _destinations,
address _receiver,
address _inputAsset,
address _outputAsset,
uint256 _amount,
uint24 _maxFee,
uint48 _ttl,
bytes calldata _data,
bool _usesPermit2
) internal returns (bytes32 _intentId, Intent memory _intent) {
if (_destinations.length == 1) {
// output asset should not be null if the intent has a single destination and ttl != 0
if (_ttl != 0 && _outputAsset == address(0)) revert EverclearSpoke_NewIntent_InvalidIntent();
} else {
// output asset should be null if the intent has multiple destinations
// ttl should be 0 if the intent has multiple destinations
if (_ttl != 0 || _outputAsset != address(0)) revert EverclearSpoke_NewIntent_InvalidIntent();
}
if (_maxFee > Common.DBPS_DENOMINATOR) {
revert EverclearSpoke_NewIntent_MaxFeeExceeded(_maxFee, Common.DBPS_DENOMINATOR);
}
if (_data.length > Common.MAX_CALLDATA_SIZE) {
revert EverclearSpoke_NewIntent_CalldataExceedsLimit();
}
uint256 _normalizedAmount =
AssetUtils.normalizeDecimals(ERC20(_inputAsset).decimals(), Common.DEFAULT_NORMALIZED_DECIMALS, _amount);
// check normalized amount before pulling tokens
if (_normalizedAmount == 0) {
revert EverclearSpoke_NewIntent_ZeroAmount();
}
if (!_usesPermit2) {
Strategy _strategy = strategies[_inputAsset];
if (_strategy == Strategy.DEFAULT) {
_pullTokens(msg.sender, _inputAsset, _amount);
} else {
ISettlementModule _module = modules[_strategy];
_module.handleBurnStrategy(_inputAsset, msg.sender, _amount, '');
}
}
_intent = Intent({
initiator: msg.sender.toBytes32(),
receiver: _receiver.toBytes32(),
inputAsset: _inputAsset.toBytes32(),
outputAsset: _outputAsset.toBytes32(),
maxFee: _maxFee,
origin: DOMAIN,
nonce: ++nonce,
timestamp: uint48(block.timestamp),
ttl: _ttl,
amount: _normalizedAmount,
destinations: _destinations,
data: _data
});
_intentId = keccak256(abi.encode(_intent));
intentQueue.enqueueIntent(_intentId);
status[_intentId] = IntentStatus.ADDED;
emit IntentAdded(_intentId, intentQueue.last, _intent);
}
/**
* @notice Fills an intent
* @param _intent The intent structure
* @param _solver The solver address
* @param _fee The total fee, expressed in dbps, represents the solver fee plus the sum of protocol fees for the token
* @return _fillMessage The fill message
*/
function _fillIntent(
Intent calldata _intent,
address _solver,
uint24 _fee
) internal validDestination(_intent) returns (FillMessage memory _fillMessage) {
bytes32 _intentId = keccak256(abi.encode(_intent));
if (block.timestamp >= _intent.timestamp + _intent.ttl) {
revert EverclearSpoke_FillIntent_IntentExpired(_intentId);
}
if (_fee > _intent.maxFee) {
revert EverclearSpoke_FillIntent_MaxFeeExceeded(_fee, _intent.maxFee);
}
if (status[_intentId] != IntentStatus.NONE) {
revert EverclearSpoke_FillIntent_InvalidStatus(_intentId);
}
uint256 _amount = AssetUtils.normalizeDecimals(
Common.DEFAULT_NORMALIZED_DECIMALS, ERC20(_intent.outputAsset.toAddress()).decimals(), _intent.amount
);
uint256 _feeDeduction = _amount * _fee / Common.DBPS_DENOMINATOR;
uint256 _finalAmount = _amount - _feeDeduction;
if (balances[_intent.outputAsset][_solver.toBytes32()] < _finalAmount) {
revert EverclearSpoke_FillIntent_InsufficientFunds(
_finalAmount, balances[_intent.outputAsset][_solver.toBytes32()]
);
}
balances[_intent.outputAsset][_solver.toBytes32()] -= _finalAmount;
status[_intentId] = IntentStatus.FILLED;
if (_intent.receiver != 0 && _intent.outputAsset != 0 && _amount != 0) {
_pushTokens(_intent.receiver.toAddress(), _intent.outputAsset.toAddress(), _finalAmount);
}
if (keccak256(_intent.data) != Constants.EMPTY_HASH) {
_executeCalldata(_intentId, _intent.data);
}
_fillMessage = FillMessage({
intentId: _intentId,
initiator: _intent.initiator,
solver: _solver.toBytes32(),
executionTimestamp: uint48(block.timestamp),
fee: _fee
});
fillQueue.enqueueFill(_fillMessage);
emit IntentFilled(_intentId, _solver, _fee, fillQueue.last, _intent);
}
/**
* @notice Verifies a signature
* @param _signer The signer of the message
* @param _data The data of the message
* @param _nonce The nonce of the message
* @param _signature The signature of the message
*/
function _verifySignature(address _signer, bytes memory _data, uint256 _nonce, bytes calldata _signature) internal {
bytes32 _hash = keccak256(_data);
address _recoveredSigner = ECDSA.recover(MessageHashUtils.toEthSignedMessageHash(_hash), _signature);
if (_recoveredSigner != _signer) {
revert EverclearSpoke_InvalidSignature();
}
_useCheckedNonce(_recoveredSigner, _nonce);
}
/**
* @notice Process the intent queue messages to send a batching message to the transport layer
* @param _intents The intents to process, the order of the intents must match the order in the queue
* @return _batchIntentmessage The batched intent message
* @return _firstIdx The first index of the intents processed
*/
function _processIntentQueue(
Intent[] calldata _intents
)
internal
validQueueAmount(intentQueue.first, intentQueue.last, _intents.length)
returns (bytes memory _batchIntentmessage, uint256 _firstIdx)
{
_firstIdx = intentQueue.first;
for (uint32 _i; _i < _intents.length; _i++) {
bytes32 _queueIntentId = intentQueue.dequeueIntent();
bytes32 _intentHash = keccak256(abi.encode(_intents[_i]));
// verify the intent and its position in the queue
if (_queueIntentId != _intentHash) {
revert EverclearSpoke_ProcessIntentQueue_NotFound(_intentHash, _i);
}
}
_batchIntentmessage = MessageLib.formatIntentMessageBatch(_intents);
}
/**
* @notice Process the fill queue messages to send a batching message to the transport layer
* @param _amount The amount of messages to process
* @return _batchFillMessage The batched fill message
* @return _firstIdx The first index of the fills processed
*/
function _processFillQueue(
uint32 _amount
)
internal
validQueueAmount(fillQueue.first, fillQueue.last, _amount)
returns (bytes memory _batchFillMessage, uint256 _firstIdx)
{
_firstIdx = fillQueue.first;
FillMessage[] memory _fillMessages = new FillMessage[](_amount);
for (uint32 _i; _i < _amount; _i++) {
_fillMessages[_i] = fillQueue.dequeueFill();
}
_batchFillMessage = MessageLib.formatFillMessageBatch(_fillMessages);
}
/**
* @notice Executes the calldata of an intent
* @param _intentId The intent ID
* @param _data The calldata of the intent
*/
function _executeCalldata(bytes32 _intentId, bytes memory _data) internal {
(address _target, bytes memory _calldata) = abi.decode(_data, (address, bytes));
(bool _success, bytes memory _returnData) = callExecutor.excessivelySafeCall(
_target, gasleft() - Constants.EXECUTE_CALLDATA_RESERVE_GAS, 0, Constants.DEFAULT_COPY_BYTES, _calldata
);
if (_success) {
emit ExternalCalldataExecuted(_intentId, _returnData);
} else {
revert EverclearSpoke_ExecuteIntentCalldata_ExternalCallFailed();
}
}
/**
* @notice Pull tokens from the sender to the spoke contract
* @param _sender The address of the sender
* @param _asset The address of the asset
* @param _amount The amount of the asset
*/
function _pullTokens(address _sender, address _asset, uint256 _amount) internal {
IERC20(_asset).safeTransferFrom(_sender, address(this), _amount);
}
/**
* @notice Push tokens from the spoke contract to the recipient
* @param _recipient The address of the recipient
* @param _asset The address of the asset
* @param _amount The amount of the asset
*/
function _pushTokens(address _recipient, address _asset, uint256 _amount) internal {
IERC20(_asset).safeTransfer(_recipient, _amount);
}
/**
* @notice Perform a `delegatcall`
* @param _delegatee The address of the delegatee
*/
function _delegate(
address _delegatee
) internal {
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(), _delegatee, 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()) }
}
}
/**
* @notice Checks that the upgrade function is called by the owner
*/
function _authorizeUpgrade(
address
) internal override onlyOwner {}
/**
* @notice Process queue checks (applied when a relayer tries to process a queue)
* @param _domain The domain of the queue
* @param _relayer The relayer address
* @param _ttl The time to live of the message
*/
function _processQueueChecks(uint32 _domain, address _relayer, uint256 _ttl) internal view {
if (_domain != DOMAIN) {
revert EverclearSpoke_ProcessFillViaRelayer_WrongDomain();
}
if (_relayer != msg.sender) {
revert EverclearSpoke_ProcessFillViaRelayer_NotRelayer();
}
if (block.timestamp > _ttl) {
revert EverclearSpoke_ProcessFillViaRelayer_TTLExpired();
}
}
}
// 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/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.0) (utils/Nonces.sol)
pragma solidity ^0.8.20;
import {Initializable} from "../proxy/utils/Initializable.sol";
/**
* @dev Provides tracking nonces for addresses. Nonces will only increment.
*/
abstract contract NoncesUpgradeable is Initializable {
/**
* @dev The nonce used for an `account` is not the expected current nonce.
*/
error InvalidAccountNonce(address account, uint256 currentNonce);
/// @custom:storage-location erc7201:openzeppelin.storage.Nonces
struct NoncesStorage {
mapping(address account => uint256) _nonces;
}
// keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Nonces")) - 1)) & ~bytes32(uint256(0xff))
bytes32 private constant NoncesStorageLocation = 0x5ab42ced628888259c08ac98db1eb0cf702fc1501344311d8b100cd1bfe4bb00;
function _getNoncesStorage() private pure returns (NoncesStorage storage $) {
assembly {
$.slot := NoncesStorageLocation
}
}
function __Nonces_init() internal onlyInitializing {
}
function __Nonces_init_unchained() internal onlyInitializing {
}
/**
* @dev Returns the next unused nonce for an address.
*/
function nonces(address owner) public view virtual returns (uint256) {
NoncesStorage storage $ = _getNoncesStorage();
return $._nonces[owner];
}
/**
* @dev Consumes a nonce.
*
* Returns the current value and increments nonce.
*/
function _useNonce(address owner) internal virtual returns (uint256) {
NoncesStorage storage $ = _getNoncesStorage();
// For each account, the nonce has an initial value of 0, can only be incremented by one, and cannot be
// decremented or reset. This guarantees that the nonce never overflows.
unchecked {
// It is important to do x++ and not ++x here.
return $._nonces[owner]++;
}
}
/**
* @dev Same as {_useNonce} but checking that `nonce` is the next valid for `owner`.
*/
function _useCheckedNonce(address owner, uint256 nonce) internal virtual {
uint256 current = _useNonce(owner);
if (nonce != current) {
revert InvalidAccountNonce(owner, current);
}
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/ERC20.sol)
pragma solidity ^0.8.20;
import {IERC20} from "./IERC20.sol";
import {IERC20Metadata} from "./extensions/IERC20Metadata.sol";
import {Context} from "../../utils/Context.sol";
import {IERC20Errors} from "../../interfaces/draft-IERC6093.sol";
/**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
*
* TIP: For a detailed writeup see our guide
* https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* The default value of {decimals} is 18. To change this, you should override
* this function so it returns a different value.
*
* We have followed general OpenZeppelin Contracts guidelines: functions revert
* instead returning `false` on failure. This behavior is nonetheless
* conventional and does not conflict with the expectations of ERC20
* applications.
*
* Additionally, an {Approval} event is emitted on calls to {transferFrom}.
* This allows applications to reconstruct the allowance for all accounts just
* by listening to said events. Other implementations of the EIP may not emit
* these events, as it isn't required by the specification.
*/
abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors {
mapping(address account => uint256) private _balances;
mapping(address account => mapping(address spender => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {symbol}.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual returns (string memory) {
return _symbol;
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5.05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the default value returned by this function, unless
* it's overridden.
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual returns (uint8) {
return 18;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual returns (uint256) {
return _balances[account];
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - the caller must have a balance of at least `value`.
*/
function transfer(address to, uint256 value) public virtual returns (bool) {
address owner = _msgSender();
_transfer(owner, to, value);
return true;
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual returns (uint256) {
return _allowances[owner][spender];
}
/**
* @dev See {IERC20-approve}.
*
* NOTE: If `value` is the maximum `uint256`, the allowance is not updated on
* `transferFrom`. This is semantically equivalent to an infinite approval.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 value) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, value);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* NOTE: Does not update the allowance if the current allowance
* is the maximum `uint256`.
*
* Requirements:
*
* - `from` and `to` cannot be the zero address.
* - `from` must have a balance of at least `value`.
* - the caller must have allowance for ``from``'s tokens of at least
* `value`.
*/
function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, value);
_transfer(from, to, value);
return true;
}
/**
* @dev Moves a `value` amount of tokens from `from` to `to`.
*
* This internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* NOTE: This function is not virtual, {_update} should be overridden instead.
*/
function _transfer(address from, address to, uint256 value) internal {
if (from == address(0)) {
revert ERC20InvalidSender(address(0));
}
if (to == address(0)) {
revert ERC20InvalidReceiver(address(0));
}
_update(from, to, value);
}
/**
* @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`
* (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding
* this function.
*
* Emits a {Transfer} event.
*/
function _update(address from, address to, uint256 value) internal virtual {
if (from == address(0)) {
// Overflow check required: The rest of the code assumes that totalSupply never overflows
_totalSupply += value;
} else {
uint256 fromBalance = _balances[from];
if (fromBalance < value) {
revert ERC20InsufficientBalance(from, fromBalance, value);
}
unchecked {
// Overflow not possible: value <= fromBalance <= totalSupply.
_balances[from] = fromBalance - value;
}
}
if (to == address(0)) {
unchecked {
// Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.
_totalSupply -= value;
}
} else {
unchecked {
// Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.
_balances[to] += value;
}
}
emit Transfer(from, to, value);
}
/**
* @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).
* Relies on the `_update` mechanism
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* NOTE: This function is not virtual, {_update} should be overridden instead.
*/
function _mint(address account, uint256 value) internal {
if (account == address(0)) {
revert ERC20InvalidReceiver(address(0));
}
_update(address(0), account, value);
}
/**
* @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.
* Relies on the `_update` mechanism.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* NOTE: This function is not virtual, {_update} should be overridden instead
*/
function _burn(address account, uint256 value) internal {
if (account == address(0)) {
revert ERC20InvalidSender(address(0));
}
_update(account, address(0), value);
}
/**
* @dev Sets `value` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*
* Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
*/
function _approve(address owner, address spender, uint256 value) internal {
_approve(owner, spender, value, true);
}
/**
* @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.
*
* By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by
* `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any
* `Approval` event during `transferFrom` operations.
*
* Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to
* true using the following override:
* ```
* function _approve(address owner, address spender, uint256 value, bool) internal virtual override {
* super._approve(owner, spender, value, true);
* }
* ```
*
* Requirements are the same as {_approve}.
*/
function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {
if (owner == address(0)) {
revert ERC20InvalidApprover(address(0));
}
if (spender == address(0)) {
revert ERC20InvalidSpender(address(0));
}
_allowances[owner][spender] = value;
if (emitEvent) {
emit Approval(owner, spender, value);
}
}
/**
* @dev Updates `owner` s allowance for `spender` based on spent `value`.
*
* Does not update the allowance value in case of infinite allowance.
* Revert if not enough allowance is available.
*
* Does not emit an {Approval} event.
*/
function _spendAllowance(address owner, address spender, uint256 value) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
if (currentAllowance < value) {
revert ERC20InsufficientAllowance(spender, currentAllowance, value);
}
unchecked {
_approve(owner, spender, currentAllowance - value, false);
}
}
}
}
// 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) (token/ERC20/utils/SafeERC20.sol)
pragma solidity ^0.8.20;
import {IERC20} from "../IERC20.sol";
import {IERC20Permit} from "../extensions/IERC20Permit.sol";
import {Address} from "../../../utils/Address.sol";
/**
* @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 An operation with an ERC20 token failed.
*/
error SafeERC20FailedOperation(address token);
/**
* @dev Indicates a failed `decreaseAllowance` request.
*/
error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);
/**
* @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.encodeCall(token.transfer, (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.encodeCall(token.transferFrom, (from, to, 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);
forceApprove(token, spender, oldAllowance + value);
}
/**
* @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
* value, non-reverting calls are assumed to be successful.
*/
function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
unchecked {
uint256 currentAllowance = token.allowance(address(this), spender);
if (currentAllowance < requestedDecrease) {
revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
}
forceApprove(token, spender, currentAllowance - requestedDecrease);
}
}
/**
* @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.encodeCall(token.approve, (spender, value));
if (!_callOptionalReturnBool(token, approvalCall)) {
_callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
_callOptionalReturn(token, approvalCall);
}
}
/**
* @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);
if (returndata.length != 0 && !abi.decode(returndata, (bool))) {
revert SafeERC20FailedOperation(address(token));
}
}
/**
* @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(token).code.length > 0;
}
}
// 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
pragma solidity 0.8.23;
/**
* @title AssetUtils
* @notice Library for asset utility functions
*/
library AssetUtils {
/**
* @notice This function translates the _amount in _in decimals
* to _out decimals
*
* @param _in The decimals of the asset in / amount in
* @param _out The decimals of the target asset
* @param _amount The value to normalize to the `_out` decimals
* @return _normalized Normalized decimals.
*/
function normalizeDecimals(uint8 _in, uint8 _out, uint256 _amount) internal pure returns (uint256 _normalized) {
if (_in == _out) {
return _amount;
}
// Convert this value to the same decimals as _out
if (_in < _out) {
_normalized = _amount * (10 ** (_out - _in));
} else {
_normalized = _amount / (10 ** (_in - _out));
}
}
/**
* @notice Get the hash of an asset
* @param _asset The address of the asset
* @param _domain The domain of the asset
* @return _assetHash The hash of the asset
*/
function getAssetHash(bytes32 _asset, uint32 _domain) internal pure returns (bytes32 _assetHash) {
return keccak256(abi.encode(_asset, _domain));
}
}
// SPDX-License-Identifier: MIT
pragma solidity 0.8.23;
library Constants {
// Default normalized decimals for tokens
uint8 public constant DEFAULT_NORMALIZED_DECIMALS = 18;
// 1/10 of a basis point denominator
uint24 public constant DBPS_DENOMINATOR = 100_000;
// Precomputed hashes (reduce gas costs)
bytes32 public constant GATEWAY_HASH = keccak256(abi.encode('GATEWAY'));
bytes32 public constant MAILBOX_HASH = keccak256(abi.encode('MAILBOX'));
bytes32 public constant LIGHTHOUSE_HASH = keccak256(abi.encode('LIGHTHOUSE'));
bytes32 public constant WATCHTOWER_HASH = keccak256(abi.encode('WATCHTOWER'));
bytes32 public constant MAX_FEE_HASH = keccak256(abi.encode('MAX_FEE'));
bytes32 public constant INTENT_TTL_HASH = keccak256(abi.encode('INTENT_TTL'));
// Default gas limit for external calls
uint256 public constant DEFAULT_GAS_LIMIT = 50_000;
// Maximum calldata size for external calls
uint256 public constant MAX_CALLDATA_SIZE = 50_000;
}
// SPDX-License-Identifier: MIT
pragma solidity 0.8.23;
import {IEverclear} from 'interfaces/common/IEverclear.sol';
library MessageLib {
/*//////////////////////////////////////////////////////////////
ENUMS
//////////////////////////////////////////////////////////////*/
/**
* @dev Enum for message types
* INTENT: Intent message type
* FILL: Fill message type
* SETTLEMENT: Settlement message type
* VAR_UPDATE: Variable update message type
*/
enum MessageType {
INTENT,
FILL,
SETTLEMENT,
VAR_UPDATE
}
/*//////////////////////////////////////////////////////////////
GENERAL PURPOSE FUNCTIONS
//////////////////////////////////////////////////////////////*/
/**
* @dev Formats a message with a message type and data
* @param _messageType The message type
* @param _data The data to send in the message
* @return _message The formatted message
*/
function formatMessage(MessageType _messageType, bytes memory _data) internal pure returns (bytes memory _message) {
_message = abi.encode(uint8(_messageType), _data);
}
/**
* @dev Parses a message into its message type and data
* @param _message The message to parse
* @return _messageType The message type
* @return _data The data in the message
*/
function parseMessage(
bytes memory _message
) internal pure returns (MessageType _messageType, bytes memory _data) {
uint8 _msgTypeNumber;
(_msgTypeNumber, _data) = abi.decode(_message, (uint8, bytes));
_messageType = MessageType(_msgTypeNumber);
}
/*//////////////////////////////////////////////////////////////
MESSAGE FORMATTING
//////////////////////////////////////////////////////////////*/
/**
* @dev Formats an intent message
* @param _intents Array of intents
* @return _message The formatted intent message
*/
function formatIntentMessageBatch(
IEverclear.Intent[] memory _intents
) internal pure returns (bytes memory _message) {
_message = formatMessage(MessageType.INTENT, abi.encode(_intents));
}
/**
* @dev Formats a fill message
* @param _fillMessages Array of fill messages
* @return _message The formatted fill message
*/
function formatFillMessageBatch(
IEverclear.FillMessage[] memory _fillMessages
) internal pure returns (bytes memory _message) {
_message = formatMessage(MessageType.FILL, abi.encode(_fillMessages));
}
/**
* @dev Formats a settlement message
* @param _settlementMessages Array of settlement messages
* @return _message The formatted settlement message
*/
function formatSettlementBatch(
IEverclear.Settlement[] memory _settlementMessages
) internal pure returns (bytes memory _message) {
_message = formatMessage(MessageType.SETTLEMENT, abi.encode(_settlementMessages));
}
/**
* @dev Formats a var update message
* @param _data The data (encoded variable)
* @return _message The formatted var update message
*/
function formatVarUpdateMessage(
bytes memory _data
) internal pure returns (bytes memory _message) {
_message = formatMessage(MessageType.VAR_UPDATE, _data);
}
/**
* @dev Formats an address updating message (Mailbox, SecurityModule, Gateway)
* @param _updateVariable the name of the variable being updated
* @param _address The new address
* @return _message The formatted address update message
*/
function formatAddressUpdateMessage(
bytes32 _updateVariable,
bytes32 _address
) internal pure returns (bytes memory _message) {
_message = formatVarUpdateMessage(abi.encode(_updateVariable, abi.encode(_address)));
}
/**
* @dev Formats a uint updating message (MaxRoutersFee)
* @param _updateVariable the hashed name of the variable being updated
* @param _value The new value
* @return _message The formatted uint update message
*/
function formatUintUpdateMessage(
bytes32 _updateVariable,
uint256 _value
) internal pure returns (bytes memory _message) {
_message = formatVarUpdateMessage(abi.encode(_updateVariable, abi.encode(_value)));
}
/*//////////////////////////////////////////////////////////////
MESSAGE PARSING
//////////////////////////////////////////////////////////////*/
/**
* @dev Parses an intent message
* @param _data The intent message data
* @return _intents Array of decoded intents
*/
function parseIntentMessageBatch(
bytes memory _data
) internal pure returns (IEverclear.Intent[] memory _intents) {
(_intents) = abi.decode(_data, (IEverclear.Intent[]));
}
/**
* @dev Parses a fill message
* @param _data The packed fill message data
* @return _fillMessages Array of fill messages
*/
function parseFillMessageBatch(
bytes memory _data
) internal pure returns (IEverclear.FillMessage[] memory _fillMessages) {
(_fillMessages) = abi.decode(_data, (IEverclear.FillMessage[]));
}
/**
* @dev Parses a settlement message
* @param _data The packed settlement message data
* @return _settlementMessages Array of settlement messages
*/
function parseSettlementBatch(
bytes memory _data
) internal pure returns (IEverclear.Settlement[] memory _settlementMessages) {
(_settlementMessages) = abi.decode(_data, (IEverclear.Settlement[]));
}
/**
* @dev Parses a var update message
* @param _data The abi encoded variable
* @return _updateVariable The hashed name of the variable being updated
* @return _varData The encoded variable data
*/
function parseVarUpdateMessage(
bytes memory _data
) internal pure returns (bytes32 _updateVariable, bytes memory _varData) {
(_updateVariable, _varData) = abi.decode(_data, (bytes32, bytes));
}
/**
* @dev Parses an address update message
* @param _data The abi encoded address
* @return _address The decoded address
*/
function parseAddressUpdateMessage(
bytes memory _data
) internal pure returns (bytes32 _address) {
_address = abi.decode(_data, (bytes32));
}
/**
* @dev Parses a uint update message
* @param _data The abi encoded uint
* @return _value The decoded uint
*/
function parseUintUpdateMessage(
bytes memory _data
) internal pure returns (uint256 _value) {
_value = abi.decode(_data, (uint256));
}
}
// SPDX-License-Identifier: MIT
pragma solidity 0.8.23;
import {IEverclear} from 'interfaces/common/IEverclear.sol';
/**
* @title QueueLib
* @notice Library for managing queues
*/
library QueueLib {
/**
* @notice Structure for the IntentQueue
* @dev first should always be initialized to 1
* @param first The first position in the queue
* @param last The last position in the queue
* @param queue The queue of intent ids
*/
struct IntentQueue {
uint256 first;
uint256 last;
mapping(uint256 _position => bytes32 _intentId) queue;
}
/**
* @notice Structure for the FillQueue
* @dev Member first should always be initialized to 1
* @param first The first position in the queue
* @param last The last position in the queue
* @param queue The queue of fill messages
*/
struct FillQueue {
uint256 first;
uint256 last;
mapping(uint256 _position => IEverclear.FillMessage _fillMessage) queue;
}
/**
* @notice Thrown when the queue is empty
*/
error Queue_EmptyQueue();
/**
* @notice Enqueue an intent id to the IntentQueue
* @param _queue The IntentQueue
* @param _intentId The intent id to enqueue
*/
function enqueueIntent(IntentQueue storage _queue, bytes32 _intentId) internal {
_queue.last += 1;
_queue.queue[_queue.last] = _intentId;
}
/**
* @notice Enqueue a fill message to the FillQueue
* @param _queue The FillQueue
* @param _fillMessage The fill message to enqueue
*/
function enqueueFill(FillQueue storage _queue, IEverclear.FillMessage memory _fillMessage) internal {
_queue.last += 1;
_queue.queue[_queue.last] = _fillMessage;
}
/**
* @notice Dequeue an intent id from the IntentQueue
* @param _queue The IntentQueue
* @return _intentId The dequeued intent id
*/
function dequeueIntent(
IntentQueue storage _queue
) internal returns (bytes32 _intentId) {
// non-empty queue check
if (_queue.last < _queue.first) revert Queue_EmptyQueue();
_intentId = _queue.queue[_queue.first];
delete _queue.queue[_queue.first];
_queue.first += 1;
}
/**
* @notice Dequeue a fill message from the FillQueue
* @param _queue The FillQueue
* @return _fillMessage The dequeued fill message
*/
function dequeueFill(
FillQueue storage _queue
) internal returns (IEverclear.FillMessage memory _fillMessage) {
// non-empty queue
if (_queue.last < _queue.first) revert Queue_EmptyQueue();
_fillMessage = _queue.queue[_queue.first];
delete _queue.queue[_queue.first];
_queue.first += 1;
}
}
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity 0.8.23;
/**
* @title TypeCasts
* @notice Library for type casts
*/
library TypeCasts {
// alignment preserving cast
/**
* @notice Cast an address to a bytes32
* @param _addr The address to cast
*/
function toBytes32(
address _addr
) internal pure returns (bytes32) {
return bytes32(uint256(uint160(_addr)));
}
// alignment preserving cast
/**
* @notice Cast a bytes32 to an address
* @param _buf The bytes32 to cast
*/
function toAddress(
bytes32 _buf
) internal pure returns (address) {
return address(uint160(uint256(_buf)));
}
}
// SPDX-License-Identifier: MIT
pragma solidity 0.8.23;
library Constants {
// Reserved gas required after the calldata execution
uint256 public constant EXECUTE_CALLDATA_RESERVE_GAS = 10_000;
// Bytes to copy from the calldata
uint16 public constant DEFAULT_COPY_BYTES = 256;
// The empty hash
bytes32 public constant EMPTY_HASH = keccak256('');
}
// SPDX-License-Identifier: MIT
pragma solidity 0.8.23;
/**
* @title IEverclear
* @notice Common interface for EverclearHub and EverclearSpoke
*/
interface IEverclear {
/*//////////////////////////////////////////////////////////////
ENUMS
//////////////////////////////////////////////////////////////*/
/**
* @notice Enum representing statuses of an intent
*/
enum IntentStatus {
NONE, // 0
ADDED, // 1
DEPOSIT_PROCESSED, // 2
FILLED, // 3
ADDED_AND_FILLED, // 4
INVOICED, // 5
SETTLED, // 6
SETTLED_AND_MANUALLY_EXECUTED, // 7
UNSUPPORTED, // 8
UNSUPPORTED_RETURNED // 9
}
/**
* @notice Enum representing asset strategies
*/
enum Strategy {
DEFAULT,
XERC20
}
/*///////////////////////////////////////////////////////////////
STRUCTS
//////////////////////////////////////////////////////////////*/
/**
* @notice The structure of an intent
* @param initiator The address of the intent initiator
* @param receiver The address of the intent receiver
* @param inputAsset The address of the intent asset on origin
* @param outputAsset The address of the intent asset on destination
* @param maxFee The maximum fee that can be taken by solvers
* @param origin The origin chain of the intent
* @param destinations The possible destination chains of the intent
* @param nonce The nonce of the intent
* @param timestamp The timestamp of the intent
* @param ttl The time to live of the intent
* @param amount The amount of the intent asset normalized to 18 decimals
* @param data The data of the intent
*/
struct Intent {
bytes32 initiator;
bytes32 receiver;
bytes32 inputAsset;
bytes32 outputAsset;
uint24 maxFee;
uint32 origin;
uint64 nonce;
uint48 timestamp;
uint48 ttl;
uint256 amount;
uint32[] destinations;
bytes data;
}
/**
* @notice The structure of a fill message
* @param intentId The ID of the intent
* @param solver The address of the intent solver in bytes32 format
* @param initiator The address of the intent initiator
* @param fee The total fee of the expressed in dbps, represents the solver fee plus the sum of protocol fees for the token
* @param executionTimestamp The execution timestamp of the intent
*/
struct FillMessage {
bytes32 intentId;
bytes32 solver;
bytes32 initiator;
uint24 fee;
uint48 executionTimestamp;
}
/**
* @notice The structure of a settlement
* @param intentId The ID of the intent
* @param amount The amount of the asset
* @param asset The address of the asset
* @param recipient The address of the recipient
* @param updateVirtualBalance If set to true, the settlement will not be transferred to the recipient in spoke domain and the virtual balance will be increased
*/
struct Settlement {
bytes32 intentId;
uint256 amount;
bytes32 asset;
bytes32 recipient;
bool updateVirtualBalance;
}
}
// SPDX-License-Identifier: MIT
pragma solidity 0.8.23;
/**
* @title IMessageReceiver
* @notice Interface for the transport layer communication with the message receiver
*/
interface IMessageReceiver {
/*///////////////////////////////////////////////////////////////
LOGIC
//////////////////////////////////////////////////////////////*/
/**
* @notice Receive a message from the transport layer
* @param _message The message to receive encoded as bytes
* @dev This function should be called by the the gateway contract
*/
function receiveMessage(
bytes calldata _message
) external;
}
// SPDX-License-Identifier: MIT
pragma solidity 0.8.23;
import {IERC20} from '@openzeppelin/contracts/token/ERC20/IERC20.sol';
/**
* @title IPermit2
* @notice Interface for permit2
*/
interface IPermit2 {
/*///////////////////////////////////////////////////////////////
STRUCTS
//////////////////////////////////////////////////////////////*/
/**
* @notice Struct for token and amount in a permit message
* @param token The token to transfer
* @param amount The amount to transfer
*/
struct TokenPermissions {
IERC20 token;
uint256 amount;
}
/**
* @notice Struct for the permit2 message
* @param permitted The permitted token and amount
* @param nonce The unique identifier for this permit
* @param deadline The expiration for this permit
*/
struct PermitTransferFrom {
TokenPermissions permitted;
uint256 nonce;
uint256 deadline;
}
/**
* @notice Struct for the transfer details for permitTransferFrom()
* @param to The recipient of the tokens
* @param requestedAmount The amount to transfer
*/
struct SignatureTransferDetails {
address to;
uint256 requestedAmount;
}
/*///////////////////////////////////////////////////////////////
LOGIC
//////////////////////////////////////////////////////////////*/
/**
* @notice Consume a permit2 message and transfer tokens
* @param permit The permit message
* @param transferDetails The transfer details
* @param owner The owner of the tokens
* @param signature The signature of the permit
*/
function permitTransferFrom(
PermitTransferFrom calldata permit,
SignatureTransferDetails calldata transferDetails,
address owner,
bytes calldata signature
) external;
}
// SPDX-License-Identifier: MIT
pragma solidity 0.8.23;
/**
* @title ISettlementModule
* @notice Interface for the base settlement module
*/
interface ISettlementModule {
/*///////////////////////////////////////////////////////////////
LOGIC
//////////////////////////////////////////////////////////////*/
/**
* @notice Handle a mint action for a specific strategy
* @param _asset The address of the asset to mint
* @param _recipient The recipient of the minted assets
* @param _fallbackRecipient The fallback recipient of the minted assets (in case of failure)
* @param _amount The amount to mint
* @param _data Extra data needed by some modules
* @return _success The outcome of the minting strategy
* @dev In case of failure, the parent module will handle the operation accordingly
*/
function handleMintStrategy(
address _asset,
address _recipient,
address _fallbackRecipient,
uint256 _amount,
bytes calldata _data
) external returns (bool _success);
/**
* @notice Handle a burn action for a specific strategy
* @param _asset The address of the asset to burn
* @param _user The user whose assets are being burned
* @param _amount The amount to burn
* @param _data Extra data needed by some modules
* @dev In case of failure, the `newIntent` flow will revert
*/
function handleBurnStrategy(address _asset, address _user, uint256 _amount, bytes calldata _data) external;
}
// SPDX-License-Identifier: MIT
pragma solidity 0.8.23;
import {IEverclear} from 'interfaces/common/IEverclear.sol';
import {ISettlementModule} from 'interfaces/common/ISettlementModule.sol';
import {ISpokeStorage} from './ISpokeStorage.sol';
/**
* @title IEverclearSpoke
* @notice Interface for the EverclearSpoke contract
*/
interface IEverclearSpoke is ISpokeStorage {
/*///////////////////////////////////////////////////////////////
STRUCTS
//////////////////////////////////////////////////////////////*/
/**
* @notice Parameters needed to execute a permit2
* @param nonce The nonce of the permit
* @param deadline The deadline of the permit
* @param signature The signature of the permit
*/
struct Permit2Params {
uint256 nonce;
uint256 deadline;
bytes signature;
}
/*///////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////*/
/**
* @notice emitted when a new intent is added on origin
* @param _intentId The ID of the intent
* @param _queueIdx The index of the intent in the IntentQueue
* @param _intent The intent object
*/
event IntentAdded(bytes32 indexed _intentId, uint256 _queueIdx, Intent _intent);
/**
* @notice emitted when an intent is filled on destination
* @param _intentId The ID of the intent
* @param _solver The address of the intent solver
* @param _totalFeeDBPS The total amount of fee deducted from the transferred amount
* @param _queueIdx The index of the FillMessage in the FillQueue
* @param _intent The full intent object
*/
event IntentFilled(
bytes32 indexed _intentId, address indexed _solver, uint256 _totalFeeDBPS, uint256 _queueIdx, Intent _intent
);
/**
* @notice emitted when solver (or anyone) deposits an asset in the EverclearSpoke
* @param _depositant The address of the depositant
* @param _asset The address of the deposited asset
* @param _amount The amount of the deposited asset
*/
event Deposited(address indexed _depositant, address indexed _asset, uint256 _amount);
/**
* @notice emitted when solver (or anyone) withdraws an asset from the EverclearSpoke
* @param _withdrawer The address of the withdrawer
* @param _asset The address of the withdrawn asset
* @param _amount The amount of the withdrawn asset
*/
event Withdrawn(address indexed _withdrawer, address indexed _asset, uint256 _amount);
/**
* @notice Emitted when the intent queue is processed
* @param _messageId The ID of the message
* @param _firstIdx The first index of the queue to be processed
* @param _lastIdx The last index of the queue to be processed
* @param _quote The quote amount
*/
event IntentQueueProcessed(bytes32 indexed _messageId, uint256 _firstIdx, uint256 _lastIdx, uint256 _quote);
/**
* @notice Emitted when the fill queue is processed
* @param _messageId The ID of the message
* @param _firstIdx The first index of the queue to be processed
* @param _lastIdx The last index of the queue to be processed
* @param _quote The quote amount
*/
event FillQueueProcessed(bytes32 indexed _messageId, uint256 _firstIdx, uint256 _lastIdx, uint256 _quote);
/**
* @notice Emitted when an external call is executed
* @param _intentId The ID of the intent
* @param _returnData The return data of the call
*/
event ExternalCalldataExecuted(bytes32 indexed _intentId, bytes _returnData);
/*///////////////////////////////////////////////////////////////
ERRORS
//////////////////////////////////////////////////////////////*/
/**
* @notice Thrown when the intent is already filled
* @param _intentId The id of the intent which is being tried to fill
*/
error EverclearSpoke_FillIntent_InvalidStatus(bytes32 _intentId);
/**
* @notice Thrown when trying to fill an expired intent
* @param _intentId The id of the intent which is being tried to fill
*/
error EverclearSpoke_FillIntent_IntentExpired(bytes32 _intentId);
/**
* @notice Thrown when calling newIntent with invalid intent parameters
*/
error EverclearSpoke_NewIntent_InvalidIntent();
/**
* @notice Thrown when the maxFee is exceeded
* @param _fee The fee chosen by the user
* @param _maxFee The maximum possible fee
*/
error EverclearSpoke_NewIntent_MaxFeeExceeded(uint256 _fee, uint24 _maxFee);
/**
* @notice Thrown when the intent amount is zero
*/
error EverclearSpoke_NewIntent_ZeroAmount();
/**
* @notice Thrown when the solver doesnt have sufficient funds to fill an intent
* @param _requested The amount of tokens needed to fill the intent
* @param _available The amount of tokens the solver has deposited in the `EverclearSpoke`
*/
error EverclearSpoke_FillIntent_InsufficientFunds(uint256 _requested, uint256 _available);
/**
* @notice Thrown when the fee exceeds the maximum fee
* @param _fee The fee chosen by the solver
* @param _maxFee The actual fee the intent solver set for his intent
*/
error EverclearSpoke_FillIntent_MaxFeeExceeded(uint256 _fee, uint24 _maxFee);
/**
* @notice Thrown when the intent calldata exceeds the limit
*/
error EverclearSpoke_NewIntent_CalldataExceedsLimit();
/**
* @notice Thrown when a signature signer does not match the expected address
*/
error EverclearSpoke_InvalidSignature();
/**
* @notice Thrown when the domain does not match the expected domain
*/
error EverclearSpoke_ProcessFillViaRelayer_WrongDomain();
/**
* @notice Thrown when the relayer address does not match the msg.sender
*/
error EverclearSpoke_ProcessFillViaRelayer_NotRelayer();
/**
* @notice Thrown when the TTL of the message has expired
*/
error EverclearSpoke_ProcessFillViaRelayer_TTLExpired();
/**
* @notice Thrown when processing the intent queue and the intent is not found in the position specified in the parameter
* @param _intentId The id of the intent being processed
* @param _position The position specified by the queue processor
*/
error EverclearSpoke_ProcessIntentQueue_NotFound(bytes32 _intentId, uint256 _position);
/**
* @notice Thrown when trying to execute the calldata of an intent with invalid status
* @param _intentId The id of the intent whose calldata is trying to be executed
*/
error EverclearSpoke_ExecuteIntentCalldata_InvalidStatus(bytes32 _intentId);
/**
* @notice Thrown when the external call failed on executeIntentCalldata
*/
error EverclearSpoke_ExecuteIntentCalldata_ExternalCallFailed();
/*///////////////////////////////////////////////////////////////
LOGIC
//////////////////////////////////////////////////////////////*/
/**
* @notice Pauses the contract
* @dev only the lighthouse and watchtower can pause the contract
*/
function pause() external;
/**
* @notice Unpauses the contract
* @dev only the lighthouse and watchtower can unpause the contract
*/
function unpause() external;
/**
* @notice Sets a minting / burning strategy for an asset
* @param _asset The asset address
* @param _strategy The strategy id (see `enum Strategy`)
*/
function setStrategyForAsset(address _asset, IEverclear.Strategy _strategy) external;
/**
* @notice Sets a module for a strategy
* @param _strategy The strategy id (see `enum Strategy`)
* @param _module The module contract
*/
function setModuleForStrategy(IEverclear.Strategy _strategy, ISettlementModule _module) external;
/**
* @notice Updates the security module
* @param _newSecurityModule The address of the new security module
*/
function updateSecurityModule(
address _newSecurityModule
) external;
/**
* @notice Initialize the EverclearSpoke contract
* @param _init The spoke initialization parameters
*/
function initialize(
SpokeInitializationParams calldata _init
) external;
/**
* @notice Creates a new intent
* @param _destinations The possible destination chains of the intent
* @param _receiver The destinantion address of the intent
* @param _inputAsset The asset address on origin
* @param _outputAsset The asset address on destination
* @param _amount The amount of the asset
* @param _maxFee The maximum fee that can be taken by solvers
* @param _ttl The time to live of the intent
* @param _data The data of the intent
* @return _intentId The ID of the intent
* @return _intent The intent object
*/
function newIntent(
uint32[] memory _destinations,
address _receiver,
address _inputAsset,
address _outputAsset,
uint256 _amount,
uint24 _maxFee,
uint48 _ttl,
bytes calldata _data
) external returns (bytes32 _intentId, Intent calldata _intent);
/**
* @notice Creates a new intent with permit2
* @param _destinations The possible destination chains of the intent
* @param _receiver The destinantion address of the intent
* @param _inputAsset The asset address on origin
* @param _outputAsset The asset address on destination
* @param _amount The amount of the asset
* @param _maxFee The maximum fee that can be taken by solvers
* @param _ttl The time to live of the intent
* @param _data The data of the intent
* @param _permit2Params The parameters needed to execute a permit2
* @return _intentId The ID of the intent
* @return _intent The intent object
*/
function newIntent(
uint32[] memory _destinations,
address _receiver,
address _inputAsset,
address _outputAsset,
uint256 _amount,
uint24 _maxFee,
uint48 _ttl,
bytes calldata _data,
Permit2Params calldata _permit2Params
) external returns (bytes32 _intentId, Intent calldata _intent);
/**
* @notice fills an intent
* @param _intent The intent structure
* @param _fee The total fee, expressed in dbps, represents the solver fee plus the sum of protocol fees for the token
* @return _fillMessage The enqueued fill message
*/
function fillIntent(Intent calldata _intent, uint24 _fee) external returns (FillMessage calldata _fillMessage);
/**
* @notice Allows a relayer to fill an intent for a solver
* @param _solver The address of the solver
* @param _intent The intent structure
* @param _nonce The nonce of the signature
* @param _fee The total fee, expressed in dbps, represents the solver fee plus the sum of protocol fees for the token
* @param _signature The solver signature
* @return _fillMessage The enqueued fill message
*/
function fillIntentForSolver(
address _solver,
Intent calldata _intent,
uint256 _nonce,
uint24 _fee,
bytes calldata _signature
) external returns (FillMessage memory _fillMessage);
/**
* @notice Process the intent queue messages to send a batched message to the transport layer
* @param _intents The intents to process, must respect the intent queue order
*/
function processIntentQueue(
Intent[] calldata _intents
) external payable;
/**
* @notice Process the fill queue messages to send a batched message to the transport layer
* @param _amount The amount of messages to process and batch
*/
function processFillQueue(
uint32 _amount
) external payable;
/**
* @notice Process the intent queue messages to send a batched message to the transport layer (via relayer)
* @param _domain The domain of the message
* @param _intents The intents to process, must respect the intent queue order
* @param _relayer The address of the relayer
* @param _ttl The time to live of the message
* @param _nonce The nonce of the signature
* @param _bufferDBPS The buffer in DBPS to add to the fee
* @param _signature The signature of the data
*/
function processIntentQueueViaRelayer(
uint32 _domain,
Intent[] calldata _intents,
address _relayer,
uint256 _ttl,
uint256 _nonce,
uint256 _bufferDBPS,
bytes calldata _signature
) external;
/**
* @notice Process the fill queue messages to send a batched message to the transport layer (via relayer)
* @param _domain The domain of the message
* @param _amount The amount of messages to process and batch
* @param _relayer The address of the relayer
* @param _ttl The time to live of the message
* @param _nonce The nonce of the signature
* @param _bufferDBPS The buffer in DBPS to add to the fee
* @param _signature The signature of the data
*/
function processFillQueueViaRelayer(
uint32 _domain,
uint32 _amount,
address _relayer,
uint256 _ttl,
uint256 _nonce,
uint256 _bufferDBPS,
bytes calldata _signature
) external;
/**
* @notice deposits an asset into the EverclearSpoke
* @dev should be only called by solvers but it is permissionless, the funds will be used by the solvers to execute intents
* @param _asset The address of the asset
* @param _amount The amount of the asset
*/
function deposit(address _asset, uint256 _amount) external;
/**
* @notice withdraws an asset from the EverclearSpoke
* @dev can be called by solvers or users
* @param _asset The address of the asset
* @param _amount The amount of the asset
*/
function withdraw(address _asset, uint256 _amount) external;
/**
* @notice Updates the gateway
* @param _newGateway The address of the new gateway
*/
function updateGateway(
address _newGateway
) external;
/**
* @notice Updates the message receiver
* @param _newMessageReceiver The address of the new message receiver
*/
function updateMessageReceiver(
address _newMessageReceiver
) external;
/**
* @notice Updates the max gas limit used for outgoing messages
* @param _newGasLimit The new gas limit
*/
function updateMessageGasLimit(
uint256 _newGasLimit
) external;
/**
* @notice Executes the calldata of an intent
* @param _intent The intent object
*/
function executeIntentCalldata(
Intent calldata _intent
) external;
}
// SPDX-License-Identifier: MIT
pragma solidity 0.8.23;
import {IGateway} from 'interfaces/common/IGateway.sol';
/**
* @title ISpokeGateway
* @notice Interface for the SpokeGateway contract, sends and receives messages to and from the transport layer
*/
interface ISpokeGateway is IGateway {
/*///////////////////////////////////////////////////////////////
LOGIC
//////////////////////////////////////////////////////////////*/
/**
* @notice Initialize Gateway variables
* @param _owner The address of the owner
* @param _mailbox The address of the local mailbox
* @param _receiver The address of the local message receiver (EverclearSpoke)
* @param _interchainSecurityModule The address of the chosen interchain security module
* @param _everclearId The id of the Everclear domain
* @param _hubGateway The bytes32 representation of the Hub gateway
* @dev Only called once on initialization
*/
function initialize(
address _owner,
address _mailbox,
address _receiver,
address _interchainSecurityModule,
uint32 _everclearId,
bytes32 _hubGateway
) external;
/*///////////////////////////////////////////////////////////////
VIEWS
//////////////////////////////////////////////////////////////*/
/**
* @notice Returns the Everclear hub chain id
* @return _hubChainId The Everclear chain id
*/
function EVERCLEAR_ID() external view returns (uint32 _hubChainId);
/**
* @notice Returns the `HubGateway` gateway address
* @return _hubGateway The `HubGateway` address
*/
function EVERCLEAR_GATEWAY() external view returns (bytes32 _hubGateway);
}
// SPDX-License-Identifier: MIT
pragma solidity 0.8.23;
import {QueueLib} from 'contracts/common/QueueLib.sol';
import {IPermit2} from 'interfaces/common/IPermit2.sol';
import {ISettlementModule} from 'interfaces/common/ISettlementModule.sol';
import {ICallExecutor} from 'interfaces/intent/ICallExecutor.sol';
import {ISpokeGateway} from 'interfaces/intent/ISpokeGateway.sol';
import {ISpokeStorage} from 'interfaces/intent/ISpokeStorage.sol';
/**
* @title SpokeStorage
* @notice Storage layout and modifiers for the `EverclearSpoke`
*/
abstract contract SpokeStorage is ISpokeStorage {
/// @inheritdoc ISpokeStorage
bytes32 public constant FILL_INTENT_FOR_SOLVER_TYPEHASH = keccak256(
'function fillIntentForSolver(address _solver, Intent calldata _intent, uint256 _nonce, uint24 _fee, bytes memory _signature)'
);
/// @inheritdoc ISpokeStorage
bytes32 public constant PROCESS_INTENT_QUEUE_VIA_RELAYER_TYPEHASH = keccak256(
'function processIntentQueueViaRelayer(uint32 _domain, Intent[] memory _intents, address _relayer, uint256 _ttl, uint256 _nonce, uint256 _bufferDBPS, bytes memory _signature)'
);
/// @inheritdoc ISpokeStorage
bytes32 public constant PROCESS_FILL_QUEUE_VIA_RELAYER_TYPEHASH = keccak256(
'function processFillQueueViaRelayer(uint32 _domain, uint32 _amount, address _relayer, uint256 _ttl, uint256 _nonce, uint256 _bufferDBPS, bytes memory _signature)'
);
/// @inheritdoc ISpokeStorage
IPermit2 public constant PERMIT2 = IPermit2(0x000000000022D473030F116dDEE9F6B43aC78BA3);
/// @inheritdoc ISpokeStorage
uint32 public EVERCLEAR;
/// @inheritdoc ISpokeStorage
uint32 public DOMAIN;
/// @inheritdoc ISpokeStorage
address public lighthouse;
/// @inheritdoc ISpokeStorage
address public watchtower;
/// @inheritdoc ISpokeStorage
address public messageReceiver;
/// @inheritdoc ISpokeStorage
ISpokeGateway public gateway;
/// @inheritdoc ISpokeStorage
ICallExecutor public callExecutor;
/// @inheritdoc ISpokeStorage
bool public paused;
/// @inheritdoc ISpokeStorage
uint64 public nonce;
/// @inheritdoc ISpokeStorage
uint256 public messageGasLimit;
/// @inheritdoc ISpokeStorage
mapping(bytes32 _asset => mapping(bytes32 _user => uint256 _amount)) public balances;
/// @inheritdoc ISpokeStorage
mapping(bytes32 _intentId => IntentStatus status) public status;
/// @inheritdoc ISpokeStorage
mapping(address _asset => Strategy _strategy) public strategies;
/// @inheritdoc ISpokeStorage
mapping(Strategy _strategy => ISettlementModule _module) public modules;
/**
* @notice The intent queue
*/
QueueLib.IntentQueue public intentQueue;
/**
* @notice The fill queue
*/
QueueLib.FillQueue public fillQueue;
/**
* @notice Checks that the address is valid
*/
modifier validAddress(
address _address
) {
if (_address == address(0)) {
revert EverclearSpoke_ZeroAddress();
}
_;
}
/**
* @notice Checks that the local domain is included in the destinations
* @param _intent The intent to check
*/
modifier validDestination(
Intent calldata _intent
) {
// when it's an xcall executable, destinations.length is always 1
if (_intent.destinations[0] != DOMAIN) {
revert EverclearSpoke_WrongDestination();
}
_;
}
/**
* @notice Checks when processing a queue that the amount is valid for the queue being processed
* @param _first The first index of the queue
* @param _last The last index of the queue
* @param _amount The amount to process
*/
modifier validQueueAmount(uint256 _first, uint256 _last, uint256 _amount) {
if (_amount == 0) {
revert EverclearSpoke_ProcessQueue_ZeroAmount();
}
if (_first + _amount - 1 > _last) {
revert EverclearSpoke_ProcessQueue_InvalidAmount(_first, _last, _amount);
}
_;
}
/**
* @notice Checks that the contract is not paused
*/
modifier whenNotPaused() {
if (paused) {
revert EverclearSpoke_Paused();
}
_;
}
/**
* @notice Checks that the caller has access to pause the contract
*/
modifier hasPauseAccess() {
if (msg.sender != lighthouse && msg.sender != watchtower) {
revert EverclearSpoke_Pause_NotAuthorized();
}
_;
}
}
// 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) (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) (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) (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/extensions/IERC20Metadata.sol)
pragma solidity ^0.8.20;
import {IERC20} from "../IERC20.sol";
/**
* @dev Interface for the optional metadata functions from the ERC20 standard.
*/
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)
pragma solidity ^0.8.20;
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
function _contextSuffixLength() internal view virtual returns (uint256) {
return 0;
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol)
pragma solidity ^0.8.20;
/**
* @dev Standard ERC20 Errors
* Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC20 tokens.
*/
interface IERC20Errors {
/**
* @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
* @param sender Address whose tokens are being transferred.
* @param balance Current balance for the interacting account.
* @param needed Minimum amount required to perform a transfer.
*/
error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);
/**
* @dev Indicates a failure with the token `sender`. Used in transfers.
* @param sender Address whose tokens are being transferred.
*/
error ERC20InvalidSender(address sender);
/**
* @dev Indicates a failure with the token `receiver`. Used in transfers.
* @param receiver Address to which tokens are being transferred.
*/
error ERC20InvalidReceiver(address receiver);
/**
* @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
* @param spender Address that may be allowed to operate on tokens without being their owner.
* @param allowance Amount of tokens a `spender` is allowed to operate with.
* @param needed Minimum amount required to perform a transfer.
*/
error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);
/**
* @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
* @param approver Address initiating an approval operation.
*/
error ERC20InvalidApprover(address approver);
/**
* @dev Indicates a failure with the `spender` to be approved. Used in approvals.
* @param spender Address that may be allowed to operate on tokens without being their owner.
*/
error ERC20InvalidSpender(address spender);
}
/**
* @dev Standard ERC721 Errors
* Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC721 tokens.
*/
interface IERC721Errors {
/**
* @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in EIP-20.
* Used in balance queries.
* @param owner Address of the current owner of a token.
*/
error ERC721InvalidOwner(address owner);
/**
* @dev Indicates a `tokenId` whose `owner` is the zero address.
* @param tokenId Identifier number of a token.
*/
error ERC721NonexistentToken(uint256 tokenId);
/**
* @dev Indicates an error related to the ownership over a particular token. Used in transfers.
* @param sender Address whose tokens are being transferred.
* @param tokenId Identifier number of a token.
* @param owner Address of the current owner of a token.
*/
error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);
/**
* @dev Indicates a failure with the token `sender`. Used in transfers.
* @param sender Address whose tokens are being transferred.
*/
error ERC721InvalidSender(address sender);
/**
* @dev Indicates a failure with the token `receiver`. Used in transfers.
* @param receiver Address to which tokens are being transferred.
*/
error ERC721InvalidReceiver(address receiver);
/**
* @dev Indicates a failure with the `operator`’s approval. Used in transfers.
* @param operator Address that may be allowed to operate on tokens without being their owner.
* @param tokenId Identifier number of a token.
*/
error ERC721InsufficientApproval(address operator, uint256 tokenId);
/**
* @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
* @param approver Address initiating an approval operation.
*/
error ERC721InvalidApprover(address approver);
/**
* @dev Indicates a failure with the `operator` to be approved. Used in approvals.
* @param operator Address that may be allowed to operate on tokens without being their owner.
*/
error ERC721InvalidOperator(address operator);
}
/**
* @dev Standard ERC1155 Errors
* Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC1155 tokens.
*/
interface IERC1155Errors {
/**
* @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
* @param sender Address whose tokens are being transferred.
* @param balance Current balance for the interacting account.
* @param needed Minimum amount required to perform a transfer.
* @param tokenId Identifier number of a token.
*/
error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);
/**
* @dev Indicates a failure with the token `sender`. Used in transfers.
* @param sender Address whose tokens are being transferred.
*/
error ERC1155InvalidSender(address sender);
/**
* @dev Indicates a failure with the token `receiver`. Used in transfers.
* @param receiver Address to which tokens are being transferred.
*/
error ERC1155InvalidReceiver(address receiver);
/**
* @dev Indicates a failure with the `operator`’s approval. Used in transfers.
* @param operator Address that may be allowed to operate on tokens without being their owner.
* @param owner Address of the current owner of a token.
*/
error ERC1155MissingApprovalForAll(address operator, address owner);
/**
* @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
* @param approver Address initiating an approval operation.
*/
error ERC1155InvalidApprover(address approver);
/**
* @dev Indicates a failure with the `operator` to be approved. Used in approvals.
* @param operator Address that may be allowed to operate on tokens without being their owner.
*/
error ERC1155InvalidOperator(address operator);
/**
* @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
* Used in batch transfers.
* @param idsLength Length of the array of token identifiers
* @param valuesLength Length of the array of token amounts
*/
error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Permit.sol)
pragma solidity ^0.8.20;
/**
* @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);
}
// 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/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.23;
import {IEverclear} from 'interfaces/common/IEverclear.sol';
import {IPermit2} from 'interfaces/common/IPermit2.sol';
import {ISettlementModule} from 'interfaces/common/ISettlementModule.sol';
import {ICallExecutor} from 'interfaces/intent/ICallExecutor.sol';
import {ISpokeGateway} from 'interfaces/intent/ISpokeGateway.sol';
/**
* @title ISpokeStorage
* @notice Interface for the SpokeStorage contract
*/
interface ISpokeStorage is IEverclear {
/*///////////////////////////////////////////////////////////////
STRUCTS
//////////////////////////////////////////////////////////////*/
/**
* @notice Parameters needed to initiliaze `EverclearSpoke`
* @param gateway The local `SpokeGateway`
* @param callExecutor The local `CallExecutor`
* @param messageReceiver The address for the `SpokeMessageReceiver` module
* @param lighthouse The address for the Lighthouse agent
* @param watchtower The address for the Watchtower agent
* @param hubDomain The chain id for the Everclear domain
* @param owner The initial owner of the contract
*/
struct SpokeInitializationParams {
ISpokeGateway gateway;
ICallExecutor callExecutor;
address messageReceiver;
address lighthouse;
address watchtower;
uint32 hubDomain;
address owner;
}
/*///////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////*/
/**
* @notice emitted when the Gateway address is updated
* @param _oldGateway The address of the old gateway
* @param _newGateway The address of the new gateway
*/
event GatewayUpdated(address _oldGateway, address _newGateway);
/**
* @notice emitted when the Lighthouse address is updated
* @param _oldLightHouse The address of the old lighthouse
* @param _newLightHouse The address of the new lighthouse
*/
event LighthouseUpdated(address _oldLightHouse, address _newLightHouse);
/**
* @notice emitted when the Watchtower address is updated
* @param _oldWatchtower The address of the old watchtower
* @param _newWatchtower The address of the new watchtower
*/
event WatchtowerUpdated(address _oldWatchtower, address _newWatchtower);
/**
* @notice emitted when the MessageReceiver address is updated
* @param _oldMessageReceiver The address of the old message receiver
* @param _newMessageReceiver The address of the new message receiver
*/
event MessageReceiverUpdated(address _oldMessageReceiver, address _newMessageReceiver);
/**
* @notice emitted when messageGasLimit is updated
* @param _oldGasLimit The old gas limit
* @param _newGasLimit The new gas limit
*/
event MessageGasLimitUpdated(uint256 _oldGasLimit, uint256 _newGasLimit);
/**
* @notice emitted when the protocol is paused (domain-level)
*/
event Paused();
/**
* @notice emitted when the protocol is paused (domain-level)
*/
event Unpaused();
/**
* @notice emitted when a strategy is set for an asset
* @param _asset The address of the asset being configured
* @param _strategy The id for the strategy (see `enum Strategy`)
*/
event StrategySetForAsset(address _asset, IEverclear.Strategy _strategy);
/**
* @notice emitted when the module is set for a strategy
* @param _strategy The id for the strategy (see `enum Strategy`)
* @param _module The settlement module
*/
event ModuleSetForStrategy(IEverclear.Strategy _strategy, ISettlementModule _module);
/**
* @notice emitted when the EverclearSpoke processes a settlement
* @param _intentId The ID of the intent
* @param _account The address of the account
* @param _asset The address of the asset
* @param _amount The amount of the asset
*/
event Settled(bytes32 indexed _intentId, address _account, address _asset, uint256 _amount);
/**
* @notice emitted when `_handleSettlement` fails to transfer tokens to a user (eg. blacklisted recipient)
* @param _asset The address of the asset
* @param _recipient The address of the recipient
* @param _amount The amount of the asset
*/
event AssetTransferFailed(address indexed _asset, address indexed _recipient, uint256 _amount);
/**
* @notice emitted when `_handleSettlement` fails to mint the non-default stategy asset
* @param _asset The address of the asset
* @param _recipient The address of the recipient
* @param _amount The amount of the asset
* @param _strategy The strategy used for the asset
*/
event AssetMintFailed(address indexed _asset, address indexed _recipient, uint256 _amount, Strategy _strategy);
/*///////////////////////////////////////////////////////////////
ERRORS
//////////////////////////////////////////////////////////////*/
/**
* @notice Thrown when the spoke is receiving a message from an address that is not the authorized gateway, admin or owner
*/
error EverclearSpoke_Unauthorized();
/**
* @notice Thrown when a message is not a valid message type
*/
error EverclearSpoke_InvalidMessageType();
/**
* @notice Thrown when the destination is wrong
*/
error EverclearSpoke_WrongDestination();
/**
* @notice Thrown when a variable update is invalid
*/
error EverclearSpoke_InvalidVarUpdate();
/**
* @notice Thrown when calling to a processQueue method with a zero amount
*/
error EverclearSpoke_ProcessQueue_ZeroAmount();
/**
* @notice Thrown when calling to a processQueue method with an invalid amount
* @param _first The index of the first element of the queue
* @param _last The index of the last element of the queue
* @param _amount The amount of items being tried to process
*/
error EverclearSpoke_ProcessQueue_InvalidAmount(uint256 _first, uint256 _last, uint256 _amount);
/**
* @notice Thrown when calling a function with the zero address
*/
error EverclearSpoke_ZeroAddress();
/**
* @notice Thrown when a function is called when the spoke is paused
*/
error EverclearSpoke_Paused();
/**
* @notice Thrown when the caller is not authorized to pause the spoke
*/
error EverclearSpoke_Pause_NotAuthorized();
/*///////////////////////////////////////////////////////////////
VIEWS
//////////////////////////////////////////////////////////////*/
/**
* @notice returns the typehash for `fillIntentForSolver`
* @return _typeHash The `fillIntentForSolver` type hash
*/
function FILL_INTENT_FOR_SOLVER_TYPEHASH() external view returns (bytes32 _typeHash);
/**
* @notice returns the typehash for `processIntentQueueViaRelayer`
* @return _typeHash The `processIntentQueueViaRelayer` type hash
*/
function PROCESS_INTENT_QUEUE_VIA_RELAYER_TYPEHASH() external view returns (bytes32 _typeHash);
/**
* @notice returns the typehash for `processFillQueueViaRelayer`
* @return _typeHash The `processFillQueueViaRelayer` type hash
*/
function PROCESS_FILL_QUEUE_VIA_RELAYER_TYPEHASH() external view returns (bytes32 _typeHash);
/**
* @notice returns the permit2 contract
* @return _permit2 The Permit2 singleton address
*/
function PERMIT2() external view returns (IPermit2 _permit2);
/**
* @notice returns the domain id for the Everclear rollup
* @return _domain The id of the Everclear domain
*/
function EVERCLEAR() external view returns (uint32 _domain);
/**
* @notice returns the current domain
* @return _domain The id of the current domain
*/
function DOMAIN() external view returns (uint32 _domain);
/**
* @notice returns the lighthouse address
* @return _lighthouse The address of the Lighthouse agent
*/
function lighthouse() external view returns (address _lighthouse);
/**
* @notice returns the watchtower address
* @return _watchtower The address of the Watchtower agent
*/
function watchtower() external view returns (address _watchtower);
/**
* @notice returns the message receiver address
* @return _messageReceiver The address of the `SpokeMessageReceiver`
*/
function messageReceiver() external view returns (address _messageReceiver);
/**
* @notice returns the gateway
* @return _gateway The local `SpokeGateway`
*/
function gateway() external view returns (ISpokeGateway _gateway);
/**
* @notice returns the call executor
* @return _callExecutor The local `CallExecutor`
*/
function callExecutor() external view returns (ICallExecutor _callExecutor);
/**
* @notice returns the paused status of the spoke
* @return _paused The boolean indicating if the contract is paused
*/
function paused() external view returns (bool _paused);
/**
* @notice returns the current intent nonce
* @return _nonce The current nonce
*/
function nonce() external view returns (uint64 _nonce);
/**
* @notice returns the gas limit used for outgoing messages
* @return _messageGasLimit the max gas limit
*/
function messageGasLimit() external view returns (uint256 _messageGasLimit);
/**
* @notice returns the balance of an asset for a user
* @param _asset The address of the asset
* @param _user The address of the user
* @return _amount The amount of assets locked in the contract
*/
function balances(bytes32 _asset, bytes32 _user) external view returns (uint256 _amount);
/**
* @notice returns the status of an intent
* @param _intentId The ID of the intent
* @return _status The status of the intent
*/
function status(
bytes32 _intentId
) external view returns (IntentStatus _status);
/**
* @notice returns the configured strategy id for an asset
* @param _asset The address of the asset
* @return _strategy The strategy for the asset
*/
function strategies(
address _asset
) external view returns (IEverclear.Strategy _strategy);
/**
* @notice returns the module address for a strategy
* @param _strategy The strategy id
* @return _module The strategy module
*/
function modules(
IEverclear.Strategy _strategy
) external view returns (ISettlementModule _module);
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import {IMailbox} from '@hyperlane/interfaces/IMailbox.sol';
import {IMessageReceiver} from 'interfaces/common/IMessageReceiver.sol';
interface IGateway {
/*///////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////*/
/**
* @notice Emitted when the mailbox is updated
* @param _oldMailbox The old mailbox address
* @param _newMailbox The new mailbox address
*/
event MailboxUpdated(address _oldMailbox, address _newMailbox);
/**
* @notice Emitted when the security module is updated
* @param _oldSecurityModule The old security module address
* @param _newSecurityModule The new security module address
*/
event SecurityModuleUpdated(address _oldSecurityModule, address _newSecurityModule);
/*///////////////////////////////////////////////////////////////
ERRORS
//////////////////////////////////////////////////////////////*/
/**
* @notice Thrown when the message origin is invalid
*/
error Gateway_Handle_InvalidOriginDomain();
/**
* @notice Thrown when the sender is not the appropriate remote Gateway
*/
error Gateway_Handle_InvalidSender();
/**
* @notice Thrown when the caller is not the local mailbox
*/
error Gateway_Handle_NotCalledByMailbox();
/**
* @notice Thrown when the GasTank does not have enough native asset to cover the fee
*/
error Gateway_SendMessage_InsufficientBalance();
/**
* @notice Thrown when the message dispatcher is not the local receiver
*/
error Gateway_SendMessage_UnauthorizedCaller();
/**
* @notice Thrown when the call returning the unused fee fails
*/
error Gateway_SendMessage_UnsuccessfulRebate();
/**
* @notice Thrown when an address equals the address zero
*/
error Gateway_ZeroAddress();
/*///////////////////////////////////////////////////////////////
LOGIC
//////////////////////////////////////////////////////////////*/
/**
* @notice Send a message to the transport layer using the gas tank
* @param _chainId The id of the destination chain
* @param _message The message to send
* @param _fee The fee to send the message
* @param _gasLimit The gas limit to use on destination
* @return _messageId The id message of the transport layer
* @return _feeSpent The fee spent to send the message
* @dev only called by the spoke contract
*/
function sendMessage(
uint32 _chainId,
bytes memory _message,
uint256 _fee,
uint256 _gasLimit
) external returns (bytes32 _messageId, uint256 _feeSpent);
/**
* @notice Send a message to the transport layer
* @param _chainId The id of the destination chain
* @param _message The message to send
* @param _gasLimit The gas limit to use on destination
* @return _messageId The id message of the transport layer
* @return _feeSpent The fee spent to send the message
* @dev only called by the spoke contract
*/
function sendMessage(
uint32 _chainId,
bytes memory _message,
uint256 _gasLimit
) external payable returns (bytes32 _messageId, uint256 _feeSpent);
/**
* @notice Updates the mailbox
* @param _mailbox The new mailbox address
* @dev only called by the `receiver`
*/
function updateMailbox(
address _mailbox
) external;
/**
* @notice Updates the gateway security module
* @param _securityModule The address of the new security module
* @dev only called by the `receiver`
*/
function updateSecurityModule(
address _securityModule
) external;
/*///////////////////////////////////////////////////////////////
VIEWS
//////////////////////////////////////////////////////////////*/
/**
* @notice Returns the transport layer message routing smart contract
* @dev this is independent of the transport layer used, adopting mailbox name because its descriptive enough
* using address instead of specific interface to be independent from HL or any other TL
* @return _mailbox The mailbox contract
*/
function mailbox() external view returns (IMailbox _mailbox);
/**
* @notice Returns the message receiver for this Gateway (EverclearHub / EverclearSpoke)
* @return _receiver The message receiver
*/
function receiver() external view returns (IMessageReceiver _receiver);
/**
* @notice Quotes cost of sending a message to the transport layer
* @param _chainId The id of the destination chain
* @param _message The message to send
* @param _gasLimit The gas limit for delivering the message
* @return _fee The fee to send the message
*/
function quoteMessage(uint32 _chainId, bytes memory _message, uint256 _gasLimit) external view returns (uint256 _fee);
}
// SPDX-License-Identifier: MIT
pragma solidity 0.8.23;
/**
* @title ICallExecutor
* @notice Interface for the CallExecutor contract, executes calls to external contracts
*/
interface ICallExecutor {
/**
* @notice Safely call a target contract, use when you _really_ really _really_ don't trust the called
* contract. This prevents the called contract from causing reversion of the caller in as many ways as we can.
* @param _target The address to call
* @param _gas The amount of gas to forward to the remote contract
* @param _value The value in wei to send to the remote contract
* @param _maxCopy The maximum number of bytes of returndata to copy to memory
* @param _calldata The data to send to the remote contract
* @return _success Whether the call was successful
* @return _returnData Returndata as `.call()`. Returndata is capped to `_maxCopy` bytes.
*/
function excessivelySafeCall(
address _target,
uint256 _gas,
uint256 _value,
uint16 _maxCopy,
bytes memory _calldata
) external returns (bool _success, bytes memory _returnData);
}
// 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) (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/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 OR Apache-2.0
pragma solidity >=0.8.0;
import {IInterchainSecurityModule} from "./IInterchainSecurityModule.sol";
import {IPostDispatchHook} from "./hooks/IPostDispatchHook.sol";
interface IMailbox {
// ============ Events ============
/**
* @notice Emitted when a new message is dispatched via Hyperlane
* @param sender The address that dispatched the message
* @param destination The destination domain of the message
* @param recipient The message recipient address on `destination`
* @param message Raw bytes of message
*/
event Dispatch(
address indexed sender,
uint32 indexed destination,
bytes32 indexed recipient,
bytes message
);
/**
* @notice Emitted when a new message is dispatched via Hyperlane
* @param messageId The unique message identifier
*/
event DispatchId(bytes32 indexed messageId);
/**
* @notice Emitted when a Hyperlane message is processed
* @param messageId The unique message identifier
*/
event ProcessId(bytes32 indexed messageId);
/**
* @notice Emitted when a Hyperlane message is delivered
* @param origin The origin domain of the message
* @param sender The message sender address on `origin`
* @param recipient The address that handled the message
*/
event Process(
uint32 indexed origin,
bytes32 indexed sender,
address indexed recipient
);
function localDomain() external view returns (uint32);
function delivered(bytes32 messageId) external view returns (bool);
function defaultIsm() external view returns (IInterchainSecurityModule);
function defaultHook() external view returns (IPostDispatchHook);
function requiredHook() external view returns (IPostDispatchHook);
function latestDispatchedId() external view returns (bytes32);
function dispatch(
uint32 destinationDomain,
bytes32 recipientAddress,
bytes calldata messageBody
) external payable returns (bytes32 messageId);
function quoteDispatch(
uint32 destinationDomain,
bytes32 recipientAddress,
bytes calldata messageBody
) external view returns (uint256 fee);
function dispatch(
uint32 destinationDomain,
bytes32 recipientAddress,
bytes calldata body,
bytes calldata defaultHookMetadata
) external payable returns (bytes32 messageId);
function quoteDispatch(
uint32 destinationDomain,
bytes32 recipientAddress,
bytes calldata messageBody,
bytes calldata defaultHookMetadata
) external view returns (uint256 fee);
function dispatch(
uint32 destinationDomain,
bytes32 recipientAddress,
bytes calldata body,
bytes calldata customHookMetadata,
IPostDispatchHook customHook
) external payable returns (bytes32 messageId);
function quoteDispatch(
uint32 destinationDomain,
bytes32 recipientAddress,
bytes calldata messageBody,
bytes calldata customHookMetadata,
IPostDispatchHook customHook
) external view returns (uint256 fee);
function process(
bytes calldata metadata,
bytes calldata message
) external payable;
function recipientIsm(
address recipient
) external view returns (IInterchainSecurityModule module);
}
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.6.11;
interface IInterchainSecurityModule {
enum Types {
UNUSED,
ROUTING,
AGGREGATION,
LEGACY_MULTISIG,
MERKLE_ROOT_MULTISIG,
MESSAGE_ID_MULTISIG,
NULL, // used with relayer carrying no metadata
CCIP_READ
}
/**
* @notice Returns an enum that represents the type of security model
* encoded by this ISM.
* @dev Relayers infer how to fetch and format metadata.
*/
function moduleType() external view returns (uint8);
/**
* @notice Defines a security model responsible for verifying interchain
* messages based on the provided metadata.
* @param _metadata Off-chain metadata provided by a relayer, specific to
* the security model encoded by the module (e.g. validator signatures)
* @param _message Hyperlane encoded interchain message
* @return True if the message was verified
*/
function verify(
bytes calldata _metadata,
bytes calldata _message
) external returns (bool);
}
interface ISpecifiesInterchainSecurityModule {
function interchainSecurityModule()
external
view
returns (IInterchainSecurityModule);
}
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.0;
/*@@@@@@@ @@@@@@@@@
@@@@@@@@@ @@@@@@@@@
@@@@@@@@@ @@@@@@@@@
@@@@@@@@@ @@@@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@ HYPERLANE @@@@@@@
@@@@@@@@@@@@@@@@@@@@@@@@@
@@@@@@@@@ @@@@@@@@@
@@@@@@@@@ @@@@@@@@@
@@@@@@@@@ @@@@@@@@@
@@@@@@@@@ @@@@@@@@*/
interface IPostDispatchHook {
enum Types {
UNUSED,
ROUTING,
AGGREGATION,
MERKLE_TREE,
INTERCHAIN_GAS_PAYMASTER,
FALLBACK_ROUTING,
ID_AUTH_ISM,
PAUSABLE,
PROTOCOL_FEE,
LAYER_ZERO_V1
}
/**
* @notice Returns an enum that represents the type of hook
*/
function hookType() external view returns (uint8);
/**
* @notice Returns whether the hook supports metadata
* @param metadata metadata
* @return Whether the hook supports metadata
*/
function supportsMetadata(
bytes calldata metadata
) external view returns (bool);
/**
* @notice Post action after a message is dispatched via the Mailbox
* @param metadata The metadata required for the hook
* @param message The message passed from the Mailbox.dispatch() call
*/
function postDispatch(
bytes calldata metadata,
bytes calldata message
) external payable;
/**
* @notice Compute the payment required by the postDispatch call
* @param metadata The metadata required for the hook
* @param message The message passed from the Mailbox.dispatch() call
* @return Quoted payment for the postDispatch call
*/
function quoteDispatch(
bytes calldata metadata,
bytes calldata message
) external view returns (uint256);
}