Overview
ETH Balance
5,134.484903826991953224 ETH
Eth Value
$19,711,802.04 (@ $3,839.10/ETH)Token Holdings
More Info
Private Name Tags
ContractCreator
Latest 25 from a total of 1,396 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Deposit | 21339458 | 1 hr ago | IN | 5 ETH | 0.00492434 | ||||
Deposit | 21339330 | 1 hr ago | IN | 40 ETH | 0.00657711 | ||||
Deposit | 21338633 | 4 hrs ago | IN | 0.02055325 ETH | 0.00314142 | ||||
Deposit | 21338307 | 5 hrs ago | IN | 2.9 ETH | 0.00483442 | ||||
Instant Redeem W... | 21337429 | 8 hrs ago | IN | 0 ETH | 0.00282142 | ||||
Deposit | 21337215 | 9 hrs ago | IN | 17.5 ETH | 0.00450544 | ||||
Deposit | 21336599 | 11 hrs ago | IN | 0.0001 ETH | 0.00213405 | ||||
Deposit | 21335962 | 13 hrs ago | IN | 7.62361153 ETH | 0.00311384 | ||||
Deposit | 21335717 | 14 hrs ago | IN | 0.013 ETH | 0.00201828 | ||||
Deposit | 21331428 | 28 hrs ago | IN | 2 ETH | 0.00455891 | ||||
Deposit | 21331033 | 29 hrs ago | IN | 3 ETH | 0.00511053 | ||||
Deposit | 21330307 | 32 hrs ago | IN | 0.02 ETH | 0.0047927 | ||||
Deposit | 21329482 | 34 hrs ago | IN | 0.38 ETH | 0.00211545 | ||||
Deposit | 21329278 | 35 hrs ago | IN | 3 ETH | 0.00351324 | ||||
Deposit | 21326819 | 43 hrs ago | IN | 29.8 ETH | 0.00250649 | ||||
Deposit | 21321441 | 2 days ago | IN | 16 ETH | 0.00375824 | ||||
Deposit | 21321164 | 2 days ago | IN | 10 ETH | 0.00307608 | ||||
Deposit | 21320319 | 2 days ago | IN | 26 ETH | 0.00184386 | ||||
Deposit | 21313240 | 3 days ago | IN | 0.0001 ETH | 0.00102705 | ||||
Deposit | 21313230 | 3 days ago | IN | 0.0001 ETH | 0.00106113 | ||||
Deposit | 21313141 | 3 days ago | IN | 0.0001 ETH | 0.00111156 | ||||
Deposit | 21312863 | 3 days ago | IN | 0.0001 ETH | 0.00111947 | ||||
Deposit | 21312645 | 3 days ago | IN | 0.0001 ETH | 0.00126622 | ||||
Deposit | 21310309 | 4 days ago | IN | 0.9 ETH | 0.00314227 | ||||
Deposit | 21309476 | 4 days ago | IN | 0.003 ETH | 0.00296955 |
Latest 25 internal transactions (View All)
Advanced mode:
Parent Transaction Hash | Block | From | To | |||
---|---|---|---|---|---|---|
21337920 | 6 hrs ago | 0.003 ETH | ||||
21337469 | 8 hrs ago | 0.03509267 ETH | ||||
21337429 | 8 hrs ago | 24.875 ETH | ||||
21337366 | 8 hrs ago | 2 ETH | ||||
21336944 | 9 hrs ago | 0.0001 ETH | ||||
21336944 | 9 hrs ago | 39.926968 ETH | ||||
21335443 | 14 hrs ago | 39.926968 ETH | ||||
21335423 | 15 hrs ago | 39.926968 ETH | ||||
21333085 | 22 hrs ago | 0.03504617 ETH | ||||
21331836 | 27 hrs ago | 0.1 ETH | ||||
21330269 | 32 hrs ago | 0.001 ETH | ||||
21329872 | 33 hrs ago | 0.001 ETH | ||||
21329727 | 34 hrs ago | 0.001 ETH | ||||
21328786 | 37 hrs ago | 0.03743802 ETH | ||||
21324547 | 2 days ago | 0 ETH | ||||
21324322 | 2 days ago | 0.04406988 ETH | ||||
21323502 | 2 days ago | 63 ETH | ||||
21319261 | 2 days ago | 0.03908654 ETH | ||||
21315765 | 3 days ago | 132 ETH | ||||
21308435 | 4 days ago | 1.44187113 ETH | ||||
21307833 | 4 days ago | 1.5488922 ETH | ||||
21306044 | 4 days ago | 1.48982339 ETH | ||||
21305743 | 4 days ago | 1.02383656 ETH | ||||
21305149 | 4 days ago | 1.21150768 ETH | ||||
21303952 | 5 days ago | 2.28436511 ETH |
Loading...
Loading
This contract may be a proxy contract. Click on More Options and select Is this a proxy? to confirm and enable the "Read as Proxy" & "Write as Proxy" tabs.
Contract Name:
PirexEth
Compiler Version
v0.8.19+commit.7dd6d404
Optimization Enabled:
Yes with 200 runs
Other Settings:
paris EvmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: MIT pragma solidity 0.8.19; import {ERC20} from "solmate/tokens/ERC20.sol"; import {SafeTransferLib} from "solmate/utils/SafeTransferLib.sol"; import {Errors} from "./libraries/Errors.sol"; import {DataTypes} from "./libraries/DataTypes.sol"; import {IPirexFees} from "./interfaces/IPirexFees.sol"; import {PirexEthValidators} from "./PirexEthValidators.sol"; /** * @title Main contract for handling interactions with pxETH * @notice This contract manages various interactions with pxETH, such as deposits, redemptions, and fee adjustments. * @dev This contract inherits from PirexEthValidators and utilizes SafeTransferLib for ERC20 token transfers. * @author redactedcartel.finance */ contract PirexEth is PirexEthValidators { /** * @notice Smart contract uses the SafeTransferLib library for secure ERC20 token transfers. * @dev The SafeTransferLib library provides enhanced safety checks and error handling for ERC20 token transfers, * reducing the risk of common vulnerabilities such as reentrancy attacks. By using this library, * the smart contract ensures safer and more reliable interactions with ERC20 tokens. */ using SafeTransferLib for ERC20; /** * @notice Immutable reference to the Pirex fee repository and distribution contract. * @dev The `pirexFees` variable holds the address of the Pirex fee repository and distribution contract (IPirexFees). * This contract is responsible for managing and distributing fees collected within the Pirex ecosystem. * As an immutable variable, its value is set at deployment and cannot be changed thereafter. */ IPirexFees public immutable pirexFees; /** * @notice Mapping of maximum fees allowed for different operations in the contract. * @dev The `maxFees` mapping associates each fee type (Deposit, Redemption, InstantRedemption) with its corresponding maximum fee percentage. * For example, a value of 200000 represents a maximum fee of 20% (200000 / 1000000). * Developers can access and modify these maximum fees directly through this public mapping. */ mapping(DataTypes.Fees => uint32) public maxFees; /** * @notice Mapping of fees for different operations in the contract. * @dev The `fees` mapping associates each fee type (Deposit, Redemption, InstantRedemption) with its corresponding fee percentage. * For example, a value of 5000 represents a 0.5% fee (5000 / 1000000). * Developers can access and modify these fees directly through this public mapping. */ mapping(DataTypes.Fees => uint32) public fees; /** * @notice Current pause state of the contract. * @dev The `paused` state variable indicates whether certain functionalities of the contract are currently paused or active. * A value of 1 denotes a paused state, while 0 indicates the contract is not paused. */ uint256 public paused; // Events /** * @notice Event emitted when ETH is deposited, minting pxETH, and optionally compounding into the vault. * @dev Use this event to log details about the deposit, including the caller's address, the receiver's address, whether compounding occurred, the deposited amount, received pxETH amount, and fee amount. * @param caller address indexed Address of the entity initiating the deposit. * @param receiver address indexed Address of the receiver of the minted pxETH or apxEth. * @param shouldCompound bool indexed Boolean indicating whether compounding into the vault occurred. * @param deposited uint256 Amount of ETH deposited. * @param receivedAmount uint256 Amount of pxETH minted for the receiver. * @param feeAmount uint256 Amount of pxETH distributed as fees. */ event Deposit( address indexed caller, address indexed receiver, bool indexed shouldCompound, uint256 deposited, uint256 receivedAmount, uint256 feeAmount ); /** * @notice Event emitted when a redemption is initiated by burning pxETH in return for upxETH. * @dev Use this event to log details about the redemption initiation, including the redeemed asset amount, post-fee amount, and the receiver's address. * @param assets uint256 Amount of pxETH burnt for the redemption. * @param postFeeAmount uint256 Amount of pxETH distributed to the receiver after deducting fees. * @param receiver address indexed Address of the receiver of the upxETH. */ event InitiateRedemption( uint256 assets, uint256 postFeeAmount, address indexed receiver ); /** * @notice Event emitted when ETH is redeemed using UpxETH. * @dev Use this event to log details about the redemption, including the tokenId, redeemed asset amount, and the receiver's address. * @param tokenId uint256 Identifier for the redemption batch. * @param assets uint256 Amount of ETH redeemed. * @param receiver address indexed Address of the receiver of the redeemed ETH. */ event RedeemWithUpxEth( uint256 tokenId, uint256 assets, address indexed receiver ); /** * @notice Event emitted when pxETH is redeemed for ETH with fees. * @dev Use this event to log details about pxETH redemption, including the redeemed asset amount, post-fee amount, and the receiver's address. * @param assets uint256 Amount of pxETH redeemed. * @param postFeeAmount uint256 Amount of ETH received by the receiver after deducting fees. * @param _receiver address indexed Address of the receiver of the redeemed ETH. */ event RedeemWithPxEth( uint256 assets, uint256 postFeeAmount, address indexed _receiver ); /** * @notice Event emitted when the fee amount for a specific fee type is set. * @dev Use this event to log changes in the fee amount for a particular fee type, including the fee type and the new fee amount. * @param f DataTypes.Fees indexed (Deposit, Redemption, InstantRedemption) for which the fee amount is being set. * @param fee uint32 New fee amount for the specified fee type. */ event SetFee(DataTypes.Fees indexed f, uint32 fee); /** * @notice Event emitted when the maximum fee for a specific fee type is set. * @dev Use this event to log changes in the maximum fee for a particular fee type, including the fee type and the new maximum fee. * @param f DataTypes.Fees indexed Deposit, Redemption or InstantRedemption for which the maximum fee is being set. * @param maxFee uint32 New maximum fee amount for the specified fee type. */ event SetMaxFee(DataTypes.Fees indexed f, uint32 maxFee); /** * @notice Event emitted when the contract's pause state is toggled. * @dev Use this event to log changes in the contract's pause state, including the account triggering the change and the new state. * @param account address Address of the entity toggling the pause state. * @param state uint256 New pause state: 1 for paused, 0 for not paused. */ event SetPauseState(address account, uint256 state); /** * @notice Event emitted when an emergency withdrawal occurs. * @dev Use this event to log details about emergency withdrawals, including the receiver's address, the token involved, and the withdrawn amount. * @param receiver address indexed Address of the receiver of the emergency withdrawal. * @param token address indexed Address of the token involved in the emergency withdrawal. * @param amount uint256 Amount withdrawn in the emergency withdrawal. */ event EmergencyWithdrawal( address indexed receiver, address indexed token, uint256 amount ); // Modifiers /** * @dev Use this modifier to check if the contract is not currently paused before allowing function execution. */ modifier whenNotPaused() { if (paused == _PAUSED) revert Errors.Paused(); _; } /** * @notice Contract constructor to initialize PirexEthValidator with necessary parameters and configurations. * @dev This constructor sets up the PirexEthValidator contract, configuring key parameters and initializing state variables. * @param _pxEth address PxETH contract address * @param _admin address Admin address * @param _beaconChainDepositContract address The address of the beacon chain deposit contract * @param _upxEth address UpxETH address * @param _depositSize uint256 Amount of eth to stake * @param _preDepositAmount uint256 Amount of ETH for pre-deposit * @param _pirexFees address PirexFees contract address * @param _initialDelay uint48 Delay required to schedule the acceptance * of an access control transfer started */ constructor( address _pxEth, address _admin, address _beaconChainDepositContract, address _upxEth, uint256 _depositSize, uint256 _preDepositAmount, address _pirexFees, uint48 _initialDelay ) PirexEthValidators( _pxEth, _admin, _beaconChainDepositContract, _upxEth, _depositSize, _preDepositAmount, _initialDelay ) { if (_pirexFees == address(0)) revert Errors.ZeroAddress(); pirexFees = IPirexFees(_pirexFees); maxFees[DataTypes.Fees.Deposit] = 200_000; maxFees[DataTypes.Fees.Redemption] = 200_000; maxFees[DataTypes.Fees.InstantRedemption] = 200_000; paused = _NOT_PAUSED; } /*////////////////////////////////////////////////////////////// MUTATIVE FUNCTIONS //////////////////////////////////////////////////////////////*/ /** * @notice Set fee * @dev This function allows an entity with the GOVERNANCE_ROLE to set the fee amount for a specific fee type. * @param f DataTypes.Fees Fee * @param fee uint32 Fee amount */ function setFee( DataTypes.Fees f, uint32 fee ) external onlyRole(GOVERNANCE_ROLE) { if (fee > maxFees[f]) revert Errors.InvalidFee(); fees[f] = fee; emit SetFee(f, fee); } /** * @notice Set Max fee * @dev This function allows an entity with the GOVERNANCE_ROLE to set the maximum fee for a specific fee type. * @param f DataTypes.Fees Fee * @param maxFee uint32 Max fee amount */ function setMaxFee( DataTypes.Fees f, uint32 maxFee ) external onlyRole(GOVERNANCE_ROLE) { if (maxFee < fees[f] || maxFee > DENOMINATOR) revert Errors.InvalidMaxFee(); maxFees[f] = maxFee; emit SetMaxFee(f, maxFee); } /** * @notice Toggle the contract's pause state * @dev This function allows an entity with the GOVERNANCE_ROLE to toggle the contract's pause state. */ function togglePauseState() external onlyRole(GOVERNANCE_ROLE) { paused = paused == _PAUSED ? _NOT_PAUSED : _PAUSED; emit SetPauseState(msg.sender, paused); } /** * @notice Emergency withdrawal for all ERC20 tokens (except pxETH) and ETH * @dev This function should only be called under major emergency * @param receiver address Receiver address * @param token address Token address * @param amount uint256 Token amount */ function emergencyWithdraw( address receiver, address token, uint256 amount ) external onlyRole(GOVERNANCE_ROLE) onlyWhenDepositEtherPaused { if (paused == _NOT_PAUSED) revert Errors.NotPaused(); if (receiver == address(0)) revert Errors.ZeroAddress(); if (amount == 0) revert Errors.ZeroAmount(); if (token == address(pxEth)) revert Errors.InvalidToken(); if (token == address(0)) { // Update pendingDeposit when affected by emergency withdrawal uint256 remainingBalance = address(this).balance - amount; if (pendingDeposit > remainingBalance) { pendingDeposit = remainingBalance; } // Handle ETH withdrawal (bool _success, ) = payable(receiver).call{value: amount}(""); assert(_success); } else { ERC20(token).safeTransfer(receiver, amount); } emit EmergencyWithdrawal(receiver, token, amount); } /** * @notice Handle pxETH minting in return for ETH deposits * @dev This function handles the minting of pxETH in return for ETH deposits. * @param receiver address Receiver of the minted pxETH or apxEth * @param shouldCompound bool Whether to also compound into the vault * @return postFeeAmount uint256 pxETH minted for the receiver * @return feeAmount uint256 pxETH distributed as fees */ function deposit( address receiver, bool shouldCompound ) external payable whenNotPaused nonReentrant returns (uint256 postFeeAmount, uint256 feeAmount) { if (msg.value == 0) revert Errors.ZeroAmount(); if (receiver == address(0)) revert Errors.ZeroAddress(); // Get the pxETH amounts for the receiver and the protocol (fees) (postFeeAmount, feeAmount) = _computeAssetAmounts( DataTypes.Fees.Deposit, msg.value ); // Mint pxETH for the receiver (or this contract if compounding) excluding fees _mintPxEth(shouldCompound ? address(this) : receiver, postFeeAmount); if (shouldCompound) { // Deposit pxETH excluding fees into the autocompounding vault // then mint shares (apxETH) for the user autoPxEth.deposit(postFeeAmount, receiver); } // Mint pxETH for fee distribution contract if (feeAmount != 0) { _mintPxEth(address(pirexFees), feeAmount); } // Redirect the deposit to beacon chain deposit contract _addPendingDeposit(msg.value); emit Deposit( msg.sender, receiver, shouldCompound, msg.value, postFeeAmount, feeAmount ); } /** * @notice Initiate redemption by burning pxETH in return for upxETH * @dev This function is used to initiate redemption by burning pxETH and receiving upxETH. * @param _assets uint256 If caller is AutoPxEth then apxETH; pxETH otherwise. * @param _receiver address Receiver for upxETH. * @param _shouldTriggerValidatorExit bool Whether the initiation should trigger voluntary exit. * @return postFeeAmount uint256 pxETH burnt for the receiver. * @return feeAmount uint256 pxETH distributed as fees. */ function initiateRedemption( uint256 _assets, address _receiver, bool _shouldTriggerValidatorExit ) external override whenNotPaused nonReentrant returns (uint256 postFeeAmount, uint256 feeAmount) { if (_assets == 0) revert Errors.ZeroAmount(); if (_receiver == address(0)) revert Errors.ZeroAddress(); uint256 _pxEthAmount; if (msg.sender == address(autoPxEth)) { // The pxETH amount is calculated as per apxETH-ETH ratio during current block _pxEthAmount = autoPxEth.redeem( _assets, address(this), address(this) ); } else { _pxEthAmount = _assets; } // Get the pxETH amounts for the receiver and the protocol (fees) (postFeeAmount, feeAmount) = _computeAssetAmounts( DataTypes.Fees.Redemption, _pxEthAmount ); uint256 _requiredValidators = (pendingWithdrawal + postFeeAmount) / DEPOSIT_SIZE; if (_shouldTriggerValidatorExit && _requiredValidators == 0) revert Errors.NoValidatorExit(); if (_requiredValidators > getStakingValidatorCount()) revert Errors.NotEnoughValidators(); emit InitiateRedemption(_pxEthAmount, postFeeAmount, _receiver); address _owner = msg.sender == address(autoPxEth) ? address(this) : msg.sender; _burnPxEth(_owner, postFeeAmount); if (feeAmount != 0) { // Allow PirexFees to distribute fees directly from sender pxEth.operatorApprove(_owner, address(pirexFees), feeAmount); // Distribute fees pirexFees.distributeFees(_owner, address(pxEth), feeAmount); } _initiateRedemption( postFeeAmount, _receiver, _shouldTriggerValidatorExit ); } /** * @notice Bulk redeem back ETH using a set of upxEth identifiers * @dev This function allows the bulk redemption of ETH using upxEth tokens. * @param _tokenIds uint256[] Redeem batch identifiers * @param _amounts uint256[] Amounts of ETH to redeem for each identifier * @param _receiver address Address of the ETH receiver */ function bulkRedeemWithUpxEth( uint256[] calldata _tokenIds, uint256[] calldata _amounts, address _receiver ) external whenNotPaused nonReentrant { uint256 tLen = _tokenIds.length; uint256 aLen = _amounts.length; if (tLen == 0) revert Errors.EmptyArray(); if (tLen != aLen) revert Errors.MismatchedArrayLengths(); for (uint256 i; i < tLen; ++i) { _redeemWithUpxEth(_tokenIds[i], _amounts[i], _receiver); } } /** * @notice Redeem back ETH using a single upxEth identifier * @dev This function allows the redemption of ETH using upxEth tokens. * @param _tokenId uint256 Redeem batch identifier * @param _assets uint256 Amount of ETH to redeem * @param _receiver address Address of the ETH receiver */ function redeemWithUpxEth( uint256 _tokenId, uint256 _assets, address _receiver ) external whenNotPaused nonReentrant { _redeemWithUpxEth(_tokenId, _assets, _receiver); } /** * @notice Instant redeem back ETH using pxETH * @dev This function burns pxETH, calculates fees, and transfers ETH to the receiver. * @param _assets uint256 Amount of pxETH to redeem. * @param _receiver address Address of the ETH receiver. * @return postFeeAmount uint256 Post-fee amount for the receiver. * @return feeAmount uinit256 Fee amount sent to the PirexFees. */ function instantRedeemWithPxEth( uint256 _assets, address _receiver ) external whenNotPaused nonReentrant returns (uint256 postFeeAmount, uint256 feeAmount) { if (_assets == 0) revert Errors.ZeroAmount(); if (_receiver == address(0)) revert Errors.ZeroAddress(); // Get the pxETH amounts for the receiver and the protocol (fees) (postFeeAmount, feeAmount) = _computeAssetAmounts( DataTypes.Fees.InstantRedemption, _assets ); if (postFeeAmount > buffer) revert Errors.NotEnoughBuffer(); if (feeAmount != 0) { // Allow PirexFees to distribute fees directly from sender pxEth.operatorApprove(msg.sender, address(pirexFees), feeAmount); // Distribute fees pirexFees.distributeFees(msg.sender, address(pxEth), feeAmount); } _burnPxEth(msg.sender, postFeeAmount); buffer -= postFeeAmount; (bool _success, ) = payable(_receiver).call{value: postFeeAmount}(""); assert(_success); emit RedeemWithPxEth(_assets, postFeeAmount, _receiver); } /*////////////////////////////////////////////////////////////// INTERNAL FUNCTIONS //////////////////////////////////////////////////////////////*/ /** * @notice Redeem back ETH using upxEth * @dev This function allows the redemption of ETH using upxEth tokens. * @param _tokenId uint256 Redeem batch identifier * @param _assets uint256 Amount of ETH to redeem * @param _receiver address Address of the ETH receiver */ function _redeemWithUpxEth( uint256 _tokenId, uint256 _assets, address _receiver ) internal { if (_assets == 0) revert Errors.ZeroAmount(); if (_receiver == address(0)) revert Errors.ZeroAddress(); DataTypes.ValidatorStatus _validatorStatus = status[ batchIdToValidator[_tokenId] ]; if ( _validatorStatus != DataTypes.ValidatorStatus.Dissolved && _validatorStatus != DataTypes.ValidatorStatus.Slashed ) { revert Errors.StatusNotDissolvedOrSlashed(); } if (outstandingRedemptions < _assets) revert Errors.NotEnoughETH(); outstandingRedemptions -= _assets; upxEth.burn(msg.sender, _tokenId, _assets); (bool _success, ) = payable(_receiver).call{value: _assets}(""); assert(_success); emit RedeemWithUpxEth(_tokenId, _assets, _receiver); } /** * @dev This function calculates the post-fee asset amount and fee amount based on the specified fee type and total assets. * @param f DataTypes.Fees representing the fee type. * @param assets uint256 Total ETH or pxETH asset amount. * @return postFeeAmount uint256 Post-fee asset amount (for mint/burn/claim/etc.). * @return feeAmount uint256 Fee amount. */ function _computeAssetAmounts( DataTypes.Fees f, uint256 assets ) internal view returns (uint256 postFeeAmount, uint256 feeAmount) { feeAmount = (assets * fees[f]) / DENOMINATOR; postFeeAmount = assets - feeAmount; } }
// SPDX-License-Identifier: AGPL-3.0-only pragma solidity >=0.8.0; /// @notice Modern and gas efficient ERC20 + EIP-2612 implementation. /// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC20.sol) /// @author Modified from Uniswap (https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2ERC20.sol) /// @dev Do not manually set balances without updating totalSupply, as the sum of all user balances must not exceed it. abstract contract ERC20 { /*////////////////////////////////////////////////////////////// EVENTS //////////////////////////////////////////////////////////////*/ event Transfer(address indexed from, address indexed to, uint256 amount); event Approval(address indexed owner, address indexed spender, uint256 amount); /*////////////////////////////////////////////////////////////// METADATA STORAGE //////////////////////////////////////////////////////////////*/ string public name; string public symbol; uint8 public immutable decimals; /*////////////////////////////////////////////////////////////// ERC20 STORAGE //////////////////////////////////////////////////////////////*/ uint256 public totalSupply; mapping(address => uint256) public balanceOf; mapping(address => mapping(address => uint256)) public allowance; /*////////////////////////////////////////////////////////////// EIP-2612 STORAGE //////////////////////////////////////////////////////////////*/ uint256 internal immutable INITIAL_CHAIN_ID; bytes32 internal immutable INITIAL_DOMAIN_SEPARATOR; mapping(address => uint256) public nonces; /*////////////////////////////////////////////////////////////// CONSTRUCTOR //////////////////////////////////////////////////////////////*/ constructor( string memory _name, string memory _symbol, uint8 _decimals ) { name = _name; symbol = _symbol; decimals = _decimals; INITIAL_CHAIN_ID = block.chainid; INITIAL_DOMAIN_SEPARATOR = computeDomainSeparator(); } /*////////////////////////////////////////////////////////////// ERC20 LOGIC //////////////////////////////////////////////////////////////*/ function approve(address spender, uint256 amount) public virtual returns (bool) { allowance[msg.sender][spender] = amount; emit Approval(msg.sender, spender, amount); return true; } function transfer(address to, uint256 amount) public virtual returns (bool) { balanceOf[msg.sender] -= amount; // Cannot overflow because the sum of all user // balances can't exceed the max uint256 value. unchecked { balanceOf[to] += amount; } emit Transfer(msg.sender, to, amount); return true; } function transferFrom( address from, address to, uint256 amount ) public virtual returns (bool) { uint256 allowed = allowance[from][msg.sender]; // Saves gas for limited approvals. if (allowed != type(uint256).max) allowance[from][msg.sender] = allowed - amount; balanceOf[from] -= amount; // Cannot overflow because the sum of all user // balances can't exceed the max uint256 value. unchecked { balanceOf[to] += amount; } emit Transfer(from, to, amount); return true; } /*////////////////////////////////////////////////////////////// EIP-2612 LOGIC //////////////////////////////////////////////////////////////*/ function permit( address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) public virtual { require(deadline >= block.timestamp, "PERMIT_DEADLINE_EXPIRED"); // Unchecked because the only math done is incrementing // the owner's nonce which cannot realistically overflow. unchecked { address recoveredAddress = ecrecover( keccak256( abi.encodePacked( "\x19\x01", DOMAIN_SEPARATOR(), keccak256( abi.encode( keccak256( "Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)" ), owner, spender, value, nonces[owner]++, deadline ) ) ) ), v, r, s ); require(recoveredAddress != address(0) && recoveredAddress == owner, "INVALID_SIGNER"); allowance[recoveredAddress][spender] = value; } emit Approval(owner, spender, value); } function DOMAIN_SEPARATOR() public view virtual returns (bytes32) { return block.chainid == INITIAL_CHAIN_ID ? INITIAL_DOMAIN_SEPARATOR : computeDomainSeparator(); } function computeDomainSeparator() internal view virtual returns (bytes32) { return keccak256( abi.encode( keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"), keccak256(bytes(name)), keccak256("1"), block.chainid, address(this) ) ); } /*////////////////////////////////////////////////////////////// INTERNAL MINT/BURN LOGIC //////////////////////////////////////////////////////////////*/ function _mint(address to, uint256 amount) internal virtual { totalSupply += amount; // Cannot overflow because the sum of all user // balances can't exceed the max uint256 value. unchecked { balanceOf[to] += amount; } emit Transfer(address(0), to, amount); } function _burn(address from, uint256 amount) internal virtual { balanceOf[from] -= amount; // Cannot underflow because a user's balance // will never be larger than the total supply. unchecked { totalSupply -= amount; } emit Transfer(from, address(0), amount); } }
// SPDX-License-Identifier: AGPL-3.0-only pragma solidity >=0.8.0; import {ERC20} from "../tokens/ERC20.sol"; /// @notice Safe ETH and ERC20 transfer library that gracefully handles missing return values. /// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/SafeTransferLib.sol) /// @dev Use with caution! Some functions in this library knowingly create dirty bits at the destination of the free memory pointer. /// @dev Note that none of the functions in this library check that a token has code at all! That responsibility is delegated to the caller. library SafeTransferLib { /*////////////////////////////////////////////////////////////// ETH OPERATIONS //////////////////////////////////////////////////////////////*/ function safeTransferETH(address to, uint256 amount) internal { bool success; /// @solidity memory-safe-assembly assembly { // Transfer the ETH and store if it succeeded or not. success := call(gas(), to, amount, 0, 0, 0, 0) } require(success, "ETH_TRANSFER_FAILED"); } /*////////////////////////////////////////////////////////////// ERC20 OPERATIONS //////////////////////////////////////////////////////////////*/ function safeTransferFrom( ERC20 token, address from, address to, uint256 amount ) internal { bool success; /// @solidity memory-safe-assembly assembly { // Get a pointer to some free memory. let freeMemoryPointer := mload(0x40) // Write the abi-encoded calldata into memory, beginning with the function selector. mstore(freeMemoryPointer, 0x23b872dd00000000000000000000000000000000000000000000000000000000) mstore(add(freeMemoryPointer, 4), from) // Append the "from" argument. mstore(add(freeMemoryPointer, 36), to) // Append the "to" argument. mstore(add(freeMemoryPointer, 68), amount) // Append the "amount" argument. success := and( // Set success to whether the call reverted, if not we check it either // returned exactly 1 (can't just be non-zero data), or had no return data. or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())), // We use 100 because the length of our calldata totals up like so: 4 + 32 * 3. // We use 0 and 32 to copy up to 32 bytes of return data into the scratch space. // Counterintuitively, this call must be positioned second to the or() call in the // surrounding and() call or else returndatasize() will be zero during the computation. call(gas(), token, 0, freeMemoryPointer, 100, 0, 32) ) } require(success, "TRANSFER_FROM_FAILED"); } function safeTransfer( ERC20 token, address to, uint256 amount ) internal { bool success; /// @solidity memory-safe-assembly assembly { // Get a pointer to some free memory. let freeMemoryPointer := mload(0x40) // Write the abi-encoded calldata into memory, beginning with the function selector. mstore(freeMemoryPointer, 0xa9059cbb00000000000000000000000000000000000000000000000000000000) mstore(add(freeMemoryPointer, 4), to) // Append the "to" argument. mstore(add(freeMemoryPointer, 36), amount) // Append the "amount" argument. success := and( // Set success to whether the call reverted, if not we check it either // returned exactly 1 (can't just be non-zero data), or had no return data. or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())), // We use 68 because the length of our calldata totals up like so: 4 + 32 * 2. // We use 0 and 32 to copy up to 32 bytes of return data into the scratch space. // Counterintuitively, this call must be positioned second to the or() call in the // surrounding and() call or else returndatasize() will be zero during the computation. call(gas(), token, 0, freeMemoryPointer, 68, 0, 32) ) } require(success, "TRANSFER_FAILED"); } function safeApprove( ERC20 token, address to, uint256 amount ) internal { bool success; /// @solidity memory-safe-assembly assembly { // Get a pointer to some free memory. let freeMemoryPointer := mload(0x40) // Write the abi-encoded calldata into memory, beginning with the function selector. mstore(freeMemoryPointer, 0x095ea7b300000000000000000000000000000000000000000000000000000000) mstore(add(freeMemoryPointer, 4), to) // Append the "to" argument. mstore(add(freeMemoryPointer, 36), amount) // Append the "amount" argument. success := and( // Set success to whether the call reverted, if not we check it either // returned exactly 1 (can't just be non-zero data), or had no return data. or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())), // We use 68 because the length of our calldata totals up like so: 4 + 32 * 2. // We use 0 and 32 to copy up to 32 bytes of return data into the scratch space. // Counterintuitively, this call must be positioned second to the or() call in the // surrounding and() call or else returndatasize() will be zero during the computation. call(gas(), token, 0, freeMemoryPointer, 68, 0, 32) ) } require(success, "APPROVE_FAILED"); } }
// SPDX-License-Identifier: MIT pragma solidity 0.8.19; library Errors { /** * @dev Zero address specified */ error ZeroAddress(); /** * @dev Zero amount specified */ error ZeroAmount(); /** * @dev Invalid fee specified */ error InvalidFee(); /** * @dev Invalid max fee specified */ error InvalidMaxFee(); /** * @dev Zero multiplier used */ error ZeroMultiplier(); /** * @dev ETH deposit is paused */ error DepositingEtherPaused(); /** * @dev ETH deposit is not paused */ error DepositingEtherNotPaused(); /** * @dev Contract is paused */ error Paused(); /** * @dev Contract is not paused */ error NotPaused(); /** * @dev Validator not yet dissolved */ error NotDissolved(); /** * @dev Validator not yet withdrawable */ error NotWithdrawable(); /** * @dev Validator has been previously used before */ error NoUsedValidator(); /** * @dev Not oracle adapter */ error NotOracleAdapter(); /** * @dev Not reward recipient */ error NotRewardRecipient(); /** * @dev Exceeding max value */ error ExceedsMax(); /** * @dev No rewards available */ error NoRewards(); /** * @dev Not PirexEth */ error NotPirexEth(); /** * @dev Not minter */ error NotMinter(); /** * @dev Not burner */ error NotBurner(); /** * @dev Empty string */ error EmptyString(); /** * @dev Validator is Not Staking */ error ValidatorNotStaking(); /** * @dev not enough buffer */ error NotEnoughBuffer(); /** * @dev validator queue empty */ error ValidatorQueueEmpty(); /** * @dev out of bounds */ error OutOfBounds(); /** * @dev cannot trigger validator exit */ error NoValidatorExit(); /** * @dev cannot initiate redemption partially */ error NoPartialInitiateRedemption(); /** * @dev not enough validators */ error NotEnoughValidators(); /** * @dev not enough ETH */ error NotEnoughETH(); /** * @dev max processed count is invalid (< 1) */ error InvalidMaxProcessedCount(); /** * @dev fromIndex and toIndex are invalid */ error InvalidIndexRanges(); /** * @dev ETH is not allowed */ error NoETHAllowed(); /** * @dev ETH is not passed */ error NoETH(); /** * @dev validator status is neither dissolved nor slashed */ error StatusNotDissolvedOrSlashed(); /** * @dev validator status is neither withdrawable nor staking */ error StatusNotWithdrawableOrStaking(); /** * @dev account is not approved */ error AccountNotApproved(); /** * @dev invalid token specified */ error InvalidToken(); /** * @dev not same as deposit size */ error InvalidAmount(); /** * @dev contract not recognised */ error UnrecorgnisedContract(); /** * @dev empty array */ error EmptyArray(); /** * @dev arrays length mismatch */ error MismatchedArrayLengths(); }
// SPDX-License-Identifier: MIT pragma solidity 0.8.19; /** * @title DataTypes * @notice Library containing various data structures and enums for the PirexEth. * @dev This library provides data structures and enums crucial for the functionality of the Pirex protocol. * @author redactedcartel.finance */ library DataTypes { // Validator struct type struct Validator { // Publickey of the validator bytes pubKey; // Signature associated with the validator bytes signature; // Root hash of deposit data for the validator bytes32 depositDataRoot; // beneficiazry address to receive pxEth against preDeposit address receiver; } // ValidatorDeque struct type struct ValidatorDeque { // Beginning index of the validator deque int128 _begin; // End index of the validator deque int128 _end; // Mapping of validator index to Validator struct mapping(int128 => Validator) _validators; } // Burner Account Type struct BurnerAccount { // Address of the burner account address account; // Amount associated with the burner account uint256 amount; } // Configurable fees enum Fees { // Fee type for deposit Deposit, // Fee type for redemption Redemption, // Fee type for instant redemption InstantRedemption } // Configurable contracts enum Contract { // PxEth contract PxEth, // UpxEth contract UpxEth, // AutoPxEth contract AutoPxEth, // OracleAdapter contract OracleAdapter, // PirexEth contract PirexEth, // RewardRecipient contract RewardRecipient } // Validator statuses enum ValidatorStatus { // The validator is not staking and has no defined status. None, // The validator is actively participating in the staking process. // It could be in one of the following states: pending_initialized, pending_queued, or active_ongoing. Staking, // The validator has proceed with the withdrawal process. // It represents a meta state for active_exiting, exited_unslashed, and the withdrawal process being possible. Withdrawable, // The validator's status indicating that ETH is released to the pirexEthValidators // It represents the withdrawal_done status. Dissolved, // The validator's status indicating that it has been slashed due to misbehavior. // It serves as a meta state encompassing active_slashed, exited_slashed, // and the possibility of starting the withdrawal process (withdrawal_possible) or already completed (withdrawal_done) // with the release of ETH, subject to a penalty for the misbehavior. Slashed } }
// SPDX-License-Identifier: MIT pragma solidity 0.8.19; /** * @title IPirexFees * @notice Interface for managing fee distribution in the PirexEth. * @dev This interface defines functions related to the distribution of fees in the Pirex protocol. * @author redactedcartel.finance */ interface IPirexFees { /** * @notice Distributes fees from a specified source. * @dev This function is responsible for distributing fees in the specified token amount. * @param from address Address representing the source of fees. * @param token address Address of the fee token. * @param amount uint256 The amount of the fee token to be distributed. */ function distributeFees( address from, address token, uint256 amount ) external; }
// SPDX-License-Identifier: MIT pragma solidity 0.8.19; import {ReentrancyGuard} from "solmate/utils/ReentrancyGuard.sol"; import {ERC20} from "solmate/tokens/ERC20.sol"; import {SafeTransferLib} from "solmate/utils/SafeTransferLib.sol"; import {AccessControlDefaultAdminRules} from "openzeppelin-contracts/contracts/access/AccessControlDefaultAdminRules.sol"; import {UpxEth} from "./tokens/UpxEth.sol"; import {Errors} from "./libraries/Errors.sol"; import {DataTypes} from "./libraries/DataTypes.sol"; import {ValidatorQueue} from "./libraries/ValidatorQueue.sol"; import {IOracleAdapter} from "./interfaces/IOracleAdapter.sol"; import {IPirexEth} from "./interfaces/IPirexEth.sol"; import {IDepositContract} from "./interfaces/IDepositContract.sol"; import {AutoPxEth} from "./AutoPxEth.sol"; import {PxEth} from "./PxEth.sol"; /** * @title PirexEthValidators * @notice Manages validators and deposits for the Eth2.0 deposit contract * @dev This contract includes functionality for handling validator-related operations and deposits. * @author redactedcartel.finance */ abstract contract PirexEthValidators is ReentrancyGuard, AccessControlDefaultAdminRules, IPirexEth { /** * @dev This library provides enhanced safety features for ERC20 token transfers, reducing the risk of common vulnerabilities. */ using ValidatorQueue for DataTypes.ValidatorDeque; /** * @dev This library extends the functionality of the DataTypes.ValidatorDeque data structure to facilitate validator management. */ using SafeTransferLib for ERC20; /** * @notice Denominator used for mathematical calculations. * @dev This constant is used as a divisor in various mathematical calculations * throughout the contract to achieve precise percentages and ratios. */ uint256 internal constant DENOMINATOR = 1_000_000; // Roles /** * @notice The role assigned to external keepers responsible for specific protocol functions. * @dev This role is assigned to external entities that are responsible for performing specific * functions within the protocol, such as validator upkeep and maintenance. */ bytes32 internal constant KEEPER_ROLE = keccak256("KEEPER_ROLE"); /** * @notice The role assigned to governance entities responsible for managing protocol parameters. * @dev This role is assigned to governance entities that have the authority to manage and * update various protocol parameters, ensuring the smooth operation and evolution of the protocol. */ bytes32 internal constant GOVERNANCE_ROLE = keccak256("GOVERNANCE_ROLE"); /** * @notice Paused status indicator when depositing Ether is not paused. * @dev This constant represents the status indicator when depositing Ether is not paused. * It is used as a reference for the depositEtherPaused state variable to determine whether * depositing Ether is currently allowed or paused. */ uint256 internal constant _NOT_PAUSED = 1; /** * @notice Paused status indicator when depositing Ether is paused. * @dev This constant represents the status indicator when depositing Ether is paused. * It is used as a reference for the depositEtherPaused state variable to determine * whether depositing Ether is currently allowed or paused. */ uint256 internal constant _PAUSED = 2; /** * @notice The address of the external beacon chain deposit contract. * @dev This variable holds the immutable address of the external beacon chain deposit contract. * It is used to interact with the contract for depositing validators to the Ethereum 2.0 beacon chain. */ address public immutable beaconChainDepositContract; /** * @notice The amount of Ether that a validator must deposit before being added to the initialized validator queue. * @dev This variable represents the immutable pre-deposit amount required for a validator to be added to the initialized validator queue. * Validators need to deposit this amount of Ether to be put in initialized validator queue. */ uint256 public immutable preDepositAmount; /** * @notice The default deposit size for validators, set once during contract initialization. * @dev This variable represents the immutable default deposit size for validators. * It is set during the contract initialization and represents the amount of Ether a validator needs to deposit * to participate in the Ethereum 2.0 staking process. */ uint256 public immutable DEPOSIT_SIZE; /** * @notice The withdrawal credentials used when processing validator withdrawals. * @dev This variable holds the withdrawal credentials, which are used to receive valdiator rewards */ bytes public withdrawalCredentials; /** * @notice Buffer for instant withdrawals and emergency top-ups. * @dev This variable represents the buffer amount, * which is utilized for immediate withdrawals and emergency top-ups. * It serves as a reserve to facilitate rapid withdrawals or cover unexpected events within the protocol. */ uint256 public buffer; /** * @notice Maximum buffer size for instant withdrawals and emergency top-ups. * @dev This variable represents the upper limit for the buffer size, * determining the maximum amount that can be reserved for immediate withdrawals, * and emergency top-ups in the protocol. */ uint256 public maxBufferSize; /** * @notice Percentage of pxEth total supply allocated to determine the max buffer size. * @dev This variable represents the percentage of the total supply of pxEth that is allocated * to determine the maximum buffer size. It influences the dynamic adjustment of the buffer * size based on the total supply of pxEth in the protocol. */ uint256 public maxBufferSizePct; /** * @notice Maximum count of validators to be processed in a single `_deposit` call. * @dev This variable determines the maximum number of validators that can be processed in a single call to the `_deposit` function. * It helps control the efficiency and gas cost of the depositing process. */ uint256 public maxProcessedValidatorCount = 20; // Pirex contracts /** * @notice The UpxEth contract responsible for managing the upxEth token. * @dev This variable holds the address of the UpxEth contract, * which represents pending redemption. */ UpxEth public upxEth; /** * @notice The PxEth contract responsible for managing the pxEth token. * @dev This variable holds the address of the PxEth contract, * which represents ETH deposit made to Dinero protocol. */ PxEth public pxEth; /** * @notice The AutoPxEth contract responsible for automated management of the pxEth token. * @dev This variable holds the address of the AutoPxEth contract, * which represents pxEth deposit to auto compounding vault. */ AutoPxEth public autoPxEth; /** * @notice The OracleAdapter contract responsible for interfacing with the oracle for protocol data. * @dev This variable holds the address of the OracleAdapter contract, * which is used to request validator exit and update its status to dissolves or slashed. */ IOracleAdapter public oracleAdapter; /** * @notice The address designated as the reward recipient for protocol incentives. * @dev This variable holds the address of the entity designated to receive consensus, * execution and MEV rewards. */ address public rewardRecipient; /** * @notice Indicator for whether depositing Ether to the beacon chain deposit contract is paused or not. * @dev This variable holds the status indicator (paused or not) for depositing Ether to the beacon chain deposit contract. */ uint256 public depositEtherPaused; /** * @notice Buffer for pending deposits to be staked, r * equired to be greater than or equal to multiples of DEPOSIT_SIZE, including preDepositAmount. * @dev This variable holds the amount of pending deposits that are waiting to be staked. * It ensures that the buffer size is sufficient for multiples of DEPOSIT_SIZE, including preDepositAmount. */ uint256 public pendingDeposit; /** * @notice Queue to prioritize validator spinning on a FIFO basis. * @dev This internal variable represents a deque (double-ended queue) used to prioritize validator * spinning based on a First-In-First-Out (FIFO) basis. */ DataTypes.ValidatorDeque internal _initializedValidators; /** * @notice Queue to prioritize the next validator to be exited when required on a FIFO basis. * @dev This internal variable represents a deque (double-ended queue) used to prioritize validators * for exiting based on a First-In-First-Out (FIFO) basis. */ DataTypes.ValidatorDeque internal _stakingValidators; /** * @notice Buffer for withdrawals to be unstaked, required to be greater than or equal to multiples of DEPOSIT_SIZE. * @dev This variable holds the amount of Ether that is pending withdrawal, * and it must be greater than or equal to multiples of DEPOSIT_SIZE. */ uint256 public pendingWithdrawal; /** * @notice ETH available for redemptions. * @dev This variable represents the amount of Ether available for redemptions by burning upxEth. */ uint256 public outstandingRedemptions; /** * @notice Batch Id for validator's voluntary exit. * @dev This variable represents the batch ID for a validator's voluntary exit. */ uint256 public batchId; /** * @notice End block for the ETH rewards calculation. * @dev This variable represents the block number until which ETH rewards are computed. */ uint256 public endBlock; /** * @notice Validator statuses, mapping from validator public key to their status. * @dev This mapping tracks the status of each validator, using their public key as the identifier. */ mapping(bytes => DataTypes.ValidatorStatus) public status; /** * @notice Mapping from batchId to validator public key. * @dev This mapping tracks the batch ID of each unstaked validator */ mapping(uint256 => bytes) public batchIdToValidator; /** * @notice Accounts designated for burning pxEth when the buffer is used for top-up and the validator is slashed. * @dev This mapping identifies accounts designated for burning pxEth under specific conditions. */ mapping(address => bool) public burnerAccounts; // Events /** * @notice Emitted when a validator is deposited, indicating the addition of a new validator. * @dev This event is triggered when a user deposits ETH for staking, creating a new validator. * Validators play a crucial role in the proof-of-stake consensus mechanism and contribute * to the security and functionality of the network. The `pubKey` parameter represents the public key of the deposited validator. * @param pubKey bytes Public key of the deposited validator. */ event ValidatorDeposit(bytes pubKey); /** * @notice Emitted when a contract address is set. * @dev This event is triggered when a contract address is set for a specific contract type. * @param c DataTypes.Contract The type of the contract being set. * @param contractAddress address The address of the contract being set. */ event SetContract(DataTypes.Contract indexed c, address contractAddress); /** * @notice Emitted when the status of depositing Ether is paused or unpaused. * @dev This event is triggered when there is a change in the status of depositing Ether. * The `newStatus` parameter indicates whether depositing Ether is currently paused or unpaused. * Pausing depositing Ether can be useful in certain scenarios, such as during contract upgrades or emergency situations. * @param newStatus uint256 The new status indicating whether depositing Ether is paused or unpaused. */ event DepositEtherPaused(uint256 newStatus); /** * @notice Emitted when harvesting rewards. * @dev This event is triggered when rewards are harvested. The `amount` parameter indicates the amount of rewards harvested, * and the `endBlock` parameter specifies the block until which ETH rewards are computed. * @param amount uint256 The amount of rewards harvested. * @param endBlock uint256 The block until which ETH rewards are computed. */ event Harvest(uint256 amount, uint256 endBlock); /** * @notice Emitted when the max buffer size percentage is set. * @dev This event is triggered when the max buffer size percentage is updated. * The `pct` parameter represents the new max buffer size percentage. * @param pct uint256 The new max buffer size percentage. */ event SetMaxBufferSizePct(uint256 pct); /** * @notice Emitted when a burner account is approved. * @dev This event is triggered when a burner account is approved. * The `account` parameter represents the approved burner account. * @param account address The approved burner account. */ event ApproveBurnerAccount(address indexed account); /** * @notice Emitted when a burner account is revoked. * @dev This event is triggered when a burner account is revoked. * The `account` parameter represents the revoked burner account. * @param account address The revoked burner account. */ event RevokeBurnerAccount(address indexed account); /** * @notice Emitted when a validator is dissolved. * @dev This event is triggered when a validator is dissolved, indicating the update of the validator state. * @param pubKey bytes Public key of the dissolved validator. */ event DissolveValidator(bytes pubKey); /** * @notice Emitted when a validator is slashed. * @dev This event is triggered when a validator is slashed, indicating the slashing action and its details. * @param pubKey bytes Public key of the slashed validator. * @param useBuffer bool Indicates whether a buffer is used during slashing. * @param releasedAmount uint256 Amount released from the Beacon chain. * @param penalty uint256 Penalty amount. */ event SlashValidator( bytes pubKey, bool useBuffer, uint256 releasedAmount, uint256 penalty ); /** * @notice Emitted when a validator's stake is topped up. * @dev This event is triggered when a validator's stake is topped up, indicating the top-up action and its details. * @param pubKey bytes Public key of the topped-up validator. * @param useBuffer bool Indicates whether a buffer is used during topping up. * @param topUpAmount uint256 Amount topped up. */ event TopUp(bytes pubKey, bool useBuffer, uint256 topUpAmount); /** * @notice Emitted when the maximum processed validator count is set. * @dev This event is triggered when the maximum count of processed validators is set, indicating a change in the processing limit. * @param count uint256 The new maximum count of processed validators. */ event SetMaxProcessedValidatorCount(uint256 count); /** * @notice Emitted when the max buffer size is updated. * @dev This event is triggered when max buffer size is updated * @param maxBufferSize uint256 The updated maximum buffer size. */ event UpdateMaxBufferSize(uint256 maxBufferSize); /** * @notice Emitted when the withdrawal credentials are set. * @dev This event is triggered when the withdrawal credentials are updated, indicating a change in the credentials used for validator withdrawals. * @param withdrawalCredentials bytes The new withdrawal credentials. */ event SetWithdrawCredentials(bytes withdrawalCredentials); // Modifiers /** * @dev Reverts if the sender is not the specified reward recipient. Used to control access to functions that * are intended for the designated recipient of rewards. */ modifier onlyRewardRecipient() { if (msg.sender != rewardRecipient) revert Errors.NotRewardRecipient(); _; } /** * @dev Reverts if depositing Ether is not paused. Used to control access to functions that should only be * callable when depositing Ether is in a paused state. */ modifier onlyWhenDepositEtherPaused() { if (depositEtherPaused == _NOT_PAUSED) revert Errors.DepositingEtherNotPaused(); _; } /*////////////////////////////////////////////////////////////// CONSTRUCTOR/INITIALIZATION LOGIC //////////////////////////////////////////////////////////////*/ /** * @notice Initializes the PirexEthValidators contract. * @dev Initializes the contract with the provided parameters and sets up the initial state. * @param _pxEth address PxETH contract address * @param _admin address Admin address * @param _beaconChainDepositContract address The address of the deposit precompile * @param _upxEth address UpxETH address * @param _depositSize uint256 Amount of ETH to stake * @param _preDepositAmount uint256 Amount of ETH for pre-deposit * @param _initialDelay uint48 Delay required to schedule the acceptance * of an access control transfer started */ constructor( address _pxEth, address _admin, address _beaconChainDepositContract, address _upxEth, uint256 _depositSize, uint256 _preDepositAmount, uint48 _initialDelay ) AccessControlDefaultAdminRules(_initialDelay, _admin) { if (_pxEth == address(0)) revert Errors.ZeroAddress(); if (_beaconChainDepositContract == address(0)) revert Errors.ZeroAddress(); if (_upxEth == address(0)) revert Errors.ZeroAddress(); if (_depositSize < 1 ether && _depositSize % 1 gwei != 0) revert Errors.ZeroMultiplier(); if ( _preDepositAmount > _depositSize || _preDepositAmount < 1 ether || _preDepositAmount % 1 gwei != 0 ) revert Errors.ZeroMultiplier(); pxEth = PxEth(_pxEth); DEPOSIT_SIZE = _depositSize; beaconChainDepositContract = _beaconChainDepositContract; preDepositAmount = _preDepositAmount; upxEth = UpxEth(_upxEth); depositEtherPaused = _NOT_PAUSED; } /*////////////////////////////////////////////////////////////// VIEW //////////////////////////////////////////////////////////////*/ /** * @notice Get the number of initialized validators * @dev Returns the count of validators that are ready to be staked. * @return uint256 count of validators ready to be staked */ function getInitializedValidatorCount() external view returns (uint256) { return _initializedValidators.count(); } /** * @notice Get the number of staked validators * @dev Returns the count of validators with staking status. * @return uint256 count of validators with staking status */ function getStakingValidatorCount() public view returns (uint256) { return _stakingValidators.count(); } /** * @notice Get the initialized validator info at the specified index * @dev Returns the details of the initialized validator at the given index. * @param _i uint256 Index * @return bytes Public key * @return bytes Withdrawal credentials * @return bytes Signature * @return bytes32 Deposit data root hash * @return address pxETH receiver */ function getInitializedValidatorAt( uint256 _i ) external view returns (bytes memory, bytes memory, bytes memory, bytes32, address) { return _initializedValidators.get(withdrawalCredentials, _i); } /** * @notice Get the staking validator info at the specified index * @dev Returns the details of the staking validator at the given index. * @param _i uint256 Index * @return bytes Public key * @return bytes Withdrawal credentials * @return bytes Signature * @return bytes32 Deposit data root hash * @return address pxETH receiver */ function getStakingValidatorAt( uint256 _i ) external view returns (bytes memory, bytes memory, bytes memory, bytes32, address) { return _stakingValidators.get(withdrawalCredentials, _i); } /*////////////////////////////////////////////////////////////// RESTRICTED FUNCTIONS //////////////////////////////////////////////////////////////*/ /** * @notice Set a contract address * @dev Allows the governance role to set the address for a contract in the system. * @param _contract DataTypes.Contract Contract * @param contractAddress address Contract address */ function setContract( DataTypes.Contract _contract, address contractAddress ) external onlyRole(GOVERNANCE_ROLE) { if (contractAddress == address(0)) revert Errors.ZeroAddress(); emit SetContract(_contract, contractAddress); if (_contract == DataTypes.Contract.UpxEth) { upxEth = UpxEth(contractAddress); } else if (_contract == DataTypes.Contract.PxEth) { pxEth = PxEth(contractAddress); } else if (_contract == DataTypes.Contract.AutoPxEth) { ERC20 pxEthERC20 = ERC20(address(pxEth)); address oldVault = address(autoPxEth); if (oldVault != address(0)) { pxEthERC20.safeApprove(oldVault, 0); } autoPxEth = AutoPxEth(contractAddress); pxEthERC20.safeApprove(address(autoPxEth), type(uint256).max); } else if (_contract == DataTypes.Contract.OracleAdapter) { oracleAdapter = IOracleAdapter(contractAddress); } else if (_contract == DataTypes.Contract.RewardRecipient) { rewardRecipient = contractAddress; withdrawalCredentials = abi.encodePacked( bytes1(0x01), bytes11(0x0), contractAddress ); emit SetWithdrawCredentials(withdrawalCredentials); } else { revert Errors.UnrecorgnisedContract(); } } /** * @notice Set the percentage that will be applied to total supply of pxEth to determine maxBufferSize * @dev Allows the governance role to set the percentage of the total supply of pxEth that will be used as maxBufferSize. * @param _pct uint256 Max buffer size percentage */ function setMaxBufferSizePct( uint256 _pct ) external onlyRole(GOVERNANCE_ROLE) { if (_pct > DENOMINATOR) { revert Errors.ExceedsMax(); } maxBufferSizePct = _pct; emit SetMaxBufferSizePct(_pct); } /** * @notice Set the maximum count of validators to be processed in a single _deposit call * @dev Only the role with the GOVERNANCE_ROLE can execute this function. * @param _count uint256 Maximum count of validators to be processed */ function setMaxProcessedValidatorCount( uint256 _count ) external onlyRole(GOVERNANCE_ROLE) { if (_count == 0) { revert Errors.InvalidMaxProcessedCount(); } maxProcessedValidatorCount = _count; emit SetMaxProcessedValidatorCount(_count); } /** * @notice Toggle the ability to deposit ETH to validators * @dev Only the role with the GOVERNANCE_ROLE can execute this function. */ function togglePauseDepositEther() external onlyRole(GOVERNANCE_ROLE) { depositEtherPaused = depositEtherPaused == _NOT_PAUSED ? _PAUSED : _NOT_PAUSED; emit DepositEtherPaused(depositEtherPaused); } /** * @notice Approve or revoke addresses as burner accounts * @dev Only the role with the GOVERNANCE_ROLE can execute this function. * @param _accounts address[] An array of addresses to be approved or revoked as burner accounts. * @param _state bool A boolean indicating whether to approve (true) or revoke (false) the burner account state. */ function toggleBurnerAccounts( address[] calldata _accounts, bool _state ) external onlyRole(GOVERNANCE_ROLE) { uint256 _len = _accounts.length; for (uint256 _i; _i < _len; ) { address account = _accounts[_i]; burnerAccounts[account] = _state; if (_state) { emit ApproveBurnerAccount(account); } else { emit RevokeBurnerAccount(account); } unchecked { ++_i; } } } /*////////////////////////////////////////////////////////////// MUTATIVE FUNCTIONS //////////////////////////////////////////////////////////////*/ /** * @notice Update validator to Dissolve once Oracle confirms ETH release * @dev Only the reward recipient can initiate the dissolution process. * @param _pubKey bytes The public key of the validator to be dissolved. */ function dissolveValidator( bytes calldata _pubKey ) external payable override onlyRewardRecipient { uint256 _amount = msg.value; if (_amount != DEPOSIT_SIZE) revert Errors.InvalidAmount(); if (status[_pubKey] != DataTypes.ValidatorStatus.Withdrawable) revert Errors.NotWithdrawable(); status[_pubKey] = DataTypes.ValidatorStatus.Dissolved; outstandingRedemptions += _amount; emit DissolveValidator(_pubKey); } /** * @notice Update validator state to be slashed * @dev Only the reward recipient can initiate the slashing process. * @param _pubKey bytes The public key of the validator to be slashed. * @param _removeIndex uint256 Index of the validator to be slashed. * @param _amount uint256 ETH amount released from the Beacon chain. * @param _unordered bool Whether to remove from the staking validator queue in order or not. * @param _useBuffer bool Whether to use the buffer to compensate for the loss. * @param _burnerAccounts DataTypes.BurnerAccount[] Burner accounts providing additional compensation. */ function slashValidator( bytes calldata _pubKey, uint256 _removeIndex, uint256 _amount, bool _unordered, bool _useBuffer, DataTypes.BurnerAccount[] calldata _burnerAccounts ) external payable override onlyRewardRecipient { uint256 _ethAmount = msg.value; uint256 _defaultDepositSize = DEPOSIT_SIZE; DataTypes.ValidatorStatus _status = status[_pubKey]; if ( _status != DataTypes.ValidatorStatus.Staking && _status != DataTypes.ValidatorStatus.Withdrawable ) revert Errors.StatusNotWithdrawableOrStaking(); if (_useBuffer) { _updateBuffer(_defaultDepositSize - _ethAmount, _burnerAccounts); } else if (_ethAmount != _defaultDepositSize) { revert Errors.InvalidAmount(); } // It is possible that validator can be slashed while exiting if (_status == DataTypes.ValidatorStatus.Staking) { bytes memory _removedPubKey; if (!_unordered) { _removedPubKey = _stakingValidators.removeOrdered(_removeIndex); } else { _removedPubKey = _stakingValidators.removeUnordered( _removeIndex ); } assert(keccak256(_pubKey) == keccak256(_removedPubKey)); _addPendingDeposit(_defaultDepositSize); } else { outstandingRedemptions += _defaultDepositSize; } status[_pubKey] = DataTypes.ValidatorStatus.Slashed; emit SlashValidator( _pubKey, _useBuffer, _amount, DEPOSIT_SIZE - _amount ); } /** * @notice Add multiple synced validators in the queue to be ready for staking. * @dev Only callable when depositing Ether is paused and by a user with the GOVERNANCE_ROLE. * @param _validators DataTypes.Validator[] An array of validator details (public key, withdrawal credentials, etc.). */ function addInitializedValidators( DataTypes.Validator[] memory _validators ) external onlyWhenDepositEtherPaused onlyRole(GOVERNANCE_ROLE) { uint256 _arrayLength = _validators.length; for (uint256 _i; _i < _arrayLength; ) { if ( status[_validators[_i].pubKey] != DataTypes.ValidatorStatus.None ) revert Errors.NoUsedValidator(); _initializedValidators.add(_validators[_i], withdrawalCredentials); unchecked { ++_i; } } } /** * @notice Swap initialized validators specified by the indexes. * @dev Only callable when depositing Ether is paused and by a user with the GOVERNANCE_ROLE. * @param _fromIndex uint256 The index of the validator to be swapped from. * @param _toIndex uint256 The index of the validator to be swapped to. */ function swapInitializedValidator( uint256 _fromIndex, uint256 _toIndex ) external onlyWhenDepositEtherPaused onlyRole(GOVERNANCE_ROLE) { _initializedValidators.swap(_fromIndex, _toIndex); } /** * @notice Pop initialized validators from the queue. * @dev Only callable when depositing Ether is paused and by a user with the GOVERNANCE_ROLE. * @param _times uint256 The count of pop operations to be performed. */ function popInitializedValidator( uint256 _times ) external onlyWhenDepositEtherPaused onlyRole(GOVERNANCE_ROLE) { _initializedValidators.pop(_times); } /** * @notice Remove an initialized validator from the queue. * @dev Only callable when depositing Ether is paused and by a user with the GOVERNANCE_ROLE. * @param _pubKey bytes The public key of the validator to be removed. * @param _removeIndex uint256 The index of the validator to be removed. * @param _unordered bool A flag indicating whether removal should be unordered (true) or ordered (false). */ function removeInitializedValidator( bytes calldata _pubKey, uint256 _removeIndex, bool _unordered ) external onlyWhenDepositEtherPaused onlyRole(GOVERNANCE_ROLE) { bytes memory _removedPubKey; if (_unordered) { _removedPubKey = _initializedValidators.removeUnordered( _removeIndex ); } else { _removedPubKey = _initializedValidators.removeOrdered(_removeIndex); } assert(keccak256(_removedPubKey) == keccak256(_pubKey)); } /** * @notice Clear all initialized validators from the queue. * @dev Only callable when depositing Ether is paused and by a user with the GOVERNANCE_ROLE. */ function clearInitializedValidator() external onlyWhenDepositEtherPaused onlyRole(GOVERNANCE_ROLE) { _initializedValidators.clear(); } /** * @notice Trigger a privileged deposit to the ETH 2.0 deposit contract. * @dev Only callable by a user with the KEEPER_ROLE and ensures that depositing Ether is not paused. * This function initiates the deposit process to the ETH 2.0 deposit contract. */ function depositPrivileged() external nonReentrant onlyRole(KEEPER_ROLE) { // Initial pause check if (depositEtherPaused == _PAUSED) revert Errors.DepositingEtherPaused(); _deposit(); } /** * @notice Top up ETH to a staking validator if the current balance drops below the effective balance. * @dev Only callable by a user with the KEEPER_ROLE. * @param _pubKey bytes Validator public key. * @param _signature bytes A BLS12-381 signature. * @param _depositDataRoot bytes32 The SHA-256 hash of the SSZ-encoded DepositData object. * @param _topUpAmount uint256 Top-up amount in ETH. * @param _useBuffer bool Whether to use a buffer to compensate for the loss. * @param _burnerAccounts DataTypes.BurnerAccount[] Array of burner accounts. */ function topUpStake( bytes calldata _pubKey, bytes calldata _signature, bytes32 _depositDataRoot, uint256 _topUpAmount, bool _useBuffer, DataTypes.BurnerAccount[] calldata _burnerAccounts ) external payable nonReentrant onlyRole(KEEPER_ROLE) { if (status[_pubKey] != DataTypes.ValidatorStatus.Staking) revert Errors.ValidatorNotStaking(); if (_useBuffer) { if (msg.value > 0) { revert Errors.NoETHAllowed(); } _updateBuffer(_topUpAmount, _burnerAccounts); } else if (msg.value != _topUpAmount) { revert Errors.NoETH(); } (bool success, ) = beaconChainDepositContract.call{value: _topUpAmount}( abi.encodeCall( IDepositContract.deposit, (_pubKey, withdrawalCredentials, _signature, _depositDataRoot) ) ); assert(success); emit TopUp(_pubKey, _useBuffer, _topUpAmount); } /** * @notice Harvest and mint staking rewards when available. * @dev Only callable by the reward recipient. * @param _endBlock uint256 Block until which ETH rewards are computed. */ function harvest( uint256 _endBlock ) external payable override onlyRewardRecipient { if (msg.value != 0) { // update end block endBlock = _endBlock; // Mint pxETH directly for the vault _mintPxEth(address(autoPxEth), msg.value); // Update rewards tracking with the newly added rewards autoPxEth.notifyRewardAmount(); // Direct the excess balance for pending deposit _addPendingDeposit(msg.value); emit Harvest(msg.value, _endBlock); } } /*////////////////////////////////////////////////////////////// INTERNAL FUNCTIONS //////////////////////////////////////////////////////////////*/ /** * @dev Mints the specified amount of pxETH and updates the maximum buffer size. * @param _account address The address to which pxETH will be minted. * @param _amount uint256 The amount of pxETH to be minted. */ function _mintPxEth(address _account, uint256 _amount) internal { pxEth.mint(_account, _amount); uint256 _maxBufferSize = (pxEth.totalSupply() * maxBufferSizePct) / DENOMINATOR; maxBufferSize = _maxBufferSize; emit UpdateMaxBufferSize(_maxBufferSize); } /** * @dev Burns the specified amount of pxETH from the given account and updates the maximum buffer size. * @param _account address The address from which pxETH will be burned. * @param _amount uint256 The amount of pxETH to be burned. */ function _burnPxEth(address _account, uint256 _amount) internal { pxEth.burn(_account, _amount); uint256 _maxBufferSize = (pxEth.totalSupply() * maxBufferSizePct) / DENOMINATOR; maxBufferSize = _maxBufferSize; emit UpdateMaxBufferSize(_maxBufferSize); } /** * @dev Processes the deposit of validators, taking into account the maximum processed validator count, * the remaining deposit amount, and the status of initialized validators. It iterates through initialized * validators, deposits them into the Beacon chain, mints pxETH if needed, and updates the validator status. */ function _deposit() internal { uint256 remainingCount = maxProcessedValidatorCount; uint256 _remainingdepositAmount = DEPOSIT_SIZE - preDepositAmount; while ( _initializedValidators.count() != 0 && pendingDeposit >= _remainingdepositAmount && remainingCount > 0 ) { // Get validator information ( bytes memory _pubKey, bytes memory _withdrawalCredentials, bytes memory _signature, bytes32 _depositDataRoot, address _receiver ) = _initializedValidators.getNext(withdrawalCredentials); // Make sure the validator hasn't been deposited into already // to prevent sending an extra eth equal to `_remainingdepositAmount` // until withdrawals are allowed if (status[_pubKey] != DataTypes.ValidatorStatus.None) revert Errors.NoUsedValidator(); (bool success, ) = beaconChainDepositContract.call{ value: _remainingdepositAmount }( abi.encodeCall( IDepositContract.deposit, ( _pubKey, _withdrawalCredentials, _signature, _depositDataRoot ) ) ); assert(success); pendingDeposit -= _remainingdepositAmount; if (preDepositAmount != 0) { _mintPxEth(_receiver, preDepositAmount); } unchecked { --remainingCount; } status[_pubKey] = DataTypes.ValidatorStatus.Staking; _stakingValidators.add( DataTypes.Validator( _pubKey, _signature, _depositDataRoot, _receiver ), _withdrawalCredentials ); emit ValidatorDeposit(_pubKey); } } /** * @dev Adds the specified amount to the pending deposit, considering the available buffer space and deposit pause status. * If the buffer space is available, it may be fully or partially utilized. The method then checks if depositing * ETH is not paused and spins up a validator if conditions are met. * @param _amount uint256 The amount of ETH to be added to the pending deposit. */ function _addPendingDeposit(uint256 _amount) internal virtual { uint256 _remainingBufferSpace = ( maxBufferSize > buffer ? maxBufferSize - buffer : 0 ); uint256 _remainingAmount = _amount; if (_remainingBufferSpace != 0) { bool _canBufferSpaceFullyUtilized = _remainingBufferSpace <= _remainingAmount; buffer += _canBufferSpaceFullyUtilized ? _remainingBufferSpace : _remainingAmount; _remainingAmount -= _canBufferSpaceFullyUtilized ? _remainingBufferSpace : _remainingAmount; } pendingDeposit += _remainingAmount; if (depositEtherPaused == _NOT_PAUSED) { // Spin up a validator when possible _deposit(); } } /** * @dev Initiates the redemption process by adding the specified amount of pxETH to the pending withdrawal. * Iteratively processes pending withdrawals in multiples of DEPOSIT_SIZE, triggering validator exits, updating * batch information, and changing validator statuses accordingly. The process continues until the remaining * pending withdrawal is less than DEPOSIT_SIZE. If `_shouldTriggerValidatorExit` is true and there's remaining * pxETH after the redemption process, the function reverts, preventing partial initiation of redemption. * @param _pxEthAmount uint256 The amount of pxETH to be redeemed. * @param _receiver address The receiver address for upxETH. * @param _shouldTriggerValidatorExit bool Whether to initiate partial redemption with a validator exit or not. */ function _initiateRedemption( uint256 _pxEthAmount, address _receiver, bool _shouldTriggerValidatorExit ) internal { pendingWithdrawal += _pxEthAmount; while (pendingWithdrawal / DEPOSIT_SIZE != 0) { uint256 _allocationPossible = DEPOSIT_SIZE + _pxEthAmount - pendingWithdrawal; upxEth.mint(_receiver, batchId, _allocationPossible, ""); (bytes memory _pubKey, , , , ) = _stakingValidators.getNext( withdrawalCredentials ); pendingWithdrawal -= DEPOSIT_SIZE; _pxEthAmount -= _allocationPossible; oracleAdapter.requestVoluntaryExit(_pubKey); batchIdToValidator[batchId++] = _pubKey; status[_pubKey] = DataTypes.ValidatorStatus.Withdrawable; } if (_shouldTriggerValidatorExit && _pxEthAmount > 0) revert Errors.NoPartialInitiateRedemption(); if (_pxEthAmount > 0) { upxEth.mint(_receiver, batchId, _pxEthAmount, ""); } } /** * @dev Checks if the contract has enough buffer to cover the specified amount. Iterates through the provided * `_burnerAccounts`, verifies each account's approval status, burns the corresponding amount of pxETH, and * updates the buffer accordingly. Reverts if there is insufficient buffer, if an account is not approved, or * if the sum of burned amounts does not match the specified amount. * @param _amount uint256 The amount to be updated in the buffer. * @param _burnerAccounts DataTypes.BurnerAccount[] An array of burner account details (account and amount). */ function _updateBuffer( uint256 _amount, DataTypes.BurnerAccount[] calldata _burnerAccounts ) private { if (buffer < _amount) { revert Errors.NotEnoughBuffer(); } uint256 _len = _burnerAccounts.length; uint256 _sum; for (uint256 _i; _i < _len; ) { if (!burnerAccounts[_burnerAccounts[_i].account]) revert Errors.AccountNotApproved(); _sum += _burnerAccounts[_i].amount; _burnPxEth(_burnerAccounts[_i].account, _burnerAccounts[_i].amount); unchecked { ++_i; } } assert(_sum == _amount); buffer -= _amount; } }
// SPDX-License-Identifier: AGPL-3.0-only pragma solidity >=0.8.0; /// @notice Gas optimized reentrancy protection for smart contracts. /// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/ReentrancyGuard.sol) /// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/ReentrancyGuard.sol) abstract contract ReentrancyGuard { uint256 private locked = 1; modifier nonReentrant() virtual { require(locked == 1, "REENTRANCY"); locked = 2; _; locked = 1; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (access/AccessControlDefaultAdminRules.sol) pragma solidity ^0.8.0; import "./AccessControl.sol"; import "./IAccessControlDefaultAdminRules.sol"; import "../utils/math/SafeCast.sol"; import "../interfaces/IERC5313.sol"; /** * @dev Extension of {AccessControl} that allows specifying special rules to manage * the `DEFAULT_ADMIN_ROLE` holder, which is a sensitive role with special permissions * over other roles that may potentially have privileged rights in the system. * * If a specific role doesn't have an admin role assigned, the holder of the * `DEFAULT_ADMIN_ROLE` will have the ability to grant it and revoke it. * * This contract implements the following risk mitigations on top of {AccessControl}: * * * Only one account holds the `DEFAULT_ADMIN_ROLE` since deployment until it's potentially renounced. * * Enforces a 2-step process to transfer the `DEFAULT_ADMIN_ROLE` to another account. * * Enforces a configurable delay between the two steps, with the ability to cancel before the transfer is accepted. * * The delay can be changed by scheduling, see {changeDefaultAdminDelay}. * * It is not possible to use another role to manage the `DEFAULT_ADMIN_ROLE`. * * Example usage: * * ```solidity * contract MyToken is AccessControlDefaultAdminRules { * constructor() AccessControlDefaultAdminRules( * 3 days, * msg.sender // Explicit initial `DEFAULT_ADMIN_ROLE` holder * ) {} * } * ``` * * _Available since v4.9._ */ abstract contract AccessControlDefaultAdminRules is IAccessControlDefaultAdminRules, IERC5313, AccessControl { // pending admin pair read/written together frequently address private _pendingDefaultAdmin; uint48 private _pendingDefaultAdminSchedule; // 0 == unset uint48 private _currentDelay; address private _currentDefaultAdmin; // pending delay pair read/written together frequently uint48 private _pendingDelay; uint48 private _pendingDelaySchedule; // 0 == unset /** * @dev Sets the initial values for {defaultAdminDelay} and {defaultAdmin} address. */ constructor(uint48 initialDelay, address initialDefaultAdmin) { require(initialDefaultAdmin != address(0), "AccessControl: 0 default admin"); _currentDelay = initialDelay; _grantRole(DEFAULT_ADMIN_ROLE, initialDefaultAdmin); } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IAccessControlDefaultAdminRules).interfaceId || super.supportsInterface(interfaceId); } /** * @dev See {IERC5313-owner}. */ function owner() public view virtual returns (address) { return defaultAdmin(); } /// /// Override AccessControl role management /// /** * @dev See {AccessControl-grantRole}. Reverts for `DEFAULT_ADMIN_ROLE`. */ function grantRole(bytes32 role, address account) public virtual override(AccessControl, IAccessControl) { require(role != DEFAULT_ADMIN_ROLE, "AccessControl: can't directly grant default admin role"); super.grantRole(role, account); } /** * @dev See {AccessControl-revokeRole}. Reverts for `DEFAULT_ADMIN_ROLE`. */ function revokeRole(bytes32 role, address account) public virtual override(AccessControl, IAccessControl) { require(role != DEFAULT_ADMIN_ROLE, "AccessControl: can't directly revoke default admin role"); super.revokeRole(role, account); } /** * @dev See {AccessControl-renounceRole}. * * For the `DEFAULT_ADMIN_ROLE`, it only allows renouncing in two steps by first calling * {beginDefaultAdminTransfer} to the `address(0)`, so it's required that the {pendingDefaultAdmin} schedule * has also passed when calling this function. * * After its execution, it will not be possible to call `onlyRole(DEFAULT_ADMIN_ROLE)` functions. * * NOTE: Renouncing `DEFAULT_ADMIN_ROLE` will leave the contract without a {defaultAdmin}, * thereby disabling any functionality that is only available for it, and the possibility of reassigning a * non-administrated role. */ function renounceRole(bytes32 role, address account) public virtual override(AccessControl, IAccessControl) { if (role == DEFAULT_ADMIN_ROLE && account == defaultAdmin()) { (address newDefaultAdmin, uint48 schedule) = pendingDefaultAdmin(); require( newDefaultAdmin == address(0) && _isScheduleSet(schedule) && _hasSchedulePassed(schedule), "AccessControl: only can renounce in two delayed steps" ); delete _pendingDefaultAdminSchedule; } super.renounceRole(role, account); } /** * @dev See {AccessControl-_grantRole}. * * For `DEFAULT_ADMIN_ROLE`, it only allows granting if there isn't already a {defaultAdmin} or if the * role has been previously renounced. * * NOTE: Exposing this function through another mechanism may make the `DEFAULT_ADMIN_ROLE` * assignable again. Make sure to guarantee this is the expected behavior in your implementation. */ function _grantRole(bytes32 role, address account) internal virtual override { if (role == DEFAULT_ADMIN_ROLE) { require(defaultAdmin() == address(0), "AccessControl: default admin already granted"); _currentDefaultAdmin = account; } super._grantRole(role, account); } /** * @dev See {AccessControl-_revokeRole}. */ function _revokeRole(bytes32 role, address account) internal virtual override { if (role == DEFAULT_ADMIN_ROLE && account == defaultAdmin()) { delete _currentDefaultAdmin; } super._revokeRole(role, account); } /** * @dev See {AccessControl-_setRoleAdmin}. Reverts for `DEFAULT_ADMIN_ROLE`. */ function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual override { require(role != DEFAULT_ADMIN_ROLE, "AccessControl: can't violate default admin rules"); super._setRoleAdmin(role, adminRole); } /// /// AccessControlDefaultAdminRules accessors /// /** * @inheritdoc IAccessControlDefaultAdminRules */ function defaultAdmin() public view virtual returns (address) { return _currentDefaultAdmin; } /** * @inheritdoc IAccessControlDefaultAdminRules */ function pendingDefaultAdmin() public view virtual returns (address newAdmin, uint48 schedule) { return (_pendingDefaultAdmin, _pendingDefaultAdminSchedule); } /** * @inheritdoc IAccessControlDefaultAdminRules */ function defaultAdminDelay() public view virtual returns (uint48) { uint48 schedule = _pendingDelaySchedule; return (_isScheduleSet(schedule) && _hasSchedulePassed(schedule)) ? _pendingDelay : _currentDelay; } /** * @inheritdoc IAccessControlDefaultAdminRules */ function pendingDefaultAdminDelay() public view virtual returns (uint48 newDelay, uint48 schedule) { schedule = _pendingDelaySchedule; return (_isScheduleSet(schedule) && !_hasSchedulePassed(schedule)) ? (_pendingDelay, schedule) : (0, 0); } /** * @inheritdoc IAccessControlDefaultAdminRules */ function defaultAdminDelayIncreaseWait() public view virtual returns (uint48) { return 5 days; } /// /// AccessControlDefaultAdminRules public and internal setters for defaultAdmin/pendingDefaultAdmin /// /** * @inheritdoc IAccessControlDefaultAdminRules */ function beginDefaultAdminTransfer(address newAdmin) public virtual onlyRole(DEFAULT_ADMIN_ROLE) { _beginDefaultAdminTransfer(newAdmin); } /** * @dev See {beginDefaultAdminTransfer}. * * Internal function without access restriction. */ function _beginDefaultAdminTransfer(address newAdmin) internal virtual { uint48 newSchedule = SafeCast.toUint48(block.timestamp) + defaultAdminDelay(); _setPendingDefaultAdmin(newAdmin, newSchedule); emit DefaultAdminTransferScheduled(newAdmin, newSchedule); } /** * @inheritdoc IAccessControlDefaultAdminRules */ function cancelDefaultAdminTransfer() public virtual onlyRole(DEFAULT_ADMIN_ROLE) { _cancelDefaultAdminTransfer(); } /** * @dev See {cancelDefaultAdminTransfer}. * * Internal function without access restriction. */ function _cancelDefaultAdminTransfer() internal virtual { _setPendingDefaultAdmin(address(0), 0); } /** * @inheritdoc IAccessControlDefaultAdminRules */ function acceptDefaultAdminTransfer() public virtual { (address newDefaultAdmin, ) = pendingDefaultAdmin(); require(_msgSender() == newDefaultAdmin, "AccessControl: pending admin must accept"); _acceptDefaultAdminTransfer(); } /** * @dev See {acceptDefaultAdminTransfer}. * * Internal function without access restriction. */ function _acceptDefaultAdminTransfer() internal virtual { (address newAdmin, uint48 schedule) = pendingDefaultAdmin(); require(_isScheduleSet(schedule) && _hasSchedulePassed(schedule), "AccessControl: transfer delay not passed"); _revokeRole(DEFAULT_ADMIN_ROLE, defaultAdmin()); _grantRole(DEFAULT_ADMIN_ROLE, newAdmin); delete _pendingDefaultAdmin; delete _pendingDefaultAdminSchedule; } /// /// AccessControlDefaultAdminRules public and internal setters for defaultAdminDelay/pendingDefaultAdminDelay /// /** * @inheritdoc IAccessControlDefaultAdminRules */ function changeDefaultAdminDelay(uint48 newDelay) public virtual onlyRole(DEFAULT_ADMIN_ROLE) { _changeDefaultAdminDelay(newDelay); } /** * @dev See {changeDefaultAdminDelay}. * * Internal function without access restriction. */ function _changeDefaultAdminDelay(uint48 newDelay) internal virtual { uint48 newSchedule = SafeCast.toUint48(block.timestamp) + _delayChangeWait(newDelay); _setPendingDelay(newDelay, newSchedule); emit DefaultAdminDelayChangeScheduled(newDelay, newSchedule); } /** * @inheritdoc IAccessControlDefaultAdminRules */ function rollbackDefaultAdminDelay() public virtual onlyRole(DEFAULT_ADMIN_ROLE) { _rollbackDefaultAdminDelay(); } /** * @dev See {rollbackDefaultAdminDelay}. * * Internal function without access restriction. */ function _rollbackDefaultAdminDelay() internal virtual { _setPendingDelay(0, 0); } /** * @dev Returns the amount of seconds to wait after the `newDelay` will * become the new {defaultAdminDelay}. * * The value returned guarantees that if the delay is reduced, it will go into effect * after a wait that honors the previously set delay. * * See {defaultAdminDelayIncreaseWait}. */ function _delayChangeWait(uint48 newDelay) internal view virtual returns (uint48) { uint48 currentDelay = defaultAdminDelay(); // When increasing the delay, we schedule the delay change to occur after a period of "new delay" has passed, up // to a maximum given by defaultAdminDelayIncreaseWait, by default 5 days. For example, if increasing from 1 day // to 3 days, the new delay will come into effect after 3 days. If increasing from 1 day to 10 days, the new // delay will come into effect after 5 days. The 5 day wait period is intended to be able to fix an error like // using milliseconds instead of seconds. // // When decreasing the delay, we wait the difference between "current delay" and "new delay". This guarantees // that an admin transfer cannot be made faster than "current delay" at the time the delay change is scheduled. // For example, if decreasing from 10 days to 3 days, the new delay will come into effect after 7 days. return newDelay > currentDelay ? uint48(Math.min(newDelay, defaultAdminDelayIncreaseWait())) // no need to safecast, both inputs are uint48 : currentDelay - newDelay; } /// /// Private setters /// /** * @dev Setter of the tuple for pending admin and its schedule. * * May emit a DefaultAdminTransferCanceled event. */ function _setPendingDefaultAdmin(address newAdmin, uint48 newSchedule) private { (, uint48 oldSchedule) = pendingDefaultAdmin(); _pendingDefaultAdmin = newAdmin; _pendingDefaultAdminSchedule = newSchedule; // An `oldSchedule` from `pendingDefaultAdmin()` is only set if it hasn't been accepted. if (_isScheduleSet(oldSchedule)) { // Emit for implicit cancellations when another default admin was scheduled. emit DefaultAdminTransferCanceled(); } } /** * @dev Setter of the tuple for pending delay and its schedule. * * May emit a DefaultAdminDelayChangeCanceled event. */ function _setPendingDelay(uint48 newDelay, uint48 newSchedule) private { uint48 oldSchedule = _pendingDelaySchedule; if (_isScheduleSet(oldSchedule)) { if (_hasSchedulePassed(oldSchedule)) { // Materialize a virtual delay _currentDelay = _pendingDelay; } else { // Emit for implicit cancellations when another delay was scheduled. emit DefaultAdminDelayChangeCanceled(); } } _pendingDelay = newDelay; _pendingDelaySchedule = newSchedule; } /// /// Private helpers /// /** * @dev Defines if an `schedule` is considered set. For consistency purposes. */ function _isScheduleSet(uint48 schedule) private pure returns (bool) { return schedule != 0; } /** * @dev Defines if an `schedule` is considered passed. For consistency purposes. */ function _hasSchedulePassed(uint48 schedule) private view returns (bool) { return schedule < block.timestamp; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/presets/ERC1155PresetMinterPauser.sol) pragma solidity 0.8.19; import {ERC1155} from "solmate/tokens/ERC1155.sol"; import {AccessControlDefaultAdminRules} from "openzeppelin-contracts/contracts/access/AccessControlDefaultAdminRules.sol"; /** * @title UpxEth * @notice Semi Fungible token contract used as an IOU by user * @dev ERC1155 token contract with minting and burning capabilities, using AccessControl for role-based access. * * UpxEth contract includes: * - Total supply tracking for each token ID * - Token burning functionality for holders * - Minter role for token creation * * The contract deploys with the default admin role, allowing it to grant minter and burner roles to other accounts. * The contract uses AccessControl for role-based access control. * * Deprecated in favor of [Contracts Wizard](https://wizard.openzeppelin.com/). * @author redactedcartel.finance */ contract UpxEth is AccessControlDefaultAdminRules, ERC1155 { /** * @dev Bytes32 constant representing the role to mint new tokens. */ bytes32 internal constant MINTER_ROLE = keccak256("MINTER_ROLE"); /** * @dev Bytes32 constant representing the role to burn (destroy) tokens. */ bytes32 internal constant BURNER_ROLE = keccak256("BURNER_ROLE"); /** * @dev Constructor to initialize the UpxEth contract. * @param _initialDelay uint48 Initial delay for AccessControl's admin lock, set by the contract deployer. */ constructor( uint48 _initialDelay ) AccessControlDefaultAdminRules(_initialDelay, msg.sender) {} /** * @notice Mints new tokens for a specific address. * @dev Restricted to accounts with the MINTER_ROLE. * @param to address Address to receive the minted tokens. * @param id uint256 Token ID to mint. * @param amount uint256 Amount of tokens to mint. * @param data bytes Additional data to include in the minting transaction. */ function mint( address to, uint256 id, uint256 amount, bytes calldata data ) external onlyRole(MINTER_ROLE) { _mint(to, id, amount, data); } /** * @notice Mints a batch of new tokens for a specific address. * @dev Restricted to accounts with the MINTER_ROLE. * @param to address Address to receive the minted tokens. * @param ids uint256[] Array of token IDs to mint. * @param amounts uint256[] Array of amounts of tokens to mint. * @param data bytes Additional data to include in the minting transaction. */ function mintBatch( address to, uint256[] calldata ids, uint256[] calldata amounts, bytes calldata data ) external onlyRole(MINTER_ROLE) { _batchMint(to, ids, amounts, data); } /** * @notice Burns a batch of tokens from a specific address. * @dev Restricted to accounts with the BURNER_ROLE. * @param from address Address from which to burn tokens. * @param ids uint256[] Array of token IDs to burn. * @param amounts uint256[] Array of amounts of tokens to burn. */ function burnBatch( address from, uint256[] calldata ids, uint256[] calldata amounts ) external onlyRole(BURNER_ROLE) { _batchBurn(from, ids, amounts); } /** * @notice Burns a specific amount of tokens from a specific address. * @dev Restricted to accounts with the BURNER_ROLE. * @param from address Address from which to burn tokens. * @param id uint256 Token ID to burn. * @param amount uint256 Amount of tokens to burn. */ function burn( address from, uint256 id, uint256 amount ) external onlyRole(BURNER_ROLE) { _burn(from, id, amount); } /** * @inheritdoc ERC1155 * @dev Not implemented due to semi-fungible only requirement */ function uri(uint256 id) public view override returns (string memory) {} /** * @inheritdoc ERC1155 */ function supportsInterface( bytes4 interfaceId ) public view override(AccessControlDefaultAdminRules, ERC1155) returns (bool) { return super.supportsInterface(interfaceId); } }
// SPDX-License-Identifier: MIT pragma solidity 0.8.19; import {SafeCast} from "openzeppelin-contracts/contracts/utils/math/SafeCast.sol"; import {DataTypes} from "./DataTypes.sol"; import {Errors} from "./Errors.sol"; /** * @title ValidatorQueue * @notice Library for managing a FIFO queue of validators in the Pirex protocol. * @dev This library provides functions for adding, swapping, and removing validators in the validator queue. * It also includes functions for popping validators from the end of the queue, retrieving validator information, and clearing the entire queue. * @author redactedcartel.finance */ library ValidatorQueue { /** * @notice Emitted when a validator is added to the queue. * @dev This event is emitted when a validator is successfully added to the end of the queue. * @param pubKey bytes Public key of the added validator. * @param withdrawalCredential bytes Withdrawal credentials associated with the added validator. */ event ValidatorAdded(bytes pubKey, bytes withdrawalCredential); /** * @notice Emitted when the entire validator queue is cleared. * @dev This event is emitted when all validators are removed from the queue, clearing it completely. */ event ValidatorQueueCleared(); /** * @notice Emitted when a validator is removed from the queue. * @dev This event is emitted when a validator is successfully removed from the queue, either ordered or unordered. * @param pubKey bytes Public key of the removed validator. * @param removeIndex uint256 Index of the removed validator. * @param unordered bool Indicates whether the removal was unordered. */ event ValidatorRemoved(bytes pubKey, uint256 removeIndex, bool unordered); /** * @notice Emitted when validators are popped from the front of the queue. * @dev This event is emitted when validators are successfully popped from the front of the queue. * @param times uint256 Number of pop operations performed. */ event ValidatorsPopped(uint256 times); /** * @notice Emitted when two validators are swapped in the queue. * @dev This event is emitted when two validators are successfully swapped in the queue. * @param fromPubKey bytes Public key of the first validator being swapped. * @param toPubKey bytes Public key of the second validator being swapped. * @param fromIndex uint256 Index of the first validator. * @param toIndex uint256 Index of the second validator. */ event ValidatorsSwapped( bytes fromPubKey, bytes toPubKey, uint256 fromIndex, uint256 toIndex ); /** * @notice Adds a synchronized validator to the FIFO queue, ready for staking. * @dev This function adds a validator to the end of the queue with the associated withdrawal credentials. * @param deque DataTypes.ValidatorDeque Storage reference to the validator deque. * @param validator DataTypes.Validator Validator information to be added. * @param withdrawalCredentials bytes Withdrawal credentials associated with the validator. */ function add( DataTypes.ValidatorDeque storage deque, DataTypes.Validator memory validator, bytes memory withdrawalCredentials ) external { int128 backIndex = deque._end; deque._validators[backIndex] = validator; unchecked { deque._end = backIndex + 1; } emit ValidatorAdded(validator.pubKey, withdrawalCredentials); } /** * @notice Swaps the location of one validator with another. * @dev This function swaps the position of two validators in the queue. * @param deque DataTypes.ValidatorDeque Storage reference to the validator deque. * @param fromIndex uint256 Index of the validator to be swapped. * @param toIndex uint256 Index of the validator to swap with. */ function swap( DataTypes.ValidatorDeque storage deque, uint256 fromIndex, uint256 toIndex ) public { if (fromIndex == toIndex) revert Errors.InvalidIndexRanges(); if (empty(deque)) revert Errors.ValidatorQueueEmpty(); int128 fromidx = SafeCast.toInt128( int256(deque._begin) + SafeCast.toInt256(fromIndex) ); if (fromidx >= deque._end) revert Errors.OutOfBounds(); int128 toidx = SafeCast.toInt128( int256(deque._begin) + SafeCast.toInt256(toIndex) ); if (toidx >= deque._end) revert Errors.OutOfBounds(); // Get the original values DataTypes.Validator memory fromVal = deque._validators[fromidx]; DataTypes.Validator memory toVal = deque._validators[toidx]; // Set the swapped values deque._validators[toidx] = fromVal; deque._validators[fromidx] = toVal; emit ValidatorsSwapped( fromVal.pubKey, toVal.pubKey, fromIndex, toIndex ); } /** * @notice Removes validators from the end of the queue, in case they were added in error. * @dev This function removes validators from the end of the queue, specified by the number of times to pop. * @param deque DataTypes.ValidatorDeque Storage reference to the validator deque. * @param times uint256 Number of pop operations to perform. * @return validator DataTypes.Validator Removed and returned validator. */ function pop( DataTypes.ValidatorDeque storage deque, uint256 times ) public returns (DataTypes.Validator memory validator) { // Loop through and remove validator entries at the end for (uint256 _i; _i < times; ) { if (empty(deque)) revert Errors.ValidatorQueueEmpty(); int128 backIndex; unchecked { backIndex = deque._end - 1; ++_i; } validator = deque._validators[backIndex]; delete deque._validators[backIndex]; deque._end = backIndex; } emit ValidatorsPopped(times); } /** * @notice Check if the deque is empty * @dev Returns true if the validator deque is empty, otherwise false. * @param deque DataTypes.ValidatorDeque Storage reference to the validator deque. * @return bool True if the deque is empty, otherwise false. */ function empty( DataTypes.ValidatorDeque storage deque ) public view returns (bool) { return deque._end <= deque._begin; } /** * @notice Remove a validator from the array using a more gas-efficient loop. * @dev Removes a validator at the specified index and emits an event. * @param deque DataTypes.ValidatorDeque Storage reference to the validator deque. * @param removeIndex uint256 Index of the validator to remove. * @return removedPubKey bytes Public key of the removed validator. */ function removeOrdered( DataTypes.ValidatorDeque storage deque, uint256 removeIndex ) external returns (bytes memory removedPubKey) { int128 idx = SafeCast.toInt128( int256(deque._begin) + SafeCast.toInt256(removeIndex) ); if (idx >= deque._end) revert Errors.OutOfBounds(); // Get the pubkey for the validator to remove (for informational purposes) removedPubKey = deque._validators[idx].pubKey; for (int128 _i = idx; _i < deque._end - 1; ) { deque._validators[_i] = deque._validators[_i + 1]; unchecked { ++_i; } } pop(deque, 1); emit ValidatorRemoved(removedPubKey, removeIndex, false); } /** * @notice Remove a validator from the array using swap and pop. * @dev Removes a validator at the specified index by swapping it with the last validator and then popping the last validator. * @param deque DataTypes.ValidatorDeque Storage reference to the validator deque. * @param removeIndex uint256 Index of the validator to remove. * @return removedPubkey bytes Public key of the removed validator. */ function removeUnordered( DataTypes.ValidatorDeque storage deque, uint256 removeIndex ) external returns (bytes memory removedPubkey) { int128 idx = SafeCast.toInt128( int256(deque._begin) + SafeCast.toInt256(removeIndex) ); if (idx >= deque._end) revert Errors.OutOfBounds(); // Get the pubkey for the validator to remove (for informational purposes) removedPubkey = deque._validators[idx].pubKey; // Swap the (validator to remove) with the last validator in the array if needed uint256 lastIndex = count(deque) - 1; if (removeIndex != lastIndex) { swap(deque, removeIndex, lastIndex); } // Pop off the validator to remove, which is now at the end of the array pop(deque, 1); emit ValidatorRemoved(removedPubkey, removeIndex, true); } /** * @notice Remove the last validator from the validators array and return its information * @dev Removes and returns information about the last validator in the queue. * @param deque DataTypes.ValidatorDeque Deque * @param _withdrawalCredentials bytes Credentials * @return pubKey bytes Key * @return withdrawalCredentials bytes Credentials * @return signature bytes Signature * @return depositDataRoot bytes32 Deposit data root * @return receiver address account to receive pxEth */ function getNext( DataTypes.ValidatorDeque storage deque, bytes memory _withdrawalCredentials ) external returns ( bytes memory pubKey, bytes memory withdrawalCredentials, bytes memory signature, bytes32 depositDataRoot, address receiver ) { if (empty(deque)) revert Errors.ValidatorQueueEmpty(); int128 frontIndex = deque._begin; DataTypes.Validator memory popped = deque._validators[frontIndex]; delete deque._validators[frontIndex]; unchecked { deque._begin = frontIndex + 1; } // Return the validator's information pubKey = popped.pubKey; withdrawalCredentials = _withdrawalCredentials; signature = popped.signature; depositDataRoot = popped.depositDataRoot; receiver = popped.receiver; } /** * @notice Return the information of the i'th validator in the registry * @dev Returns information about the validator at the specified index without removing it from the deque. * @param deque DataTypes.ValidatorDeque Deque * @param _withdrawalCredentials bytes Credentials * @param _index uint256 Index * @return pubKey bytes Key * @return withdrawalCredentials bytes Credentials * @return signature bytes Signature * @return depositDataRoot bytes32 Deposit data root * @return receiver address account to receive pxEth */ function get( DataTypes.ValidatorDeque storage deque, bytes memory _withdrawalCredentials, uint256 _index ) external view returns ( bytes memory pubKey, bytes memory withdrawalCredentials, bytes memory signature, bytes32 depositDataRoot, address receiver ) { // int256(deque._begin) is a safe upcast int128 idx = SafeCast.toInt128( int256(deque._begin) + SafeCast.toInt256(_index) ); if (idx >= deque._end) revert Errors.OutOfBounds(); DataTypes.Validator memory _v = deque._validators[idx]; // Return the validator's information pubKey = _v.pubKey; withdrawalCredentials = _withdrawalCredentials; signature = _v.signature; depositDataRoot = _v.depositDataRoot; receiver = _v.receiver; } /** * @notice Empties the validator queue. * @dev Clears the entire validator deque, setting both begin and end to 0. * Emits an event to signal the clearing of the queue. * @param deque DataTypes.ValidatorDeque Storage reference to the validator deque. */ function clear(DataTypes.ValidatorDeque storage deque) external { deque._begin = 0; deque._end = 0; emit ValidatorQueueCleared(); } /** * @notice Returns the number of validators in the queue. * @dev Calculates and returns the number of validators in the deque. * @param deque DataTypes.ValidatorDeque Storage reference to the validator deque. * @return uint256 Number of validators in the deque. */ function count( DataTypes.ValidatorDeque storage deque ) public view returns (uint256) { // The interface preserves the invariant that begin <= end so we assume this will not overflow. // We also assume there are at most int256.max items in the queue. unchecked { return uint256(int256(deque._end) - int256(deque._begin)); } } }
// SPDX-License-Identifier: MIT pragma solidity 0.8.19; /** * @title IOracleAdapter * @notice Interface for Oracle Adapters * @dev This interface defines the methods for interacting with OracleAdapter. * @author redactedcartel.finance */ interface IOracleAdapter { /** * @notice Requests a voluntary exit for a specific public key * @dev This function is used to initiate a voluntary exit process. * @param _pubKey bytes The public key of the entity requesting the exit. */ function requestVoluntaryExit(bytes calldata _pubKey) external; }
// SPDX-License-Identifier: MIT pragma solidity 0.8.19; import {DataTypes} from "../libraries/DataTypes.sol"; /** * @title IPirexEth * @notice Interface for the PirexEth contract * @dev This interface defines the methods for interacting with PirexEth. * @author redactedcartel.finance */ interface IPirexEth { /** * @notice Initiate redemption by burning pxETH in return for upxETH * @dev This function allows the initiation of redemption by burning pxETH in exchange for upxETH. * @param _assets uint256 The amount of assets to burn. If the caller is AutoPxEth, then apxETH; pxETH otherwise. * @param _receiver address The address to receive upxETH. * @param _shouldTriggerValidatorExit bool Whether the initiation should trigger voluntary exit. * @return postFeeAmount uint256 The amount of pxETH burnt for the receiver. * @return feeAmount uint256 The amount of pxETH distributed as fees. */ function initiateRedemption( uint256 _assets, address _receiver, bool _shouldTriggerValidatorExit ) external returns (uint256 postFeeAmount, uint256 feeAmount); /** * @notice Dissolve validator * @dev This function dissolves a validator. * @param _pubKey bytes The public key of the validator. */ function dissolveValidator(bytes calldata _pubKey) external payable; /** * @notice Update validator state to be slashed * @dev This function updates the validator state to be slashed. * @param _pubKey bytes The public key of the validator. * @param _removeIndex uint256 The index of the validator to be slashed. * @param _amount uint256 The ETH amount released from the Beacon chain. * @param _unordered bool Whether to remove from the staking validator queue in order or not. * @param _useBuffer bool Whether to use a buffer to compensate for the loss. * @param _burnerAccounts DataTypes.BurnerAccount[] Burner accounts. */ function slashValidator( bytes calldata _pubKey, uint256 _removeIndex, uint256 _amount, bool _unordered, bool _useBuffer, DataTypes.BurnerAccount[] calldata _burnerAccounts ) external payable; /** * @notice Harvest and mint staking rewards when available * @dev This function harvests and mints staking rewards when available. * @param _endBlock uint256 The block until which ETH rewards are computed. */ function harvest(uint256 _endBlock) external payable; }
// SPDX-License-Identifier: CC0-1.0 pragma solidity 0.8.19; // This interface is designed to be compatible with the Vyper version. /// @notice This is the Ethereum 2.0 deposit contract interface. /// For more information see the Phase 0 specification under https://github.com/ethereum/eth2.0-specs interface IDepositContract { /// @notice Submit a Phase 0 DepositData object. /// @param pubkey A BLS12-381 public key. /// @param withdrawal_credentials Commitment to a public key for withdrawals. /// @param signature A BLS12-381 signature. /// @param deposit_data_root The SHA-256 hash of the SSZ-encoded DepositData object. /// Used as a protection against malformed input. function deposit( bytes calldata pubkey, bytes calldata withdrawal_credentials, bytes calldata signature, bytes32 deposit_data_root ) external payable; /// @notice Query the current deposit count. /// @return The deposit count encoded as a little endian 64-bit number. function get_deposit_count() external view returns (bytes memory); }
// SPDX-License-Identifier: MIT pragma solidity 0.8.19; import {Ownable2Step} from "openzeppelin-contracts/contracts/access/Ownable2Step.sol"; import {ERC4626} from "solmate/mixins/ERC4626.sol"; import {ERC20} from "solmate/tokens/ERC20.sol"; import {FixedPointMathLib} from "solmate/utils/FixedPointMathLib.sol"; import {SafeTransferLib} from "solmate/utils/SafeTransferLib.sol"; import {Errors} from "./libraries/Errors.sol"; import {IPirexEth} from "./interfaces/IPirexEth.sol"; /** * @title AutoPxEth * @notice Autocompounding vault for (staked) pxETH, adapted from pxCVX vault system * @dev This contract enables autocompounding for pxETH assets and includes various fee mechanisms. * @author redactedcartel.finance */ contract AutoPxEth is Ownable2Step, ERC4626 { /** * @dev Library: SafeTransferLib - Provides safe transfer functions for ERC20 tokens. */ using SafeTransferLib for ERC20; /** * @dev Library: FixedPointMathLib - Provides fixed-point arithmetic for uint256. */ using FixedPointMathLib for uint256; // Constants /** * @dev Maximum withdrawal penalty percentage. */ uint256 private constant MAX_WITHDRAWAL_PENALTY = 50_000; /** * @dev Maximum platform fee percentage. */ uint256 private constant MAX_PLATFORM_FEE = 200_000; /** * @dev Fee denominator for precise fee calculations. */ uint256 private constant FEE_DENOMINATOR = 1_000_000; /** * @dev Duration of the rewards period. */ uint256 private constant REWARDS_DURATION = 7 days; // State variables for tracking rewards and actively staked assets /** * @notice Reference to the PirexEth contract. */ IPirexEth public pirexEth; /** * @notice Timestamp when the current rewards period will end. */ uint256 public periodFinish; /** * @notice Rate at which rewards are distributed per second. */ uint256 public rewardRate; /** * @notice Timestamp of the last update to the reward variables. */ uint256 public lastUpdateTime; /** * @notice Accumulated reward per token stored. */ uint256 public rewardPerTokenStored; /** * @notice Last calculated reward per token paid to stakers. */ uint256 public rewardPerTokenPaid; /** * @notice Total rewards available for distribution. */ uint256 public rewards; /** * @notice Total assets actively staked in the vault. */ uint256 public totalStaked; // State variables related to fees /** * @notice Withdrawal penalty percentage. */ uint256 public withdrawalPenalty = 30_000; /** * @notice Platform fee percentage. */ uint256 public platformFee = 100_000; /** * @notice Address of the platform that receives fees. */ address public platform; // Events /** * @notice Emitted when rewards are harvested and staked. * @dev This event is emitted when a user triggers the harvest function. * @param caller address indexed Address that triggered the harvest. * @param value uint256 Amount of rewards harvested. */ event Harvest(address indexed caller, uint256 value); /** * @notice Emitted when the withdrawal penalty is updated. * @dev This event is emitted when the withdrawal penalty is modified. * @param penalty uint256 New withdrawal penalty percentage. */ event WithdrawalPenaltyUpdated(uint256 penalty); /** * @notice Emitted when the platform fee is updated. * @dev This event is emitted when the platform fee is modified. * @param fee uint256 New platform fee percentage. */ event PlatformFeeUpdated(uint256 fee); /** * @notice Emitted when the platform address is updated. * @dev This event is emitted when the platform address is modified. * @param _platform address New platform address. */ event PlatformUpdated(address _platform); /** * @notice Emitted when new rewards are added to the vault. * @dev This event is emitted when new rewards are added to the vault. * @param reward uint256 Amount of rewards added. */ event RewardAdded(uint256 reward); /** * @notice Emitted when the PirexEth contract address is set. * @dev This event is emitted when the PirexEth contract address is set. * @param _pirexEth address New PirexEth contract address. */ event SetPirexEth(address _pirexEth); // Modifiers /** * @dev Update reward states modifier * @param updateEarned bool Whether to update earned amount so far */ modifier updateReward(bool updateEarned) { rewardPerTokenStored = rewardPerToken(); lastUpdateTime = lastTimeRewardApplicable(); if (updateEarned) { rewards = earned(); rewardPerTokenPaid = rewardPerTokenStored; } _; } /** * @dev Contract constructor * @param _asset address Asset contract address * @param _platform address Platform address */ constructor( address _asset, address _platform ) ERC4626(ERC20(_asset), "Autocompounding Pirex Ether", "apxETH") { if (_platform == address(0)) revert Errors.ZeroAddress(); platform = _platform; } /*////////////////////////////////////////////////////////////// RESTRICTED FUNCTIONS //////////////////////////////////////////////////////////////*/ /** * @notice Set the PirexEth contract address * @dev Function access restricted to only owner * @param _pirexEth address PirexEth contract address */ function setPirexEth(address _pirexEth) external onlyOwner { if (_pirexEth == address(0)) revert Errors.ZeroAddress(); emit SetPirexEth(_pirexEth); pirexEth = IPirexEth(_pirexEth); } /** * @notice Set the withdrawal penalty * @dev Function access restricted to only owner * @param penalty uint256 Withdrawal penalty */ function setWithdrawalPenalty(uint256 penalty) external onlyOwner { if (penalty > MAX_WITHDRAWAL_PENALTY) revert Errors.ExceedsMax(); withdrawalPenalty = penalty; emit WithdrawalPenaltyUpdated(penalty); } /** * @notice Set the platform fee * @dev Function access restricted to only owner * @param fee uint256 Platform fee */ function setPlatformFee(uint256 fee) external onlyOwner { if (fee > MAX_PLATFORM_FEE) revert Errors.ExceedsMax(); platformFee = fee; emit PlatformFeeUpdated(fee); } /** * @notice Set the platform * @dev Function access restricted to only owner * @param _platform address Platform */ function setPlatform(address _platform) external onlyOwner { if (_platform == address(0)) revert Errors.ZeroAddress(); platform = _platform; emit PlatformUpdated(_platform); } /** * @notice Notify and sync the newly added rewards to be streamed over time * @dev Rewards are streamed following the duration set in REWARDS_DURATION */ function notifyRewardAmount() external updateReward(false) { if (msg.sender != address(pirexEth)) revert Errors.NotPirexEth(); // Rewards transferred directly to this contract are not added to totalStaked // To get the rewards w/o relying on a potentially incorrect passed in arg, // we can use the difference between the asset balance and totalStaked. // Additionally, to avoid re-distributing rewards, deduct the output of `earned` uint256 rewardBalance = asset.balanceOf(address(this)) - totalStaked - earned(); rewardRate = rewardBalance / REWARDS_DURATION; if (rewardRate == 0) revert Errors.NoRewards(); lastUpdateTime = block.timestamp; periodFinish = block.timestamp + REWARDS_DURATION; emit RewardAdded(rewardBalance); } /*////////////////////////////////////////////////////////////// VIEWS //////////////////////////////////////////////////////////////*/ /** * @inheritdoc ERC4626 * @notice Get the amount of available pxETH in the contract * @dev Rewards are streamed for the duration set in REWARDS_DURATION */ function totalAssets() public view override returns (uint256) { // Based on the current totalStaked and available rewards uint256 _totalStaked = totalStaked; uint256 _rewards = ((_totalStaked * (rewardPerToken() - rewardPerTokenPaid)) / 1e18) + rewards; // Deduct the exact reward amount staked (after fees are deducted when calling `harvest`) return _totalStaked + ( _rewards == 0 ? 0 : (_rewards - ((_rewards * platformFee) / FEE_DENOMINATOR)) ); } /** * @notice Returns the last effective timestamp of the current reward period * @return uint256 Timestamp */ function lastTimeRewardApplicable() public view returns (uint256) { return block.timestamp < periodFinish ? block.timestamp : periodFinish; } /** * @notice Returns the amount of rewards per staked token/asset * @return uint256 Rewards amount */ function rewardPerToken() public view returns (uint256) { if (totalStaked == 0) { return rewardPerTokenStored; } return rewardPerTokenStored + ((((lastTimeRewardApplicable() - lastUpdateTime) * rewardRate) * 1e18) / totalStaked); } /** * @notice Returns the earned rewards amount so far * @return uint256 Rewards amount */ function earned() public view returns (uint256) { return ((totalStaked * (rewardPerToken() - rewardPerTokenPaid)) / 1e18) + rewards; } /** * @notice Return the amount of assets per 1 (1e18) share * @return uint256 Assets */ function assetsPerShare() external view returns (uint256) { return previewRedeem(1e18); } /*////////////////////////////////////////////////////////////// INTERNAL FUNCTIONS //////////////////////////////////////////////////////////////*/ /** * @dev Internal method to keep track of the total amount of staked token/asset on deposit/mint */ function _stake(uint256 amount) internal updateReward(true) { totalStaked += amount; } /** * @dev Internal method to keep track of the total amount of staked token/asset on withdrawal/redeem */ function _withdraw(uint256 amount) internal updateReward(true) { totalStaked -= amount; } /*////////////////////////////////////////////////////////////// ERC4626 OVERRIDES //////////////////////////////////////////////////////////////*/ /** * @inheritdoc ERC4626 * @dev Deduct the specified amount of assets from totalStaked to prepare for transfer to the user * @param assets uint256 Assets */ function beforeWithdraw(uint256 assets, uint256) internal override { // Perform harvest to make sure that totalStaked is always equal or larger than assets to be withdrawn if (assets > totalStaked) harvest(); _withdraw(assets); } /** * @inheritdoc ERC4626 * @dev Include the new assets in totalStaked so that rewards can be properly distributed * @param assets uint256 Assets */ function afterDeposit(uint256 assets, uint256) internal override { _stake(assets); } /** * @inheritdoc ERC4626 * @dev Preview the amount of assets a user would receive from redeeming shares */ function previewRedeem( uint256 shares ) public view override returns (uint256) { // Calculate assets based on a user's % ownership of vault shares uint256 assets = convertToAssets(shares); uint256 _totalSupply = totalSupply; // Calculate a penalty - zero if user is the last to withdraw. uint256 penalty = (_totalSupply == 0 || _totalSupply - shares == 0) ? 0 : assets.mulDivUp(withdrawalPenalty, FEE_DENOMINATOR); // Round up the penalty in favour of the protocol. // Redeemable amount is the post-penalty amount return assets - penalty; } /** * @inheritdoc ERC4626 * @notice Preview the amount of shares a user would need to redeem the specified asset amount * @dev This modified version takes into consideration the withdrawal fee */ function previewWithdraw( uint256 assets ) public view override returns (uint256) { // Calculate shares based on the specified assets' proportion of the pool uint256 shares = convertToShares(assets); // Save 1 SLOAD uint256 _totalSupply = totalSupply; // Factor in additional shares to fulfill withdrawal if user is not the last to withdraw return (_totalSupply == 0 || _totalSupply - shares == 0) ? shares : (shares * FEE_DENOMINATOR) / (FEE_DENOMINATOR - withdrawalPenalty); } /*////////////////////////////////////////////////////////////// MUTATIVE FUNCTIONS //////////////////////////////////////////////////////////////*/ /** * @notice Harvest and stake available rewards after distributing fees to the platform * @dev This function claims and stakes the available rewards, deducting a fee for the platform. */ function harvest() public updateReward(true) { uint256 _rewards = rewards; if (_rewards != 0) { rewards = 0; // Fee for platform uint256 feeAmount = (_rewards * platformFee) / FEE_DENOMINATOR; // Deduct fee from reward balance _rewards -= feeAmount; // Claimed rewards should be in pxETH asset.safeTransfer(platform, feeAmount); // Stake rewards sans fee _stake(_rewards); emit Harvest(msg.sender, _rewards); } } /** * @notice Override transfer logic to trigger direct `initiateRedemption`. * @dev This function overrides the standard transfer logic to initiate redemption when transferring to the PirexEth contract. * @param to address Transfer destination * @param amount uint256 Amount * @return bool */ function transfer( address to, uint256 amount ) public override returns (bool) { super.transfer(to, amount); if (to == address(pirexEth)) { pirexEth.initiateRedemption(amount, msg.sender, false); } return true; } /** * @notice Override transferFrom logic to trigger direct `initiateRedemption`. * @dev This function overrides the standard transferFrom logic to initiate redemption when transferring from the PirexEth contract. * @param from Address of the transfer origin. * @param to Address of the transfer destination. * @param amount Amount of tokens to transfer. * @return A boolean indicating the success of the transfer. */ function transferFrom( address from, address to, uint256 amount ) public override returns (bool) { super.transferFrom(from, to, amount); if (to == address(pirexEth)) { pirexEth.initiateRedemption(amount, from, false); } return true; } }
// SPDX-License-Identifier: MIT pragma solidity 0.8.19; import {DineroERC20} from "./DineroERC20.sol"; import {Errors} from "./libraries/Errors.sol"; /** * @title PxEth * @notice The PxEth token, the main token for the PirexEth system used in the Dinero ecosystem. * @dev Extends the DineroERC20 contract and includes additional functionality. * @author redactedcartel.finance */ contract PxEth is DineroERC20 { // Roles /** * @notice The OPERATOR_ROLE role assigned for operator functions in the PxEth token contract. * @dev Used to control access to critical functions. */ bytes32 private constant OPERATOR_ROLE = keccak256("OPERATOR_ROLE"); /** * @notice Constructor to initialize the PxEth token. * @dev Inherits from the DineroERC20 contract and sets the name, symbol, decimals, admin, and initial delay. * @param _admin address Admin address. * @param _initialDelay uint48 Delay required to schedule the acceptance of an access control transfer started. */ constructor( address _admin, uint48 _initialDelay ) DineroERC20("Pirex Ether", "pxETH", 18, _admin, _initialDelay) {} /** * @notice Operator function to approve allowances for specified accounts and amounts. * @dev Only callable by the operator role. * @param _from address Owner of the tokens. * @param _to address Account to be approved. * @param _amount uint256 Amount to be approved. */ function operatorApprove( address _from, address _to, uint256 _amount ) external onlyRole(OPERATOR_ROLE) { if (_from == address(0)) revert Errors.ZeroAddress(); if (_to == address(0)) revert Errors.ZeroAddress(); allowance[_from][_to] = _amount; emit Approval(_from, _to, _amount); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (access/AccessControl.sol) pragma solidity ^0.8.0; import "./IAccessControl.sol"; import "../utils/Context.sol"; import "../utils/Strings.sol"; import "../utils/introspection/ERC165.sol"; /** * @dev Contract module that allows children to implement role-based access * control mechanisms. This is a lightweight version that doesn't allow enumerating role * members except through off-chain means by accessing the contract event logs. Some * applications may benefit from on-chain enumerability, for those cases see * {AccessControlEnumerable}. * * Roles are referred to by their `bytes32` identifier. These should be exposed * in the external API and be unique. The best way to achieve this is by * using `public constant` hash digests: * * ```solidity * bytes32 public constant MY_ROLE = keccak256("MY_ROLE"); * ``` * * Roles can be used to represent a set of permissions. To restrict access to a * function call, use {hasRole}: * * ```solidity * function foo() public { * require(hasRole(MY_ROLE, msg.sender)); * ... * } * ``` * * Roles can be granted and revoked dynamically via the {grantRole} and * {revokeRole} functions. Each role has an associated admin role, and only * accounts that have a role's admin role can call {grantRole} and {revokeRole}. * * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means * that only accounts with this role will be able to grant or revoke other * roles. More complex role relationships can be created by using * {_setRoleAdmin}. * * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to * grant and revoke this role. Extra precautions should be taken to secure * accounts that have been granted it. We recommend using {AccessControlDefaultAdminRules} * to enforce additional security measures for this role. */ abstract contract AccessControl is Context, IAccessControl, ERC165 { struct RoleData { mapping(address => bool) members; bytes32 adminRole; } mapping(bytes32 => RoleData) private _roles; bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00; /** * @dev Modifier that checks that an account has a specific role. Reverts * with a standardized message including the required role. * * The format of the revert reason is given by the following regular expression: * * /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/ * * _Available since v4.1._ */ modifier onlyRole(bytes32 role) { _checkRole(role); _; } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId); } /** * @dev Returns `true` if `account` has been granted `role`. */ function hasRole(bytes32 role, address account) public view virtual override returns (bool) { return _roles[role].members[account]; } /** * @dev Revert with a standard message if `_msgSender()` is missing `role`. * Overriding this function changes the behavior of the {onlyRole} modifier. * * Format of the revert message is described in {_checkRole}. * * _Available since v4.6._ */ function _checkRole(bytes32 role) internal view virtual { _checkRole(role, _msgSender()); } /** * @dev Revert with a standard message if `account` is missing `role`. * * The format of the revert reason is given by the following regular expression: * * /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/ */ function _checkRole(bytes32 role, address account) internal view virtual { if (!hasRole(role, account)) { revert( string( abi.encodePacked( "AccessControl: account ", Strings.toHexString(account), " is missing role ", Strings.toHexString(uint256(role), 32) ) ) ); } } /** * @dev Returns the admin role that controls `role`. See {grantRole} and * {revokeRole}. * * To change a role's admin, use {_setRoleAdmin}. */ function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) { return _roles[role].adminRole; } /** * @dev Grants `role` to `account`. * * If `account` had not been already granted `role`, emits a {RoleGranted} * event. * * Requirements: * * - the caller must have ``role``'s admin role. * * May emit a {RoleGranted} event. */ function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) { _grantRole(role, account); } /** * @dev Revokes `role` from `account`. * * If `account` had been granted `role`, emits a {RoleRevoked} event. * * Requirements: * * - the caller must have ``role``'s admin role. * * May emit a {RoleRevoked} event. */ function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) { _revokeRole(role, account); } /** * @dev Revokes `role` from the calling account. * * Roles are often managed via {grantRole} and {revokeRole}: this function's * purpose is to provide a mechanism for accounts to lose their privileges * if they are compromised (such as when a trusted device is misplaced). * * If the calling account had been revoked `role`, emits a {RoleRevoked} * event. * * Requirements: * * - the caller must be `account`. * * May emit a {RoleRevoked} event. */ function renounceRole(bytes32 role, address account) public virtual override { require(account == _msgSender(), "AccessControl: can only renounce roles for self"); _revokeRole(role, account); } /** * @dev Grants `role` to `account`. * * If `account` had not been already granted `role`, emits a {RoleGranted} * event. Note that unlike {grantRole}, this function doesn't perform any * checks on the calling account. * * May emit a {RoleGranted} event. * * [WARNING] * ==== * This function should only be called from the constructor when setting * up the initial roles for the system. * * Using this function in any other way is effectively circumventing the admin * system imposed by {AccessControl}. * ==== * * NOTE: This function is deprecated in favor of {_grantRole}. */ function _setupRole(bytes32 role, address account) internal virtual { _grantRole(role, account); } /** * @dev Sets `adminRole` as ``role``'s admin role. * * Emits a {RoleAdminChanged} event. */ function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual { bytes32 previousAdminRole = getRoleAdmin(role); _roles[role].adminRole = adminRole; emit RoleAdminChanged(role, previousAdminRole, adminRole); } /** * @dev Grants `role` to `account`. * * Internal function without access restriction. * * May emit a {RoleGranted} event. */ function _grantRole(bytes32 role, address account) internal virtual { if (!hasRole(role, account)) { _roles[role].members[account] = true; emit RoleGranted(role, account, _msgSender()); } } /** * @dev Revokes `role` from `account`. * * Internal function without access restriction. * * May emit a {RoleRevoked} event. */ function _revokeRole(bytes32 role, address account) internal virtual { if (hasRole(role, account)) { _roles[role].members[account] = false; emit RoleRevoked(role, account, _msgSender()); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (access/IAccessControlDefaultAdminRules.sol) pragma solidity ^0.8.0; import "./IAccessControl.sol"; /** * @dev External interface of AccessControlDefaultAdminRules declared to support ERC165 detection. * * _Available since v4.9._ */ interface IAccessControlDefaultAdminRules is IAccessControl { /** * @dev Emitted when a {defaultAdmin} transfer is started, setting `newAdmin` as the next * address to become the {defaultAdmin} by calling {acceptDefaultAdminTransfer} only after `acceptSchedule` * passes. */ event DefaultAdminTransferScheduled(address indexed newAdmin, uint48 acceptSchedule); /** * @dev Emitted when a {pendingDefaultAdmin} is reset if it was never accepted, regardless of its schedule. */ event DefaultAdminTransferCanceled(); /** * @dev Emitted when a {defaultAdminDelay} change is started, setting `newDelay` as the next * delay to be applied between default admin transfer after `effectSchedule` has passed. */ event DefaultAdminDelayChangeScheduled(uint48 newDelay, uint48 effectSchedule); /** * @dev Emitted when a {pendingDefaultAdminDelay} is reset if its schedule didn't pass. */ event DefaultAdminDelayChangeCanceled(); /** * @dev Returns the address of the current `DEFAULT_ADMIN_ROLE` holder. */ function defaultAdmin() external view returns (address); /** * @dev Returns a tuple of a `newAdmin` and an accept schedule. * * After the `schedule` passes, the `newAdmin` will be able to accept the {defaultAdmin} role * by calling {acceptDefaultAdminTransfer}, completing the role transfer. * * A zero value only in `acceptSchedule` indicates no pending admin transfer. * * NOTE: A zero address `newAdmin` means that {defaultAdmin} is being renounced. */ function pendingDefaultAdmin() external view returns (address newAdmin, uint48 acceptSchedule); /** * @dev Returns the delay required to schedule the acceptance of a {defaultAdmin} transfer started. * * This delay will be added to the current timestamp when calling {beginDefaultAdminTransfer} to set * the acceptance schedule. * * NOTE: If a delay change has been scheduled, it will take effect as soon as the schedule passes, making this * function returns the new delay. See {changeDefaultAdminDelay}. */ function defaultAdminDelay() external view returns (uint48); /** * @dev Returns a tuple of `newDelay` and an effect schedule. * * After the `schedule` passes, the `newDelay` will get into effect immediately for every * new {defaultAdmin} transfer started with {beginDefaultAdminTransfer}. * * A zero value only in `effectSchedule` indicates no pending delay change. * * NOTE: A zero value only for `newDelay` means that the next {defaultAdminDelay} * will be zero after the effect schedule. */ function pendingDefaultAdminDelay() external view returns (uint48 newDelay, uint48 effectSchedule); /** * @dev Starts a {defaultAdmin} transfer by setting a {pendingDefaultAdmin} scheduled for acceptance * after the current timestamp plus a {defaultAdminDelay}. * * Requirements: * * - Only can be called by the current {defaultAdmin}. * * Emits a DefaultAdminRoleChangeStarted event. */ function beginDefaultAdminTransfer(address newAdmin) external; /** * @dev Cancels a {defaultAdmin} transfer previously started with {beginDefaultAdminTransfer}. * * A {pendingDefaultAdmin} not yet accepted can also be cancelled with this function. * * Requirements: * * - Only can be called by the current {defaultAdmin}. * * May emit a DefaultAdminTransferCanceled event. */ function cancelDefaultAdminTransfer() external; /** * @dev Completes a {defaultAdmin} transfer previously started with {beginDefaultAdminTransfer}. * * After calling the function: * * - `DEFAULT_ADMIN_ROLE` should be granted to the caller. * - `DEFAULT_ADMIN_ROLE` should be revoked from the previous holder. * - {pendingDefaultAdmin} should be reset to zero values. * * Requirements: * * - Only can be called by the {pendingDefaultAdmin}'s `newAdmin`. * - The {pendingDefaultAdmin}'s `acceptSchedule` should've passed. */ function acceptDefaultAdminTransfer() external; /** * @dev Initiates a {defaultAdminDelay} update by setting a {pendingDefaultAdminDelay} scheduled for getting * into effect after the current timestamp plus a {defaultAdminDelay}. * * This function guarantees that any call to {beginDefaultAdminTransfer} done between the timestamp this * method is called and the {pendingDefaultAdminDelay} effect schedule will use the current {defaultAdminDelay} * set before calling. * * The {pendingDefaultAdminDelay}'s effect schedule is defined in a way that waiting until the schedule and then * calling {beginDefaultAdminTransfer} with the new delay will take at least the same as another {defaultAdmin} * complete transfer (including acceptance). * * The schedule is designed for two scenarios: * * - When the delay is changed for a larger one the schedule is `block.timestamp + newDelay` capped by * {defaultAdminDelayIncreaseWait}. * - When the delay is changed for a shorter one, the schedule is `block.timestamp + (current delay - new delay)`. * * A {pendingDefaultAdminDelay} that never got into effect will be canceled in favor of a new scheduled change. * * Requirements: * * - Only can be called by the current {defaultAdmin}. * * Emits a DefaultAdminDelayChangeScheduled event and may emit a DefaultAdminDelayChangeCanceled event. */ function changeDefaultAdminDelay(uint48 newDelay) external; /** * @dev Cancels a scheduled {defaultAdminDelay} change. * * Requirements: * * - Only can be called by the current {defaultAdmin}. * * May emit a DefaultAdminDelayChangeCanceled event. */ function rollbackDefaultAdminDelay() external; /** * @dev Maximum time in seconds for an increase to {defaultAdminDelay} (that is scheduled using {changeDefaultAdminDelay}) * to take effect. Default to 5 days. * * When the {defaultAdminDelay} is scheduled to be increased, it goes into effect after the new delay has passed with * the purpose of giving enough time for reverting any accidental change (i.e. using milliseconds instead of seconds) * that may lock the contract. However, to avoid excessive schedules, the wait is capped by this function and it can * be overrode for a custom {defaultAdminDelay} increase scheduling. * * IMPORTANT: Make sure to add a reasonable amount of time while overriding this value, otherwise, * there's a risk of setting a high new delay that goes into effect almost immediately without the * possibility of human intervention in the case of an input error (eg. set milliseconds instead of seconds). */ function defaultAdminDelayIncreaseWait() external view returns (uint48); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SafeCast.sol) // This file was procedurally generated from scripts/generate/templates/SafeCast.js. pragma solidity ^0.8.0; /** * @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. * * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing * all math on `uint256` and `int256` and then downcasting. */ library SafeCast { /** * @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 * * _Available since v4.7._ */ function toUint248(uint256 value) internal pure returns (uint248) { require(value <= type(uint248).max, "SafeCast: value doesn't fit in 248 bits"); 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 * * _Available since v4.7._ */ function toUint240(uint256 value) internal pure returns (uint240) { require(value <= type(uint240).max, "SafeCast: value doesn't fit in 240 bits"); 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 * * _Available since v4.7._ */ function toUint232(uint256 value) internal pure returns (uint232) { require(value <= type(uint232).max, "SafeCast: value doesn't fit in 232 bits"); 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 * * _Available since v4.2._ */ function toUint224(uint256 value) internal pure returns (uint224) { require(value <= type(uint224).max, "SafeCast: value doesn't fit in 224 bits"); 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 * * _Available since v4.7._ */ function toUint216(uint256 value) internal pure returns (uint216) { require(value <= type(uint216).max, "SafeCast: value doesn't fit in 216 bits"); 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 * * _Available since v4.7._ */ function toUint208(uint256 value) internal pure returns (uint208) { require(value <= type(uint208).max, "SafeCast: value doesn't fit in 208 bits"); 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 * * _Available since v4.7._ */ function toUint200(uint256 value) internal pure returns (uint200) { require(value <= type(uint200).max, "SafeCast: value doesn't fit in 200 bits"); 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 * * _Available since v4.7._ */ function toUint192(uint256 value) internal pure returns (uint192) { require(value <= type(uint192).max, "SafeCast: value doesn't fit in 192 bits"); 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 * * _Available since v4.7._ */ function toUint184(uint256 value) internal pure returns (uint184) { require(value <= type(uint184).max, "SafeCast: value doesn't fit in 184 bits"); 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 * * _Available since v4.7._ */ function toUint176(uint256 value) internal pure returns (uint176) { require(value <= type(uint176).max, "SafeCast: value doesn't fit in 176 bits"); 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 * * _Available since v4.7._ */ function toUint168(uint256 value) internal pure returns (uint168) { require(value <= type(uint168).max, "SafeCast: value doesn't fit in 168 bits"); 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 * * _Available since v4.7._ */ function toUint160(uint256 value) internal pure returns (uint160) { require(value <= type(uint160).max, "SafeCast: value doesn't fit in 160 bits"); 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 * * _Available since v4.7._ */ function toUint152(uint256 value) internal pure returns (uint152) { require(value <= type(uint152).max, "SafeCast: value doesn't fit in 152 bits"); 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 * * _Available since v4.7._ */ function toUint144(uint256 value) internal pure returns (uint144) { require(value <= type(uint144).max, "SafeCast: value doesn't fit in 144 bits"); 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 * * _Available since v4.7._ */ function toUint136(uint256 value) internal pure returns (uint136) { require(value <= type(uint136).max, "SafeCast: value doesn't fit in 136 bits"); 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 * * _Available since v2.5._ */ function toUint128(uint256 value) internal pure returns (uint128) { require(value <= type(uint128).max, "SafeCast: value doesn't fit in 128 bits"); 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 * * _Available since v4.7._ */ function toUint120(uint256 value) internal pure returns (uint120) { require(value <= type(uint120).max, "SafeCast: value doesn't fit in 120 bits"); 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 * * _Available since v4.7._ */ function toUint112(uint256 value) internal pure returns (uint112) { require(value <= type(uint112).max, "SafeCast: value doesn't fit in 112 bits"); 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 * * _Available since v4.7._ */ function toUint104(uint256 value) internal pure returns (uint104) { require(value <= type(uint104).max, "SafeCast: value doesn't fit in 104 bits"); 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 * * _Available since v4.2._ */ function toUint96(uint256 value) internal pure returns (uint96) { require(value <= type(uint96).max, "SafeCast: value doesn't fit in 96 bits"); 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 * * _Available since v4.7._ */ function toUint88(uint256 value) internal pure returns (uint88) { require(value <= type(uint88).max, "SafeCast: value doesn't fit in 88 bits"); 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 * * _Available since v4.7._ */ function toUint80(uint256 value) internal pure returns (uint80) { require(value <= type(uint80).max, "SafeCast: value doesn't fit in 80 bits"); 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 * * _Available since v4.7._ */ function toUint72(uint256 value) internal pure returns (uint72) { require(value <= type(uint72).max, "SafeCast: value doesn't fit in 72 bits"); 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 * * _Available since v2.5._ */ function toUint64(uint256 value) internal pure returns (uint64) { require(value <= type(uint64).max, "SafeCast: value doesn't fit in 64 bits"); 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 * * _Available since v4.7._ */ function toUint56(uint256 value) internal pure returns (uint56) { require(value <= type(uint56).max, "SafeCast: value doesn't fit in 56 bits"); 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 * * _Available since v4.7._ */ function toUint48(uint256 value) internal pure returns (uint48) { require(value <= type(uint48).max, "SafeCast: value doesn't fit in 48 bits"); 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 * * _Available since v4.7._ */ function toUint40(uint256 value) internal pure returns (uint40) { require(value <= type(uint40).max, "SafeCast: value doesn't fit in 40 bits"); 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 * * _Available since v2.5._ */ function toUint32(uint256 value) internal pure returns (uint32) { require(value <= type(uint32).max, "SafeCast: value doesn't fit in 32 bits"); 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 * * _Available since v4.7._ */ function toUint24(uint256 value) internal pure returns (uint24) { require(value <= type(uint24).max, "SafeCast: value doesn't fit in 24 bits"); 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 * * _Available since v2.5._ */ function toUint16(uint256 value) internal pure returns (uint16) { require(value <= type(uint16).max, "SafeCast: value doesn't fit in 16 bits"); 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 * * _Available since v2.5._ */ function toUint8(uint256 value) internal pure returns (uint8) { require(value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits"); return uint8(value); } /** * @dev Converts a signed int256 into an unsigned uint256. * * Requirements: * * - input must be greater than or equal to 0. * * _Available since v3.0._ */ function toUint256(int256 value) internal pure returns (uint256) { require(value >= 0, "SafeCast: value must be positive"); 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 * * _Available since v4.7._ */ function toInt248(int256 value) internal pure returns (int248 downcasted) { downcasted = int248(value); require(downcasted == value, "SafeCast: value doesn't fit in 248 bits"); } /** * @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 * * _Available since v4.7._ */ function toInt240(int256 value) internal pure returns (int240 downcasted) { downcasted = int240(value); require(downcasted == value, "SafeCast: value doesn't fit in 240 bits"); } /** * @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 * * _Available since v4.7._ */ function toInt232(int256 value) internal pure returns (int232 downcasted) { downcasted = int232(value); require(downcasted == value, "SafeCast: value doesn't fit in 232 bits"); } /** * @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 * * _Available since v4.7._ */ function toInt224(int256 value) internal pure returns (int224 downcasted) { downcasted = int224(value); require(downcasted == value, "SafeCast: value doesn't fit in 224 bits"); } /** * @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 * * _Available since v4.7._ */ function toInt216(int256 value) internal pure returns (int216 downcasted) { downcasted = int216(value); require(downcasted == value, "SafeCast: value doesn't fit in 216 bits"); } /** * @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 * * _Available since v4.7._ */ function toInt208(int256 value) internal pure returns (int208 downcasted) { downcasted = int208(value); require(downcasted == value, "SafeCast: value doesn't fit in 208 bits"); } /** * @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 * * _Available since v4.7._ */ function toInt200(int256 value) internal pure returns (int200 downcasted) { downcasted = int200(value); require(downcasted == value, "SafeCast: value doesn't fit in 200 bits"); } /** * @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 * * _Available since v4.7._ */ function toInt192(int256 value) internal pure returns (int192 downcasted) { downcasted = int192(value); require(downcasted == value, "SafeCast: value doesn't fit in 192 bits"); } /** * @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 * * _Available since v4.7._ */ function toInt184(int256 value) internal pure returns (int184 downcasted) { downcasted = int184(value); require(downcasted == value, "SafeCast: value doesn't fit in 184 bits"); } /** * @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 * * _Available since v4.7._ */ function toInt176(int256 value) internal pure returns (int176 downcasted) { downcasted = int176(value); require(downcasted == value, "SafeCast: value doesn't fit in 176 bits"); } /** * @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 * * _Available since v4.7._ */ function toInt168(int256 value) internal pure returns (int168 downcasted) { downcasted = int168(value); require(downcasted == value, "SafeCast: value doesn't fit in 168 bits"); } /** * @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 * * _Available since v4.7._ */ function toInt160(int256 value) internal pure returns (int160 downcasted) { downcasted = int160(value); require(downcasted == value, "SafeCast: value doesn't fit in 160 bits"); } /** * @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 * * _Available since v4.7._ */ function toInt152(int256 value) internal pure returns (int152 downcasted) { downcasted = int152(value); require(downcasted == value, "SafeCast: value doesn't fit in 152 bits"); } /** * @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 * * _Available since v4.7._ */ function toInt144(int256 value) internal pure returns (int144 downcasted) { downcasted = int144(value); require(downcasted == value, "SafeCast: value doesn't fit in 144 bits"); } /** * @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 * * _Available since v4.7._ */ function toInt136(int256 value) internal pure returns (int136 downcasted) { downcasted = int136(value); require(downcasted == value, "SafeCast: value doesn't fit in 136 bits"); } /** * @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 * * _Available since v3.1._ */ function toInt128(int256 value) internal pure returns (int128 downcasted) { downcasted = int128(value); require(downcasted == value, "SafeCast: value doesn't fit in 128 bits"); } /** * @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 * * _Available since v4.7._ */ function toInt120(int256 value) internal pure returns (int120 downcasted) { downcasted = int120(value); require(downcasted == value, "SafeCast: value doesn't fit in 120 bits"); } /** * @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 * * _Available since v4.7._ */ function toInt112(int256 value) internal pure returns (int112 downcasted) { downcasted = int112(value); require(downcasted == value, "SafeCast: value doesn't fit in 112 bits"); } /** * @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 * * _Available since v4.7._ */ function toInt104(int256 value) internal pure returns (int104 downcasted) { downcasted = int104(value); require(downcasted == value, "SafeCast: value doesn't fit in 104 bits"); } /** * @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 * * _Available since v4.7._ */ function toInt96(int256 value) internal pure returns (int96 downcasted) { downcasted = int96(value); require(downcasted == value, "SafeCast: value doesn't fit in 96 bits"); } /** * @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 * * _Available since v4.7._ */ function toInt88(int256 value) internal pure returns (int88 downcasted) { downcasted = int88(value); require(downcasted == value, "SafeCast: value doesn't fit in 88 bits"); } /** * @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 * * _Available since v4.7._ */ function toInt80(int256 value) internal pure returns (int80 downcasted) { downcasted = int80(value); require(downcasted == value, "SafeCast: value doesn't fit in 80 bits"); } /** * @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 * * _Available since v4.7._ */ function toInt72(int256 value) internal pure returns (int72 downcasted) { downcasted = int72(value); require(downcasted == value, "SafeCast: value doesn't fit in 72 bits"); } /** * @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 * * _Available since v3.1._ */ function toInt64(int256 value) internal pure returns (int64 downcasted) { downcasted = int64(value); require(downcasted == value, "SafeCast: value doesn't fit in 64 bits"); } /** * @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 * * _Available since v4.7._ */ function toInt56(int256 value) internal pure returns (int56 downcasted) { downcasted = int56(value); require(downcasted == value, "SafeCast: value doesn't fit in 56 bits"); } /** * @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 * * _Available since v4.7._ */ function toInt48(int256 value) internal pure returns (int48 downcasted) { downcasted = int48(value); require(downcasted == value, "SafeCast: value doesn't fit in 48 bits"); } /** * @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 * * _Available since v4.7._ */ function toInt40(int256 value) internal pure returns (int40 downcasted) { downcasted = int40(value); require(downcasted == value, "SafeCast: value doesn't fit in 40 bits"); } /** * @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 * * _Available since v3.1._ */ function toInt32(int256 value) internal pure returns (int32 downcasted) { downcasted = int32(value); require(downcasted == value, "SafeCast: value doesn't fit in 32 bits"); } /** * @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 * * _Available since v4.7._ */ function toInt24(int256 value) internal pure returns (int24 downcasted) { downcasted = int24(value); require(downcasted == value, "SafeCast: value doesn't fit in 24 bits"); } /** * @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 * * _Available since v3.1._ */ function toInt16(int256 value) internal pure returns (int16 downcasted) { downcasted = int16(value); require(downcasted == value, "SafeCast: value doesn't fit in 16 bits"); } /** * @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 * * _Available since v3.1._ */ function toInt8(int256 value) internal pure returns (int8 downcasted) { downcasted = int8(value); require(downcasted == value, "SafeCast: value doesn't fit in 8 bits"); } /** * @dev Converts an unsigned uint256 into a signed int256. * * Requirements: * * - input must be less than or equal to maxInt256. * * _Available since v3.0._ */ function toInt256(uint256 value) internal pure returns (int256) { // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive require(value <= uint256(type(int256).max), "SafeCast: value doesn't fit in an int256"); return int256(value); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (interfaces/IERC5313.sol) pragma solidity ^0.8.0; /** * @dev Interface for the Light Contract Ownership Standard. * * A standardized minimal interface required to identify an account that controls a contract * * _Available since v4.9._ */ interface IERC5313 { /** * @dev Gets the address of the owner. */ function owner() external view returns (address); }
// SPDX-License-Identifier: AGPL-3.0-only pragma solidity >=0.8.0; /// @notice Minimalist and gas efficient standard ERC1155 implementation. /// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC1155.sol) abstract contract ERC1155 { /*////////////////////////////////////////////////////////////// EVENTS //////////////////////////////////////////////////////////////*/ event TransferSingle( address indexed operator, address indexed from, address indexed to, uint256 id, uint256 amount ); event TransferBatch( address indexed operator, address indexed from, address indexed to, uint256[] ids, uint256[] amounts ); event ApprovalForAll(address indexed owner, address indexed operator, bool approved); event URI(string value, uint256 indexed id); /*////////////////////////////////////////////////////////////// ERC1155 STORAGE //////////////////////////////////////////////////////////////*/ mapping(address => mapping(uint256 => uint256)) public balanceOf; mapping(address => mapping(address => bool)) public isApprovedForAll; /*////////////////////////////////////////////////////////////// METADATA LOGIC //////////////////////////////////////////////////////////////*/ function uri(uint256 id) public view virtual returns (string memory); /*////////////////////////////////////////////////////////////// ERC1155 LOGIC //////////////////////////////////////////////////////////////*/ function setApprovalForAll(address operator, bool approved) public virtual { isApprovedForAll[msg.sender][operator] = approved; emit ApprovalForAll(msg.sender, operator, approved); } function safeTransferFrom( address from, address to, uint256 id, uint256 amount, bytes calldata data ) public virtual { require(msg.sender == from || isApprovedForAll[from][msg.sender], "NOT_AUTHORIZED"); balanceOf[from][id] -= amount; balanceOf[to][id] += amount; emit TransferSingle(msg.sender, from, to, id, amount); require( to.code.length == 0 ? to != address(0) : ERC1155TokenReceiver(to).onERC1155Received(msg.sender, from, id, amount, data) == ERC1155TokenReceiver.onERC1155Received.selector, "UNSAFE_RECIPIENT" ); } function safeBatchTransferFrom( address from, address to, uint256[] calldata ids, uint256[] calldata amounts, bytes calldata data ) public virtual { require(ids.length == amounts.length, "LENGTH_MISMATCH"); require(msg.sender == from || isApprovedForAll[from][msg.sender], "NOT_AUTHORIZED"); // Storing these outside the loop saves ~15 gas per iteration. uint256 id; uint256 amount; for (uint256 i = 0; i < ids.length; ) { id = ids[i]; amount = amounts[i]; balanceOf[from][id] -= amount; balanceOf[to][id] += amount; // An array can't have a total length // larger than the max uint256 value. unchecked { ++i; } } emit TransferBatch(msg.sender, from, to, ids, amounts); require( to.code.length == 0 ? to != address(0) : ERC1155TokenReceiver(to).onERC1155BatchReceived(msg.sender, from, ids, amounts, data) == ERC1155TokenReceiver.onERC1155BatchReceived.selector, "UNSAFE_RECIPIENT" ); } function balanceOfBatch(address[] calldata owners, uint256[] calldata ids) public view virtual returns (uint256[] memory balances) { require(owners.length == ids.length, "LENGTH_MISMATCH"); balances = new uint256[](owners.length); // Unchecked because the only math done is incrementing // the array index counter which cannot possibly overflow. unchecked { for (uint256 i = 0; i < owners.length; ++i) { balances[i] = balanceOf[owners[i]][ids[i]]; } } } /*////////////////////////////////////////////////////////////// ERC165 LOGIC //////////////////////////////////////////////////////////////*/ function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) { return interfaceId == 0x01ffc9a7 || // ERC165 Interface ID for ERC165 interfaceId == 0xd9b67a26 || // ERC165 Interface ID for ERC1155 interfaceId == 0x0e89341c; // ERC165 Interface ID for ERC1155MetadataURI } /*////////////////////////////////////////////////////////////// INTERNAL MINT/BURN LOGIC //////////////////////////////////////////////////////////////*/ function _mint( address to, uint256 id, uint256 amount, bytes memory data ) internal virtual { balanceOf[to][id] += amount; emit TransferSingle(msg.sender, address(0), to, id, amount); require( to.code.length == 0 ? to != address(0) : ERC1155TokenReceiver(to).onERC1155Received(msg.sender, address(0), id, amount, data) == ERC1155TokenReceiver.onERC1155Received.selector, "UNSAFE_RECIPIENT" ); } function _batchMint( address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data ) internal virtual { uint256 idsLength = ids.length; // Saves MLOADs. require(idsLength == amounts.length, "LENGTH_MISMATCH"); for (uint256 i = 0; i < idsLength; ) { balanceOf[to][ids[i]] += amounts[i]; // An array can't have a total length // larger than the max uint256 value. unchecked { ++i; } } emit TransferBatch(msg.sender, address(0), to, ids, amounts); require( to.code.length == 0 ? to != address(0) : ERC1155TokenReceiver(to).onERC1155BatchReceived(msg.sender, address(0), ids, amounts, data) == ERC1155TokenReceiver.onERC1155BatchReceived.selector, "UNSAFE_RECIPIENT" ); } function _batchBurn( address from, uint256[] memory ids, uint256[] memory amounts ) internal virtual { uint256 idsLength = ids.length; // Saves MLOADs. require(idsLength == amounts.length, "LENGTH_MISMATCH"); for (uint256 i = 0; i < idsLength; ) { balanceOf[from][ids[i]] -= amounts[i]; // An array can't have a total length // larger than the max uint256 value. unchecked { ++i; } } emit TransferBatch(msg.sender, from, address(0), ids, amounts); } function _burn( address from, uint256 id, uint256 amount ) internal virtual { balanceOf[from][id] -= amount; emit TransferSingle(msg.sender, from, address(0), id, amount); } } /// @notice A generic interface for a contract which properly accepts ERC1155 tokens. /// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC1155.sol) abstract contract ERC1155TokenReceiver { function onERC1155Received( address, address, uint256, uint256, bytes calldata ) external virtual returns (bytes4) { return ERC1155TokenReceiver.onERC1155Received.selector; } function onERC1155BatchReceived( address, address, uint256[] calldata, uint256[] calldata, bytes calldata ) external virtual returns (bytes4) { return ERC1155TokenReceiver.onERC1155BatchReceived.selector; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable2Step.sol) pragma solidity ^0.8.0; import "./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. * * By default, the owner account will be the one that deploys the contract. 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(); require(pendingOwner() == sender, "Ownable2Step: caller is not the new owner"); _transferOwnership(sender); } }
// SPDX-License-Identifier: AGPL-3.0-only pragma solidity >=0.8.0; import {ERC20} from "../tokens/ERC20.sol"; import {SafeTransferLib} from "../utils/SafeTransferLib.sol"; import {FixedPointMathLib} from "../utils/FixedPointMathLib.sol"; /// @notice Minimal ERC4626 tokenized Vault implementation. /// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/mixins/ERC4626.sol) abstract contract ERC4626 is ERC20 { using SafeTransferLib for ERC20; using FixedPointMathLib for uint256; /*////////////////////////////////////////////////////////////// EVENTS //////////////////////////////////////////////////////////////*/ event Deposit(address indexed caller, address indexed owner, uint256 assets, uint256 shares); event Withdraw( address indexed caller, address indexed receiver, address indexed owner, uint256 assets, uint256 shares ); /*////////////////////////////////////////////////////////////// IMMUTABLES //////////////////////////////////////////////////////////////*/ ERC20 public immutable asset; constructor( ERC20 _asset, string memory _name, string memory _symbol ) ERC20(_name, _symbol, _asset.decimals()) { asset = _asset; } /*////////////////////////////////////////////////////////////// DEPOSIT/WITHDRAWAL LOGIC //////////////////////////////////////////////////////////////*/ function deposit(uint256 assets, address receiver) public virtual returns (uint256 shares) { // Check for rounding error since we round down in previewDeposit. require((shares = previewDeposit(assets)) != 0, "ZERO_SHARES"); // Need to transfer before minting or ERC777s could reenter. asset.safeTransferFrom(msg.sender, address(this), assets); _mint(receiver, shares); emit Deposit(msg.sender, receiver, assets, shares); afterDeposit(assets, shares); } function mint(uint256 shares, address receiver) public virtual returns (uint256 assets) { assets = previewMint(shares); // No need to check for rounding error, previewMint rounds up. // Need to transfer before minting or ERC777s could reenter. asset.safeTransferFrom(msg.sender, address(this), assets); _mint(receiver, shares); emit Deposit(msg.sender, receiver, assets, shares); afterDeposit(assets, shares); } function withdraw( uint256 assets, address receiver, address owner ) public virtual returns (uint256 shares) { shares = previewWithdraw(assets); // No need to check for rounding error, previewWithdraw rounds up. if (msg.sender != owner) { uint256 allowed = allowance[owner][msg.sender]; // Saves gas for limited approvals. if (allowed != type(uint256).max) allowance[owner][msg.sender] = allowed - shares; } beforeWithdraw(assets, shares); _burn(owner, shares); emit Withdraw(msg.sender, receiver, owner, assets, shares); asset.safeTransfer(receiver, assets); } function redeem( uint256 shares, address receiver, address owner ) public virtual returns (uint256 assets) { if (msg.sender != owner) { uint256 allowed = allowance[owner][msg.sender]; // Saves gas for limited approvals. if (allowed != type(uint256).max) allowance[owner][msg.sender] = allowed - shares; } // Check for rounding error since we round down in previewRedeem. require((assets = previewRedeem(shares)) != 0, "ZERO_ASSETS"); beforeWithdraw(assets, shares); _burn(owner, shares); emit Withdraw(msg.sender, receiver, owner, assets, shares); asset.safeTransfer(receiver, assets); } /*////////////////////////////////////////////////////////////// ACCOUNTING LOGIC //////////////////////////////////////////////////////////////*/ function totalAssets() public view virtual returns (uint256); function convertToShares(uint256 assets) public view virtual returns (uint256) { uint256 supply = totalSupply; // Saves an extra SLOAD if totalSupply is non-zero. return supply == 0 ? assets : assets.mulDivDown(supply, totalAssets()); } function convertToAssets(uint256 shares) public view virtual returns (uint256) { uint256 supply = totalSupply; // Saves an extra SLOAD if totalSupply is non-zero. return supply == 0 ? shares : shares.mulDivDown(totalAssets(), supply); } function previewDeposit(uint256 assets) public view virtual returns (uint256) { return convertToShares(assets); } function previewMint(uint256 shares) public view virtual returns (uint256) { uint256 supply = totalSupply; // Saves an extra SLOAD if totalSupply is non-zero. return supply == 0 ? shares : shares.mulDivUp(totalAssets(), supply); } function previewWithdraw(uint256 assets) public view virtual returns (uint256) { uint256 supply = totalSupply; // Saves an extra SLOAD if totalSupply is non-zero. return supply == 0 ? assets : assets.mulDivUp(supply, totalAssets()); } function previewRedeem(uint256 shares) public view virtual returns (uint256) { return convertToAssets(shares); } /*////////////////////////////////////////////////////////////// DEPOSIT/WITHDRAWAL LIMIT LOGIC //////////////////////////////////////////////////////////////*/ function maxDeposit(address) public view virtual returns (uint256) { return type(uint256).max; } function maxMint(address) public view virtual returns (uint256) { return type(uint256).max; } function maxWithdraw(address owner) public view virtual returns (uint256) { return convertToAssets(balanceOf[owner]); } function maxRedeem(address owner) public view virtual returns (uint256) { return balanceOf[owner]; } /*////////////////////////////////////////////////////////////// INTERNAL HOOKS LOGIC //////////////////////////////////////////////////////////////*/ function beforeWithdraw(uint256 assets, uint256 shares) internal virtual {} function afterDeposit(uint256 assets, uint256 shares) internal virtual {} }
// 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: MIT pragma solidity 0.8.19; import {ERC20} from "solmate/tokens/ERC20.sol"; import {AccessControlDefaultAdminRules} from "openzeppelin-contracts/contracts/access/AccessControlDefaultAdminRules.sol"; import {Errors} from "./libraries/Errors.sol"; /** * @title DineroERC20 * @dev A Standard ERC20 token with minting and burning with access control. * @author redactedcartel.finance */ contract DineroERC20 is ERC20, AccessControlDefaultAdminRules { // Roles /** * @dev Bytes32 constant representing the role to mint new tokens. */ bytes32 private constant MINTER_ROLE = keccak256("MINTER_ROLE"); /** * @dev Bytes32 constant representing the role to burn (destroy) tokens. */ bytes32 private constant BURNER_ROLE = keccak256("BURNER_ROLE"); /** * @notice Constructor to initialize ERC20 token with access control. * @param _name string Token name. * @param _symbol string Token symbol. * @param _decimals uint8 Token decimals. * @param _admin address Admin address. * @param _initialDelay uint48 Delay required to schedule the acceptance * of an access control transfer started. */ constructor( string memory _name, string memory _symbol, uint8 _decimals, address _admin, uint48 _initialDelay ) AccessControlDefaultAdminRules(_initialDelay, _admin) ERC20(_name, _symbol, _decimals) { if (bytes(_name).length == 0) revert Errors.EmptyString(); if (bytes(_symbol).length == 0) revert Errors.EmptyString(); if (_decimals == 0) revert Errors.ZeroAmount(); } /** * @notice Mints tokens to an address. * @dev Only callable by minters. * @param _to address Address to mint tokens to. * @param _amount uint256 Amount of tokens to mint. */ function mint(address _to, uint256 _amount) external onlyRole(MINTER_ROLE) { if (_to == address(0)) revert Errors.ZeroAddress(); if (_amount == 0) revert Errors.ZeroAmount(); _mint(_to, _amount); } /** * @notice Burns tokens from an address. * @dev Only callable by burners. * @param _from address Address to burn tokens from. * @param _amount uint256 Amount of tokens to burn. */ function burn( address _from, uint256 _amount ) external onlyRole(BURNER_ROLE) { if (_from == address(0)) revert Errors.ZeroAddress(); if (_amount == 0) revert Errors.ZeroAmount(); _burn(_from, _amount); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol) pragma solidity ^0.8.0; /** * @dev External interface of AccessControl declared to support ERC165 detection. */ interface IAccessControl { /** * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole` * * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite * {RoleAdminChanged} not being emitted signaling this. * * _Available since v3.1._ */ event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole); /** * @dev Emitted when `account` is granted `role`. * * `sender` is the account that originated the contract call, an admin role * bearer except when using {AccessControl-_setupRole}. */ event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender); /** * @dev Emitted when `account` is revoked `role`. * * `sender` is the account that originated the contract call: * - if using `revokeRole`, it is the admin role bearer * - if using `renounceRole`, it is the role bearer (i.e. `account`) */ event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender); /** * @dev Returns `true` if `account` has been granted `role`. */ function hasRole(bytes32 role, address account) external view returns (bool); /** * @dev Returns the admin role that controls `role`. See {grantRole} and * {revokeRole}. * * To change a role's admin, use {AccessControl-_setRoleAdmin}. */ function getRoleAdmin(bytes32 role) external view returns (bytes32); /** * @dev Grants `role` to `account`. * * If `account` had not been already granted `role`, emits a {RoleGranted} * event. * * Requirements: * * - the caller must have ``role``'s admin role. */ function grantRole(bytes32 role, address account) external; /** * @dev Revokes `role` from `account`. * * If `account` had been granted `role`, emits a {RoleRevoked} event. * * Requirements: * * - the caller must have ``role``'s admin role. */ function revokeRole(bytes32 role, address account) external; /** * @dev Revokes `role` from the calling account. * * Roles are often managed via {grantRole} and {revokeRole}: this function's * purpose is to provide a mechanism for accounts to lose their privileges * if they are compromised (such as when a trusted device is misplaced). * * If the calling account had been granted `role`, emits a {RoleRevoked} * event. * * Requirements: * * - the caller must be `account`. */ function renounceRole(bytes32 role, address account) external; }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/Context.sol) pragma solidity ^0.8.0; /** * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol) pragma solidity ^0.8.0; import "./math/Math.sol"; import "./math/SignedMath.sol"; /** * @dev String operations. */ library Strings { bytes16 private constant _SYMBOLS = "0123456789abcdef"; uint8 private constant _ADDRESS_LENGTH = 20; /** * @dev Converts a `uint256` to its ASCII `string` decimal representation. */ function toString(uint256 value) internal pure returns (string memory) { unchecked { uint256 length = Math.log10(value) + 1; string memory buffer = new string(length); uint256 ptr; /// @solidity memory-safe-assembly assembly { ptr := add(buffer, add(32, length)) } while (true) { ptr--; /// @solidity memory-safe-assembly assembly { mstore8(ptr, byte(mod(value, 10), _SYMBOLS)) } value /= 10; if (value == 0) break; } return buffer; } } /** * @dev Converts a `int256` to its ASCII `string` decimal representation. */ function toString(int256 value) internal pure returns (string memory) { return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value)))); } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation. */ function toHexString(uint256 value) internal pure returns (string memory) { unchecked { return toHexString(value, Math.log256(value) + 1); } } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length. */ function toHexString(uint256 value, uint256 length) internal pure returns (string memory) { bytes memory buffer = new bytes(2 * length + 2); buffer[0] = "0"; buffer[1] = "x"; for (uint256 i = 2 * length + 1; i > 1; --i) { buffer[i] = _SYMBOLS[value & 0xf]; value >>= 4; } require(value == 0, "Strings: hex length insufficient"); return string(buffer); } /** * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation. */ function toHexString(address addr) internal pure returns (string memory) { return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH); } /** * @dev Returns true if the two strings are equal. */ function equal(string memory a, string memory b) internal pure returns (bool) { return keccak256(bytes(a)) == keccak256(bytes(b)); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol) pragma solidity ^0.8.0; import "./IERC165.sol"; /** * @dev Implementation of the {IERC165} interface. * * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check * for the additional interface id that will be supported. For example: * * ```solidity * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId); * } * ``` * * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation. */ abstract contract ERC165 is IERC165 { /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IERC165).interfaceId; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol) pragma solidity ^0.8.0; import "../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. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor() { _transferOwnership(_msgSender()); } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { _checkOwner(); _; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { require(owner() == _msgSender(), "Ownable: caller is not the owner"); } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby disabling any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { _transferOwnership(address(0)); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol) pragma solidity ^0.8.0; /** * @dev Standard math utilities missing in the Solidity language. */ library Math { enum Rounding { Down, // Toward negative infinity Up, // Toward infinity Zero // Toward zero } /** * @dev Returns the largest of two numbers. */ function max(uint256 a, uint256 b) internal pure returns (uint256) { return a > b ? a : b; } /** * @dev Returns the smallest of two numbers. */ function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } /** * @dev Returns the average of two numbers. The result is rounded towards * zero. */ function average(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b) / 2 can overflow. return (a & b) + (a ^ b) / 2; } /** * @dev Returns the ceiling of the division of two numbers. * * This differs from standard division with `/` in that it rounds up instead * of rounding down. */ function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b - 1) / b can overflow on addition, so we distribute. return a == 0 ? 0 : (a - 1) / b + 1; } /** * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0 * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) * with further edits by Uniswap Labs also under MIT license. */ function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) { unchecked { // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256 // variables such that product = prod1 * 2^256 + prod0. uint256 prod0; // Least significant 256 bits of the product uint256 prod1; // Most significant 256 bits of the product assembly { let mm := mulmod(x, y, not(0)) prod0 := mul(x, y) prod1 := sub(sub(mm, prod0), lt(mm, prod0)) } // Handle non-overflow cases, 256 by 256 division. if (prod1 == 0) { // Solidity will revert if denominator == 0, unlike the div opcode on its own. // The surrounding unchecked block does not change this fact. // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic. return prod0 / denominator; } // Make sure the result is less than 2^256. Also prevents denominator == 0. require(denominator > prod1, "Math: mulDiv overflow"); /////////////////////////////////////////////// // 512 by 256 division. /////////////////////////////////////////////// // Make division exact by subtracting the remainder from [prod1 prod0]. uint256 remainder; assembly { // Compute remainder using mulmod. remainder := mulmod(x, y, denominator) // Subtract 256 bit number from 512 bit number. prod1 := sub(prod1, gt(remainder, prod0)) prod0 := sub(prod0, remainder) } // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1. // See https://cs.stackexchange.com/q/138556/92363. // Does not overflow because the denominator cannot be zero at this stage in the function. uint256 twos = denominator & (~denominator + 1); assembly { // Divide denominator by twos. denominator := div(denominator, twos) // Divide [prod1 prod0] by twos. prod0 := div(prod0, twos) // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one. twos := add(div(sub(0, twos), twos), 1) } // Shift in bits from prod1 into prod0. prod0 |= prod1 * twos; // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for // four bits. That is, denominator * inv = 1 mod 2^4. uint256 inverse = (3 * denominator) ^ 2; // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works // in modular arithmetic, doubling the correct bits in each step. inverse *= 2 - denominator * inverse; // inverse mod 2^8 inverse *= 2 - denominator * inverse; // inverse mod 2^16 inverse *= 2 - denominator * inverse; // inverse mod 2^32 inverse *= 2 - denominator * inverse; // inverse mod 2^64 inverse *= 2 - denominator * inverse; // inverse mod 2^128 inverse *= 2 - denominator * inverse; // inverse mod 2^256 // Because the division is now exact we can divide by multiplying with the modular inverse of denominator. // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1 // is no longer required. result = prod0 * inverse; return result; } } /** * @notice Calculates x * y / denominator with full precision, following the selected rounding direction. */ function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) { uint256 result = mulDiv(x, y, denominator); if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) { result += 1; } return result; } /** * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down. * * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11). */ function sqrt(uint256 a) internal pure returns (uint256) { if (a == 0) { return 0; } // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target. // // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`. // // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)` // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))` // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)` // // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit. uint256 result = 1 << (log2(a) >> 1); // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128, // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision // into the expected uint128 result. unchecked { result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; return min(result, a / result); } } /** * @notice Calculates sqrt(a), following the selected rounding direction. */ function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = sqrt(a); return result + (rounding == Rounding.Up && result * result < a ? 1 : 0); } } /** * @dev Return the log in base 2, rounded down, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 128; } if (value >> 64 > 0) { value >>= 64; result += 64; } if (value >> 32 > 0) { value >>= 32; result += 32; } if (value >> 16 > 0) { value >>= 16; result += 16; } if (value >> 8 > 0) { value >>= 8; result += 8; } if (value >> 4 > 0) { value >>= 4; result += 4; } if (value >> 2 > 0) { value >>= 2; result += 2; } if (value >> 1 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 2, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log2(value); return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0); } } /** * @dev Return the log in base 10, rounded down, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >= 10 ** 64) { value /= 10 ** 64; result += 64; } if (value >= 10 ** 32) { value /= 10 ** 32; result += 32; } if (value >= 10 ** 16) { value /= 10 ** 16; result += 16; } if (value >= 10 ** 8) { value /= 10 ** 8; result += 8; } if (value >= 10 ** 4) { value /= 10 ** 4; result += 4; } if (value >= 10 ** 2) { value /= 10 ** 2; result += 2; } if (value >= 10 ** 1) { result += 1; } } return result; } /** * @dev Return the log in base 10, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log10(value); return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0); } } /** * @dev Return the log in base 256, rounded down, of a positive value. * Returns 0 if given 0. * * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string. */ function log256(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 16; } if (value >> 64 > 0) { value >>= 64; result += 8; } if (value >> 32 > 0) { value >>= 32; result += 4; } if (value >> 16 > 0) { value >>= 16; result += 2; } if (value >> 8 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 256, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log256(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log256(value); return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol) pragma solidity ^0.8.0; /** * @dev Standard signed math utilities missing in the Solidity language. */ library SignedMath { /** * @dev Returns the largest of two signed numbers. */ function max(int256 a, int256 b) internal pure returns (int256) { return a > b ? a : b; } /** * @dev Returns the smallest of two signed numbers. */ function min(int256 a, int256 b) internal pure returns (int256) { return a < b ? a : b; } /** * @dev Returns the average of two signed numbers without overflow. * The result is rounded towards zero. */ function average(int256 a, int256 b) internal pure returns (int256) { // Formula from the book "Hacker's Delight" int256 x = (a & b) + ((a ^ b) >> 1); return x + (int256(uint256(x) >> 255) & (a ^ b)); } /** * @dev Returns the absolute unsigned value of a signed value. */ function abs(int256 n) internal pure returns (uint256) { unchecked { // must be unchecked in order to support `n = type(int256).min` return uint256(n >= 0 ? n : -n); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol) pragma solidity ^0.8.0; /** * @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); }
{ "remappings": [ "ds-test/=lib/forge-std/lib/ds-test/src/", "forge-std/=lib/forge-std/src/", "openzeppelin-contracts/=lib/openzeppelin-contracts/", "solmate/=lib/solmate/src/", "erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/", "openzeppelin/=lib/openzeppelin-contracts/contracts/" ], "optimizer": { "enabled": true, "runs": 200 }, "metadata": { "useLiteralContent": false, "bytecodeHash": "ipfs", "appendCBOR": true }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } }, "evmVersion": "paris", "libraries": { "src/libraries/ValidatorQueue.sol": { "ValidatorQueue": "0x9e0d7d79735e1c63333128149c7b616a0dc0bbdb" } } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"address","name":"_pxEth","type":"address"},{"internalType":"address","name":"_admin","type":"address"},{"internalType":"address","name":"_beaconChainDepositContract","type":"address"},{"internalType":"address","name":"_upxEth","type":"address"},{"internalType":"uint256","name":"_depositSize","type":"uint256"},{"internalType":"uint256","name":"_preDepositAmount","type":"uint256"},{"internalType":"address","name":"_pirexFees","type":"address"},{"internalType":"uint48","name":"_initialDelay","type":"uint48"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AccountNotApproved","type":"error"},{"inputs":[],"name":"DepositingEtherNotPaused","type":"error"},{"inputs":[],"name":"DepositingEtherPaused","type":"error"},{"inputs":[],"name":"EmptyArray","type":"error"},{"inputs":[],"name":"ExceedsMax","type":"error"},{"inputs":[],"name":"InvalidAmount","type":"error"},{"inputs":[],"name":"InvalidFee","type":"error"},{"inputs":[],"name":"InvalidMaxFee","type":"error"},{"inputs":[],"name":"InvalidMaxProcessedCount","type":"error"},{"inputs":[],"name":"InvalidToken","type":"error"},{"inputs":[],"name":"MismatchedArrayLengths","type":"error"},{"inputs":[],"name":"NoETH","type":"error"},{"inputs":[],"name":"NoETHAllowed","type":"error"},{"inputs":[],"name":"NoPartialInitiateRedemption","type":"error"},{"inputs":[],"name":"NoUsedValidator","type":"error"},{"inputs":[],"name":"NoValidatorExit","type":"error"},{"inputs":[],"name":"NotEnoughBuffer","type":"error"},{"inputs":[],"name":"NotEnoughETH","type":"error"},{"inputs":[],"name":"NotEnoughValidators","type":"error"},{"inputs":[],"name":"NotPaused","type":"error"},{"inputs":[],"name":"NotRewardRecipient","type":"error"},{"inputs":[],"name":"NotWithdrawable","type":"error"},{"inputs":[],"name":"Paused","type":"error"},{"inputs":[],"name":"StatusNotDissolvedOrSlashed","type":"error"},{"inputs":[],"name":"StatusNotWithdrawableOrStaking","type":"error"},{"inputs":[],"name":"UnrecorgnisedContract","type":"error"},{"inputs":[],"name":"ValidatorNotStaking","type":"error"},{"inputs":[],"name":"ZeroAddress","type":"error"},{"inputs":[],"name":"ZeroAmount","type":"error"},{"inputs":[],"name":"ZeroMultiplier","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"}],"name":"ApproveBurnerAccount","type":"event"},{"anonymous":false,"inputs":[],"name":"DefaultAdminDelayChangeCanceled","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint48","name":"newDelay","type":"uint48"},{"indexed":false,"internalType":"uint48","name":"effectSchedule","type":"uint48"}],"name":"DefaultAdminDelayChangeScheduled","type":"event"},{"anonymous":false,"inputs":[],"name":"DefaultAdminTransferCanceled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newAdmin","type":"address"},{"indexed":false,"internalType":"uint48","name":"acceptSchedule","type":"uint48"}],"name":"DefaultAdminTransferScheduled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"caller","type":"address"},{"indexed":true,"internalType":"address","name":"receiver","type":"address"},{"indexed":true,"internalType":"bool","name":"shouldCompound","type":"bool"},{"indexed":false,"internalType":"uint256","name":"deposited","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"receivedAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"feeAmount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newStatus","type":"uint256"}],"name":"DepositEtherPaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes","name":"pubKey","type":"bytes"}],"name":"DissolveValidator","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"receiver","type":"address"},{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"EmergencyWithdrawal","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"endBlock","type":"uint256"}],"name":"Harvest","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"assets","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"postFeeAmount","type":"uint256"},{"indexed":true,"internalType":"address","name":"receiver","type":"address"}],"name":"InitiateRedemption","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"assets","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"postFeeAmount","type":"uint256"},{"indexed":true,"internalType":"address","name":"_receiver","type":"address"}],"name":"RedeemWithPxEth","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"assets","type":"uint256"},{"indexed":true,"internalType":"address","name":"receiver","type":"address"}],"name":"RedeemWithUpxEth","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"}],"name":"RevokeBurnerAccount","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"enum DataTypes.Contract","name":"c","type":"uint8"},{"indexed":false,"internalType":"address","name":"contractAddress","type":"address"}],"name":"SetContract","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"enum DataTypes.Fees","name":"f","type":"uint8"},{"indexed":false,"internalType":"uint32","name":"fee","type":"uint32"}],"name":"SetFee","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"pct","type":"uint256"}],"name":"SetMaxBufferSizePct","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"enum DataTypes.Fees","name":"f","type":"uint8"},{"indexed":false,"internalType":"uint32","name":"maxFee","type":"uint32"}],"name":"SetMaxFee","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"count","type":"uint256"}],"name":"SetMaxProcessedValidatorCount","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"state","type":"uint256"}],"name":"SetPauseState","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes","name":"withdrawalCredentials","type":"bytes"}],"name":"SetWithdrawCredentials","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes","name":"pubKey","type":"bytes"},{"indexed":false,"internalType":"bool","name":"useBuffer","type":"bool"},{"indexed":false,"internalType":"uint256","name":"releasedAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"penalty","type":"uint256"}],"name":"SlashValidator","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes","name":"pubKey","type":"bytes"},{"indexed":false,"internalType":"bool","name":"useBuffer","type":"bool"},{"indexed":false,"internalType":"uint256","name":"topUpAmount","type":"uint256"}],"name":"TopUp","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"maxBufferSize","type":"uint256"}],"name":"UpdateMaxBufferSize","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes","name":"pubKey","type":"bytes"}],"name":"ValidatorDeposit","type":"event"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DEPOSIT_SIZE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"acceptDefaultAdminTransfer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"bytes","name":"pubKey","type":"bytes"},{"internalType":"bytes","name":"signature","type":"bytes"},{"internalType":"bytes32","name":"depositDataRoot","type":"bytes32"},{"internalType":"address","name":"receiver","type":"address"}],"internalType":"struct DataTypes.Validator[]","name":"_validators","type":"tuple[]"}],"name":"addInitializedValidators","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"autoPxEth","outputs":[{"internalType":"contract AutoPxEth","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"batchId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"batchIdToValidator","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"beaconChainDepositContract","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newAdmin","type":"address"}],"name":"beginDefaultAdminTransfer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"buffer","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_tokenIds","type":"uint256[]"},{"internalType":"uint256[]","name":"_amounts","type":"uint256[]"},{"internalType":"address","name":"_receiver","type":"address"}],"name":"bulkRedeemWithUpxEth","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"burnerAccounts","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cancelDefaultAdminTransfer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint48","name":"newDelay","type":"uint48"}],"name":"changeDefaultAdminDelay","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"clearInitializedValidator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"defaultAdmin","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"defaultAdminDelay","outputs":[{"internalType":"uint48","name":"","type":"uint48"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"defaultAdminDelayIncreaseWait","outputs":[{"internalType":"uint48","name":"","type":"uint48"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"bool","name":"shouldCompound","type":"bool"}],"name":"deposit","outputs":[{"internalType":"uint256","name":"postFeeAmount","type":"uint256"},{"internalType":"uint256","name":"feeAmount","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"depositEtherPaused","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"depositPrivileged","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"_pubKey","type":"bytes"}],"name":"dissolveValidator","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"endBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"enum DataTypes.Fees","name":"","type":"uint8"}],"name":"fees","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_i","type":"uint256"}],"name":"getInitializedValidatorAt","outputs":[{"internalType":"bytes","name":"","type":"bytes"},{"internalType":"bytes","name":"","type":"bytes"},{"internalType":"bytes","name":"","type":"bytes"},{"internalType":"bytes32","name":"","type":"bytes32"},{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getInitializedValidatorCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_i","type":"uint256"}],"name":"getStakingValidatorAt","outputs":[{"internalType":"bytes","name":"","type":"bytes"},{"internalType":"bytes","name":"","type":"bytes"},{"internalType":"bytes","name":"","type":"bytes"},{"internalType":"bytes32","name":"","type":"bytes32"},{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getStakingValidatorCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_endBlock","type":"uint256"}],"name":"harvest","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_assets","type":"uint256"},{"internalType":"address","name":"_receiver","type":"address"},{"internalType":"bool","name":"_shouldTriggerValidatorExit","type":"bool"}],"name":"initiateRedemption","outputs":[{"internalType":"uint256","name":"postFeeAmount","type":"uint256"},{"internalType":"uint256","name":"feeAmount","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_assets","type":"uint256"},{"internalType":"address","name":"_receiver","type":"address"}],"name":"instantRedeemWithPxEth","outputs":[{"internalType":"uint256","name":"postFeeAmount","type":"uint256"},{"internalType":"uint256","name":"feeAmount","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"maxBufferSize","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxBufferSizePct","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"enum DataTypes.Fees","name":"","type":"uint8"}],"name":"maxFees","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxProcessedValidatorCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"oracleAdapter","outputs":[{"internalType":"contract IOracleAdapter","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"outstandingRedemptions","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingDefaultAdmin","outputs":[{"internalType":"address","name":"newAdmin","type":"address"},{"internalType":"uint48","name":"schedule","type":"uint48"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingDefaultAdminDelay","outputs":[{"internalType":"uint48","name":"newDelay","type":"uint48"},{"internalType":"uint48","name":"schedule","type":"uint48"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingDeposit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingWithdrawal","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pirexFees","outputs":[{"internalType":"contract IPirexFees","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_times","type":"uint256"}],"name":"popInitializedValidator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"preDepositAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pxEth","outputs":[{"internalType":"contract PxEth","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"uint256","name":"_assets","type":"uint256"},{"internalType":"address","name":"_receiver","type":"address"}],"name":"redeemWithUpxEth","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"_pubKey","type":"bytes"},{"internalType":"uint256","name":"_removeIndex","type":"uint256"},{"internalType":"bool","name":"_unordered","type":"bool"}],"name":"removeInitializedValidator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rewardRecipient","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rollbackDefaultAdminDelay","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"enum DataTypes.Contract","name":"_contract","type":"uint8"},{"internalType":"address","name":"contractAddress","type":"address"}],"name":"setContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"enum DataTypes.Fees","name":"f","type":"uint8"},{"internalType":"uint32","name":"fee","type":"uint32"}],"name":"setFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pct","type":"uint256"}],"name":"setMaxBufferSizePct","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"enum DataTypes.Fees","name":"f","type":"uint8"},{"internalType":"uint32","name":"maxFee","type":"uint32"}],"name":"setMaxFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_count","type":"uint256"}],"name":"setMaxProcessedValidatorCount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"_pubKey","type":"bytes"},{"internalType":"uint256","name":"_removeIndex","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"bool","name":"_unordered","type":"bool"},{"internalType":"bool","name":"_useBuffer","type":"bool"},{"components":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"internalType":"struct DataTypes.BurnerAccount[]","name":"_burnerAccounts","type":"tuple[]"}],"name":"slashValidator","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes","name":"","type":"bytes"}],"name":"status","outputs":[{"internalType":"enum DataTypes.ValidatorStatus","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_fromIndex","type":"uint256"},{"internalType":"uint256","name":"_toIndex","type":"uint256"}],"name":"swapInitializedValidator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_accounts","type":"address[]"},{"internalType":"bool","name":"_state","type":"bool"}],"name":"toggleBurnerAccounts","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"togglePauseDepositEther","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"togglePauseState","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"_pubKey","type":"bytes"},{"internalType":"bytes","name":"_signature","type":"bytes"},{"internalType":"bytes32","name":"_depositDataRoot","type":"bytes32"},{"internalType":"uint256","name":"_topUpAmount","type":"uint256"},{"internalType":"bool","name":"_useBuffer","type":"bool"},{"components":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"internalType":"struct DataTypes.BurnerAccount[]","name":"_burnerAccounts","type":"tuple[]"}],"name":"topUpStake","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"upxEth","outputs":[{"internalType":"contract UpxEth","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdrawalCredentials","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"view","type":"function"}]
Contract Creation Code
610100604052600160005560146008553480156200001c57600080fd5b50604051620061e3380380620061e38339810160408190526200003f916200044d565b8787878787878680866001600160a01b038116620000a45760405162461bcd60e51b815260206004820152601e60248201527f416363657373436f6e74726f6c3a20302064656661756c742061646d696e000060448201526064015b60405180910390fd5b600280546001600160d01b0316600160d01b65ffffffffffff851602179055620000d0600082620002f4565b50506001600160a01b038716620000fa5760405163d92e233d60e01b815260040160405180910390fd5b6001600160a01b038516620001225760405163d92e233d60e01b815260040160405180910390fd5b6001600160a01b0384166200014a5760405163d92e233d60e01b815260040160405180910390fd5b670de0b6b3a7640000831080156200017057506200016d633b9aca0084620004f1565b15155b156200018f576040516303373dc760e61b815260040160405180910390fd5b82821180620001a55750670de0b6b3a764000082105b80620001bf5750620001bc633b9aca0083620004f1565b15155b15620001de576040516303373dc760e61b815260040160405180910390fd5b50600a80546001600160a01b03199081166001600160a01b039889161790915560c09290925292851660805260a09290925260098054909216908416179055506001600e558216620002435760405163d92e233d60e01b815260040160405180910390fd5b506001600160a01b031660e0525050601b60205250507f584f46c60af19681376031579adb04a2416e54ee5505351c2a8435e3766026ea805462030d4063ffffffff1991821681179092557f9fafca4c9c0d5c2cbf85f49fd8ab8212430ce78c2a0cb75b51e0f9c4f9ace003805482168317905560026000527f1dd2f4b94a51cfb409e6e317a497f7cfd9013960a1c723f830c49c05a25f08a58054909116909117905550506001601d5562000514565b81620003985760006200030f6003546001600160a01b031690565b6001600160a01b0316146200037c5760405162461bcd60e51b815260206004820152602c60248201527f416363657373436f6e74726f6c3a2064656661756c742061646d696e20616c7260448201526b1958591e4819dc985b9d195960a21b60648201526084016200009b565b600380546001600160a01b0319166001600160a01b0383161790555b620003a48282620003a8565b5050565b60008281526001602090815260408083206001600160a01b038516845290915290205460ff16620003a45760008281526001602081815260408084206001600160a01b0386168086529252808420805460ff19169093179092559051339285917f2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d9190a45050565b80516001600160a01b03811681146200044857600080fd5b919050565b600080600080600080600080610100898b0312156200046b57600080fd5b620004768962000430565b97506200048660208a0162000430565b96506200049660408a0162000430565b9550620004a660608a0162000430565b94506080890151935060a08901519250620004c460c08a0162000430565b915060e089015165ffffffffffff81168114620004e057600080fd5b809150509295985092959890939650565b6000826200050f57634e487b7160e01b600052601260045260246000fd5b500690565b60805160a05160c05160e051615c17620005cc60003960008181610b1a01528181611788015281816117fc0152818161281901528181612a190152612a8d0152600081816106c301528181611663015281816118b701528181611c8e01528181611f4f015281816139320152818161396f01528181613aa70152613c9c015260008181610cd701528181613c7b01528181613f260152613f500152600081816109cd0152818161110e0152613e450152615c176000f3fe60806040526004361061041a5760003560e01c80638b4d434b1161021e578063bebaeabe11610123578063d602b9fd116100ab578063eb2b01c31161007a578063eb2b01c314610cc5578063edaafe2014610cf9578063f64c6f3214610d0f578063f7a1f5ff14610d25578063fe196cf814610d3b57600080fd5b8063d602b9fd14610c5d578063d65ea23214610c72578063ddc6326214610c92578063e63ea40814610ca557600080fd5b8063cc8463c8116100f2578063cc8463c814610bc2578063cefc142914610bd7578063cf6eefb714610bec578063d547741f14610c27578063d58ac11f14610c4757600080fd5b8063bebaeabe14610b3c578063c34d97d114610b5c578063c8ad10fb14610b8c578063ca72be2914610ba257600080fd5b8063a62277f0116101a6578063b4a2656911610175578063b4a2656914610a8a578063b5e5e64c14610aaa578063babd37eb14610abf578063bb807e7514610af2578063bc8a72b614610b0857600080fd5b8063a62277f0146109ef578063ad45517d14610a0f578063adc9740c14610a57578063b09c18d714610a6a57600080fd5b806391d14854116101ed57806391d14854146109325780639a82c61514610952578063a1eda53c14610972578063a217fddf146109a6578063a5eb31bf146109bb57600080fd5b80638b4d434b146108bd5780638bdd9beb146108dd5780638da5cb5b146108fd57806390abccf41461091257600080fd5b806336568abe116103245780635c975abb116102ac5780636b4f0b771161027b5780636b4f0b77146108365780637e28882214610849578063842d96f31461085f57806384ef8ffc1461087f578063865e6fd31461089d57600080fd5b80635c975abb146107cb5780635fb8bc56146107e1578063634e93da146107f6578063649a5ec71461081657600080fd5b80634573e3b3116102f35780634573e3b31461073a57806348b6ce5e1461074d5780634972134a146107625780634cd79e0a146107785780634df8a5e71461079a57600080fd5b806336568abe1461069157806336bf3325146106b15780633d9f3163146106e55780633faae3441461070557600080fd5b806310f4686b116103a757806326d976191161037657806326d97619146105d45780632da2c826146105f45780632f2ff15d1461060957806331f50da914610629578063357c13541461064957600080fd5b806310f4686b1461053557806317f3334014610555578063206583ac1461058d578063248a9ca3146105a357600080fd5b806305c9399c116103ee57806305c9399c146104b7578063083c6323146104d75780630aa6220b146104ed5780630dcb8c1a1461050257806310cf3f851461052257600080fd5b80628803d31461041f5780630154cd981461043657806301ffc9a71461045e578063022d63fb1461048e575b600080fd5b34801561042b57600080fd5b50610434610d5b565b005b34801561044257600080fd5b5061044b610dca565b6040519081526020015b60405180910390f35b34801561046a57600080fd5b5061047e6104793660046149f5565b610e46565b6040519015158152602001610455565b34801561049a57600080fd5b50620697805b60405165ffffffffffff9091168152602001610455565b3480156104c357600080fd5b506104346104d2366004614a33565b610e71565b3480156104e357600080fd5b5061044b60175481565b3480156104f957600080fd5b50610434610f90565b34801561050e57600080fd5b5061043461051d366004614a88565b610fa6565b610434610530366004614b5d565b61100e565b34801561054157600080fd5b50610434610550366004614d0a565b61122a565b34801561056157600080fd5b50600d54610575906001600160a01b031681565b6040516001600160a01b039091168152602001610455565b34801561059957600080fd5b5061044b600e5481565b3480156105af57600080fd5b5061044b6105be366004614e47565b6000908152600160208190526040909120015490565b3480156105e057600080fd5b50600a54610575906001600160a01b031681565b34801561060057600080fd5b5061044b61137c565b34801561061557600080fd5b50610434610624366004614e60565b6113b6565b34801561063557600080fd5b50600b54610575906001600160a01b031681565b34801561065557600080fd5b5061067c610664366004614e85565b601c6020526000908152604090205463ffffffff1681565b60405163ffffffff9091168152602001610455565b34801561069d57600080fd5b506104346106ac366004614e60565b611430565b3480156106bd57600080fd5b5061044b7f000000000000000000000000000000000000000000000000000000000000000081565b3480156106f157600080fd5b50600c54610575906001600160a01b031681565b34801561071157600080fd5b50610725610720366004614ea0565b61151a565b60408051928352602083019190915201610455565b610434610748366004614ede565b611889565b34801561075957600080fd5b506104346119e3565b34801561076e57600080fd5b5061044b60165481565b34801561078457600080fd5b5061078d611a84565b6040516104559190614f6f565b3480156107a657600080fd5b506107ba6107b5366004614e47565b611b12565b604051610455959493929190614f82565b3480156107d757600080fd5b5061044b601d5481565b3480156107ed57600080fd5b50610434611bb0565b34801561080257600080fd5b50610434610811366004614fde565b611c34565b34801561082257600080fd5b50610434610831366004614ffb565b611c48565b610434610844366004615023565b611c5c565b34801561085557600080fd5b5061044b60145481565b34801561086b57600080fd5b5061043461087a366004614e47565b611f99565b34801561088b57600080fd5b506003546001600160a01b0316610575565b3480156108a957600080fd5b506104346108b83660046150c9565b612058565b3480156108c957600080fd5b506104346108d836600461513f565b6122d4565b3480156108e957600080fd5b50600954610575906001600160a01b031681565b34801561090957600080fd5b506105756123d0565b34801561091e57600080fd5b5061043461092d366004615189565b6123e4565b34801561093e57600080fd5b5061047e61094d366004614e60565b612495565b34801561095e57600080fd5b506107ba61096d366004614e47565b6124c0565b34801561097e57600080fd5b50610987612507565b6040805165ffffffffffff938416815292909116602083015201610455565b3480156109b257600080fd5b5061044b600081565b3480156109c757600080fd5b506105757f000000000000000000000000000000000000000000000000000000000000000081565b3480156109fb57600080fd5b50610434610a0a3660046151ab565b61255b565b348015610a1b57600080fd5b50610a4a610a2a366004615207565b805160208183018101805160188252928201919093012091525460ff1681565b6040516104559190615259565b610725610a65366004615281565b6126d3565b348015610a7657600080fd5b50610434610a85366004614e47565b6128a7565b348015610a9657600080fd5b50610725610aa5366004614e60565b612920565b348015610ab657600080fd5b50610434612bd2565b348015610acb57600080fd5b5061067c610ada366004614e85565b601b6020526000908152604090205463ffffffff1681565b348015610afe57600080fd5b5061044b60075481565b348015610b1457600080fd5b506105757f000000000000000000000000000000000000000000000000000000000000000081565b348015610b4857600080fd5b50610434610b573660046152b6565b612c33565b348015610b6857600080fd5b5061047e610b77366004614fde565b601a6020526000908152604090205460ff1681565b348015610b9857600080fd5b5061044b60065481565b348015610bae57600080fd5b50610434610bbd366004614e47565b612d28565b348015610bce57600080fd5b506104a0612d96565b348015610be357600080fd5b50610434612df5565b348015610bf857600080fd5b50610c01612e73565b604080516001600160a01b03909316835265ffffffffffff909116602083015201610455565b348015610c3357600080fd5b50610434610c42366004614e60565b612e94565b348015610c5357600080fd5b5061044b60085481565b348015610c6957600080fd5b50610434612f11565b348015610c7e57600080fd5b50610434610c8d366004614a33565b612f24565b610434610ca0366004614e47565b61304d565b348015610cb157600080fd5b50610434610cc0366004615339565b613140565b348015610cd157600080fd5b5061044b7f000000000000000000000000000000000000000000000000000000000000000081565b348015610d0557600080fd5b5061044b60055481565b348015610d1b57600080fd5b5061044b600f5481565b348015610d3157600080fd5b5061044b60155481565b348015610d4757600080fd5b5061078d610d56366004614e47565b613312565b600080516020615bc2833981519152610d738161332b565b6002601d5414610d84576002610d87565b60015b601d8190556040805133815260208101929092527f2d9e22b609aa013375d7aa3ea850989ca303c2abf9fc24c5f45975e1e3753a9191015b60405180910390a150565b6040516284499160e81b815260106004820152600090739e0d7d79735e1c63333128149c7b616a0dc0bbdb906384499100906024015b602060405180830381865af4158015610e1d573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610e41919061537a565b905090565b60006001600160e01b031982166318a4c3c360e11b1480610e6b5750610e6b82613335565b92915050565b600080516020615bc2833981519152610e898161332b565b601b6000846002811115610e9f57610e9f615243565b6002811115610eb057610eb0615243565b815260208101919091526040016000205463ffffffff9081169083161115610eeb576040516358d620b360e01b815260040160405180910390fd5b81601c6000856002811115610f0257610f02615243565b6002811115610f1357610f13615243565b815260200190815260200160002060006101000a81548163ffffffff021916908363ffffffff160217905550826002811115610f5157610f51615243565b60405163ffffffff841681527f60cca38ba894e5ddc4db50e39d1e729d5ae76ddbd3874395ead72add5125bc0f906020015b60405180910390a2505050565b6000610f9b8161332b565b610fa361336a565b50565b6002601d5403610fc9576040516313d0ff5960e31b815260040160405180910390fd5b600054600114610ff45760405162461bcd60e51b8152600401610feb90615393565b60405180910390fd5b6002600055611004838383613377565b5050600160005550565b6000546001146110305760405162461bcd60e51b8152600401610feb90615393565b60026000557ffc8737ab85eb45125971625a9ebdb75cc78e01d5c1fa80c4c6e5203f47bc4fab61105f8161332b565b600160188b8b6040516110739291906153b7565b9081526040519081900360200190205460ff16600481111561109757611097615243565b146110b55760405163fbce7d8f60e01b815260040160405180910390fd5b83156110ea5734156110da5760405163a64d921760e01b815260040160405180910390fd5b6110e5858484613596565b61110a565b84341461110a5760405163b66458d760e01b815260040160405180910390fd5b60007f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316868c8c60048d8d8d604051602401611153969594939291906154a7565b60408051601f198184030181529181526020820180516001600160e01b03166304512a2360e31b1790525161118891906154f6565b60006040518083038185875af1925050503d80600081146111c5576040519150601f19603f3d011682016040523d82523d6000602084013e6111ca565b606091505b50509050806111db576111db615512565b7fd46a7d25717262ee24042f45e4cc24e830907282b10be8c30177e24aab5e55be8b8b87896040516112109493929190615528565b60405180910390a150506001600055505050505050505050565b6001600e540361124d57604051638a4560db60e01b815260040160405180910390fd5b600080516020615bc28339815191526112658161332b565b815160005b8181101561137657600060188583815181106112885761128861554f565b6020026020010151600001516040516112a191906154f6565b9081526040519081900360200190205460ff1660048111156112c5576112c5615243565b146112e3576040516348921c7b60e11b815260040160405180910390fd5b6010739e0d7d79735e1c63333128149c7b616a0dc0bbdb6376f5c13990918684815181106113135761131361554f565b602002602001015160046040518463ffffffff1660e01b815260040161133b939291906155bc565b60006040518083038186803b15801561135357600080fd5b505af4158015611367573d6000803e3d6000fd5b5050505080600101905061126a565b50505050565b6040516284499160e81b815260126004820152600090739e0d7d79735e1c63333128149c7b616a0dc0bbdb90638449910090602401610e00565b816114225760405162461bcd60e51b815260206004820152603660248201527f416363657373436f6e74726f6c3a2063616e2774206469726563746c79206772604482015275616e742064656661756c742061646d696e20726f6c6560501b6064820152608401610feb565b61142c82826136d7565b5050565b8115801561144b57506003546001600160a01b038281169116145b156115105760008061145b612e73565b90925090506001600160a01b03821615801561147e575065ffffffffffff811615155b801561149157504265ffffffffffff8216105b6114fb5760405162461bcd60e51b815260206004820152603560248201527f416363657373436f6e74726f6c3a206f6e6c792063616e2072656e6f756e636560448201527420696e2074776f2064656c6179656420737465707360581b6064820152608401610feb565b50506002805465ffffffffffff60a01b191690555b61142c82826136fd565b6000806002601d5403611540576040516313d0ff5960e31b815260040160405180910390fd5b6000546001146115625760405162461bcd60e51b8152600401610feb90615393565b6002600090815585900361158957604051631f2a200560e01b815260040160405180910390fd5b6001600160a01b0384166115b05760405163d92e233d60e01b815260040160405180910390fd5b600b546000906001600160a01b0316330361164857600b54604051635d043b2960e11b815260048101889052306024820181905260448201526001600160a01b039091169063ba087652906064016020604051808303816000875af115801561161d573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611641919061537a565b905061164b565b50845b611656600182613777565b60145491945092506000907f00000000000000000000000000000000000000000000000000000000000000009061168e908690615607565b611698919061561a565b90508480156116a5575080155b156116c357604051635fa4c85d60e01b815260040160405180910390fd5b6116cb61137c565b8111156116eb576040516315caeb5160e31b815260040160405180910390fd5b60408051838152602081018690526001600160a01b038816917fa126fc6d7777e110f6fc53f11f34b4695af73524f2b2f5585dc81b4e148733f2910160405180910390a2600b546000906001600160a01b0316331461174a573361174c565b305b905061175881866137e5565b831561186c57600a54604051630c29702960e01b81526001600160a01b0390911690630c297029906117b29084907f000000000000000000000000000000000000000000000000000000000000000090899060040161563c565b600060405180830381600087803b1580156117cc57600080fd5b505af11580156117e0573d6000803e3d6000fd5b5050600a54604051631e75e2a960e11b81526001600160a01b037f000000000000000000000000000000000000000000000000000000000000000081169450633cebc5529350611839928692911690899060040161563c565b600060405180830381600087803b15801561185357600080fd5b505af1158015611867573d6000803e3d6000fd5b505050505b611877858888613918565b50506001600055509094909350915050565b600d546001600160a01b031633146118b45760405163b5674cfd60e01b815260040160405180910390fd5b347f000000000000000000000000000000000000000000000000000000000000000081146118f55760405163162908e360e11b815260040160405180910390fd5b6002601884846040516119099291906153b7565b9081526040519081900360200190205460ff16600481111561192d5761192d615243565b1461194b576040516328c5214b60e01b815260040160405180910390fd5b60036018848460405161195f9291906153b7565b908152604051908190036020019020805460ff1916600183600481111561198857611988615243565b0217905550806015600082825461199f9190615607565b90915550506040517f4697c5b19666f0fa70dd3d4b8b68758069307e15f2dff52de0708f9ab0eacaff906119d69085908590615660565b60405180910390a1505050565b6001600e5403611a0657604051638a4560db60e01b815260040160405180910390fd5b600080516020615bc2833981519152611a1e8161332b565b604051631e9708a560e31b815260106004820152739e0d7d79735e1c63333128149c7b616a0dc0bbdb9063f4b845289060240160006040518083038186803b158015611a6957600080fd5b505af4158015611a7d573d6000803e3d6000fd5b5050505050565b60048054611a91906153f0565b80601f0160208091040260200160405190810160405280929190818152602001828054611abd906153f0565b8015611b0a5780601f10611adf57610100808354040283529160200191611b0a565b820191906000526020600020905b815481529060010190602001808311611aed57829003601f168201915b505050505081565b60608060606000806010739e0d7d79735e1c63333128149c7b616a0dc0bbdb6388d5ab9290916004896040518463ffffffff1660e01b8152600401611b5993929190615674565b600060405180830381865af4158015611b76573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f19168201604052611b9e91908101906156e2565b939a9299509097509550909350915050565b600054600114611bd25760405162461bcd60e51b8152600401610feb90615393565b60026000557ffc8737ab85eb45125971625a9ebdb75cc78e01d5c1fa80c4c6e5203f47bc4fab611c018161332b565b6002600e5403611c24576040516378b5fe1360e01b815260040160405180910390fd5b611c2c613c71565b506001600055565b6000611c3f8161332b565b61142c8261408f565b6000611c538161332b565b61142c82614102565b600d546001600160a01b03163314611c875760405163b5674cfd60e01b815260040160405180910390fd5b60405134907f000000000000000000000000000000000000000000000000000000000000000090600090601890611cc1908d908d906153b7565b9081526040519081900360200190205460ff1690506001816004811115611cea57611cea615243565b14158015611d0a57506002816004811115611d0757611d07615243565b14155b15611d28576040516321f03be760e21b815260040160405180910390fd5b8515611d4757611d42611d3b848461577a565b8686613596565b611d67565b818314611d675760405163162908e360e11b815260040160405180910390fd5b6001816004811115611d7b57611d7b615243565b03611eca57606087611e0d57604051635442791360e01b815260126004820152602481018b9052739e0d7d79735e1c63333128149c7b616a0dc0bbdb90635442791390604401600060405180830381865af4158015611dde573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f19168201604052611e06919081019061578d565b9050611e8f565b60405163176d231d60e21b815260126004820152602481018b9052739e0d7d79735e1c63333128149c7b616a0dc0bbdb90635db48c7490604401600060405180830381865af4158015611e64573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f19168201604052611e8c919081019061578d565b90505b80516020820120604051611ea6908e908e906153b7565b604051809103902014611ebb57611ebb615512565b611ec48361416b565b50611ee2565b8160156000828254611edc9190615607565b90915550505b600460188c8c604051611ef69291906153b7565b908152604051908190036020019020805460ff19166001836004811115611f1f57611f1f615243565b02179055507f38dfdd34943d912ef1591f414fa0fd6acbd0ef9b5b6d071908764e7da03c80b68b8b888b611f73817f000000000000000000000000000000000000000000000000000000000000000061577a565b604051611f849594939291906157c1565b60405180910390a15050505050505050505050565b6001600e5403611fbc57604051638a4560db60e01b815260040160405180910390fd5b600080516020615bc2833981519152611fd48161332b565b60405163f3c723c760e01b81526010600482015260248101839052739e0d7d79735e1c63333128149c7b616a0dc0bbdb9063f3c723c790604401600060405180830381865af415801561202b573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f1916820160405261205391908101906157f2565b505050565b600080516020615bc28339815191526120708161332b565b6001600160a01b0382166120975760405163d92e233d60e01b815260040160405180910390fd5b8260058111156120a9576120a9615243565b6040516001600160a01b03841681527e0961cd4320f350803f764de4992b70c8fc5c948b5881a151f883df0af333579060200160405180910390a260018360058111156120f8576120f8615243565b0361211f57600980546001600160a01b0384166001600160a01b0319909116179055505050565b600083600581111561213357612133615243565b0361215a57600a80546001600160a01b0384166001600160a01b0319909116179055505050565b600283600581111561216e5761216e615243565b036121cf57600a54600b546001600160a01b03918216911680156121a1576121a16001600160a01b038316826000614205565b600b80546001600160a01b0319166001600160a01b03868116918217909255611a7d91841690600019614205565b60038360058111156121e3576121e3615243565b0361220a57600c80546001600160a01b0384166001600160a01b0319909116179055505050565b600583600581111561221e5761221e615243565b036122bb57600d80546001600160a01b0319166001600160a01b03841617905560408051600160f81b6020820152600060218201526bffffffffffffffffffffffff19606085901b16602c820152016040516020818303038152906040526004908161228a91906158e9565b507f8f746a1079cc65ea9cd881479b0267d00dc3dceebfa5d13c9beb36863a8741bc60046040516119d691906159a8565b60405163dca3e0e560e01b815260040160405180910390fd5b600080516020615bc28339815191526122ec8161332b565b8260005b818110156123c857600086868381811061230c5761230c61554f565b90506020020160208101906123219190614fde565b6001600160a01b0381166000908152601a60205260409020805460ff1916871580159190911790915590915061238a576040516001600160a01b038216907f0cf877f176d079d5bfa8093032c2b7c02bebde4c25b92a30f796e60f8f3919a090600090a26123bf565b6040516001600160a01b038216907f40bad7be9dd2ade74f56f2ebe2ffe63101f45fea53b5b3309cf7c789c690514590600090a25b506001016122f0565b505050505050565b6000610e416003546001600160a01b031690565b6001600e540361240757604051638a4560db60e01b815260040160405180910390fd5b600080516020615bc283398151915261241f8161332b565b6040516304ab817f60e01b8152601060048201526024810184905260448101839052739e0d7d79735e1c63333128149c7b616a0dc0bbdb906304ab817f9060640160006040518083038186803b15801561247857600080fd5b505af415801561248c573d6000803e3d6000fd5b50505050505050565b60009182526001602090815260408084206001600160a01b0393909316845291905290205460ff1690565b60608060606000806012739e0d7d79735e1c63333128149c7b616a0dc0bbdb6388d5ab9290916004896040518463ffffffff1660e01b8152600401611b5993929190615674565b600354600090600160d01b900465ffffffffffff16801515801561253357504265ffffffffffff821610155b61253f57600080612553565b600354600160a01b900465ffffffffffff16815b915091509091565b6001600e540361257e57604051638a4560db60e01b815260040160405180910390fd5b600080516020615bc28339815191526125968161332b565b606082156126245760405163176d231d60e21b81526010600482015260248101859052739e0d7d79735e1c63333128149c7b616a0dc0bbdb90635db48c7490604401600060405180830381865af41580156125f5573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f1916820160405261261d919081019061578d565b90506126a6565b604051635442791360e01b81526010600482015260248101859052739e0d7d79735e1c63333128149c7b616a0dc0bbdb90635442791390604401600060405180830381865af415801561267b573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f191682016040526126a3919081019061578d565b90505b85856040516126b69291906153b7565b60405180910390208180519060200120146123c8576123c8615512565b6000806002601d54036126f9576040516313d0ff5960e31b815260040160405180910390fd5b60005460011461271b5760405162461bcd60e51b8152600401610feb90615393565b6002600090815534900361274257604051631f2a200560e01b815260040160405180910390fd5b6001600160a01b0384166127695760405163d92e233d60e01b815260040160405180910390fd5b612774600034613777565b909250905061278f836127875784612789565b305b8361427c565b821561280e57600b54604051636e553f6560e01b8152600481018490526001600160a01b03868116602483015290911690636e553f65906044016020604051808303816000875af11580156127e8573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061280c919061537a565b505b801561283e5761283e7f00000000000000000000000000000000000000000000000000000000000000008261427c565b6128473461416b565b6040805134815260208101849052908101829052831515906001600160a01b0386169033907f53688f4835c0a3d757a2c2fb4f73147d7fb253f5d5ca9f0b420e6831704c74bd9060600160405180910390a4600160005590939092509050565b600080516020615bc28339815191526128bf8161332b565b620f42408211156128e3576040516395e28b8560e01b815260040160405180910390fd5b60078290556040518281527f60e884e0954bf3325b419fc0af3a6a75091d749f3a2af01d8657bb94ffc4beff906020015b60405180910390a15050565b6000806002601d5403612946576040516313d0ff5960e31b815260040160405180910390fd5b6000546001146129685760405162461bcd60e51b8152600401610feb90615393565b6002600090815584900361298f57604051631f2a200560e01b815260040160405180910390fd5b6001600160a01b0383166129b65760405163d92e233d60e01b815260040160405180910390fd5b6129c1600285613777565b60055491935091508211156129e95760405163664f459f60e11b815260040160405180910390fd5b8015612afd57600a54604051630c29702960e01b81526001600160a01b0390911690630c29702990612a439033907f000000000000000000000000000000000000000000000000000000000000000090869060040161563c565b600060405180830381600087803b158015612a5d57600080fd5b505af1158015612a71573d6000803e3d6000fd5b5050600a54604051631e75e2a960e11b81526001600160a01b037f000000000000000000000000000000000000000000000000000000000000000081169450633cebc5529350612aca923392911690869060040161563c565b600060405180830381600087803b158015612ae457600080fd5b505af1158015612af8573d6000803e3d6000fd5b505050505b612b0733836137e5565b8160056000828254612b19919061577a565b90915550506040516000906001600160a01b0385169084908381818185875af1925050503d8060008114612b69576040519150601f19603f3d011682016040523d82523d6000602084013e612b6e565b606091505b5050905080612b7f57612b7f615512565b60408051868152602081018590526001600160a01b038616917fef65d72849d1cca64b0040a01907b1f330f86a9d3e01856ce6bd55cdb8a16e0c910160405180910390a250600160005590939092509050565b600080516020615bc2833981519152612bea8161332b565b6001600e5414612bfb576001612bfe565b60025b600e8190556040519081527f66397ea162e103ec543314596384be5631955c423f5e2ca581e800e9592b608190602001610dbf565b6002601d5403612c56576040516313d0ff5960e31b815260040160405180910390fd5b600054600114612c785760405162461bcd60e51b8152600401610feb90615393565b6002600090815584908390829003612ca35760405163521299a960e01b815260040160405180910390fd5b808214612cc357604051632b477e7160e11b815260040160405180910390fd5b60005b82811015612d1957612d09888883818110612ce357612ce361554f565b90506020020135878784818110612cfc57612cfc61554f565b9050602002013586613377565b612d12816159bb565b9050612cc6565b50506001600055505050505050565b600080516020615bc2833981519152612d408161332b565b81600003612d61576040516375463e0d60e01b815260040160405180910390fd5b60088290556040518281527f52880fce23cacdff91c59389d5388b972e58527b17524a84addefcfea80ce9a190602001612914565b600354600090600160d01b900465ffffffffffff168015158015612dc157504265ffffffffffff8216105b612ddc57600254600160d01b900465ffffffffffff16612def565b600354600160a01b900465ffffffffffff165b91505090565b6000612dff612e73565b509050336001600160a01b03821614612e6b5760405162461bcd60e51b815260206004820152602860248201527f416363657373436f6e74726f6c3a2070656e64696e672061646d696e206d75736044820152671d081858d8d95c1d60c21b6064820152608401610feb565b610fa36142b5565b6002546001600160a01b03811691600160a01b90910465ffffffffffff1690565b81612f075760405162461bcd60e51b815260206004820152603760248201527f416363657373436f6e74726f6c3a2063616e2774206469726563746c7920726560448201527f766f6b652064656661756c742061646d696e20726f6c650000000000000000006064820152608401610feb565b61142c8282614380565b6000612f1c8161332b565b610fa36143a6565b600080516020615bc2833981519152612f3c8161332b565b601c6000846002811115612f5257612f52615243565b6002811115612f6357612f63615243565b815260208101919091526040016000205463ffffffff9081169083161080612f935750620f42408263ffffffff16115b15612fb15760405163a51d0c8160e01b815260040160405180910390fd5b81601b6000856002811115612fc857612fc8615243565b6002811115612fd957612fd9615243565b815260200190815260200160002060006101000a81548163ffffffff021916908363ffffffff16021790555082600281111561301757613017615243565b60405163ffffffff841681527f2c8a1b11f988520b010608bf85a9a26038b520fdad549d3b58433a5ca5fba15190602001610f83565b600d546001600160a01b031633146130785760405163b5674cfd60e01b815260040160405180910390fd5b3415610fa3576017819055600b54613099906001600160a01b03163461427c565b600b60009054906101000a90046001600160a01b03166001600160a01b0316630c51dde46040518163ffffffff1660e01b8152600401600060405180830381600087803b1580156130e957600080fd5b505af11580156130fd573d6000803e3d6000fd5b5050505061310a3461416b565b60408051348152602081018390527f6c8433a8e155f0af04dba058d4e4695f7da554578963d876bdf4a6d8d6399d9c9101610dbf565b600080516020615bc28339815191526131588161332b565b6001600e540361317b57604051638a4560db60e01b815260040160405180910390fd5b6001601d540361319e57604051636cd6020160e01b815260040160405180910390fd5b6001600160a01b0384166131c55760405163d92e233d60e01b815260040160405180910390fd5b816000036131e657604051631f2a200560e01b815260040160405180910390fd5b600a546001600160a01b03908116908416036132155760405163c1ab6dc160e01b815260040160405180910390fd5b6001600160a01b0383166132ab57600061322f834761577a565b905080600f54111561324157600f8190555b6000856001600160a01b03168460405160006040518083038185875af1925050503d806000811461328e576040519150601f19603f3d011682016040523d82523d6000602084013e613293565b606091505b50509050806132a4576132a4615512565b50506132bf565b6132bf6001600160a01b03841685846143b1565b826001600160a01b0316846001600160a01b03167f9495d03190a79a43e534c9e328ff322f6283261383f5f19c809564f6ad5a57b38460405161330491815260200190565b60405180910390a350505050565b60196020526000908152604090208054611a91906153f0565b610fa38133614429565b60006001600160e01b03198216637965db0b60e01b1480610e6b57506301ffc9a760e01b6001600160e01b0319831614610e6b565b613375600080614482565b565b8160000361339857604051631f2a200560e01b815260040160405180910390fd5b6001600160a01b0381166133bf5760405163d92e233d60e01b815260040160405180910390fd5b60008381526019602052604080822090516018916133dc916159d4565b9081526040519081900360200190205460ff169050600381600481111561340557613405615243565b141580156134255750600481600481111561342257613422615243565b14155b15613443576040516314cb5a8b60e01b815260040160405180910390fd5b82601554101561346657604051632c1d501360e11b815260040160405180910390fd5b8260156000828254613478919061577a565b9091555050600954604051637a94c56560e11b815233600482015260248101869052604481018590526001600160a01b039091169063f5298aca90606401600060405180830381600087803b1580156134d057600080fd5b505af11580156134e4573d6000803e3d6000fd5b505050506000826001600160a01b03168460405160006040518083038185875af1925050503d8060008114613535576040519150601f19603f3d011682016040523d82523d6000602084013e61353a565b606091505b505090508061354b5761354b615512565b60408051868152602081018690526001600160a01b038516917fb12ec230ea9bdc2847d084f44c404df9f15811b22a0b58c4f869e1c56e14bf3b910160405180910390a25050505050565b8260055410156135b95760405163664f459f60e11b815260040160405180910390fd5b806000805b828110156136a957601a60008686848181106135dc576135dc61554f565b6135f29260206040909202019081019150614fde565b6001600160a01b0316815260208101919091526040016000205460ff1661362c576040516309e58bbb60e11b815260040160405180910390fd5b84848281811061363e5761363e61554f565b90506040020160200135826136539190615607565b91506136a185858381811061366a5761366a61554f565b6136809260206040909202019081019150614fde565b8686848181106136925761369261554f565b905060400201602001356137e5565b6001016135be565b508481146136b9576136b9615512565b84600560008282546136cb919061577a565b90915550505050505050565b600082815260016020819052604090912001546136f38161332b565b6120538383614542565b6001600160a01b038116331461376d5760405162461bcd60e51b815260206004820152602f60248201527f416363657373436f6e74726f6c3a2063616e206f6e6c792072656e6f756e636560448201526e103937b632b9903337b91039b2b63360891b6064820152608401610feb565b61142c82826145ec565b600080620f4240601c600086600281111561379457613794615243565b60028111156137a5576137a5615243565b81526020810191909152604001600020546137c69063ffffffff1685615a4a565b6137d0919061561a565b90506137dc818461577a565b91509250929050565b600a54604051632770a7eb60e21b81526001600160a01b0384811660048301526024820184905290911690639dc29fac906044015b600060405180830381600087803b15801561383457600080fd5b505af1158015613848573d6000803e3d6000fd5b505050506000620f4240600754600a60009054906101000a90046001600160a01b03166001600160a01b03166318160ddd6040518163ffffffff1660e01b8152600401602060405180830381865afa1580156138a8573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906138cc919061537a565b6138d69190615a4a565b6138e0919061561a565b60068190556040518181529091507f8b1dd71841cb6ebc4652591239fb967e36b753ee615f32360a27d22ad66df73f906020016119d6565b826014600082825461392a9190615607565b90915550505b7f000000000000000000000000000000000000000000000000000000000000000060145461395e919061561a565b15613bc657601454600090613993857f0000000000000000000000000000000000000000000000000000000000000000615607565b61399d919061577a565b60095460165460405163731133e960e01b81526001600160a01b0387811660048301526024820192909252604481018490526080606482015260006084820152929350169063731133e99060a401600060405180830381600087803b158015613a0557600080fd5b505af1158015613a19573d6000803e3d6000fd5b505060405163031af78360e21b815260009250739e0d7d79735e1c63333128149c7b616a0dc0bbdb9150630c6bde0c90613a5a906012906004908101615a61565b600060405180830381865af4158015613a77573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f19168201604052613a9f91908101906156e2565b5050505090507f000000000000000000000000000000000000000000000000000000000000000060146000828254613ad7919061577a565b90915550613ae79050828661577a565b600c54604051631ca9451360e11b81529196506001600160a01b0316906339528a2690613b18908490600401614f6f565b600060405180830381600087803b158015613b3257600080fd5b505af1158015613b46573d6000803e3d6000fd5b5050601680548493506019925060009182613b60836159bb565b9190505581526020019081526020016000209081613b7e91906158e9565b506002601882604051613b9191906154f6565b908152604051908190036020019020805460ff19166001836004811115613bba57613bba615243565b02179055505050613930565b808015613bd35750600083115b15613bf157604051633352735960e11b815260040160405180910390fd5b82156120535760095460165460405163731133e960e01b81526001600160a01b038581166004830152602482019290925260448101869052608060648201526000608482015291169063731133e99060a401600060405180830381600087803b158015613c5d57600080fd5b505af115801561248c573d6000803e3d6000fd5b6008546000613cc07f00000000000000000000000000000000000000000000000000000000000000007f000000000000000000000000000000000000000000000000000000000000000061577a565b90505b6040516284499160e81b815260106004820152739e0d7d79735e1c63333128149c7b616a0dc0bbdb90638449910090602401602060405180830381865af4158015613d12573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190613d36919061537a565b15801590613d46575080600f5410155b8015613d525750600082115b1561142c5760008060008060006010739e0d7d79735e1c63333128149c7b616a0dc0bbdb630c6bde0c909160046040518363ffffffff1660e01b8152600401613d9c929190615a61565b600060405180830381865af4158015613db9573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f19168201604052613de191908101906156e2565b9398509196509450925090506000601886604051613dff91906154f6565b9081526040519081900360200190205460ff166004811115613e2357613e23615243565b14613e41576040516348921c7b60e11b815260040160405180910390fd5b60007f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03168787878787604051602401613e859493929190615a7a565b60408051601f198184030181529181526020820180516001600160e01b03166304512a2360e31b17905251613eba91906154f6565b60006040518083038185875af1925050503d8060008114613ef7576040519150601f19603f3d011682016040523d82523d6000602084013e613efc565b606091505b5050905080613f0d57613f0d615512565b86600f6000828254613f1f919061577a565b90915550507f000000000000000000000000000000000000000000000000000000000000000015613f7457613f74827f000000000000000000000000000000000000000000000000000000000000000061427c565b876001900397506001601887604051613f8d91906154f6565b908152604051908190036020019020805460ff19166001836004811115613fb657613fb6615243565b021790555060408051608081018252878152602081018690528082018590526001600160a01b038416606082015290516376f5c13960e01b8152739e0d7d79735e1c63333128149c7b616a0dc0bbdb916376f5c1399161401d916012918a90600401615ac5565b60006040518083038186803b15801561403557600080fd5b505af4158015614049573d6000803e3d6000fd5b505050507f9990dac99d880d1fcaac485cb74ce1cad6b3fc2eecb7d6550bf6760432b8cdf48660405161407c9190614f6f565b60405180910390a1505050505050613cc3565b6000614099612d96565b6140a242614627565b6140ac9190615af0565b90506140b88282614692565b60405165ffffffffffff821681526001600160a01b038316907f3377dc44241e779dd06afab5b788a35ca5f3b778836e2990bdb26a2a4b2e5ed69060200160405180910390a25050565b600061410d82614711565b61411642614627565b6141209190615af0565b905061412c8282614482565b6040805165ffffffffffff8085168252831660208201527ff1038c18cf84a56e432fdbfaf746924b7ea511dfe03a6506a0ceba4888788d9b9101612914565b60006005546006541161417f57600061418f565b60055460065461418f919061577a565b90508181156141db5780821115806141a757816141a9565b825b600560008282546141ba9190615607565b909155508190506141cb57816141cd565b825b6141d7908361577a565b9150505b80600f60008282546141ed9190615607565b9091555050600e546000190161205357612053613c71565b600060405163095ea7b360e01b8152836004820152826024820152602060006044836000895af13d15601f3d11600160005114161716915050806113765760405162461bcd60e51b815260206004820152600e60248201526d1054141493d59157d1905253115160921b6044820152606401610feb565b600a546040516340c10f1960e01b81526001600160a01b03848116600483015260248201849052909116906340c10f199060440161381a565b6000806142c0612e73565b915091506142d58165ffffffffffff16151590565b80156142e857504265ffffffffffff8216105b6143455760405162461bcd60e51b815260206004820152602860248201527f416363657373436f6e74726f6c3a207472616e736665722064656c6179206e6f6044820152671d081c185cdcd95960c21b6064820152608401610feb565b614361600061435c6003546001600160a01b031690565b6145ec565b61436c600083614542565b5050600280546001600160d01b0319169055565b6000828152600160208190526040909120015461439c8161332b565b61205383836145ec565b613375600080614692565b600060405163a9059cbb60e01b8152836004820152826024820152602060006044836000895af13d15601f3d11600160005114161716915050806113765760405162461bcd60e51b815260206004820152600f60248201526e1514905394d1915497d19052531151608a1b6044820152606401610feb565b6144338282612495565b61142c5761444081614760565b61444b836020614772565b60405160200161445c929190615b16565b60408051601f198184030181529082905262461bcd60e51b8252610feb91600401614f6f565b600354600160d01b900465ffffffffffff168015614505574265ffffffffffff821610156144db57600354600280546001600160d01b0316600160a01b90920465ffffffffffff16600160d01b02919091179055614505565b6040517f2b1fa2edafe6f7b9e97c1a9e0c3660e645beb2dcaa2d45bdbf9beaf5472e1ec590600090a15b50600380546001600160a01b0316600160a01b65ffffffffffff948516026001600160d01b031617600160d01b9290931691909102919091179055565b816145e257600061455b6003546001600160a01b031690565b6001600160a01b0316146145c65760405162461bcd60e51b815260206004820152602c60248201527f416363657373436f6e74726f6c3a2064656661756c742061646d696e20616c7260448201526b1958591e4819dc985b9d195960a21b6064820152608401610feb565b600380546001600160a01b0319166001600160a01b0383161790555b61142c828261490d565b8115801561460757506003546001600160a01b038281169116145b1561461d57600380546001600160a01b03191690555b61142c8282614978565b600065ffffffffffff82111561468e5760405162461bcd60e51b815260206004820152602660248201527f53616665436173743a2076616c756520646f65736e27742066697420696e203460448201526538206269747360d01b6064820152608401610feb565b5090565b600061469c612e73565b6002805465ffffffffffff8616600160a01b026001600160d01b03199091166001600160a01b0388161717905591506146de90508165ffffffffffff16151590565b15612053576040517f8886ebfc4259abdbc16601dd8fb5678e54878f47b3c34836cfc51154a960510990600090a1505050565b60008061471c612d96565b90508065ffffffffffff168365ffffffffffff16116147445761473f8382615b8b565b614759565b61475965ffffffffffff8416620697806149df565b9392505050565b6060610e6b6001600160a01b03831660145b60606000614781836002615a4a565b61478c906002615607565b6001600160401b038111156147a3576147a3614c1f565b6040519080825280601f01601f1916602001820160405280156147cd576020820181803683370190505b509050600360fc1b816000815181106147e8576147e861554f565b60200101906001600160f81b031916908160001a905350600f60fb1b816001815181106148175761481761554f565b60200101906001600160f81b031916908160001a905350600061483b846002615a4a565b614846906001615607565b90505b60018111156148be576f181899199a1a9b1b9c1cb0b131b232b360811b85600f166010811061487a5761487a61554f565b1a60f81b8282815181106148905761489061554f565b60200101906001600160f81b031916908160001a90535060049490941c936148b781615baa565b9050614849565b5083156147595760405162461bcd60e51b815260206004820181905260248201527f537472696e67733a20686578206c656e67746820696e73756666696369656e746044820152606401610feb565b6149178282612495565b61142c5760008281526001602081815260408084206001600160a01b0386168086529252808420805460ff19169093179092559051339285917f2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d9190a45050565b6149828282612495565b1561142c5760008281526001602090815260408083206001600160a01b0385168085529252808320805460ff1916905551339285917ff6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b9190a45050565b60008183106149ee5781614759565b5090919050565b600060208284031215614a0757600080fd5b81356001600160e01b03198116811461475957600080fd5b803560038110614a2e57600080fd5b919050565b60008060408385031215614a4657600080fd5b614a4f83614a1f565b9150602083013563ffffffff81168114614a6857600080fd5b809150509250929050565b6001600160a01b0381168114610fa357600080fd5b600080600060608486031215614a9d57600080fd5b83359250602084013591506040840135614ab681614a73565b809150509250925092565b60008083601f840112614ad357600080fd5b5081356001600160401b03811115614aea57600080fd5b602083019150836020828501011115614b0257600080fd5b9250929050565b80358015158114614a2e57600080fd5b60008083601f840112614b2b57600080fd5b5081356001600160401b03811115614b4257600080fd5b6020830191508360208260061b8501011115614b0257600080fd5b600080600080600080600080600060c08a8c031215614b7b57600080fd5b89356001600160401b0380821115614b9257600080fd5b614b9e8d838e01614ac1565b909b50995060208c0135915080821115614bb757600080fd5b614bc38d838e01614ac1565b909950975060408c0135965060608c01359550879150614be560808d01614b09565b945060a08c0135915080821115614bfb57600080fd5b50614c088c828d01614b19565b915080935050809150509295985092959850929598565b634e487b7160e01b600052604160045260246000fd5b604051608081016001600160401b0381118282101715614c5757614c57614c1f565b60405290565b604051601f8201601f191681016001600160401b0381118282101715614c8557614c85614c1f565b604052919050565b60006001600160401b03821115614ca657614ca6614c1f565b50601f01601f191660200190565b600082601f830112614cc557600080fd5b8135614cd8614cd382614c8d565b614c5d565b818152846020838601011115614ced57600080fd5b816020850160208301376000918101602001919091529392505050565b60006020808385031215614d1d57600080fd5b82356001600160401b0380821115614d3457600080fd5b818501915085601f830112614d4857600080fd5b813581811115614d5a57614d5a614c1f565b8060051b614d69858201614c5d565b9182528381018501918581019089841115614d8357600080fd5b86860192505b83831015614e3a57823585811115614da15760008081fd5b86016080818c03601f1901811315614db95760008081fd5b614dc1614c35565b8983013588811115614dd35760008081fd5b614de18e8c83870101614cb4565b82525060408084013589811115614df85760008081fd5b614e068f8d83880101614cb4565b838d015250606084810135828401529383013593614e2385614a73565b820193909352845250509186019190860190614d89565b9998505050505050505050565b600060208284031215614e5957600080fd5b5035919050565b60008060408385031215614e7357600080fd5b823591506020830135614a6881614a73565b600060208284031215614e9757600080fd5b61475982614a1f565b600080600060608486031215614eb557600080fd5b833592506020840135614ec781614a73565b9150614ed560408501614b09565b90509250925092565b60008060208385031215614ef157600080fd5b82356001600160401b03811115614f0757600080fd5b614f1385828601614ac1565b90969095509350505050565b60005b83811015614f3a578181015183820152602001614f22565b50506000910152565b60008151808452614f5b816020860160208601614f1f565b601f01601f19169290920160200192915050565b6020815260006147596020830184614f43565b60a081526000614f9560a0830188614f43565b8281036020840152614fa78188614f43565b90508281036040840152614fbb8187614f43565b606084019590955250506001600160a01b03919091166080909101529392505050565b600060208284031215614ff057600080fd5b813561475981614a73565b60006020828403121561500d57600080fd5b813565ffffffffffff8116811461475957600080fd5b60008060008060008060008060c0898b03121561503f57600080fd5b88356001600160401b038082111561505657600080fd5b6150628c838d01614ac1565b909a50985060208b0135975060408b0135965088915061508460608c01614b09565b955061509260808c01614b09565b945060a08b01359150808211156150a857600080fd5b506150b58b828c01614b19565b999c989b5096995094979396929594505050565b600080604083850312156150dc57600080fd5b8235600681106150eb57600080fd5b91506020830135614a6881614a73565b60008083601f84011261510d57600080fd5b5081356001600160401b0381111561512457600080fd5b6020830191508360208260051b8501011115614b0257600080fd5b60008060006040848603121561515457600080fd5b83356001600160401b0381111561516a57600080fd5b615176868287016150fb565b9094509250614ed5905060208501614b09565b6000806040838503121561519c57600080fd5b50508035926020909101359150565b600080600080606085870312156151c157600080fd5b84356001600160401b038111156151d757600080fd5b6151e387828801614ac1565b909550935050602085013591506151fc60408601614b09565b905092959194509250565b60006020828403121561521957600080fd5b81356001600160401b0381111561522f57600080fd5b61523b84828501614cb4565b949350505050565b634e487b7160e01b600052602160045260246000fd5b602081016005831061527b57634e487b7160e01b600052602160045260246000fd5b91905290565b6000806040838503121561529457600080fd5b823561529f81614a73565b91506152ad60208401614b09565b90509250929050565b6000806000806000606086880312156152ce57600080fd5b85356001600160401b03808211156152e557600080fd5b6152f189838a016150fb565b9097509550602088013591508082111561530a57600080fd5b50615317888289016150fb565b909450925050604086013561532b81614a73565b809150509295509295909350565b60008060006060848603121561534e57600080fd5b833561535981614a73565b9250602084013561536981614a73565b929592945050506040919091013590565b60006020828403121561538c57600080fd5b5051919050565b6020808252600a90820152695245454e5452414e435960b01b604082015260600190565b8183823760009101908152919050565b81835281816020850137506000828201602090810191909152601f909101601f19169091010190565b600181811c9082168061540457607f821691505b60208210810361542457634e487b7160e01b600052602260045260246000fd5b50919050565b60008154615437816153f0565b808552602060018381168015615454576001811461546e5761549c565b60ff1985168884015283151560051b88018301955061549c565b866000528260002060005b858110156154945781548a8201860152908301908401615479565b890184019650505b505050505092915050565b6080815260006154bb60808301888a6153c7565b82810360208401526154cd818861542a565b905082810360408401526154e28186886153c7565b915050826060830152979650505050505050565b60008251615508818460208701614f1f565b9190910192915050565b634e487b7160e01b600052600160045260246000fd5b60608152600061553c6060830186886153c7565b9315156020830152506040015292915050565b634e487b7160e01b600052603260045260246000fd5b600081516080845261557a6080850182614f43565b9050602083015184820360208601526155938282614f43565b604085810151908701526060948501516001600160a01b03169490950193909352509192915050565b8381526060602082015260006155d56060830185615565565b82810360408401526155e7818561542a565b9695505050505050565b634e487b7160e01b600052601160045260246000fd5b80820180821115610e6b57610e6b6155f1565b60008261563757634e487b7160e01b600052601260045260246000fd5b500490565b6001600160a01b039384168152919092166020820152604081019190915260600190565b60208152600061523b6020830184866153c7565b83815260606020820152600061568d606083018561542a565b9050826040830152949350505050565b600082601f8301126156ae57600080fd5b81516156bc614cd382614c8d565b8181528460208386010111156156d157600080fd5b61523b826020830160208701614f1f565b600080600080600060a086880312156156fa57600080fd5b85516001600160401b038082111561571157600080fd5b61571d89838a0161569d565b9650602088015191508082111561573357600080fd5b61573f89838a0161569d565b9550604088015191508082111561575557600080fd5b506157628882890161569d565b93505060608601519150608086015161532b81614a73565b81810381811115610e6b57610e6b6155f1565b60006020828403121561579f57600080fd5b81516001600160401b038111156157b557600080fd5b61523b8482850161569d565b6080815260006157d56080830187896153c7565b941515602083015250604081019290925260609091015292915050565b60006020828403121561580457600080fd5b81516001600160401b038082111561581b57600080fd5b908301906080828603121561582f57600080fd5b615837614c35565b82518281111561584657600080fd5b6158528782860161569d565b82525060208301518281111561586757600080fd5b6158738782860161569d565b602083015250604083015160408201526060830151925061589383614a73565b6060810192909252509392505050565b601f82111561205357600081815260208120601f850160051c810160208610156158ca5750805b601f850160051c820191505b818110156123c8578281556001016158d6565b81516001600160401b0381111561590257615902614c1f565b6159168161591084546153f0565b846158a3565b602080601f83116001811461594b57600084156159335750858301515b600019600386901b1c1916600185901b1785556123c8565b600085815260208120601f198616915b8281101561597a5788860151825594840194600190910190840161595b565b50858210156159985787850151600019600388901b60f8161c191681555b5050505050600190811b01905550565b602081526000614759602083018461542a565b6000600182016159cd576159cd6155f1565b5060010190565b60008083546159e2816153f0565b600182811680156159fa5760018114615a0f57615a3e565b60ff1984168752821515830287019450615a3e565b8760005260208060002060005b85811015615a355781548a820152908401908201615a1c565b50505082870194505b50929695505050505050565b8082028115828204841417610e6b57610e6b6155f1565b82815260406020820152600061523b604083018461542a565b608081526000615a8d6080830187614f43565b8281036020840152615a9f8187614f43565b90508281036040840152615ab38186614f43565b91505082606083015295945050505050565b838152606060208201526000615ade6060830185615565565b82810360408401526155e78185614f43565b65ffffffffffff818116838216019080821115615b0f57615b0f6155f1565b5092915050565b7f416363657373436f6e74726f6c3a206163636f756e7420000000000000000000815260008351615b4e816017850160208801614f1f565b7001034b99036b4b9b9b4b733903937b6329607d1b6017918401918201528351615b7f816028840160208801614f1f565b01602801949350505050565b65ffffffffffff828116828216039080821115615b0f57615b0f6155f1565b600081615bb957615bb96155f1565b50600019019056fe71840dc4906352362b0cdaf79870196c8e42acafade72d5d5a6d59291253ceb1a2646970667358221220784919cd6d3a2513dfc7d963c8632c35067de96881fb62cec6993f9e7a1ec00b64736f6c6343000813003300000000000000000000000004c154b66cb340f3ae24111cc767e0184ed00cc6000000000000000000000000e8ea8990643a0431e4b28f7f7f6878aab88fe42400000000000000000000000000000000219ab540356cbb839cbe05303d7705fa0000000000000000000000005bf2419a33f82f4c1f075b4006d7fc4104c43868000000000000000000000000000000000000000000000001bc16d674ec8000000000000000000000000000000000000000000000000000000de0b6b3a7640000000000000000000000000000177d685384aa1ac5aba41b7e649f9fa0be717fdb0000000000000000000000000000000000000000000000000000000000000000
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
00000000000000000000000004c154b66cb340f3ae24111cc767e0184ed00cc6000000000000000000000000e8ea8990643a0431e4b28f7f7f6878aab88fe42400000000000000000000000000000000219ab540356cbb839cbe05303d7705fa0000000000000000000000005bf2419a33f82f4c1f075b4006d7fc4104c43868000000000000000000000000000000000000000000000001bc16d674ec8000000000000000000000000000000000000000000000000000000de0b6b3a7640000000000000000000000000000177d685384aa1ac5aba41b7e649f9fa0be717fdb0000000000000000000000000000000000000000000000000000000000000000
-----Decoded View---------------
Arg [0] : _pxEth (address): 0x04C154b66CB340F3Ae24111CC767e0184Ed00Cc6
Arg [1] : _admin (address): 0xe8eA8990643A0431E4B28F7F7f6878aaB88fE424
Arg [2] : _beaconChainDepositContract (address): 0x00000000219ab540356cBB839Cbe05303d7705Fa
Arg [3] : _upxEth (address): 0x5BF2419a33f82F4C1f075B4006d7fC4104C43868
Arg [4] : _depositSize (uint256): 32000000000000000000
Arg [5] : _preDepositAmount (uint256): 1000000000000000000
Arg [6] : _pirexFees (address): 0x177D685384AA1Ac5ABA41b7E649F9fA0Be717fdb
Arg [7] : _initialDelay (uint48): 0
-----Encoded View---------------
8 Constructor Arguments found :
Arg [0] : 00000000000000000000000004c154b66cb340f3ae24111cc767e0184ed00cc6
Arg [1] : 000000000000000000000000e8ea8990643a0431e4b28f7f7f6878aab88fe424
Arg [2] : 00000000000000000000000000000000219ab540356cbb839cbe05303d7705fa
Arg [3] : 0000000000000000000000005bf2419a33f82f4c1f075b4006d7fc4104c43868
Arg [4] : 000000000000000000000000000000000000000000000001bc16d674ec800000
Arg [5] : 0000000000000000000000000000000000000000000000000de0b6b3a7640000
Arg [6] : 000000000000000000000000177d685384aa1ac5aba41b7e649f9fa0be717fdb
Arg [7] : 0000000000000000000000000000000000000000000000000000000000000000
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 30 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|---|---|---|---|---|
ETH | Ether (ETH) | 100.00% | $3,838.03 | 5,134.4849 | $19,706,317.61 |
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.