Contract Name:
OnchainCLOBFactory
Contract Source Code:
// SPDX-License-Identifier: BUSL-1.1
// Central Limit Order Book (CLOB) exchange
// (c) Long Gamma Labs, 2023.
pragma solidity ^0.8.26;
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {Ownable2Step} from "@openzeppelin/contracts/access/Ownable2Step.sol";
import {Errors} from "./Errors.sol";
import {OnchainCLOB} from "./OnchainCLOB.sol";
import {Proxy} from "./Proxy.sol";
import {IOnchainCLOBFactory} from "./IOnchainCLOBFactory.sol";
import {ITrieFactory} from "./ITrieFactory.sol";
/// @title LOB Factory for Protocol
/// @dev This contract is responsible for creating OnchainCLOB instances.
contract OnchainCLOBFactory is IOnchainCLOBFactory, Ownable2Step {
/// @dev An instance of ITrieFactory.
ITrieFactory immutable trieFactory;
/// @dev An instance of OnchainCLOB
OnchainCLOB immutable public lobImplementation;
/// @dev Constructor for OnchainCLOBFactory.
/// @param _owner The owner of the contract.
/// @param _trieFactory The address of the trie factory.
/// @param _watch_dog The address of the watch dog.
constructor(
address _owner,
address _trieFactory,
address _watch_dog
) Ownable(_owner) {
require(_trieFactory != address(0), Errors.AddressIsZero());
require(_watch_dog != address(0), Errors.AddressIsZero());
trieFactory = ITrieFactory(_trieFactory);
lobImplementation = new OnchainCLOB(_watch_dog);
}
/// @dev A mapping of deployers.
mapping(address => bool) public deployers;
/// @dev An event that is emitted when a OnchainCLOB is created.
event OnchainCLOBCreated(
address indexed creator,
address OnchainCLOB,
address tokenXAddress,
address tokenYAddress,
bool supports_native_eth,
uint256 scaling_token_x,
uint256 scaling_token_y,
address administrator,
address marketmaker,
address pauser,
bool should_invoke_on_trade,
uint64 admin_commission_rate,
uint64 total_aggressive_commission_rate,
uint64 total_passive_commission_rate,
uint64 passive_order_payout
);
/// @dev Sets a deployer.
/// @param deployer The address of the deployer.
/// @param allowed A boolean indicating whether the deployer is allowed.
function setDeployer(address deployer, bool allowed) external onlyOwner {
deployers[deployer] = allowed;
}
/// @dev Creates a OnchainCLOB.
/// @param tokenXAddress The address of token X.
/// @param tokenYAddress The address of token Y.
/// @param supports_native_eth A boolean indicating if the contract supports native ETH transactions.
/// @param scaling_token_x The scaling factor for token X.
/// @param scaling_token_y The scaling factor for token Y.
/// @param administrator The address of the administrator.
/// @param marketmaker The address of the market maker.
/// @param pauser The address of the pauser.
/// @param should_invoke_on_trade A boolean indicating whether to invoke on trade.
/// @param admin_commission_rate The commission rate for the administrator
/// @param total_aggressive_commission_rate The total commission rate for aggressive orders
/// @param total_passive_commission_rate The total commission rate for passive orders
/// @param passive_order_payout Payout for passive orders
/// @return The address of the created OnchainCLOB.
function createOnchainCLOB(
address tokenXAddress,
address tokenYAddress,
bool supports_native_eth,
bool is_token_x_weth,
uint256 scaling_token_x,
uint256 scaling_token_y,
address administrator,
address marketmaker,
address pauser,
bool should_invoke_on_trade,
uint64 admin_commission_rate,
uint64 total_aggressive_commission_rate,
uint64 total_passive_commission_rate,
uint64 passive_order_payout
) external returns (address) {
require(deployers[msg.sender], Errors.Forbidden());
bytes memory initializeCallData = abi.encodeWithSignature(
"initialize(address,address,address,bool,bool,uint256,uint256,address,address,address,bool,uint64,uint64,uint64,uint64)",
address(trieFactory),
tokenXAddress,
tokenYAddress,
supports_native_eth,
is_token_x_weth,
scaling_token_x,
scaling_token_y,
administrator,
marketmaker,
pauser,
should_invoke_on_trade,
admin_commission_rate,
total_aggressive_commission_rate,
total_passive_commission_rate,
passive_order_payout
);
Proxy lobProxy = new Proxy(
address(lobImplementation),
initializeCallData
);
emit OnchainCLOBCreated(
msg.sender,
address(lobProxy),
tokenXAddress,
tokenYAddress,
supports_native_eth,
scaling_token_x,
scaling_token_y,
administrator,
marketmaker,
pauser,
should_invoke_on_trade,
admin_commission_rate,
total_aggressive_commission_rate,
total_passive_commission_rate,
passive_order_payout
);
return address(lobProxy);
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)
pragma solidity ^0.8.20;
import {Context} from "../utils/Context.sol";
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* The initial owner is set to the address provided by the deployer. This can
* later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
/**
* @dev The caller account is not authorized to perform an operation.
*/
error OwnableUnauthorizedAccount(address account);
/**
* @dev The owner is not a valid owner account. (eg. `address(0)`)
*/
error OwnableInvalidOwner(address owner);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the address provided by the deployer as the initial owner.
*/
constructor(address initialOwner) {
if (initialOwner == address(0)) {
revert OwnableInvalidOwner(address(0));
}
_transferOwnership(initialOwner);
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
_checkOwner();
_;
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
return _owner;
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
if (owner() != _msgSender()) {
revert OwnableUnauthorizedAccount(_msgSender());
}
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby disabling any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
if (newOwner == address(0)) {
revert OwnableInvalidOwner(address(0));
}
_transferOwnership(newOwner);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable2Step.sol)
pragma solidity ^0.8.20;
import {Ownable} from "./Ownable.sol";
/**
* @dev Contract module which provides access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* The initial owner is specified at deployment time in the constructor for `Ownable`. This
* can later be changed with {transferOwnership} and {acceptOwnership}.
*
* This module is used through inheritance. It will make available all functions
* from parent (Ownable).
*/
abstract contract Ownable2Step is Ownable {
address private _pendingOwner;
event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner);
/**
* @dev Returns the address of the pending owner.
*/
function pendingOwner() public view virtual returns (address) {
return _pendingOwner;
}
/**
* @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one.
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual override onlyOwner {
_pendingOwner = newOwner;
emit OwnershipTransferStarted(owner(), newOwner);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner.
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual override {
delete _pendingOwner;
super._transferOwnership(newOwner);
}
/**
* @dev The new owner accepts the ownership transfer.
*/
function acceptOwnership() public virtual {
address sender = _msgSender();
if (pendingOwner() != sender) {
revert OwnableUnauthorizedAccount(sender);
}
_transferOwnership(sender);
}
}
// SPDX-License-Identifier: BUSL-1.1
// Central Limit Order Book (CLOB) exchange
// (c) Long Gamma Labs, 2023.
pragma solidity ^0.8.26;
contract Errors {
error AddressIsZero();
error ArrayLengthMismatch();
error ChainIsUnstableForTrades();
error ClaimNotAllowed();
error CommissionParamTooHigh();
error Disabled();
error EmptyOrderError();
error ExcessiveSignificantFigures();
error Expired();
error Forbidden();
error FractionalNumbersNotAllowed();
error InsufficientTokenXBalance();
error InsufficientTokenYBalance();
error InvalidCommissionRate();
error InvalidFloatingPointRepresentation();
error InvalidMarketMaker();
error InvalidPriceRange();
error InvalidTransfer();
error MarketOnlyAndPostOnlyFlagsConflict();
error MaxCommissionFailure();
error NativeETHDisabled();
error NonceExhaustedFailure();
error NotImplementedYet();
error OnlyOwnerCanCancelOrders();
error PointerAlreadyFreed();
error PriceExceedsMaximumAllowedValue();
error TransferFailed();
error UnknownOrderId();
error UnknownTrader();
error WrongOwner();
error ZeroMaxDelayNotAllowed();
error ZeroRecoveryTimeNotAllowed();
error ZeroTokenTransferNotAllowed();
error InvalidPrice();
error InvalidQuantity();
error InvalidCommission();
error InvalidExpiry();
error OrderExpired();
error InsufficientBalance();
error InsufficientAllowance();
error InvalidOrderId();
error OrderNotFound();
error OrderAlreadyCancelled();
error OrderAlreadyExecuted();
error InvalidExecutionPrice();
error InvalidExecutionQuantity();
error InvalidExecutionCommission();
error InvalidExecutionOrderId();
error InvalidExecutionOrderStatus();
error InvalidExecutionOrderExpiry();
error InvalidExecutionOrderPrice();
error InvalidExecutionOrderQuantity();
error InvalidExecutionOrderCommission();
}
// SPDX-License-Identifier: BUSL-1.1
// Central Limit Order Book (CLOB) exchange
// (c) Long Gamma Labs, 2023.
pragma solidity ^0.8.26;
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IERC20Permit} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol";
import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {Ownable2StepUpgradeable} from "@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol";
import {PausableUpgradeable} from "@openzeppelin/contracts-upgradeable/utils/PausableUpgradeable.sol";
import {ReentrancyGuardUpgradeable} from "@openzeppelin/contracts-upgradeable/utils/ReentrancyGuardUpgradeable.sol";
import {SafeCast} from "@openzeppelin/contracts/utils/math/SafeCast.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
import {FixedPointMathLib} from "@solmate/src/utils/FixedPointMathLib.sol";
import {Errors} from "./Errors.sol";
import {FP24} from "./FP24.sol";
import {IWatchDog} from "./IWatchDog.sol";
import {IOnchainCLOB} from "./IOnchainCLOB.sol";
import {ITrie} from "./ITrie.sol";
import {ITrieFactory} from "./ITrieFactory.sol";
import {ITradeConsumer} from "./ITradeConsumer.sol";
import {IWETH} from "./IWETH.sol";
/// @title Trader structure
/// @notice Used to represent a trader's state within the LOB contract
/// @dev Stores trader's unique ID, token balances, and claimable status
struct Trader {
uint64 trader_id; ///< Unique identifier for the trader
uint128 token_x; ///< Balance of token X for the trader
uint128 token_y; ///< Balance of token Y for the trader
bool claimable; ///< Flag indicating if the trader's orders are claimable "automatically"
}
/// @title Execution Result
/// @notice Structure to store information about the result of aggressive or immediate part of order execution
/// @dev Used to return data about the executed order from execution functions
struct ExecutionResult {
uint64 order_id; /// order_id Unique identifier of the order
uint128 executed_shares; /// executed_shares Number of shares/tokens executed in the aggressive part
uint128 executed_value; /// executed_value Total value of the aggressively executed part of the order
uint128 aggressive_fee; /// aggressive_fee Fee for the aggressive execution
}
/// @title Market maker configuration
struct MarketMakerConfig {
address marketmaker; /// Market maker address
bool should_invoke_on_trade; /// Invoke the onTrade method for the LP contract after each trade
}
/// @title Limit Order Book (LOB) Contract for Protocol
/// @notice Implements an on-chain limit order book for trading pairs
/// @dev Manages order placement, execution, and claiming processes
contract OnchainCLOB is IOnchainCLOB, UUPSUpgradeable, Ownable2StepUpgradeable, ReentrancyGuardUpgradeable, PausableUpgradeable {
using FixedPointMathLib for uint256;
using SafeCast for uint256;
using SafeERC20 for IERC20;
event OrderPlaced(
address indexed owner,
uint64 order_id,
bool indexed isAsk,
uint128 quantity,
uint72 price,
uint128 passive_shares,
uint128 passive_fee,
uint128 aggressive_shares,
uint128 aggressive_value,
uint128 aggressive_fee,
bool market_only,
bool post_only
);
event OrderClaimed(
uint64 order_id,
uint128 order_shares_remaining,
uint128 token_x_sent,
uint128 token_y_sent,
uint128 passive_payout,
bool only_claim
);
event ClaimableStatusChanged(
address indexed owner,
bool status
);
event MarketMakerChanged(
address new_marketmaker,
address old_marketmaker
);
event PauserChanged(
address new_pauser,
address old_pauser
);
event Deposited(
address indexed owner,
uint128 token_x,
uint128 token_y
);
event Withdrawn(
address indexed owner,
uint128 token_x,
uint128 token_y
);
uint8 constant nonce_length = 39;
uint8 constant price_length = 24;
uint256 constant wad = 1e18;
uint256 scaling_factor_token_x;
uint256 scaling_factor_token_y;
IERC20 token_x;
IERC20 token_y;
bool supports_native_eth;
bool is_token_x_weth;
ITrie askTrie;
ITrie bidTrie;
uint64 admin_commission_rate;
uint64 total_aggressive_commission_rate; // for market orders
uint64 total_passive_commission_rate; // for out-of-money limit orders
uint64 passive_order_payout_rate;
MarketMakerConfig public marketmaker_config;
address public pauser;
uint64 public nonce;
IWatchDog immutable watch_dog;
uint64 last_used_trader_id;
mapping (address => Trader) traders;
uint256 accumulated_fees;
modifier ensure(uint256 expires) {
if (block.timestamp > expires) {
revert Errors.Expired();
}
_;
}
constructor(address _watch_dog) {
watch_dog = IWatchDog(_watch_dog);
_disableInitializers();
}
/// @notice Initialize lob contract state
/// @dev Method is used instead of a constructor to initialize the contract state for compatibility with Upgradeable logic
/// @param _trie_factory Trie factory
/// @param _tokenXAddress Token X address
/// @param _tokenYAddress Token Y address
/// @param _supports_native_eth Indicates if the contract supports native ETH transactions
/// @param _is_token_x_weth Indicates if token X is WETH (Wrapped Ether)
/// @param scaling_token_x Scaling factor for token X
/// @param scaling_token_y Scaling factor for token Y
/// @param _administrator Administrator address
/// @param _marketmaker Market maker address
/// @param _pauser Pauser address
/// @param _should_invoke_on_trade Flag indicating whether to invoke the onTrade method for the LP contract after each trade
/// @param _admin_commission_rate The commission rate for the administrator
/// @param _total_aggressive_commission_rate The total commission rate for aggressive orders
/// @param _total_passive_commission_rate The total commission rate for passive orders
/// @param _passive_order_payout_rate Payout for passive orders
function initialize(
address _trie_factory,
address _tokenXAddress,
address _tokenYAddress,
bool _supports_native_eth,
bool _is_token_x_weth,
uint256 scaling_token_x,
uint256 scaling_token_y,
address _administrator,
address _marketmaker,
address _pauser,
bool _should_invoke_on_trade,
uint64 _admin_commission_rate,
uint64 _total_aggressive_commission_rate,
uint64 _total_passive_commission_rate,
uint64 _passive_order_payout_rate
) public initializer {
__UUPSUpgradeable_init();
__Ownable_init(_administrator);
__Ownable2Step_init();
__ReentrancyGuard_init();
__Pausable_init();
require(_trie_factory != address(0), Errors.AddressIsZero());
require(_tokenXAddress != address(0), Errors.AddressIsZero());
require(_tokenYAddress != address(0), Errors.AddressIsZero());
nonce = (uint64(1) << nonce_length) - uint64(1);
last_used_trader_id = 0;
scaling_factor_token_x = scaling_token_x;
scaling_factor_token_y = scaling_token_y;
token_x = IERC20(_tokenXAddress);
token_y = IERC20(_tokenYAddress);
supports_native_eth = _supports_native_eth;
is_token_x_weth = _is_token_x_weth;
ITrieFactory trie_factory = ITrieFactory(_trie_factory);
address ask_trie_address = trie_factory.createTrie(address(this));
askTrie = ITrie(ask_trie_address);
address bid_trie_address = trie_factory.createTrie(address(this));
bidTrie = ITrie(bid_trie_address);
pauser = _pauser;
_changeMarketMaker(_marketmaker, _should_invoke_on_trade);
uint256 max_rate = 2e17; // 20%
require(
_admin_commission_rate <= 1e18 &&
_total_aggressive_commission_rate <= max_rate &&
_total_passive_commission_rate <= max_rate &&
_passive_order_payout_rate <= max_rate &&
(_passive_order_payout_rate == 0 || _total_passive_commission_rate == 0),
Errors.InvalidCommissionRate()
);
admin_commission_rate = _admin_commission_rate;
total_aggressive_commission_rate = _total_aggressive_commission_rate;
total_passive_commission_rate = _total_passive_commission_rate;
passive_order_payout_rate = _passive_order_payout_rate;
accumulated_fees = 1; // This is a simple trick to avoid zeroing out issue
}
/// @notice Returns the contract configuration
/// @dev This function provides access to the main contract parameters such as scaling factors, commissions, and token addresses
/// @return _scaling_factor_token_x Scaling factor for token X
/// @return _scaling_factor_token_y Scaling factor for token Y
/// @return _token_x Address of token X
/// @return _token_y Address of token Y
/// @return _supports_native_eth Indicates if the contract supports native ETH transactions
/// @return _is_token_x_weth Indicates if token X is WETH (Wrapped Ether)
/// @return _ask_trie Address of askTrie
/// @return _bid_trie Address of bidTrie
/// @return _admin_commission_rate The commission rate for the administrator
/// @return _total_aggressive_commission_rate The total commission rate for aggressive orders
/// @return _total_passive_commission_rate The total commission rate for passive orders
/// @return _passive_order_payout_rate Payout for passive orders
/// @return _should_invoke_on_trade Flag indicating whether to invoke the onTrade method for the LP contract after each trade
function getConfig() external view returns (
uint256 _scaling_factor_token_x,
uint256 _scaling_factor_token_y,
address _token_x,
address _token_y,
bool _supports_native_eth,
bool _is_token_x_weth,
address _ask_trie,
address _bid_trie,
uint64 _admin_commission_rate,
uint64 _total_aggressive_commission_rate,
uint64 _total_passive_commission_rate,
uint64 _passive_order_payout_rate,
bool _should_invoke_on_trade
) {
return (
scaling_factor_token_x,
scaling_factor_token_y,
address(token_x),
address(token_y),
supports_native_eth,
is_token_x_weth,
address(askTrie),
address(bidTrie),
admin_commission_rate,
total_aggressive_commission_rate,
total_passive_commission_rate,
passive_order_payout_rate,
marketmaker_config.should_invoke_on_trade
);
}
/// @notice Fallback function to handle incoming ETH deposits.
receive() external payable {
require(supports_native_eth
&& (
(is_token_x_weth && msg.sender == address(token_x))
||(!is_token_x_weth && msg.sender == address(token_y))
),
Errors.Forbidden()
);
}
/// @notice Retrieves the balance of a trader by address in tokens stored on the LOB contract
/// @dev Returns the balances of tokens X and Y, and the claimable status for the specified address
/// @param address_ The address of the trader for whom the balance is being retrieved
/// @return token_x Balance of token X for the trader
/// @return token_y Balance of token Y for the trader
/// @return claimable Status indicating whether the user's orders can be automatically claimed from other addresses
function getTraderBalance(address address_) external view returns (uint128, uint128, bool) {
Trader memory trader = traders[address_];
if (trader.trader_id == 0) {
trader.claimable = true; // true by default
}
return (trader.token_x, trader.token_y, trader.claimable);
}
/// @notice Allows the administrator to change the market maker address
/// @param _marketmaker The new address of the market maker
/// @param _should_invoke_on_trade Flag indicating that the market maker must implement ITradeConsumer
/// @param _admin_commission_rate The commission rate for the administrator
/// @dev If the market maker address is null, it can be set by anyone
function changeMarketMaker(
address _marketmaker,
bool _should_invoke_on_trade,
uint64 _admin_commission_rate
) external nonReentrant {
address administrator = owner();
require(msg.sender == administrator, Errors.Forbidden());
_transferFees();
require(_admin_commission_rate <= 1e18, Errors.InvalidCommissionRate());
admin_commission_rate = _admin_commission_rate;
address marketmaker = marketmaker_config.marketmaker;
if (marketmaker != _marketmaker) {
emit MarketMakerChanged(_marketmaker, marketmaker);
}
_changeMarketMaker(_marketmaker, _should_invoke_on_trade);
}
/// @notice The new owner accepts the ownership transfer.
function acceptOwnership() public override nonReentrant {
_transferFees();
super.acceptOwnership();
}
/// @notice Sets the claimable status for the trader calling the function
/// @param status The new claimable status
function setClaimableStatus(bool status) external nonReentrant whenNotPaused {
_getOrCreateTraderId(msg.sender);
traders[msg.sender].claimable = status;
emit ClaimableStatusChanged(msg.sender, status);
}
/// @param isAsk Indicates if the order is a sell order (true) or a buy order (false)
/// @param quantity The amount of tokens to order divided by the scaling factor. This amount would be multiplied by the scaling factor inside the function
/// @param price The price per token in the order, no more than 6 significant digits
/// @param max_commission The maximum commission, which may include passive and/or aggressive fee
/// @param market_only Indicates if the order should be executed only against existing orders in the market
/// @param post_only Indicates if the order should be posted only and not executed immediately
/// @param transfer_executed_tokens Flag for transferring executed tokens (true) or crediting them to the balance (false)
/// @param expires The time at which the order will expire
/// @return order_id The identifier of the created order
/// @return executed_shares Number of executed shares
/// @return executed_value Executed value
/// @return aggressive_fee Aggressive fee
function placeOrder(
bool isAsk,
uint128 quantity,
uint72 price,
uint128 max_commission,
bool market_only,
bool post_only,
bool transfer_executed_tokens,
uint256 expires
) public payable ensure(expires) whenNotPaused returns (
uint64 order_id,
uint128 executed_shares,
uint128 executed_value,
uint128 aggressive_fee
) {
ExecutionResult memory result = _placeOrder(
isAsk,
quantity,
price,
max_commission,
market_only,
post_only,
transfer_executed_tokens
);
order_id = result.order_id;
executed_shares = result.executed_shares;
executed_value = result.executed_value;
aggressive_fee = result.aggressive_fee;
_invokeTradeConsumerCallback(result.executed_shares, isAsk);
}
/// @param isAsk Indicates if the order is a sell order (true) or a buy order (false)
/// @param quantity The amount of tokens to order divided by the scaling factor. This amount would be multiplied by the scaling factor inside the function
/// @param price The price per token in the order, no more than 6 significant digits
/// @param max_commission The maximum commission, which may include passive and/or aggressive fee
/// @param amount_to_approve The amount of tokens to approve divided by the scaling factor. This amount would be multiplied by the scaling factor inside the function
/// @param market_only Indicates if the order should be executed only against existing orders in the market
/// @param post_only Indicates if the order should be posted only and not executed immediately
/// @param transfer_executed_tokens Flag for transferring executed tokens (true) or crediting them to the balance (false)
/// @param expires The time at which the order will expire
/// @param v The component V of the signature
/// @param r The component R of the signature
/// @param s The component S of the signature
/// @return order_id The identifier of the created order
/// @return executed_shares Number of executed shares
/// @return executed_value Executed value
/// @return aggressive_fee Aggressive fee
function placeOrder(
bool isAsk,
uint128 quantity,
uint72 price,
uint128 max_commission,
uint128 amount_to_approve,
bool market_only,
bool post_only,
bool transfer_executed_tokens,
uint256 expires,
uint8 v,
bytes32 r,
bytes32 s
) public payable ensure(expires) whenNotPaused returns (
uint64 order_id,
uint128 executed_shares,
uint128 executed_value,
uint128 aggressive_fee
) {
address token_address = isAsk
? address(token_x)
: address(token_y);
IERC20Permit token = IERC20Permit(token_address);
uint256 value = isAsk
? amount_to_approve * scaling_factor_token_x
: amount_to_approve * scaling_factor_token_y;
try token.permit(msg.sender, address(this), value, expires, v, r, s) {} catch {}
ExecutionResult memory result = _placeOrder(
isAsk,
quantity,
price,
max_commission,
market_only,
post_only,
transfer_executed_tokens
);
order_id = result.order_id;
executed_shares = result.executed_shares;
executed_value = result.executed_value;
aggressive_fee = result.aggressive_fee;
_invokeTradeConsumerCallback(result.executed_shares, isAsk);
}
/// @notice Places a market order with a target token Y
/// @param isAsk Order direction: true for sell (ask), false for buy (bid)
/// @param target_token_y_value Target value of token Y for execution
/// @param price Order price
/// @param max_commission Maximum commission
/// @param transfer_executed_tokens Flag for transferring executed tokens
/// @param expires Time when the order expires
/// @return executed_shares Number of executed shares
/// @return executed_value Executed value
/// @return aggressive_fee Aggressive fee
function placeMarketOrderWithTargetValue(
bool isAsk,
uint128 target_token_y_value,
uint72 price,
uint128 max_commission,
bool transfer_executed_tokens,
uint256 expires
) public payable ensure(expires) whenNotPaused returns (
uint128 executed_shares,
uint128 executed_value,
uint128 aggressive_fee
) {
uint24 packed_price = FP24.packFP24(price);
uint64 price_id = _genPriceId(packed_price, isAsk);
uint128 order_quantity;
uint128 total_fees_and_payout_rate = total_aggressive_commission_rate + passive_order_payout_rate;
if (isAsk) {
uint128 adjusted_token_y_value = uint256(target_token_y_value).mulDivDown(
wad, wad - total_fees_and_payout_rate
).toUint128();
(order_quantity, ) = bidTrie.previewExecuteRight(
price_id, type(uint128).max, adjusted_token_y_value
);
} else {
uint128 adjusted_token_y_value = uint256(target_token_y_value).mulDivDown(
wad, wad + total_fees_and_payout_rate
).toUint128();
(order_quantity, ) = askTrie.previewExecuteRight(
price_id, type(uint128).max, adjusted_token_y_value
);
}
ExecutionResult memory result = _placeOrder(
isAsk,
order_quantity,
price,
max_commission,
true, // market_only
false, // post_only
transfer_executed_tokens
);
executed_shares = result.executed_shares;
executed_value = result.executed_value;
aggressive_fee = result.aggressive_fee;
_invokeTradeConsumerCallback(result.executed_shares, isAsk);
}
/// @notice Places a market order with a target token Y value using EIP-2612 permit
/// @param isAsk Order direction: true for sell (ask), false for buy (bid)
/// @param target_token_y_value Target value of token Y for execution
/// @param price Order price
/// @param max_commission Maximum commission
/// @param amount_to_approve The amount of tokens to approve divided by the scaling factor. This amount would be multiplied by the scaling factor inside the function
/// @param transfer_executed_tokens Flag for transferring executed tokens
/// @param expires Time when the order expires
/// @param v Signature component v
/// @param r Signature component r
/// @param s Signature component s
/// @return executed_shares Number of executed shares
/// @return executed_value Executed value
/// @return aggressive_fee Aggressive fee
function placeMarketOrderWithTargetValue(
bool isAsk,
uint128 target_token_y_value,
uint72 price,
uint128 max_commission,
uint128 amount_to_approve,
bool transfer_executed_tokens,
uint256 expires,
uint8 v,
bytes32 r,
bytes32 s
) external payable ensure(expires) whenNotPaused returns (
uint128 executed_shares,
uint128 executed_value,
uint128 aggressive_fee
) {
address token_address = isAsk
? address(token_x)
: address(token_y);
IERC20Permit token = IERC20Permit(token_address);
uint256 value = isAsk
? amount_to_approve * scaling_factor_token_x
: amount_to_approve * scaling_factor_token_y;
try token.permit(msg.sender, address(this), value, expires, v, r, s) {} catch {}
return placeMarketOrderWithTargetValue(
isAsk,
target_token_y_value,
price,
max_commission,
transfer_executed_tokens,
expires
);
}
/// @notice Allows a trader to claim or fully cancel the order
/// @param order_id The identifier of the order to claim
/// @param only_claim A flag indicating that only the executed part of the order should be sent
/// without unnecessarily removing the order.
/// @param transfer_tokens If true, transfers the tokens to the trader's address
/// @param expires The time at which the order will expire
function claimOrder(
uint64 order_id,
bool only_claim,
bool transfer_tokens,
uint256 expires
) public ensure(expires) nonReentrant whenNotPaused {
_calculateAndSendOrderPayout(msg.sender, order_id, only_claim, transfer_tokens);
}
/// @notice Allows batch claiming of orders for multiple addresses
/// @param addresses Array of trader addresses claiming orders
/// @param order_ids Array of order IDs corresponding to trader addresses
/// @param only_claim A flag indicating that only the executed part of the order should be sent
/// without unnecessarily removing the order.
/// @param expires The time at which the order will expire
function batchClaim(
address[] memory addresses,
uint64[] memory order_ids,
bool only_claim,
uint256 expires
) external ensure(expires) nonReentrant whenNotPaused {
require(addresses.length == order_ids.length, Errors.ArrayLengthMismatch());
for (uint i = 0; i < addresses.length; i++) {
_calculateAndSendOrderPayout(addresses[i], order_ids[i], only_claim, true);
}
}
/// @notice Claiming/canceling an existing order and creating the new one with the same (bid/ask) direction
/// @param old_order_id The identifier of the order to modify
/// @param new_quantity The amount of tokens for the new order
/// @param new_price The price per token for new order, no more than 6 significant digits
/// @param max_commission The maximum commission, which may include passive and/or aggressive fee
/// @param post_only Indicates if the order should be posted only and not executed immediately
/// @param transfer_tokens If true, tokens will be transferred to the order owner
/// @param expires The time at which the order will expire
function changeOrder(
uint64 old_order_id,
uint128 new_quantity,
uint72 new_price,
uint128 max_commission,
bool post_only,
bool transfer_tokens,
uint256 expires
) public whenNotPaused returns (uint64 order_id) {
if (old_order_id > 0x1) {
claimOrder(old_order_id, false, transfer_tokens, expires);
}
if (new_quantity > 0) {
bool isAsk = (old_order_id & uint64(0x1)) == 0x1;
(order_id, , , ) = placeOrder(
isAsk,
new_quantity,
new_price,
max_commission,
false,
post_only,
transfer_tokens,
expires
);
}
}
/// @notice Allows batch placing or changing of orders for multiple addresses
/// @param order_ids Array of order IDs or directions corresponding to orders
/// @param quantities Array of amounts of tokens for the new orders
/// @param prices Array of prices per token for new orders, no more than 6 significant digits for every price
/// @param max_commission_per_order The maximum commission per order, which may include passive and/or aggressive fee
/// @param post_only Indicates if the order should be posted only and not executed immediately
/// @param transfer_tokens If true, tokens will be transferred to the order owners
/// @param expires The time at which the order will expire
/// @return new_order_ids Array of new order IDs
function batchChangeOrder(
uint64[] memory order_ids,
uint128[] memory quantities,
uint72[] memory prices,
uint128 max_commission_per_order,
bool post_only,
bool transfer_tokens,
uint256 expires
) external ensure(expires) whenNotPaused returns (uint64[] memory new_order_ids) {
require(
order_ids.length == quantities.length && order_ids.length == prices.length,
Errors.ArrayLengthMismatch()
);
new_order_ids = new uint64[](order_ids.length);
for (uint i = 0; i < order_ids.length; i++) {
new_order_ids[i] = changeOrder(
order_ids[i],
quantities[i],
prices[i],
max_commission_per_order,
post_only,
transfer_tokens,
expires
);
}
return new_order_ids;
}
/// @notice Deposits the specified amounts of token X and token Y into the trader's balance on the contract
/// @param token_x_amount The amount of token X to deposit
/// @param token_y_amount The amount of token Y to deposit
function depositTokens(
uint128 token_x_amount,
uint128 token_y_amount
) public nonReentrant whenNotPaused {
uint256 actual_token_x_to_receive = 0;
uint256 actual_token_y_to_receive = 0;
if (token_x_amount > 0) {
traders[msg.sender].token_x += token_x_amount;
actual_token_x_to_receive = _convertToActualTokenXAmount(token_x_amount);
}
if (token_y_amount > 0) {
traders[msg.sender].token_y += token_y_amount;
actual_token_y_to_receive = _convertToActualTokenYAmount(token_y_amount);
}
// actual erc20 transactions
if (actual_token_x_to_receive > 0) {
_safeTansferFromWithBalanceCheck(token_x, msg.sender, address(this), actual_token_x_to_receive);
}
if (actual_token_y_to_receive > 0) {
_safeTansferFromWithBalanceCheck(token_y, msg.sender, address(this), actual_token_y_to_receive);
}
emit Deposited(msg.sender, token_x_amount, token_y_amount);
}
/// @notice Deposits the specified amounts of token X and token Y into the trader's balance on the contract
/// @param token_x_amount The amount of token X to deposit
/// @param token_y_amount The amount of token Y to deposit
/// @param v_x The component V of the signature for token X
/// @param r_x The component R of the signature for token X
/// @param s_x The component S of the signature for token X
/// @param v_y The component V of the signature for token Y
/// @param r_y The component R of the signature for token Y
/// @param s_y The component S of the signature for token Y
/// @param expires The time at which the signatures will expire
function depositTokens(
uint128 token_x_amount,
uint128 token_y_amount,
uint8 v_x,
bytes32 r_x,
bytes32 s_x,
uint8 v_y,
bytes32 r_y,
bytes32 s_y,
uint256 expires
) external whenNotPaused {
if (token_x_amount > 0) {
IERC20Permit token_x_permit = IERC20Permit(address(token_x));
try token_x_permit.permit(
msg.sender,
address(this),
token_x_amount * scaling_factor_token_x,
expires,
v_x,
r_x,
s_x
) {} catch {}
}
if (token_y_amount > 0) {
IERC20Permit token_y_permit = IERC20Permit(address(token_y));
try token_y_permit.permit(
msg.sender,
address(this),
token_y_amount * scaling_factor_token_y,
expires,
v_y,
r_y,
s_y
) {} catch {}
}
depositTokens(token_x_amount, token_y_amount);
}
/// @notice Withdraws specified amounts of token X and token Y from the trader's balance on the contract
/// @param withdraw_all If set to true, withdraws all the trader's tokens; otherwise, uses the specified amounts
/// @param token_x_amount The amount of token X to withdraw (ignored if withdraw_all = true)
/// @param token_y_amount The amount of token Y to withdraw (ignored if withdraw_all = true)
function withdrawTokens(
bool withdraw_all,
uint128 token_x_amount,
uint128 token_y_amount
) external nonReentrant whenNotPaused {
uint256 actual_token_x_to_send = 0;
uint256 actual_token_y_to_send = 0;
uint128 clients_shares = traders[msg.sender].token_x;
uint128 clients_value = traders[msg.sender].token_y;
if (withdraw_all) {
token_x_amount = clients_shares;
token_y_amount = clients_value;
}
if (token_x_amount > 0) {
require(clients_shares >= token_x_amount, Errors.InsufficientTokenXBalance());
unchecked {
traders[msg.sender].token_x = clients_shares - token_x_amount;
}
actual_token_x_to_send = _convertToActualTokenXAmount(token_x_amount);
}
if (token_y_amount > 0) {
require(clients_value >= token_y_amount, Errors.InsufficientTokenYBalance());
unchecked {
traders[msg.sender].token_y = clients_value - token_y_amount;
}
actual_token_y_to_send = _convertToActualTokenYAmount(token_y_amount);
}
// actual erc20 transactions
if (actual_token_x_to_send > 0) {
token_x.safeTransfer(msg.sender, actual_token_x_to_send);
}
if (actual_token_y_to_send > 0) {
token_y.safeTransfer(msg.sender, actual_token_y_to_send);
}
emit Withdrawn(msg.sender, token_x_amount, token_y_amount);
}
/// @notice Returns the accumulated fees.
/// @return The actual accumulated fees.
function getAccumulatedFees() external view returns (uint256) {
return (accumulated_fees - 1);
}
/// @notice Transfers the accumulated commissions to the administrator and marketmaker.
function transferFees() external whenNotPaused {
_transferFees();
}
/// @notice Pause contract
/// @dev Can be called by administrator and pauser
function pause() external {
require(msg.sender == owner() || msg.sender == pauser, Errors.Forbidden());
_pause();
}
/// @notice Unpause contract
/// @dev Can be called by administrator
function unpause() external onlyOwner {
_unpause();
}
/// @notice Change pauser by administrator
/// @param pauser_ New pauser address
/// @dev Can be called only by administrator
function changePauser(address pauser_) external onlyOwner {
if (pauser == pauser_) {
return;
}
emit PauserChanged(pauser_, pauser);
pauser = pauser_;
}
/// @notice Extracts the direction and price from the given order ID.
/// @param order_id The unique identifier of the order.
/// @return isAsk A boolean indicating if the order is an ask (true) or a bid (false).
/// @return price The price of the order.
function _extractDirectionAndPrice(uint64 order_id) internal pure returns (bool isAsk, uint72 price) {
// Orders with an order_id ending in 1 are asks, and those ending in 0 are bids.
isAsk = (order_id & uint64(0x1)) == 0x1;
uint24 packed_price = uint24(order_id >> (nonce_length + 1));
if (isAsk) {
unchecked{
packed_price = type(uint24).max - packed_price;
}
}
price = FP24.unPackFP24(packed_price);
}
function _authorizeUpgrade(address) internal override onlyOwner {}
/// @param isAsk Indicates if the order is a sell order (true) or a buy order (false)
/// @param quantity The amount of tokens to order divided by the scaling factor. This amount would be multiplied by the scaling factor inside the function
/// @param price The price per token in the order, no more than 6 significant digits
/// @param max_commission The maximum commission, which may include passive and/or aggressive fee
/// @param market_only Indicates if the order should be executed only against existing orders in the market
/// @param post_only Indicates if the order should be posted only and not executed immediately
/// @param transfer_executed_tokens Flag for transferring executed tokens (true) or crediting them to the balance (false)
/// @return execution_result ExecutionResult structure containing information about the executed order
function _placeOrder(
bool isAsk,
uint128 quantity,
uint72 price,
uint128 max_commission,
bool market_only,
bool post_only,
bool transfer_executed_tokens
) internal nonReentrant returns (ExecutionResult memory execution_result) {
require(!market_only || !post_only, Errors.MarketOnlyAndPostOnlyFlagsConflict());
require(quantity != 0 && price != 0, Errors.ZeroTokenTransferNotAllowed());
require(
msg.value == 0 || (supports_native_eth && (isAsk == is_token_x_weth)),
Errors.NativeETHDisabled()
);
uint24 packed_price = FP24.packFP24(price);
uint64 price_id = _genPriceId(packed_price, isAsk);
if (post_only) {
bool aggressive_trade = false;
if (isAsk) {
if (price_id <= bidTrie.best_offer()) {
aggressive_trade = true;
}
} else {
if (price_id <= askTrie.best_offer()) {
aggressive_trade = true;
}
}
if (aggressive_trade) {
if (msg.value > 0) {
_sendETH(msg.sender, msg.value);
}
emit OrderPlaced(
msg.sender,
0x0, // order_id
isAsk,
quantity,
price,
0, // passive_shares,
0, // passive_fee
0, // executed_shares
0, // executed_value
0, // aggressive_fee
false, // market_only,
true // post_only
);
return execution_result;
}
}
uint128 x_to_send;
uint128 y_to_send;
uint128 x_to_receive;
uint128 y_to_receive;
// processing aggressive part
uint128 executed_shares;
uint128 executed_value;
uint128 aggressive_fee;
if (!post_only) {
if (isAsk) {
(executed_shares, executed_value) = bidTrie.executeRight(price_id, quantity);
x_to_receive = executed_shares;
y_to_send = executed_value;
} else {
(executed_shares, executed_value) = askTrie.executeRight(price_id, quantity);
x_to_send = executed_shares;
y_to_receive = executed_value;
}
aggressive_fee = _calculateAndTransferTotalAggressiveFeesAndPayout(executed_value);
y_to_receive += aggressive_fee;
if (executed_shares > 0){
require(watch_dog.isChainStable(), Errors.ChainIsUnstableForTrades());
}
execution_result.executed_shares = executed_shares;
execution_result.executed_value = executed_value;
execution_result.aggressive_fee = aggressive_fee;
}
// processing passive part
uint64 order_id;
uint128 passive_shares = !market_only ? (quantity - executed_shares) : 0;
uint128 passive_fee;
if (passive_shares > 0) {
order_id = _genOrderId(packed_price, isAsk);
uint64 trader_id = _getOrCreateTraderId(msg.sender);
uint128 total_value = passive_shares * price;
passive_fee = _calculateTotalPassiveCommission(total_value);
if (isAsk) {
askTrie.addOrder(trader_id, order_id, passive_shares, total_value);
x_to_receive += passive_shares;
} else {
bidTrie.addOrder(trader_id, order_id, passive_shares, total_value);
// Orders with an order_id ending in 1 are asks, and those ending in 0 are bids.
order_id ^= 0x1;
y_to_receive += total_value + passive_fee;
}
execution_result.order_id = order_id;
}
require(passive_fee + aggressive_fee <= max_commission, Errors.MaxCommissionFailure());
emit OrderPlaced(
msg.sender,
order_id,
isAsk,
quantity,
price,
passive_shares,
passive_fee,
executed_shares,
executed_value,
aggressive_fee,
market_only,
post_only
);
// actual token transfer
_handleTokenTransfer(
msg.sender,
transfer_executed_tokens,
x_to_send,
x_to_receive,
y_to_send,
y_to_receive
);
}
/// @notice Change market maker address and should invoke on trade flag
/// @param _marketmaker New market maker address
/// @param _should_invoke_on_trade Flag indicating that the market maker must implement ITradeConsumer
function _changeMarketMaker(
address _marketmaker,
bool _should_invoke_on_trade
) internal {
if (_should_invoke_on_trade) {
IERC165 maker = IERC165(_marketmaker);
if (!maker.supportsInterface(type(ITradeConsumer).interfaceId)) {
revert Errors.InvalidMarketMaker();
}
}
require(_marketmaker != address(0), Errors.AddressIsZero());
marketmaker_config = MarketMakerConfig ({
marketmaker: _marketmaker,
should_invoke_on_trade: _should_invoke_on_trade
});
}
/// @notice Transfers the accumulated commissions to the administrator and marketmaker.
function _transferFees() internal {
uint256 total_fees = (accumulated_fees - 1) / wad;
accumulated_fees -= total_fees * wad;
if (total_fees == 0) {
return;
}
address administrator = owner();
uint256 admin_fees = total_fees.mulWadUp(admin_commission_rate);
uint256 marketmaker_fees = total_fees - admin_fees;
if (marketmaker_fees > 0) {
traders[marketmaker_config.marketmaker].token_y += marketmaker_fees.toUint128();
}
uint256 actual_token_y_to_send = _convertToActualTokenYAmount(admin_fees.toUint128());
if (actual_token_y_to_send > 0){
token_y.safeTransfer(administrator, actual_token_y_to_send);
}
}
/// @notice Retrieves or creates a trader ID for a given address.
/// @param trader_address The address of the trader for whom the ID is to be retrieved or created.
/// @return trader_id The trader ID associated with the given address.
function _getOrCreateTraderId(address trader_address) internal returns (uint64 trader_id) {
trader_id = traders[trader_address].trader_id;
if (trader_id == 0) {
// initialize a new Trader structure
trader_id = ++last_used_trader_id;
traders[trader_address].trader_id = trader_id;
traders[trader_address].claimable = true;
}
}
/// @notice Calculates and transfers the total fees and payout.
/// @param executed_value The value of the executed order.
/// @return The total aggressive fees calculated and transferred.
function _calculateAndTransferTotalAggressiveFeesAndPayout(uint128 executed_value) internal
returns (uint128) {
if (executed_value == 0) {
return 0;
}
uint128 total_fees_and_payout_rate = total_aggressive_commission_rate + passive_order_payout_rate;
if (total_fees_and_payout_rate == 0) {
return 0;
}
uint256 total_aggressive_fees_and_payout = uint256(executed_value).mulWadUp(
total_fees_and_payout_rate
);
accumulated_fees += (
total_aggressive_fees_and_payout * wad
- executed_value * uint256(passive_order_payout_rate)
+ executed_value * uint256(total_passive_commission_rate)
);
return total_aggressive_fees_and_payout.toUint128();
}
/// @notice Calculates the total passive commission for a given value.
/// @param total_value The total value for which the passive commission is to be calculated.
/// @return The total passive commission calculated.
function _calculateTotalPassiveCommission(uint128 total_value) internal view returns (uint128) {
if (total_passive_commission_rate == 0){
return 0;
}
uint256 total_passive_commissions = uint256(total_value).mulWadUp(total_passive_commission_rate);
return total_passive_commissions.toUint128();
}
/// @notice Calculates the passive order payout or refunded commissions based on the remaining shares.
/// @param isAsk A boolean flag indicating whether the order is an ask (true) or a bid (false).
/// @param price The price of the order.
/// @param remain_shares The remaining shares of the order.
/// @param total_shares The total shares of the order.
/// @return refund_value The calculated passive payout or refunded commissions.
/// @return fee_rounding_error The rounding error in the fee calculation.
function _calculatePassiveOrderPayoutOrRefundedCommissions(
bool isAsk,
uint72 price,
uint128 remain_shares,
uint128 total_shares
) internal view returns(uint128 refund_value, uint256 fee_rounding_error) {
if (passive_order_payout_rate > 0) {
uint256 executed_value = price * (total_shares - remain_shares);
uint256 passive_payout = executed_value.mulWadDown(passive_order_payout_rate);
refund_value = passive_payout.toUint128();
fee_rounding_error = executed_value * passive_order_payout_rate - refund_value * wad;
} else {
// Refunding part of the passive commission.
uint128 executed_value = price * (total_shares - remain_shares);
uint256 executed_fees = _calculateTotalPassiveCommission(executed_value);
fee_rounding_error = executed_fees * wad - executed_value * total_passive_commission_rate;
if (!isAsk) {
uint128 total_value = price * total_shares;
uint128 total_fees = _calculateTotalPassiveCommission(total_value);
refund_value = total_fees - executed_fees.toUint128();
}
}
}
/// @notice Decrements the nonce and returns the new value, reverts if nonce reaches zero.
/// @dev This function is used to ensure unique order identifiers by decrementing the nonce.
/// If the nonce reaches zero, the function will revert to prevent identifier collisions.
/// @return c_nonce The decremented nonce value.
function _getAndUpdateNonce() internal returns (uint64 c_nonce) {
c_nonce = nonce;
unchecked {
nonce -= 1;
}
require(nonce > 0, Errors.NonceExhaustedFailure());
}
/// @notice Generates a unique price identifier based on the given price and order type.
/// @param packed_price The FP2 price of the order.
/// @param isAsk A boolean indicating whether the order is an ask (true) or a bid (false).
/// @return price_id The generated unique identifier for the price.
function _genPriceId(uint24 packed_price, bool isAsk) internal pure returns (uint64 price_id) {
if (isAsk) {
price_id = uint64(packed_price) << nonce_length;
} else {
uint64 max_price = type(uint24).max;
unchecked {
price_id = (max_price - packed_price) << nonce_length;
}
}
price_id = price_id << 1 ^ 0x1;
}
/// @notice Generates a unique order identifier based on the price and order type.
/// @param packed_price The FP24 price of the order.
/// @param isAsk A boolean indicating whether the order is an ask (true) or a bid (false).
/// @return order_id The generated unique identifier for the order.
function _genOrderId(uint24 packed_price, bool isAsk) internal returns (uint64 order_id) {
uint64 c_nonce = _getAndUpdateNonce();
if (isAsk) {
unchecked {
order_id = ((uint64(type(uint24).max - packed_price) << nonce_length) | c_nonce);
}
} else {
order_id = ((uint64(packed_price) << nonce_length) | c_nonce);
}
order_id = order_id << 1 ^ 0x1;
}
/// @notice Converts the amount of token X from a simplified representation to the actual ERC20 amount.
/// @dev Multiplies the amount of token X by the scaling factor to obtain the actual amount.
/// @param token The amount of token X in a simplified representation.
/// @return Returns the actual amount of token X after scaling.
function _convertToActualTokenXAmount(uint128 token) internal view returns (uint256) {
return token * scaling_factor_token_x;
}
/// @notice Converts the amount of token Y from a simplified representation to the actual ERC20 amount.
/// @dev Multiplies the amount of token Y by the scaling factor to obtain the actual amount.
/// @param token The amount of token Y in a simplified representation.
/// @return Returns the actual amount of token Y after scaling.
function _convertToActualTokenYAmount(uint128 token) internal view returns (uint256) {
return token * scaling_factor_token_y;
}
/// @dev Calculates the payout for an order and, if necessary, transfers the tokens.
/// @param owner The owner of the order for which the payout is being calculated.
/// @param order_id The identifier of the order for which the payout is being calculated.
/// @param only_claim A flag indicating that only the executed part of the order should be sent
/// without unnecessarily removing the order.
/// @param transfer_tokens If true, tokens will be transferred to the order owner.
function _calculateAndSendOrderPayout(
address owner,
uint64 order_id,
bool only_claim,
bool transfer_tokens
) internal {
uint64 trader_id = _getOrCreateTraderId(owner);
require(traders[owner].claimable || (msg.sender == owner), Errors.ClaimNotAllowed());
(bool isAsk, uint72 price) = _extractDirectionAndPrice(order_id);
uint128 x_to_send;
uint128 y_to_send;
uint128 total_shares;
uint128 remain_shares;
uint128 order_shares_remaining = 0;
if (isAsk) {
if (only_claim) {
uint128 executed_shares;
(executed_shares, order_shares_remaining) = askTrie.claimExecuted(order_id, trader_id);
total_shares = executed_shares;
remain_shares = 0;
} else {
(total_shares, remain_shares) = askTrie.removeOrder(order_id, trader_id);
}
uint128 executed_value = (total_shares - remain_shares) * price;
uint128 fees = _calculateTotalPassiveCommission(executed_value);
x_to_send = remain_shares;
y_to_send = executed_value - fees;
} else {
if (only_claim) {
uint128 executed_shares;
(executed_shares, order_shares_remaining) = bidTrie.claimExecuted(order_id|0x1, trader_id);
total_shares = executed_shares;
remain_shares = 0;
} else {
(total_shares, remain_shares) = bidTrie.removeOrder(order_id|0x1, trader_id);
}
x_to_send = total_shares - remain_shares;
y_to_send = remain_shares * price;
}
(uint128 passive_payout, uint256 fee_rounding_error) = _calculatePassiveOrderPayoutOrRefundedCommissions(
isAsk, price, remain_shares, total_shares
);
emit OrderClaimed(order_id, order_shares_remaining, x_to_send, y_to_send, passive_payout, only_claim);
y_to_send += passive_payout;
accumulated_fees += fee_rounding_error;
require((remain_shares == 0) || (msg.sender == owner), Errors.OnlyOwnerCanCancelOrders());
_handleTokenTransfer(owner, transfer_tokens, x_to_send, 0, y_to_send, 0);
}
/// @dev Handles the transfer of tokens during the execution or claiming/cancelling of an order.
/// @param client The address of the trader executing the order.
/// @param transfer_tokens A boolean flag indicating whether to transfer the tokens immediately.
/// @param x_to_send The amount of token X to send.
/// @param x_to_receive The amount of token X to receive.
/// @param y_to_send The amount of token Y to send.
/// @param y_to_receive The amount of token Y to receive.
function _handleTokenTransfer(
address client,
bool transfer_tokens,
uint128 x_to_send,
uint128 x_to_receive,
uint128 y_to_send,
uint128 y_to_receive
) internal {
uint256 actual_token_x_to_send = 0;
uint256 actual_token_x_to_receive = 0;
uint256 actual_token_y_to_send = 0;
uint256 actual_token_y_to_receive = 0;
IWETH weth = is_token_x_weth ? IWETH(address(token_x)) : IWETH(address(token_y));
if (msg.value > 0) {
if (is_token_x_weth) {
uint128 extra_x = (msg.value / scaling_factor_token_x).toUint128();
uint256 actual_value = _convertToActualTokenXAmount(extra_x);
x_to_send += extra_x;
uint256 rounded_value = msg.value - actual_value;
actual_token_x_to_send = rounded_value;
} else {
uint128 extra_y = (msg.value / scaling_factor_token_y).toUint128();
uint256 actual_value = _convertToActualTokenYAmount(extra_y);
y_to_send += extra_y;
uint256 rounded_value = msg.value - actual_value;
actual_token_y_to_send = rounded_value;
}
}
// processing token_x
if (x_to_send > x_to_receive) {
uint128 shares_to_send;
unchecked {
shares_to_send = x_to_send - x_to_receive;
}
if (transfer_tokens) {
actual_token_x_to_send += _convertToActualTokenXAmount(shares_to_send);
} else {
traders[client].token_x += shares_to_send;
emit Deposited(client, shares_to_send, 0);
}
} else if (x_to_send < x_to_receive) {
uint128 shares_to_receive;
unchecked {
shares_to_receive = x_to_receive - x_to_send;
}
uint128 clients_shares = traders[client].token_x;
if (clients_shares >= shares_to_receive) {
unchecked {
traders[client].token_x -= shares_to_receive;
}
emit Withdrawn(client, shares_to_receive, 0);
} else {
unchecked {
shares_to_receive -= clients_shares;
}
actual_token_x_to_receive = _convertToActualTokenXAmount(shares_to_receive);
traders[client].token_x = 0;
emit Withdrawn(client, clients_shares, 0);
}
}
// processing token_y
if (y_to_send > y_to_receive) {
uint128 value_to_send;
unchecked {
value_to_send = y_to_send - y_to_receive;
}
if (transfer_tokens) {
actual_token_y_to_send += _convertToActualTokenYAmount(value_to_send);
} else {
traders[client].token_y += value_to_send;
emit Deposited(client, 0, value_to_send);
}
} else if (y_to_send < y_to_receive) {
uint128 value_to_receive;
unchecked {
value_to_receive = y_to_receive - y_to_send;
}
uint128 clients_value = traders[client].token_y;
if (clients_value >= value_to_receive) {
unchecked {
traders[client].token_y -= value_to_receive;
}
emit Withdrawn(client, 0, value_to_receive);
} else {
unchecked {
value_to_receive -= clients_value;
}
actual_token_y_to_receive = _convertToActualTokenYAmount(value_to_receive);
traders[client].token_y = 0;
emit Withdrawn(client, 0, clients_value);
}
}
// Withdrawing WETH
if (supports_native_eth) {
uint256 value_to_withdraw;
if (is_token_x_weth && (actual_token_x_to_send > address(this).balance)) {
value_to_withdraw = actual_token_x_to_send - address(this).balance;
}
if (!is_token_x_weth && (actual_token_y_to_send > address(this).balance)) {
value_to_withdraw = actual_token_y_to_send - address(this).balance;
}
if (value_to_withdraw > 0) {
weth.withdraw(value_to_withdraw);
}
}
// actual erc20 transactions
if (actual_token_x_to_send > 0) {
if (supports_native_eth && is_token_x_weth) {
_sendETH(client, actual_token_x_to_send);
} else {
token_x.safeTransfer(client, actual_token_x_to_send);
}
}
if (actual_token_x_to_receive > 0) {
_safeTansferFromWithBalanceCheck(token_x, client, address(this), actual_token_x_to_receive);
}
if (actual_token_y_to_send > 0) {
if (supports_native_eth && !is_token_x_weth) {
_sendETH(client, actual_token_y_to_send);
} else {
token_y.safeTransfer(client, actual_token_y_to_send);
}
}
if (actual_token_y_to_receive > 0) {
_safeTansferFromWithBalanceCheck(token_y, client, address(this), actual_token_y_to_receive);
}
// Depositing WETH
if (address(this).balance > 0) {
weth.deposit{value: address(this).balance}();
}
}
/// @dev Transfer tokens safely with balance check
/// @param token Token contract
/// @param from The address from which tokens are sent
/// @param to The address to which tokens are sent
/// @param value Amount of tokens
function _safeTansferFromWithBalanceCheck(IERC20 token, address from, address to, uint256 value) internal {
uint256 balance_before = token.balanceOf(address(this));
token.safeTransferFrom(from, to, value);
uint256 balance_after = token.balanceOf(address(this));
require(balance_after - balance_before == value, Errors.InvalidTransfer());
}
/// @notice Sends ETH to the specified address
/// @dev Uses a low-level call to send ETH, which allows bypassing the 2300 gas limit imposed by transfer function
/// @param to The recipient address for ETH
/// @param value The amount of ETH to send (in wei)
function _sendETH(address to, uint256 value) internal {
(bool success, ) = to.call{value: value}("");
require(success, Errors.TransferFailed());
}
/// @dev Invoke TradeConsumer onTrade callback if executed shares are greater than zero, msg.sender is not
/// market maker and should_invoke_on_trade is true
/// @param executed_shares Executed shares
/// @param isAsk A boolean indicating whether the order is an ask (true) or a bid (false)
function _invokeTradeConsumerCallback(uint128 executed_shares, bool isAsk) internal {
if (executed_shares == 0)
return;
if (marketmaker_config.should_invoke_on_trade && msg.sender != marketmaker_config.marketmaker) {
ITradeConsumer(marketmaker_config.marketmaker).onTrade(isAsk);
}
}
}
// SPDX-License-Identifier: BUSL-1.1
// Central Limit Order Book (CLOB) exchange
// (c) Long Gamma Labs, 2023.
pragma solidity ^0.8.26;
import {ERC1967Proxy} from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
contract Proxy is ERC1967Proxy {
constructor(address _implementation, bytes memory _data) ERC1967Proxy(_implementation, _data) {}
}
// SPDX-License-Identifier: BUSL-1.1
// Central Limit Order Book (CLOB) exchange
// (c) Long Gamma Labs, 2023.
pragma solidity ^0.8.26;
interface IOnchainCLOBFactory {
function setDeployer(address deployer, bool allowed) external;
function createOnchainCLOB(
address tokenXAddress,
address tokenYAddress,
bool supports_native_eth,
bool is_token_x_weth,
uint256 scaling_token_x,
uint256 scaling_token_y,
address administrator,
address marketmaker,
address pauser,
bool should_invoke_on_trade,
uint64 admin_commission_rate,
uint64 total_aggressive_commission_rate,
uint64 total_passive_commission_rate,
uint64 passive_order_payout
) external returns (address);
}
// SPDX-License-Identifier: BUSL-1.1
// Central Limit Order Book (CLOB) exchange
// (c) Long Gamma Labs, 2023.
pragma solidity ^0.8.26;
interface ITrieFactory {
function createTrie(address lob) external returns (address);
}
// 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) (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/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/introspection/IERC165.sol)
pragma solidity ^0.8.20;
/**
* @dev Interface of the ERC165 standard, as defined in the
* https://eips.ethereum.org/EIPS/eip-165[EIP].
*
* Implementers can declare support of contract interfaces, which can then be
* queried by others ({ERC165Checker}).
*
* For an implementation, see {ERC165}.
*/
interface IERC165 {
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable2Step.sol)
pragma solidity ^0.8.20;
import {OwnableUpgradeable} from "./OwnableUpgradeable.sol";
import {Initializable} from "../proxy/utils/Initializable.sol";
/**
* @dev Contract module which provides access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* The initial owner is specified at deployment time in the constructor for `Ownable`. This
* can later be changed with {transferOwnership} and {acceptOwnership}.
*
* This module is used through inheritance. It will make available all functions
* from parent (Ownable).
*/
abstract contract Ownable2StepUpgradeable is Initializable, OwnableUpgradeable {
/// @custom:storage-location erc7201:openzeppelin.storage.Ownable2Step
struct Ownable2StepStorage {
address _pendingOwner;
}
// keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Ownable2Step")) - 1)) & ~bytes32(uint256(0xff))
bytes32 private constant Ownable2StepStorageLocation = 0x237e158222e3e6968b72b9db0d8043aacf074ad9f650f0d1606b4d82ee432c00;
function _getOwnable2StepStorage() private pure returns (Ownable2StepStorage storage $) {
assembly {
$.slot := Ownable2StepStorageLocation
}
}
event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner);
function __Ownable2Step_init() internal onlyInitializing {
}
function __Ownable2Step_init_unchained() internal onlyInitializing {
}
/**
* @dev Returns the address of the pending owner.
*/
function pendingOwner() public view virtual returns (address) {
Ownable2StepStorage storage $ = _getOwnable2StepStorage();
return $._pendingOwner;
}
/**
* @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one.
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual override onlyOwner {
Ownable2StepStorage storage $ = _getOwnable2StepStorage();
$._pendingOwner = newOwner;
emit OwnershipTransferStarted(owner(), newOwner);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner.
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual override {
Ownable2StepStorage storage $ = _getOwnable2StepStorage();
delete $._pendingOwner;
super._transferOwnership(newOwner);
}
/**
* @dev The new owner accepts the ownership transfer.
*/
function acceptOwnership() public virtual {
address sender = _msgSender();
if (pendingOwner() != sender) {
revert OwnableUnauthorizedAccount(sender);
}
_transferOwnership(sender);
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Pausable.sol)
pragma solidity ^0.8.20;
import {ContextUpgradeable} from "../utils/ContextUpgradeable.sol";
import {Initializable} from "../proxy/utils/Initializable.sol";
/**
* @dev Contract module which allows children to implement an emergency stop
* mechanism that can be triggered by an authorized account.
*
* This module is used through inheritance. It will make available the
* modifiers `whenNotPaused` and `whenPaused`, which can be applied to
* the functions of your contract. Note that they will not be pausable by
* simply including this module, only once the modifiers are put in place.
*/
abstract contract PausableUpgradeable is Initializable, ContextUpgradeable {
/// @custom:storage-location erc7201:openzeppelin.storage.Pausable
struct PausableStorage {
bool _paused;
}
// keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Pausable")) - 1)) & ~bytes32(uint256(0xff))
bytes32 private constant PausableStorageLocation = 0xcd5ed15c6e187e77e9aee88184c21f4f2182ab5827cb3b7e07fbedcd63f03300;
function _getPausableStorage() private pure returns (PausableStorage storage $) {
assembly {
$.slot := PausableStorageLocation
}
}
/**
* @dev Emitted when the pause is triggered by `account`.
*/
event Paused(address account);
/**
* @dev Emitted when the pause is lifted by `account`.
*/
event Unpaused(address account);
/**
* @dev The operation failed because the contract is paused.
*/
error EnforcedPause();
/**
* @dev The operation failed because the contract is not paused.
*/
error ExpectedPause();
/**
* @dev Initializes the contract in unpaused state.
*/
function __Pausable_init() internal onlyInitializing {
__Pausable_init_unchained();
}
function __Pausable_init_unchained() internal onlyInitializing {
PausableStorage storage $ = _getPausableStorage();
$._paused = false;
}
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*
* Requirements:
*
* - The contract must not be paused.
*/
modifier whenNotPaused() {
_requireNotPaused();
_;
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*
* Requirements:
*
* - The contract must be paused.
*/
modifier whenPaused() {
_requirePaused();
_;
}
/**
* @dev Returns true if the contract is paused, and false otherwise.
*/
function paused() public view virtual returns (bool) {
PausableStorage storage $ = _getPausableStorage();
return $._paused;
}
/**
* @dev Throws if the contract is paused.
*/
function _requireNotPaused() internal view virtual {
if (paused()) {
revert EnforcedPause();
}
}
/**
* @dev Throws if the contract is not paused.
*/
function _requirePaused() internal view virtual {
if (!paused()) {
revert ExpectedPause();
}
}
/**
* @dev Triggers stopped state.
*
* Requirements:
*
* - The contract must not be paused.
*/
function _pause() internal virtual whenNotPaused {
PausableStorage storage $ = _getPausableStorage();
$._paused = true;
emit Paused(_msgSender());
}
/**
* @dev Returns to normal state.
*
* Requirements:
*
* - The contract must be paused.
*/
function _unpause() internal virtual whenPaused {
PausableStorage storage $ = _getPausableStorage();
$._paused = false;
emit Unpaused(_msgSender());
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/ReentrancyGuard.sol)
pragma solidity ^0.8.20;
import {Initializable} from "../proxy/utils/Initializable.sol";
/**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/
abstract contract ReentrancyGuardUpgradeable is Initializable {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant NOT_ENTERED = 1;
uint256 private constant ENTERED = 2;
/// @custom:storage-location erc7201:openzeppelin.storage.ReentrancyGuard
struct ReentrancyGuardStorage {
uint256 _status;
}
// keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.ReentrancyGuard")) - 1)) & ~bytes32(uint256(0xff))
bytes32 private constant ReentrancyGuardStorageLocation = 0x9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00;
function _getReentrancyGuardStorage() private pure returns (ReentrancyGuardStorage storage $) {
assembly {
$.slot := ReentrancyGuardStorageLocation
}
}
/**
* @dev Unauthorized reentrant call.
*/
error ReentrancyGuardReentrantCall();
function __ReentrancyGuard_init() internal onlyInitializing {
__ReentrancyGuard_init_unchained();
}
function __ReentrancyGuard_init_unchained() internal onlyInitializing {
ReentrancyGuardStorage storage $ = _getReentrancyGuardStorage();
$._status = NOT_ENTERED;
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and making it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
_nonReentrantBefore();
_;
_nonReentrantAfter();
}
function _nonReentrantBefore() private {
ReentrancyGuardStorage storage $ = _getReentrancyGuardStorage();
// On the first call to nonReentrant, _status will be NOT_ENTERED
if ($._status == ENTERED) {
revert ReentrancyGuardReentrantCall();
}
// Any calls to nonReentrant after this point will fail
$._status = ENTERED;
}
function _nonReentrantAfter() private {
ReentrancyGuardStorage storage $ = _getReentrancyGuardStorage();
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
$._status = NOT_ENTERED;
}
/**
* @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
* `nonReentrant` function in the call stack.
*/
function _reentrancyGuardEntered() internal view returns (bool) {
ReentrancyGuardStorage storage $ = _getReentrancyGuardStorage();
return $._status == ENTERED;
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SafeCast.sol)
// This file was procedurally generated from scripts/generate/templates/SafeCast.js.
pragma solidity ^0.8.20;
/**
* @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow
* checks.
*
* Downcasting from uint256/int256 in Solidity does not revert on overflow. This can
* easily result in undesired exploitation or bugs, since developers usually
* assume that overflows raise errors. `SafeCast` restores this intuition by
* reverting the transaction when such an operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/
library SafeCast {
/**
* @dev Value doesn't fit in an uint of `bits` size.
*/
error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);
/**
* @dev An int value doesn't fit in an uint of `bits` size.
*/
error SafeCastOverflowedIntToUint(int256 value);
/**
* @dev Value doesn't fit in an int of `bits` size.
*/
error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);
/**
* @dev An uint value doesn't fit in an int of `bits` size.
*/
error SafeCastOverflowedUintToInt(uint256 value);
/**
* @dev Returns the downcasted uint248 from uint256, reverting on
* overflow (when the input is greater than largest uint248).
*
* Counterpart to Solidity's `uint248` operator.
*
* Requirements:
*
* - input must fit into 248 bits
*/
function toUint248(uint256 value) internal pure returns (uint248) {
if (value > type(uint248).max) {
revert SafeCastOverflowedUintDowncast(248, value);
}
return uint248(value);
}
/**
* @dev Returns the downcasted uint240 from uint256, reverting on
* overflow (when the input is greater than largest uint240).
*
* Counterpart to Solidity's `uint240` operator.
*
* Requirements:
*
* - input must fit into 240 bits
*/
function toUint240(uint256 value) internal pure returns (uint240) {
if (value > type(uint240).max) {
revert SafeCastOverflowedUintDowncast(240, value);
}
return uint240(value);
}
/**
* @dev Returns the downcasted uint232 from uint256, reverting on
* overflow (when the input is greater than largest uint232).
*
* Counterpart to Solidity's `uint232` operator.
*
* Requirements:
*
* - input must fit into 232 bits
*/
function toUint232(uint256 value) internal pure returns (uint232) {
if (value > type(uint232).max) {
revert SafeCastOverflowedUintDowncast(232, value);
}
return uint232(value);
}
/**
* @dev Returns the downcasted uint224 from uint256, reverting on
* overflow (when the input is greater than largest uint224).
*
* Counterpart to Solidity's `uint224` operator.
*
* Requirements:
*
* - input must fit into 224 bits
*/
function toUint224(uint256 value) internal pure returns (uint224) {
if (value > type(uint224).max) {
revert SafeCastOverflowedUintDowncast(224, value);
}
return uint224(value);
}
/**
* @dev Returns the downcasted uint216 from uint256, reverting on
* overflow (when the input is greater than largest uint216).
*
* Counterpart to Solidity's `uint216` operator.
*
* Requirements:
*
* - input must fit into 216 bits
*/
function toUint216(uint256 value) internal pure returns (uint216) {
if (value > type(uint216).max) {
revert SafeCastOverflowedUintDowncast(216, value);
}
return uint216(value);
}
/**
* @dev Returns the downcasted uint208 from uint256, reverting on
* overflow (when the input is greater than largest uint208).
*
* Counterpart to Solidity's `uint208` operator.
*
* Requirements:
*
* - input must fit into 208 bits
*/
function toUint208(uint256 value) internal pure returns (uint208) {
if (value > type(uint208).max) {
revert SafeCastOverflowedUintDowncast(208, value);
}
return uint208(value);
}
/**
* @dev Returns the downcasted uint200 from uint256, reverting on
* overflow (when the input is greater than largest uint200).
*
* Counterpart to Solidity's `uint200` operator.
*
* Requirements:
*
* - input must fit into 200 bits
*/
function toUint200(uint256 value) internal pure returns (uint200) {
if (value > type(uint200).max) {
revert SafeCastOverflowedUintDowncast(200, value);
}
return uint200(value);
}
/**
* @dev Returns the downcasted uint192 from uint256, reverting on
* overflow (when the input is greater than largest uint192).
*
* Counterpart to Solidity's `uint192` operator.
*
* Requirements:
*
* - input must fit into 192 bits
*/
function toUint192(uint256 value) internal pure returns (uint192) {
if (value > type(uint192).max) {
revert SafeCastOverflowedUintDowncast(192, value);
}
return uint192(value);
}
/**
* @dev Returns the downcasted uint184 from uint256, reverting on
* overflow (when the input is greater than largest uint184).
*
* Counterpart to Solidity's `uint184` operator.
*
* Requirements:
*
* - input must fit into 184 bits
*/
function toUint184(uint256 value) internal pure returns (uint184) {
if (value > type(uint184).max) {
revert SafeCastOverflowedUintDowncast(184, value);
}
return uint184(value);
}
/**
* @dev Returns the downcasted uint176 from uint256, reverting on
* overflow (when the input is greater than largest uint176).
*
* Counterpart to Solidity's `uint176` operator.
*
* Requirements:
*
* - input must fit into 176 bits
*/
function toUint176(uint256 value) internal pure returns (uint176) {
if (value > type(uint176).max) {
revert SafeCastOverflowedUintDowncast(176, value);
}
return uint176(value);
}
/**
* @dev Returns the downcasted uint168 from uint256, reverting on
* overflow (when the input is greater than largest uint168).
*
* Counterpart to Solidity's `uint168` operator.
*
* Requirements:
*
* - input must fit into 168 bits
*/
function toUint168(uint256 value) internal pure returns (uint168) {
if (value > type(uint168).max) {
revert SafeCastOverflowedUintDowncast(168, value);
}
return uint168(value);
}
/**
* @dev Returns the downcasted uint160 from uint256, reverting on
* overflow (when the input is greater than largest uint160).
*
* Counterpart to Solidity's `uint160` operator.
*
* Requirements:
*
* - input must fit into 160 bits
*/
function toUint160(uint256 value) internal pure returns (uint160) {
if (value > type(uint160).max) {
revert SafeCastOverflowedUintDowncast(160, value);
}
return uint160(value);
}
/**
* @dev Returns the downcasted uint152 from uint256, reverting on
* overflow (when the input is greater than largest uint152).
*
* Counterpart to Solidity's `uint152` operator.
*
* Requirements:
*
* - input must fit into 152 bits
*/
function toUint152(uint256 value) internal pure returns (uint152) {
if (value > type(uint152).max) {
revert SafeCastOverflowedUintDowncast(152, value);
}
return uint152(value);
}
/**
* @dev Returns the downcasted uint144 from uint256, reverting on
* overflow (when the input is greater than largest uint144).
*
* Counterpart to Solidity's `uint144` operator.
*
* Requirements:
*
* - input must fit into 144 bits
*/
function toUint144(uint256 value) internal pure returns (uint144) {
if (value > type(uint144).max) {
revert SafeCastOverflowedUintDowncast(144, value);
}
return uint144(value);
}
/**
* @dev Returns the downcasted uint136 from uint256, reverting on
* overflow (when the input is greater than largest uint136).
*
* Counterpart to Solidity's `uint136` operator.
*
* Requirements:
*
* - input must fit into 136 bits
*/
function toUint136(uint256 value) internal pure returns (uint136) {
if (value > type(uint136).max) {
revert SafeCastOverflowedUintDowncast(136, value);
}
return uint136(value);
}
/**
* @dev Returns the downcasted uint128 from uint256, reverting on
* overflow (when the input is greater than largest uint128).
*
* Counterpart to Solidity's `uint128` operator.
*
* Requirements:
*
* - input must fit into 128 bits
*/
function toUint128(uint256 value) internal pure returns (uint128) {
if (value > type(uint128).max) {
revert SafeCastOverflowedUintDowncast(128, value);
}
return uint128(value);
}
/**
* @dev Returns the downcasted uint120 from uint256, reverting on
* overflow (when the input is greater than largest uint120).
*
* Counterpart to Solidity's `uint120` operator.
*
* Requirements:
*
* - input must fit into 120 bits
*/
function toUint120(uint256 value) internal pure returns (uint120) {
if (value > type(uint120).max) {
revert SafeCastOverflowedUintDowncast(120, value);
}
return uint120(value);
}
/**
* @dev Returns the downcasted uint112 from uint256, reverting on
* overflow (when the input is greater than largest uint112).
*
* Counterpart to Solidity's `uint112` operator.
*
* Requirements:
*
* - input must fit into 112 bits
*/
function toUint112(uint256 value) internal pure returns (uint112) {
if (value > type(uint112).max) {
revert SafeCastOverflowedUintDowncast(112, value);
}
return uint112(value);
}
/**
* @dev Returns the downcasted uint104 from uint256, reverting on
* overflow (when the input is greater than largest uint104).
*
* Counterpart to Solidity's `uint104` operator.
*
* Requirements:
*
* - input must fit into 104 bits
*/
function toUint104(uint256 value) internal pure returns (uint104) {
if (value > type(uint104).max) {
revert SafeCastOverflowedUintDowncast(104, value);
}
return uint104(value);
}
/**
* @dev Returns the downcasted uint96 from uint256, reverting on
* overflow (when the input is greater than largest uint96).
*
* Counterpart to Solidity's `uint96` operator.
*
* Requirements:
*
* - input must fit into 96 bits
*/
function toUint96(uint256 value) internal pure returns (uint96) {
if (value > type(uint96).max) {
revert SafeCastOverflowedUintDowncast(96, value);
}
return uint96(value);
}
/**
* @dev Returns the downcasted uint88 from uint256, reverting on
* overflow (when the input is greater than largest uint88).
*
* Counterpart to Solidity's `uint88` operator.
*
* Requirements:
*
* - input must fit into 88 bits
*/
function toUint88(uint256 value) internal pure returns (uint88) {
if (value > type(uint88).max) {
revert SafeCastOverflowedUintDowncast(88, value);
}
return uint88(value);
}
/**
* @dev Returns the downcasted uint80 from uint256, reverting on
* overflow (when the input is greater than largest uint80).
*
* Counterpart to Solidity's `uint80` operator.
*
* Requirements:
*
* - input must fit into 80 bits
*/
function toUint80(uint256 value) internal pure returns (uint80) {
if (value > type(uint80).max) {
revert SafeCastOverflowedUintDowncast(80, value);
}
return uint80(value);
}
/**
* @dev Returns the downcasted uint72 from uint256, reverting on
* overflow (when the input is greater than largest uint72).
*
* Counterpart to Solidity's `uint72` operator.
*
* Requirements:
*
* - input must fit into 72 bits
*/
function toUint72(uint256 value) internal pure returns (uint72) {
if (value > type(uint72).max) {
revert SafeCastOverflowedUintDowncast(72, value);
}
return uint72(value);
}
/**
* @dev Returns the downcasted uint64 from uint256, reverting on
* overflow (when the input is greater than largest uint64).
*
* Counterpart to Solidity's `uint64` operator.
*
* Requirements:
*
* - input must fit into 64 bits
*/
function toUint64(uint256 value) internal pure returns (uint64) {
if (value > type(uint64).max) {
revert SafeCastOverflowedUintDowncast(64, value);
}
return uint64(value);
}
/**
* @dev Returns the downcasted uint56 from uint256, reverting on
* overflow (when the input is greater than largest uint56).
*
* Counterpart to Solidity's `uint56` operator.
*
* Requirements:
*
* - input must fit into 56 bits
*/
function toUint56(uint256 value) internal pure returns (uint56) {
if (value > type(uint56).max) {
revert SafeCastOverflowedUintDowncast(56, value);
}
return uint56(value);
}
/**
* @dev Returns the downcasted uint48 from uint256, reverting on
* overflow (when the input is greater than largest uint48).
*
* Counterpart to Solidity's `uint48` operator.
*
* Requirements:
*
* - input must fit into 48 bits
*/
function toUint48(uint256 value) internal pure returns (uint48) {
if (value > type(uint48).max) {
revert SafeCastOverflowedUintDowncast(48, value);
}
return uint48(value);
}
/**
* @dev Returns the downcasted uint40 from uint256, reverting on
* overflow (when the input is greater than largest uint40).
*
* Counterpart to Solidity's `uint40` operator.
*
* Requirements:
*
* - input must fit into 40 bits
*/
function toUint40(uint256 value) internal pure returns (uint40) {
if (value > type(uint40).max) {
revert SafeCastOverflowedUintDowncast(40, value);
}
return uint40(value);
}
/**
* @dev Returns the downcasted uint32 from uint256, reverting on
* overflow (when the input is greater than largest uint32).
*
* Counterpart to Solidity's `uint32` operator.
*
* Requirements:
*
* - input must fit into 32 bits
*/
function toUint32(uint256 value) internal pure returns (uint32) {
if (value > type(uint32).max) {
revert SafeCastOverflowedUintDowncast(32, value);
}
return uint32(value);
}
/**
* @dev Returns the downcasted uint24 from uint256, reverting on
* overflow (when the input is greater than largest uint24).
*
* Counterpart to Solidity's `uint24` operator.
*
* Requirements:
*
* - input must fit into 24 bits
*/
function toUint24(uint256 value) internal pure returns (uint24) {
if (value > type(uint24).max) {
revert SafeCastOverflowedUintDowncast(24, value);
}
return uint24(value);
}
/**
* @dev Returns the downcasted uint16 from uint256, reverting on
* overflow (when the input is greater than largest uint16).
*
* Counterpart to Solidity's `uint16` operator.
*
* Requirements:
*
* - input must fit into 16 bits
*/
function toUint16(uint256 value) internal pure returns (uint16) {
if (value > type(uint16).max) {
revert SafeCastOverflowedUintDowncast(16, value);
}
return uint16(value);
}
/**
* @dev Returns the downcasted uint8 from uint256, reverting on
* overflow (when the input is greater than largest uint8).
*
* Counterpart to Solidity's `uint8` operator.
*
* Requirements:
*
* - input must fit into 8 bits
*/
function toUint8(uint256 value) internal pure returns (uint8) {
if (value > type(uint8).max) {
revert SafeCastOverflowedUintDowncast(8, value);
}
return uint8(value);
}
/**
* @dev Converts a signed int256 into an unsigned uint256.
*
* Requirements:
*
* - input must be greater than or equal to 0.
*/
function toUint256(int256 value) internal pure returns (uint256) {
if (value < 0) {
revert SafeCastOverflowedIntToUint(value);
}
return uint256(value);
}
/**
* @dev Returns the downcasted int248 from int256, reverting on
* overflow (when the input is less than smallest int248 or
* greater than largest int248).
*
* Counterpart to Solidity's `int248` operator.
*
* Requirements:
*
* - input must fit into 248 bits
*/
function toInt248(int256 value) internal pure returns (int248 downcasted) {
downcasted = int248(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(248, value);
}
}
/**
* @dev Returns the downcasted int240 from int256, reverting on
* overflow (when the input is less than smallest int240 or
* greater than largest int240).
*
* Counterpart to Solidity's `int240` operator.
*
* Requirements:
*
* - input must fit into 240 bits
*/
function toInt240(int256 value) internal pure returns (int240 downcasted) {
downcasted = int240(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(240, value);
}
}
/**
* @dev Returns the downcasted int232 from int256, reverting on
* overflow (when the input is less than smallest int232 or
* greater than largest int232).
*
* Counterpart to Solidity's `int232` operator.
*
* Requirements:
*
* - input must fit into 232 bits
*/
function toInt232(int256 value) internal pure returns (int232 downcasted) {
downcasted = int232(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(232, value);
}
}
/**
* @dev Returns the downcasted int224 from int256, reverting on
* overflow (when the input is less than smallest int224 or
* greater than largest int224).
*
* Counterpart to Solidity's `int224` operator.
*
* Requirements:
*
* - input must fit into 224 bits
*/
function toInt224(int256 value) internal pure returns (int224 downcasted) {
downcasted = int224(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(224, value);
}
}
/**
* @dev Returns the downcasted int216 from int256, reverting on
* overflow (when the input is less than smallest int216 or
* greater than largest int216).
*
* Counterpart to Solidity's `int216` operator.
*
* Requirements:
*
* - input must fit into 216 bits
*/
function toInt216(int256 value) internal pure returns (int216 downcasted) {
downcasted = int216(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(216, value);
}
}
/**
* @dev Returns the downcasted int208 from int256, reverting on
* overflow (when the input is less than smallest int208 or
* greater than largest int208).
*
* Counterpart to Solidity's `int208` operator.
*
* Requirements:
*
* - input must fit into 208 bits
*/
function toInt208(int256 value) internal pure returns (int208 downcasted) {
downcasted = int208(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(208, value);
}
}
/**
* @dev Returns the downcasted int200 from int256, reverting on
* overflow (when the input is less than smallest int200 or
* greater than largest int200).
*
* Counterpart to Solidity's `int200` operator.
*
* Requirements:
*
* - input must fit into 200 bits
*/
function toInt200(int256 value) internal pure returns (int200 downcasted) {
downcasted = int200(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(200, value);
}
}
/**
* @dev Returns the downcasted int192 from int256, reverting on
* overflow (when the input is less than smallest int192 or
* greater than largest int192).
*
* Counterpart to Solidity's `int192` operator.
*
* Requirements:
*
* - input must fit into 192 bits
*/
function toInt192(int256 value) internal pure returns (int192 downcasted) {
downcasted = int192(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(192, value);
}
}
/**
* @dev Returns the downcasted int184 from int256, reverting on
* overflow (when the input is less than smallest int184 or
* greater than largest int184).
*
* Counterpart to Solidity's `int184` operator.
*
* Requirements:
*
* - input must fit into 184 bits
*/
function toInt184(int256 value) internal pure returns (int184 downcasted) {
downcasted = int184(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(184, value);
}
}
/**
* @dev Returns the downcasted int176 from int256, reverting on
* overflow (when the input is less than smallest int176 or
* greater than largest int176).
*
* Counterpart to Solidity's `int176` operator.
*
* Requirements:
*
* - input must fit into 176 bits
*/
function toInt176(int256 value) internal pure returns (int176 downcasted) {
downcasted = int176(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(176, value);
}
}
/**
* @dev Returns the downcasted int168 from int256, reverting on
* overflow (when the input is less than smallest int168 or
* greater than largest int168).
*
* Counterpart to Solidity's `int168` operator.
*
* Requirements:
*
* - input must fit into 168 bits
*/
function toInt168(int256 value) internal pure returns (int168 downcasted) {
downcasted = int168(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(168, value);
}
}
/**
* @dev Returns the downcasted int160 from int256, reverting on
* overflow (when the input is less than smallest int160 or
* greater than largest int160).
*
* Counterpart to Solidity's `int160` operator.
*
* Requirements:
*
* - input must fit into 160 bits
*/
function toInt160(int256 value) internal pure returns (int160 downcasted) {
downcasted = int160(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(160, value);
}
}
/**
* @dev Returns the downcasted int152 from int256, reverting on
* overflow (when the input is less than smallest int152 or
* greater than largest int152).
*
* Counterpart to Solidity's `int152` operator.
*
* Requirements:
*
* - input must fit into 152 bits
*/
function toInt152(int256 value) internal pure returns (int152 downcasted) {
downcasted = int152(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(152, value);
}
}
/**
* @dev Returns the downcasted int144 from int256, reverting on
* overflow (when the input is less than smallest int144 or
* greater than largest int144).
*
* Counterpart to Solidity's `int144` operator.
*
* Requirements:
*
* - input must fit into 144 bits
*/
function toInt144(int256 value) internal pure returns (int144 downcasted) {
downcasted = int144(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(144, value);
}
}
/**
* @dev Returns the downcasted int136 from int256, reverting on
* overflow (when the input is less than smallest int136 or
* greater than largest int136).
*
* Counterpart to Solidity's `int136` operator.
*
* Requirements:
*
* - input must fit into 136 bits
*/
function toInt136(int256 value) internal pure returns (int136 downcasted) {
downcasted = int136(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(136, value);
}
}
/**
* @dev Returns the downcasted int128 from int256, reverting on
* overflow (when the input is less than smallest int128 or
* greater than largest int128).
*
* Counterpart to Solidity's `int128` operator.
*
* Requirements:
*
* - input must fit into 128 bits
*/
function toInt128(int256 value) internal pure returns (int128 downcasted) {
downcasted = int128(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(128, value);
}
}
/**
* @dev Returns the downcasted int120 from int256, reverting on
* overflow (when the input is less than smallest int120 or
* greater than largest int120).
*
* Counterpart to Solidity's `int120` operator.
*
* Requirements:
*
* - input must fit into 120 bits
*/
function toInt120(int256 value) internal pure returns (int120 downcasted) {
downcasted = int120(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(120, value);
}
}
/**
* @dev Returns the downcasted int112 from int256, reverting on
* overflow (when the input is less than smallest int112 or
* greater than largest int112).
*
* Counterpart to Solidity's `int112` operator.
*
* Requirements:
*
* - input must fit into 112 bits
*/
function toInt112(int256 value) internal pure returns (int112 downcasted) {
downcasted = int112(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(112, value);
}
}
/**
* @dev Returns the downcasted int104 from int256, reverting on
* overflow (when the input is less than smallest int104 or
* greater than largest int104).
*
* Counterpart to Solidity's `int104` operator.
*
* Requirements:
*
* - input must fit into 104 bits
*/
function toInt104(int256 value) internal pure returns (int104 downcasted) {
downcasted = int104(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(104, value);
}
}
/**
* @dev Returns the downcasted int96 from int256, reverting on
* overflow (when the input is less than smallest int96 or
* greater than largest int96).
*
* Counterpart to Solidity's `int96` operator.
*
* Requirements:
*
* - input must fit into 96 bits
*/
function toInt96(int256 value) internal pure returns (int96 downcasted) {
downcasted = int96(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(96, value);
}
}
/**
* @dev Returns the downcasted int88 from int256, reverting on
* overflow (when the input is less than smallest int88 or
* greater than largest int88).
*
* Counterpart to Solidity's `int88` operator.
*
* Requirements:
*
* - input must fit into 88 bits
*/
function toInt88(int256 value) internal pure returns (int88 downcasted) {
downcasted = int88(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(88, value);
}
}
/**
* @dev Returns the downcasted int80 from int256, reverting on
* overflow (when the input is less than smallest int80 or
* greater than largest int80).
*
* Counterpart to Solidity's `int80` operator.
*
* Requirements:
*
* - input must fit into 80 bits
*/
function toInt80(int256 value) internal pure returns (int80 downcasted) {
downcasted = int80(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(80, value);
}
}
/**
* @dev Returns the downcasted int72 from int256, reverting on
* overflow (when the input is less than smallest int72 or
* greater than largest int72).
*
* Counterpart to Solidity's `int72` operator.
*
* Requirements:
*
* - input must fit into 72 bits
*/
function toInt72(int256 value) internal pure returns (int72 downcasted) {
downcasted = int72(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(72, value);
}
}
/**
* @dev Returns the downcasted int64 from int256, reverting on
* overflow (when the input is less than smallest int64 or
* greater than largest int64).
*
* Counterpart to Solidity's `int64` operator.
*
* Requirements:
*
* - input must fit into 64 bits
*/
function toInt64(int256 value) internal pure returns (int64 downcasted) {
downcasted = int64(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(64, value);
}
}
/**
* @dev Returns the downcasted int56 from int256, reverting on
* overflow (when the input is less than smallest int56 or
* greater than largest int56).
*
* Counterpart to Solidity's `int56` operator.
*
* Requirements:
*
* - input must fit into 56 bits
*/
function toInt56(int256 value) internal pure returns (int56 downcasted) {
downcasted = int56(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(56, value);
}
}
/**
* @dev Returns the downcasted int48 from int256, reverting on
* overflow (when the input is less than smallest int48 or
* greater than largest int48).
*
* Counterpart to Solidity's `int48` operator.
*
* Requirements:
*
* - input must fit into 48 bits
*/
function toInt48(int256 value) internal pure returns (int48 downcasted) {
downcasted = int48(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(48, value);
}
}
/**
* @dev Returns the downcasted int40 from int256, reverting on
* overflow (when the input is less than smallest int40 or
* greater than largest int40).
*
* Counterpart to Solidity's `int40` operator.
*
* Requirements:
*
* - input must fit into 40 bits
*/
function toInt40(int256 value) internal pure returns (int40 downcasted) {
downcasted = int40(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(40, value);
}
}
/**
* @dev Returns the downcasted int32 from int256, reverting on
* overflow (when the input is less than smallest int32 or
* greater than largest int32).
*
* Counterpart to Solidity's `int32` operator.
*
* Requirements:
*
* - input must fit into 32 bits
*/
function toInt32(int256 value) internal pure returns (int32 downcasted) {
downcasted = int32(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(32, value);
}
}
/**
* @dev Returns the downcasted int24 from int256, reverting on
* overflow (when the input is less than smallest int24 or
* greater than largest int24).
*
* Counterpart to Solidity's `int24` operator.
*
* Requirements:
*
* - input must fit into 24 bits
*/
function toInt24(int256 value) internal pure returns (int24 downcasted) {
downcasted = int24(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(24, value);
}
}
/**
* @dev Returns the downcasted int16 from int256, reverting on
* overflow (when the input is less than smallest int16 or
* greater than largest int16).
*
* Counterpart to Solidity's `int16` operator.
*
* Requirements:
*
* - input must fit into 16 bits
*/
function toInt16(int256 value) internal pure returns (int16 downcasted) {
downcasted = int16(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(16, value);
}
}
/**
* @dev Returns the downcasted int8 from int256, reverting on
* overflow (when the input is less than smallest int8 or
* greater than largest int8).
*
* Counterpart to Solidity's `int8` operator.
*
* Requirements:
*
* - input must fit into 8 bits
*/
function toInt8(int256 value) internal pure returns (int8 downcasted) {
downcasted = int8(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(8, value);
}
}
/**
* @dev Converts an unsigned uint256 into a signed int256.
*
* Requirements:
*
* - input must be less than or equal to maxInt256.
*/
function toInt256(uint256 value) internal pure returns (int256) {
// Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive
if (value > uint256(type(int256).max)) {
revert SafeCastOverflowedUintToInt(value);
}
return int256(value);
}
}
// 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) (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: AGPL-3.0-only
pragma solidity >=0.8.0;
/// @notice Arithmetic library with operations for fixed-point numbers.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/FixedPointMathLib.sol)
/// @author Inspired by USM (https://github.com/usmfum/USM/blob/master/contracts/WadMath.sol)
library FixedPointMathLib {
/*//////////////////////////////////////////////////////////////
SIMPLIFIED FIXED POINT OPERATIONS
//////////////////////////////////////////////////////////////*/
uint256 internal constant MAX_UINT256 = 2**256 - 1;
uint256 internal constant WAD = 1e18; // The scalar of ETH and most ERC20s.
function mulWadDown(uint256 x, uint256 y) internal pure returns (uint256) {
return mulDivDown(x, y, WAD); // Equivalent to (x * y) / WAD rounded down.
}
function mulWadUp(uint256 x, uint256 y) internal pure returns (uint256) {
return mulDivUp(x, y, WAD); // Equivalent to (x * y) / WAD rounded up.
}
function divWadDown(uint256 x, uint256 y) internal pure returns (uint256) {
return mulDivDown(x, WAD, y); // Equivalent to (x * WAD) / y rounded down.
}
function divWadUp(uint256 x, uint256 y) internal pure returns (uint256) {
return mulDivUp(x, WAD, y); // Equivalent to (x * WAD) / y rounded up.
}
/*//////////////////////////////////////////////////////////////
LOW LEVEL FIXED POINT OPERATIONS
//////////////////////////////////////////////////////////////*/
function mulDivDown(
uint256 x,
uint256 y,
uint256 denominator
) internal pure returns (uint256 z) {
/// @solidity memory-safe-assembly
assembly {
// Equivalent to require(denominator != 0 && (y == 0 || x <= type(uint256).max / y))
if iszero(mul(denominator, iszero(mul(y, gt(x, div(MAX_UINT256, y)))))) {
revert(0, 0)
}
// Divide x * y by the denominator.
z := div(mul(x, y), denominator)
}
}
function mulDivUp(
uint256 x,
uint256 y,
uint256 denominator
) internal pure returns (uint256 z) {
/// @solidity memory-safe-assembly
assembly {
// Equivalent to require(denominator != 0 && (y == 0 || x <= type(uint256).max / y))
if iszero(mul(denominator, iszero(mul(y, gt(x, div(MAX_UINT256, y)))))) {
revert(0, 0)
}
// If x * y modulo the denominator is strictly greater than 0,
// 1 is added to round up the division of x * y by the denominator.
z := add(gt(mod(mul(x, y), denominator), 0), div(mul(x, y), denominator))
}
}
function rpow(
uint256 x,
uint256 n,
uint256 scalar
) internal pure returns (uint256 z) {
/// @solidity memory-safe-assembly
assembly {
switch x
case 0 {
switch n
case 0 {
// 0 ** 0 = 1
z := scalar
}
default {
// 0 ** n = 0
z := 0
}
}
default {
switch mod(n, 2)
case 0 {
// If n is even, store scalar in z for now.
z := scalar
}
default {
// If n is odd, store x in z for now.
z := x
}
// Shifting right by 1 is like dividing by 2.
let half := shr(1, scalar)
for {
// Shift n right by 1 before looping to halve it.
n := shr(1, n)
} n {
// Shift n right by 1 each iteration to halve it.
n := shr(1, n)
} {
// Revert immediately if x ** 2 would overflow.
// Equivalent to iszero(eq(div(xx, x), x)) here.
if shr(128, x) {
revert(0, 0)
}
// Store x squared.
let xx := mul(x, x)
// Round to the nearest number.
let xxRound := add(xx, half)
// Revert if xx + half overflowed.
if lt(xxRound, xx) {
revert(0, 0)
}
// Set x to scaled xxRound.
x := div(xxRound, scalar)
// If n is even:
if mod(n, 2) {
// Compute z * x.
let zx := mul(z, x)
// If z * x overflowed:
if iszero(eq(div(zx, x), z)) {
// Revert if x is non-zero.
if iszero(iszero(x)) {
revert(0, 0)
}
}
// Round to the nearest number.
let zxRound := add(zx, half)
// Revert if zx + half overflowed.
if lt(zxRound, zx) {
revert(0, 0)
}
// Return properly scaled zxRound.
z := div(zxRound, scalar)
}
}
}
}
}
/*//////////////////////////////////////////////////////////////
GENERAL NUMBER UTILITIES
//////////////////////////////////////////////////////////////*/
function sqrt(uint256 x) internal pure returns (uint256 z) {
/// @solidity memory-safe-assembly
assembly {
let y := x // We start y at x, which will help us make our initial estimate.
z := 181 // The "correct" value is 1, but this saves a multiplication later.
// This segment is to get a reasonable initial estimate for the Babylonian method. With a bad
// start, the correct # of bits increases ~linearly each iteration instead of ~quadratically.
// We check y >= 2^(k + 8) but shift right by k bits
// each branch to ensure that if x >= 256, then y >= 256.
if iszero(lt(y, 0x10000000000000000000000000000000000)) {
y := shr(128, y)
z := shl(64, z)
}
if iszero(lt(y, 0x1000000000000000000)) {
y := shr(64, y)
z := shl(32, z)
}
if iszero(lt(y, 0x10000000000)) {
y := shr(32, y)
z := shl(16, z)
}
if iszero(lt(y, 0x1000000)) {
y := shr(16, y)
z := shl(8, z)
}
// Goal was to get z*z*y within a small factor of x. More iterations could
// get y in a tighter range. Currently, we will have y in [256, 256*2^16).
// We ensured y >= 256 so that the relative difference between y and y+1 is small.
// That's not possible if x < 256 but we can just verify those cases exhaustively.
// Now, z*z*y <= x < z*z*(y+1), and y <= 2^(16+8), and either y >= 256, or x < 256.
// Correctness can be checked exhaustively for x < 256, so we assume y >= 256.
// Then z*sqrt(y) is within sqrt(257)/sqrt(256) of sqrt(x), or about 20bps.
// For s in the range [1/256, 256], the estimate f(s) = (181/1024) * (s+1) is in the range
// (1/2.84 * sqrt(s), 2.84 * sqrt(s)), with largest error when s = 1 and when s = 256 or 1/256.
// Since y is in [256, 256*2^16), let a = y/65536, so that a is in [1/256, 256). Then we can estimate
// sqrt(y) using sqrt(65536) * 181/1024 * (a + 1) = 181/4 * (y + 65536)/65536 = 181 * (y + 65536)/2^18.
// There is no overflow risk here since y < 2^136 after the first branch above.
z := shr(18, mul(z, add(y, 65536))) // A mul() is saved from starting z at 181.
// Given the worst case multiplicative error of 2.84 above, 7 iterations should be enough.
z := shr(1, add(z, div(x, z)))
z := shr(1, add(z, div(x, z)))
z := shr(1, add(z, div(x, z)))
z := shr(1, add(z, div(x, z)))
z := shr(1, add(z, div(x, z)))
z := shr(1, add(z, div(x, z)))
z := shr(1, add(z, div(x, z)))
// If x+1 is a perfect square, the Babylonian method cycles between
// floor(sqrt(x)) and ceil(sqrt(x)). This statement ensures we return floor.
// See: https://en.wikipedia.org/wiki/Integer_square_root#Using_only_integer_division
// Since the ceil is rare, we save gas on the assignment and repeat division in the rare case.
// If you don't care whether the floor or ceil square root is returned, you can remove this statement.
z := sub(z, lt(div(x, z), z))
}
}
function unsafeMod(uint256 x, uint256 y) internal pure returns (uint256 z) {
/// @solidity memory-safe-assembly
assembly {
// Mod x by y. Note this will return
// 0 instead of reverting if y is zero.
z := mod(x, y)
}
}
function unsafeDiv(uint256 x, uint256 y) internal pure returns (uint256 r) {
/// @solidity memory-safe-assembly
assembly {
// Divide x by y. Note this will return
// 0 instead of reverting if y is zero.
r := div(x, y)
}
}
function unsafeDivUp(uint256 x, uint256 y) internal pure returns (uint256 z) {
/// @solidity memory-safe-assembly
assembly {
// Add 1 to x * y if x % y > 0. Note this will
// return 0 instead of reverting if y is zero.
z := add(gt(mod(x, y), 0), div(x, y))
}
}
}
// SPDX-License-Identifier: BUSL-1.1
// Central Limit Order Book (CLOB) exchange
// (c) Long Gamma Labs, 2023.
pragma solidity ^0.8.26;
import {Errors} from "./Errors.sol";
library FP24 {
/// @dev Converts a uint72 number into a uint24 floating point representation.
/// @param a The uint72 number to be converted.
/// @return p The uint24 floating point representation of the input number.
function packFP24(uint72 a) internal pure returns (uint24) {
require(0 < a && a <= 999999000000000000000, Errors.InvalidPriceRange());
uint72 threshold_number = 999999;
uint8 e = 0;
while (a > threshold_number) {
require(a % 10 == 0, Errors.ExcessiveSignificantFigures());
a /= 10;
e++;
}
uint24 p = (uint24(e) << 20) | uint24(a);
return p;
}
/// @dev Converts a uint24 floating point number into a uint72 number.
/// @param p The uint24 floating point number to be converted.
/// @return a The uint72 number representation of the input floating point number.
function unPackFP24(uint24 p) internal pure returns (uint72) {
uint72 e = uint72(p >> 20);
uint72 a = uint72(p & 0xfffff);
require(0 < a && a <= 999999, Errors.InvalidFloatingPointRepresentation());
a *= uint72(10 ** e);
return a;
}
}
// SPDX-License-Identifier: BUSL-1.1
// Central Limit Order Book (CLOB) exchange
// (c) Long Gamma Labs, 2023.
pragma solidity ^0.8.26;
interface IWatchDog {
function touch() external;
function isChainStable() external view returns (bool);
}
// SPDX-License-Identifier: BUSL-1.1
// Central Limit Order Book (CLOB) exchange
// (c) Long Gamma Labs, 2023.
pragma solidity ^0.8.26;
interface IOnchainCLOB {
function getConfig() external view returns (
uint256 _scaling_factor_token_x,
uint256 _scaling_factor_token_y,
address _token_x,
address _token_y,
bool _supports_native_eth,
bool _is_token_x_weth,
address _ask_trie,
address _bid_trie,
uint64 _admin_commission_rate,
uint64 _total_aggressive_commission_rate,
uint64 _total_passive_commission_rate,
uint64 _passive_order_payout_rate,
bool _should_invoke_on_trade
);
receive() external payable;
function getTraderBalance(address address_) external view returns (uint128, uint128, bool);
function changeMarketMaker(
address _marketmaker,
bool _should_invoke_on_trade,
uint64 _admin_commission_rate
) external;
function setClaimableStatus(bool status) external;
function placeOrder(
bool isAsk,
uint128 quantity,
uint72 price,
uint128 max_commission,
bool market_only,
bool post_only,
bool transfer_executed_tokens,
uint256 expires
) external payable returns (
uint64 order_id,
uint128 executed_shares,
uint128 executed_value,
uint128 aggressive_fee
);
function placeOrder(
bool isAsk,
uint128 quantity,
uint72 price,
uint128 max_commission,
uint128 amount_to_approve,
bool market_only,
bool post_only,
bool transfer_executed_tokens,
uint256 expires,
uint8 v,
bytes32 r,
bytes32 s
) external payable returns (
uint64 order_id,
uint128 executed_shares,
uint128 executed_value,
uint128 aggressive_fee
);
function placeMarketOrderWithTargetValue(
bool isAsk,
uint128 target_token_y_value,
uint72 price,
uint128 max_commission,
uint128 amount_to_approve,
bool transfer_executed_tokens,
uint256 expires,
uint8 v,
bytes32 r,
bytes32 s
) external payable returns (
uint128 executed_shares,
uint128 executed_value,
uint128 aggressive_fee
);
function placeMarketOrderWithTargetValue(
bool isAsk,
uint128 target_token_y_value,
uint72 price,
uint128 max_commission,
bool transfer_executed_tokens,
uint256 expires
) external payable returns (
uint128 executed_shares,
uint128 executed_value,
uint128 aggressive_fee
);
function claimOrder(
uint64 order_id,
bool only_claim,
bool transfer_tokens,
uint256 expires
) external;
function batchClaim(
address[] memory addresses,
uint64[] memory order_ids,
bool only_claim,
uint256 expires
) external;
function changeOrder(
uint64 old_order_id,
uint128 new_quantity,
uint72 new_price,
uint128 max_commission,
bool post_only,
bool transfer_tokens,
uint256 expires
) external returns (uint64);
function batchChangeOrder(
uint64[] memory order_ids,
uint128[] memory quantities,
uint72[] memory prices,
uint128 max_commission_per_order,
bool post_only,
bool transfer_tokens,
uint256 expires
) external returns (uint64[] memory new_order_ids);
function depositTokens(uint128 token_x_amount, uint128 token_y_amount) external;
function depositTokens(
uint128 token_x_amount,
uint128 token_y_amount,
uint8 v_x,
bytes32 r_x,
bytes32 s_x,
uint8 v_y,
bytes32 r_y,
bytes32 s_y,
uint256 expires
) external;
function withdrawTokens(bool withdraw_all, uint128 token_x_amount, uint128 token_y_amount) external;
function getAccumulatedFees() external returns (uint256);
function transferFees() external;
}
// SPDX-License-Identifier: BUSL-1.1
// Central Limit Order Book (CLOB) exchange
// (c) Long Gamma Labs, 2023.
pragma solidity ^0.8.26;
interface ITrie {
function best_offer() external view returns (uint64);
function rightmost_map() external view returns (uint64);
function addOrder(uint64 trader_id, uint64 order_id, uint128 shares, uint128 value) external;
function removeOrder(uint64 order_id, uint64 order_trader_id) external returns (uint128 total_shares, uint128 remain_shares);
function claimExecuted(uint64 order_id, uint64 order_trader_id) external returns (uint128 executed_shares, uint128 remain_shares);
function getOrderInfo(uint64 order_id) external view returns (uint128 total_shares, uint128 remain_shares);
function executeRight(uint64 order_id, uint128 order_total_shares) external returns (uint128 executed_shares, uint128 executed_value);
function previewExecuteRight(uint64 order_id, uint128 max_shares, uint128 max_value) external view returns (uint128 executed_shares, uint128 executed_value);
function assembleOrderbookFromOrders(uint24 max_price_levels) external view returns (uint24[] memory array_price_ids, uint128[] memory array_shares);
}
// SPDX-License-Identifier: BUSL-1.1
// Central Limit Order Book (CLOB) exchange
// (c) Long Gamma Labs, 2023.
pragma solidity ^0.8.0;
interface ITradeConsumer {
function onTrade(bool isAsk) external;
}
// SPDX-License-Identifier: BUSL-1.1
// Central Limit Order Book (CLOB) exchange
// (c) Long Gamma Labs, 2023.
pragma solidity ^0.8.26;
interface IWETH {
function deposit() external payable;
function withdraw(uint wad) external;
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (proxy/ERC1967/ERC1967Proxy.sol)
pragma solidity ^0.8.20;
import {Proxy} from "../Proxy.sol";
import {ERC1967Utils} from "./ERC1967Utils.sol";
/**
* @dev This contract implements an upgradeable proxy. It is upgradeable because calls are delegated to an
* implementation address that can be changed. This address is stored in storage in the location specified by
* https://eips.ethereum.org/EIPS/eip-1967[EIP1967], so that it doesn't conflict with the storage layout of the
* implementation behind the proxy.
*/
contract ERC1967Proxy is Proxy {
/**
* @dev Initializes the upgradeable proxy with an initial implementation specified by `implementation`.
*
* If `_data` is nonempty, it's used as data in a delegate call to `implementation`. This will typically be an
* encoded function call, and allows initializing the storage of the proxy like a Solidity constructor.
*
* Requirements:
*
* - If `data` is empty, `msg.value` must be zero.
*/
constructor(address implementation, bytes memory _data) payable {
ERC1967Utils.upgradeToAndCall(implementation, _data);
}
/**
* @dev Returns the current implementation address.
*
* TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using
* the https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.
* `0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc`
*/
function _implementation() internal view virtual override returns (address) {
return ERC1967Utils.getImplementation();
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)
pragma solidity ^0.8.20;
import {ContextUpgradeable} from "../utils/ContextUpgradeable.sol";
import {Initializable} from "../proxy/utils/Initializable.sol";
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* The initial owner is set to the address provided by the deployer. This can
* later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
/// @custom:storage-location erc7201:openzeppelin.storage.Ownable
struct OwnableStorage {
address _owner;
}
// keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Ownable")) - 1)) & ~bytes32(uint256(0xff))
bytes32 private constant OwnableStorageLocation = 0x9016d09d72d40fdae2fd8ceac6b6234c7706214fd39c1cd1e609a0528c199300;
function _getOwnableStorage() private pure returns (OwnableStorage storage $) {
assembly {
$.slot := OwnableStorageLocation
}
}
/**
* @dev The caller account is not authorized to perform an operation.
*/
error OwnableUnauthorizedAccount(address account);
/**
* @dev The owner is not a valid owner account. (eg. `address(0)`)
*/
error OwnableInvalidOwner(address owner);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the address provided by the deployer as the initial owner.
*/
function __Ownable_init(address initialOwner) internal onlyInitializing {
__Ownable_init_unchained(initialOwner);
}
function __Ownable_init_unchained(address initialOwner) internal onlyInitializing {
if (initialOwner == address(0)) {
revert OwnableInvalidOwner(address(0));
}
_transferOwnership(initialOwner);
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
_checkOwner();
_;
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
OwnableStorage storage $ = _getOwnableStorage();
return $._owner;
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
if (owner() != _msgSender()) {
revert OwnableUnauthorizedAccount(_msgSender());
}
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby disabling any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
if (newOwner == address(0)) {
revert OwnableInvalidOwner(address(0));
}
_transferOwnership(newOwner);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
OwnableStorage storage $ = _getOwnableStorage();
address oldOwner = $._owner;
$._owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (proxy/utils/Initializable.sol)
pragma solidity ^0.8.20;
/**
* @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
* behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
* external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
* function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
*
* The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
* reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
* case an upgrade adds a module that needs to be initialized.
*
* For example:
*
* [.hljs-theme-light.nopadding]
* ```solidity
* contract MyToken is ERC20Upgradeable {
* function initialize() initializer public {
* __ERC20_init("MyToken", "MTK");
* }
* }
*
* contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
* function initializeV2() reinitializer(2) public {
* __ERC20Permit_init("MyToken");
* }
* }
* ```
*
* TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
* possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
*
* CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
* that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
*
* [CAUTION]
* ====
* Avoid leaving a contract uninitialized.
*
* An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
* contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
* the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
*
* [.hljs-theme-light.nopadding]
* ```
* /// @custom:oz-upgrades-unsafe-allow constructor
* constructor() {
* _disableInitializers();
* }
* ```
* ====
*/
abstract contract Initializable {
/**
* @dev Storage of the initializable contract.
*
* It's implemented on a custom ERC-7201 namespace to reduce the risk of storage collisions
* when using with upgradeable contracts.
*
* @custom:storage-location erc7201:openzeppelin.storage.Initializable
*/
struct InitializableStorage {
/**
* @dev Indicates that the contract has been initialized.
*/
uint64 _initialized;
/**
* @dev Indicates that the contract is in the process of being initialized.
*/
bool _initializing;
}
// keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Initializable")) - 1)) & ~bytes32(uint256(0xff))
bytes32 private constant INITIALIZABLE_STORAGE = 0xf0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a00;
/**
* @dev The contract is already initialized.
*/
error InvalidInitialization();
/**
* @dev The contract is not initializing.
*/
error NotInitializing();
/**
* @dev Triggered when the contract has been initialized or reinitialized.
*/
event Initialized(uint64 version);
/**
* @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
* `onlyInitializing` functions can be used to initialize parent contracts.
*
* Similar to `reinitializer(1)`, except that in the context of a constructor an `initializer` may be invoked any
* number of times. This behavior in the constructor can be useful during testing and is not expected to be used in
* production.
*
* Emits an {Initialized} event.
*/
modifier initializer() {
// solhint-disable-next-line var-name-mixedcase
InitializableStorage storage $ = _getInitializableStorage();
// Cache values to avoid duplicated sloads
bool isTopLevelCall = !$._initializing;
uint64 initialized = $._initialized;
// Allowed calls:
// - initialSetup: the contract is not in the initializing state and no previous version was
// initialized
// - construction: the contract is initialized at version 1 (no reininitialization) and the
// current contract is just being deployed
bool initialSetup = initialized == 0 && isTopLevelCall;
bool construction = initialized == 1 && address(this).code.length == 0;
if (!initialSetup && !construction) {
revert InvalidInitialization();
}
$._initialized = 1;
if (isTopLevelCall) {
$._initializing = true;
}
_;
if (isTopLevelCall) {
$._initializing = false;
emit Initialized(1);
}
}
/**
* @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
* contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
* used to initialize parent contracts.
*
* A reinitializer may be used after the original initialization step. This is essential to configure modules that
* are added through upgrades and that require initialization.
*
* When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`
* cannot be nested. If one is invoked in the context of another, execution will revert.
*
* Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
* a contract, executing them in the right order is up to the developer or operator.
*
* WARNING: Setting the version to 2**64 - 1 will prevent any future reinitialization.
*
* Emits an {Initialized} event.
*/
modifier reinitializer(uint64 version) {
// solhint-disable-next-line var-name-mixedcase
InitializableStorage storage $ = _getInitializableStorage();
if ($._initializing || $._initialized >= version) {
revert InvalidInitialization();
}
$._initialized = version;
$._initializing = true;
_;
$._initializing = false;
emit Initialized(version);
}
/**
* @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
* {initializer} and {reinitializer} modifiers, directly or indirectly.
*/
modifier onlyInitializing() {
_checkInitializing();
_;
}
/**
* @dev Reverts if the contract is not in an initializing state. See {onlyInitializing}.
*/
function _checkInitializing() internal view virtual {
if (!_isInitializing()) {
revert NotInitializing();
}
}
/**
* @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
* Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
* to any version. It is recommended to use this to lock implementation contracts that are designed to be called
* through proxies.
*
* Emits an {Initialized} event the first time it is successfully executed.
*/
function _disableInitializers() internal virtual {
// solhint-disable-next-line var-name-mixedcase
InitializableStorage storage $ = _getInitializableStorage();
if ($._initializing) {
revert InvalidInitialization();
}
if ($._initialized != type(uint64).max) {
$._initialized = type(uint64).max;
emit Initialized(type(uint64).max);
}
}
/**
* @dev Returns the highest version that has been initialized. See {reinitializer}.
*/
function _getInitializedVersion() internal view returns (uint64) {
return _getInitializableStorage()._initialized;
}
/**
* @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.
*/
function _isInitializing() internal view returns (bool) {
return _getInitializableStorage()._initializing;
}
/**
* @dev Returns a pointer to the storage namespace.
*/
// solhint-disable-next-line var-name-mixedcase
function _getInitializableStorage() private pure returns (InitializableStorage storage $) {
assembly {
$.slot := INITIALIZABLE_STORAGE
}
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)
pragma solidity ^0.8.20;
import {Initializable} from "../proxy/utils/Initializable.sol";
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal onlyInitializing {
}
function __Context_init_unchained() internal onlyInitializing {
}
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
function _contextSuffixLength() internal view virtual returns (uint256) {
return 0;
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/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) (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) (proxy/Proxy.sol)
pragma solidity ^0.8.20;
/**
* @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM
* instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to
* be specified by overriding the virtual {_implementation} function.
*
* Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a
* different contract through the {_delegate} function.
*
* The success and return data of the delegated call will be returned back to the caller of the proxy.
*/
abstract contract Proxy {
/**
* @dev Delegates the current call to `implementation`.
*
* This function does not return to its internal call site, it will return directly to the external caller.
*/
function _delegate(address implementation) internal virtual {
assembly {
// Copy msg.data. We take full control of memory in this inline assembly
// block because it will not return to Solidity code. We overwrite the
// Solidity scratch pad at memory position 0.
calldatacopy(0, 0, calldatasize())
// Call the implementation.
// out and outsize are 0 because we don't know the size yet.
let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
// Copy the returned data.
returndatacopy(0, 0, returndatasize())
switch result
// delegatecall returns 0 on error.
case 0 {
revert(0, returndatasize())
}
default {
return(0, returndatasize())
}
}
}
/**
* @dev This is a virtual function that should be overridden so it returns the address to which the fallback
* function and {_fallback} should delegate.
*/
function _implementation() internal view virtual returns (address);
/**
* @dev Delegates the current call to the address returned by `_implementation()`.
*
* This function does not return to its internal call site, it will return directly to the external caller.
*/
function _fallback() internal virtual {
_delegate(_implementation());
}
/**
* @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other
* function in the contract matches the call data.
*/
fallback() external payable virtual {
_fallback();
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.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
}
}
}