Source Code
Overview
S Balance
0 SS Value
$0.00Cross-Chain Transactions
Loading...
Loading
Contract Name:
EmergencyFacet
Compiler Version
v0.8.26+commit.8a97fa7a
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import "../../PetalsVault.sol";
import "../../storage/PetalsStorageLayout.sol";
import "../../00_libraries/types.sol";
import "../../00_libraries/RoleChecker.sol";
/**
* @title EmergencyFacet
* @author Petals Protocol
* @notice Handles all emergency operations for the Petals Protocol Diamond
* @dev Extracted from ControllerFacet to reduce contract size and isolate critical emergency logic
*
* This facet contains emergency functionality:
* - Protocol-wide panic (pause all vaults of a protocol)
* - Protocol-wide unpause (resume all vaults of a protocol)
* - Fault-tolerant batch operations
*
* Security:
* - All functions require MASTER_ROLE
* - ReentrancyGuard protects against reentrancy attacks
* - Continues operation even if individual vaults fail (fault-tolerant)
*/
contract EmergencyFacet is ReentrancyGuard {
// ============ Access Control ============
modifier onlyRole(uint64 role) {
if (!RoleChecker.hasRole(role, msg.sender)) {
revert UnauthorizedUpdate();
}
_;
}
// ============ Events ============
event ProtocolPanicInitiated(
bytes32 indexed baseProtocol,
uint256 totalVaults,
uint256 successCount,
uint256 failureCount
);
event ProtocolUnpaused(
bytes32 indexed baseProtocol,
uint256 totalVaults,
uint256 successCount,
uint256 failureCount
);
event VaultPanicFailed(address indexed vault, bytes reason);
event VaultUnpauseFailed(address indexed vault, bytes reason);
// ============ PROTOCOL-WIDE EMERGENCY OPERATIONS ============
/**
* @notice Emergency panic for all vaults of a specific underlying protocol
* @dev Uses direct protocol→vault mapping for O(n) complexity where n = vaults in protocol
* Fault-tolerant: continues even if individual vaults fail to panic
* @param baseProtocol The base protocol to panic (e.g., bytes32("Shadow"))
* @return totalVaults Total vaults in this protocol
* @return successCount Number of vaults successfully panicked
* @return failureCount Number of vaults that failed to panic
*/
function panicProtocol(bytes32 baseProtocol)
external
onlyRole(RoleChecker.MASTER_ROLE)
nonReentrant
returns (
uint256 totalVaults,
uint256 successCount,
uint256 failureCount
)
{
PetalsStorageLayout.AppStorage storage s = PetalsStorageLayout.getStorage();
// Direct O(1) lookup of vaults for this protocol
address[] storage protocolVaults = s.vaultsByProtocol[baseProtocol];
totalVaults = protocolVaults.length;
// Verify protocol has vaults
if (totalVaults == 0) revert ProtocolNotFound(baseProtocol);
// Iterate only the relevant vaults (not all vaults!)
for (uint256 i = 0; i < totalVaults;) {
address vault = protocolVaults[i];
// Try to pause vault (fault-tolerant)
try PetalsVault(vault).pause() {
successCount++;
} catch (bytes memory reason) {
failureCount++;
emit VaultPanicFailed(vault, reason);
}
unchecked { ++i; }
}
emit ProtocolPanicInitiated(
baseProtocol,
totalVaults,
successCount,
failureCount
);
}
/**
* @notice Unpause all vaults for a specific protocol after emergency resolution
* @dev Mirror of panicProtocol for recovery operations
* @param baseProtocol The base protocol to unpause
* @return totalVaults Total vaults in this protocol
* @return successCount Number of vaults successfully unpaused
* @return failureCount Number of vaults that failed to unpause
*/
function unpauseProtocol(bytes32 baseProtocol)
external
onlyRole(RoleChecker.MASTER_ROLE)
nonReentrant
returns (
uint256 totalVaults,
uint256 successCount,
uint256 failureCount
)
{
PetalsStorageLayout.AppStorage storage s = PetalsStorageLayout.getStorage();
address[] storage protocolVaults = s.vaultsByProtocol[baseProtocol];
totalVaults = protocolVaults.length;
if (totalVaults == 0) revert ProtocolNotFound(baseProtocol);
for (uint256 i = 0; i < totalVaults;) {
address vault = protocolVaults[i];
try PetalsVault(vault).unpause() {
successCount++;
} catch (bytes memory reason) {
failureCount++;
emit VaultUnpauseFailed(vault, reason);
}
unchecked { ++i; }
}
emit ProtocolUnpaused(
baseProtocol,
totalVaults,
successCount,
failureCount
);
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/ReentrancyGuard.sol)
pragma solidity ^0.8.20;
/**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If EIP-1153 (transient storage) is available on the chain you're deploying at,
* consider using {ReentrancyGuardTransient} instead.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant NOT_ENTERED = 1;
uint256 private constant ENTERED = 2;
uint256 private _status;
/**
* @dev Unauthorized reentrant call.
*/
error ReentrancyGuardReentrantCall();
constructor() {
_status = NOT_ENTERED;
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and making it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
_nonReentrantBefore();
_;
_nonReentrantAfter();
}
function _nonReentrantBefore() private {
// On the first call to nonReentrant, _status will be NOT_ENTERED
if (_status == ENTERED) {
revert ReentrancyGuardReentrantCall();
}
// Any calls to nonReentrant after this point will fail
_status = ENTERED;
}
function _nonReentrantAfter() private {
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = NOT_ENTERED;
}
/**
* @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
* `nonReentrant` function in the call stack.
*/
function _reentrancyGuardEntered() internal view returns (bool) {
return _status == ENTERED;
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/interfaces/IERC4626.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "../interfaces/strategies/IPetalsStrategy.sol";
import "../interfaces/internal/IPetalsVault.sol";
import "../interfaces/internal/IPetalsController.sol";
import {VaultStoredData} from "./00_libraries/types.sol";
import "../interfaces/common/ICommonErrors.sol";
import "../interfaces/common/ICommonEvents.sol";
import "../interfaces/IPermissionCache.sol";
/**
* @title PetalsVault
* @author Petals Protocol
* @notice A fully ERC4626-compliant vault with advanced security features and clone compatibility
*
* @dev The PetalsVault is a sophisticated yield-bearing vault that implements the ERC4626 standard
* with extensive security protections and gas optimizations. It operates as a minimal proxy
* (clone) pointing to a master implementation, enabling efficient deployment of multiple vaults.
*
* **Core Architecture:**
* - **ERC4626 Compliance**: Full standard compliance with proper asset/share conversions
* - **Clone Pattern**: Minimal proxy implementation for gas-efficient deployment
* - **Strategy Integration**: Seamless integration with yield-generating strategies
* - **Two-Phase Lifecycle**: Deploy → Register workflow for controlled onboarding
*
* **Security Features:**
* - **Donation Attack Protection**: Mints dead shares on first deposit to prevent manipulation
* - **Fee-on-Transfer Support**: Accurate accounting for tokens with transfer fees
* - **Role-Based Access Control**: Cached permissions with three-tier hierarchy
* - **Emergency Controls**: Pause/unpause functionality for crisis management
*
* **Fee-on-Transfer Token Behavior:**
* - `deposit()`: Fully supported - shares calculated based on actual tokens received
* - `mint()`: Will revert for fee-on-transfer tokens to maintain ERC4626 compliance
* - `withdraw()`/`redeem()`: Supported - users may receive slightly less due to token fees
*
* **Gas Optimizations:**
* - Cached state variables in critical functions
* - Minimal storage reads/writes
* - Efficient approval patterns
* - Optimized conversion calculations
*
* @notice All events emit actual amounts transferred, which may differ from requested amounts
* for fee-on-transfer tokens due to the token's fee mechanism
*/
contract PetalsVault is ERC20, IERC4626, ReentrancyGuard, ICommonErrors, ICommonEvents {
using SafeERC20 for IERC20;
using Math for uint256;
// ============ SECURITY: DONATION ATTACK PROTECTION ============
/// @notice Number of dead shares minted on first deposit to prevent donation attacks
/// @dev Makes manipulation cost equal to buying entire vault (economically impossible)
/// These shares are minted to a dead address and can never be redeemed
uint256 private constant DEAD_SHARES = 1000;
/// @notice Dead address for burning shares (0x000...dead)
/// @dev Using a recognizable dead address instead of address(0) for OpenZeppelin compatibility
address private constant DEAD_ADDRESS = 0x000000000000000000000000000000000000dEaD;
// ============ Core State Variables ============
/// @notice The underlying asset token for this vault
/// @dev Private to enforce access through asset() function
IERC20 private _asset;
/// @notice The strategy contract that generates yield for this vault
/// @dev Strategy is immutable once set during initialization
IPetalsStrategy public strategy;
/// @notice The controller contract that manages this vault
/// @dev Used for permission validation and lifecycle management
address public controller;
/// @notice Initialization state to prevent double-initialization
/// @dev Required for clone pattern compatibility
bool public initialized;
/// @notice Whether the vault is actively accepting deposits
/// @dev Can be controlled by emergency role for crisis management
bool public active;
/// @notice Whether this vault is registered with the protocol
/// @dev Unregistered vaults are experimental and not tracked
bool public isRegistered;
/// @notice Cached decimals of the underlying asset
/// @dev Stored to avoid external calls in critical functions
uint8 private _assetDecimals;
// ============ Clone ERC20 Storage ============
/// @notice The name of the vault token
/// @dev Stored separately for clone compatibility
string private _vaultName;
/// @notice The symbol of the vault token
/// @dev Stored separately for clone compatibility
string private _vaultSymbol;
// ============ Cached Permission System ============
/// @notice Role definitions that must match the controller
/// @dev These constants define the three-tier permission hierarchy
uint64 public constant MASTER_ROLE = 0; // DEFAULT_ADMIN_ROLE
uint64 public constant STRATEGIST_ROLE = 1;
uint64 public constant GUARDIAN_ROLE = 2;
/// @notice The fee recipient address that receives performance fees from this vault
/// @dev Receives performance fees but has no management permissions
address public feeRecipient;
// ============ Strategist Pause Cooldown ============
/// @notice Cooldown period for strategist pause (prevents spam)
uint256 public constant STRATEGIST_PAUSE_COOLDOWN = 6 hours;
/// @notice Track last pause time per address to enforce cooldown
mapping(address => uint256) public lastPauseTime;
// ============ EVENTS ============
event VaultStatusChanged(bool active);
event ControllerUpdateFailed(address strategy, uint256 yield, uint256 previousTotalAssets);
event VaultRegistered(address indexed vault, address indexed newFeeRecipient);
event DonationProtectionActivated(uint256 deadShares);
event UserDeposited(address indexed user, address indexed vault, uint256 amount, uint256 timestamp);
// Emergency degraded mode events
event StrategyTotalAssetsFailed(address indexed strategy);
event StrategyPanicFailed(address indexed strategy, bytes reason);
// ============ ERRORS ============
error VaultInactive();
error ERC4626ExceededMaxDeposit(address receiver, uint256 assets, uint256 max);
error ERC4626ExceededMaxMint(address receiver, uint256 shares, uint256 max);
error ERC4626ExceededMaxWithdraw(address owner, uint256 assets, uint256 max);
error ERC4626ExceededMaxRedeem(address owner, uint256 shares, uint256 max);
error AlreadyRegistered();
error AssetMismatch();
error OnlyControllerCanRegister();
error FeeOnTransferNotSupportedInMint();
// ============ MODIFIERS ============
modifier onlyRole(uint64 role) {
if (!hasRole(role, msg.sender)) {
revert UnauthorizedUpdate();
}
_;
}
modifier whenActive() {
if (!active) revert VaultInactive();
_;
}
// ============ CONSTRUCTOR ============
constructor() ERC20("", "") { }
// ============ EXTERNAL FUNCTIONS ============
/**
* @notice Initialize the vault clone with strategy, metadata, and ownership configuration
* @dev One-time initialization for minimal proxy clones. Sets up ERC4626 compliance, security roles,
* and integrates with the controller's permission caching system for gas efficiency.
* @param _strategy The yield strategy contract that manages the underlying assets
* @param name_ Human-readable name for the vault token (e.g., "Shadow wS-SHADOW Vault")
* @param symbol_ Token symbol for the vault shares (e.g., "psS-SHADOW")
* @param _feeRecipient Address that will receive performance fees from this vault
*/
function initialize(
IPetalsStrategy _strategy,
string memory name_,
string memory symbol_,
address _feeRecipient
)
external
{
if (initialized) revert AlreadyInitialized();
if (address(_strategy) == address(0)) revert InvalidStrategy(address(_strategy));
initialized = true;
active = true; // Explicitly set active state for clones
isRegistered = false; // Vaults start unregistered
strategy = _strategy;
feeRecipient = _feeRecipient; // Set fee recipient directly
// Set asset from strategy
_asset = IERC20(_strategy.asset());
// Get asset decimals
try IERC20Metadata(address(_asset)).decimals() returns (uint8 decimals_) {
_assetDecimals = decimals_;
} catch {
_assetDecimals = 18;
}
// Set ERC20 metadata
_vaultName = name_;
_vaultSymbol = symbol_;
// Set controller (msg.sender should be controller/factory)
controller = msg.sender;
// Note: Permission caching removed - simplified access control
}
/**
* @notice Register this vault (controller only)
* @dev Transfers control to protocol and marks as registered
* @param newFeeRecipient New fee recipient (protocol fee recipient)
*/
function registerVault(address newFeeRecipient) external {
if (msg.sender != controller) revert OnlyControllerCanRegister();
if (isRegistered) revert AlreadyRegistered();
isRegistered = true;
address previousFeeRecipient = feeRecipient;
feeRecipient = newFeeRecipient;
emit FeeRecipientUpdated(previousFeeRecipient, newFeeRecipient);
emit VaultRegistered(address(this), newFeeRecipient);
}
/**
* @notice Update fee recipient address (receives performance fees)
* @param newFeeRecipient New fee recipient address
* @dev Can be called by current fee recipient or STRATEGIST_ROLE
* Also updates the strategy's fee recipient to keep them synchronized
*/
function setFeeRecipient(address newFeeRecipient) external {
// Allow either current fee recipient or STRATEGIST_ROLE to update fee recipient
if (msg.sender != feeRecipient && !hasRole(STRATEGIST_ROLE, msg.sender)) {
revert UnauthorizedUpdate();
}
if (newFeeRecipient == address(0)) revert ZeroAddress();
address previousFeeRecipient = feeRecipient;
feeRecipient = newFeeRecipient;
// Also update the strategy's fee recipient to keep them synchronized
try IPetalsStrategy(address(strategy)).setFeeRecipient(newFeeRecipient) {
// Success - strategy fee recipient updated
} catch {
// Strategy doesn't support setFeeRecipient (older implementation), continue
}
emit FeeRecipientUpdated(previousFeeRecipient, newFeeRecipient);
}
/**
* @notice Execute harvest to claim and compound strategy rewards
* @dev Delegates to strategy's harvest function, which claims rewards and reinvests them
*/
function harvest() external nonReentrant {
strategy.harvest(msg.sender);
}
/**
* @notice Emergency pause to stop all vault operations and trigger strategy panic mode
* @dev GUARDIAN_ROLE can pause anytime, STRATEGIST_ROLE can pause their own vaults with cooldown
* @dev Disables deposits/withdrawals and calls strategy.panic() to secure funds during emergencies
* @dev Uses try-catch to ensure vault pause succeeds even if strategy panic fails
*/
function pause() external {
bool isGuardian = hasRole(GUARDIAN_ROLE, msg.sender);
bool isStrategist = hasRole(STRATEGIST_ROLE, msg.sender);
if (!isGuardian && !isStrategist) {
revert UnauthorizedUpdate();
}
// Strategist-specific checks
if (isStrategist && !isGuardian) {
// Verify strategist is the deployer of this vault
address vaultDeployer = _getVaultDeployer();
if (msg.sender != vaultDeployer) {
revert UnauthorizedUpdate();
}
// Enforce cooldown
if (block.timestamp < lastPauseTime[msg.sender] + STRATEGIST_PAUSE_COOLDOWN) {
revert UnauthorizedUpdate();
}
// Update cooldown tracker
lastPauseTime[msg.sender] = block.timestamp;
}
// Execute pause
active = false; // Vault is paused regardless of strategy panic result
// Try to panic strategy (best-effort)
try strategy.panic() {
// Strategy successfully secured funds from protocol
} catch (bytes memory reason) {
// Strategy panic failed - vault is still paused but funds remain in protocol
// This is acceptable - vault pause is more critical than strategy panic
// Admin must investigate why panic failed and take manual recovery action
emit StrategyPanicFailed(address(strategy), reason);
}
emit VaultStatusChanged(false);
}
/**
* @notice Unpause vault operations to resume normal functionality
* @dev Re-enables deposits and withdrawals after emergency situation is resolved
*/
function unpause() external onlyRole(GUARDIAN_ROLE) {
active = true;
emit VaultStatusChanged(true);
}
/**
* @notice Update the controller contract address for permission and operation management
* @param _controller New controller contract address
*/
function setController(address _controller) external onlyRole(MASTER_ROLE) {
controller = _controller;
}
/**
* @notice Retire the strategy and deactivate the vault (MASTER_ROLE only)
* @dev Calls retireStrat() on the strategy to withdraw all funds and deactivate
* This provides a clean interface for MASTER_ROLE to retire strategies
*/
function retireStrategy() external onlyRole(MASTER_ROLE) {
strategy.retireStrat();
active = false;
emit VaultStatusChanged(false);
}
/**
* @notice Get comprehensive vault status and asset information in a single call
* @dev Aggregates key vault metrics for efficient frontend queries and monitoring dashboards
* @return totalAssets_ Total assets under management (vault + strategy balances)
* @return vaultBalance_ Assets currently held in the vault contract
* @return strategyBalance_ Assets currently deployed in the yield strategy
* @return pricePerShare_ Current price per vault share (1e18 precision)
* @return isActive_ Whether the vault is accepting deposits and processing operations
*/
function vaultInfo()
external
view
returns (
uint256 totalAssets_,
uint256 vaultBalance_,
uint256 strategyBalance_,
uint256 pricePerShare_,
bool isActive_
)
{
totalAssets_ = totalAssets();
vaultBalance_ = _asset.balanceOf(address(this));
strategyBalance_ = strategy.totalAssets();
pricePerShare_ = convertToAssets(1e18);
isActive_ = active;
}
// ============ PUBLIC FUNCTIONS ============
/**
* @notice Check if account has role (uses cached permissions)
* @param role Role to check
* @param account Account to check
* @return hasRole Whether account has role
*/
function hasRole(uint64 role, address account) public view returns (bool) {
if (controller == address(0)) return false;
// Check role directly via controller (which delegates to AccessManager)
try IPetalsControllerForStrategy(controller).hasContractRole(address(this), role, account) returns (bool roleExists) {
return roleExists;
} catch {
return false;
}
}
/**
* @notice Get the deployer of this vault from controller
* @dev Used for strategist pause permission checks
* @return deployer Address of the vault deployer (strategist)
*/
function _getVaultDeployer() internal view returns (address deployer) {
// Call getVaultDataSimple(address) from DataProviderFacet
(bool success, bytes memory data) = controller.staticcall(
abi.encodeWithSignature("getVaultDataSimple(address)", address(this))
);
if (success && data.length > 0) {
VaultStoredData memory vaultData = abi.decode(data, (VaultStoredData));
return vaultData.strategy.deployer;
}
return address(0);
}
// ============ ERC20 Metadata Overrides (Clone Compatibility) ============
/// @notice Returns the vault token name stored during initialization
function name() public view override(ERC20, IERC20Metadata) returns (string memory) {
return _vaultName;
}
/// @notice Returns the vault token symbol stored during initialization
function symbol() public view override(ERC20, IERC20Metadata) returns (string memory) {
return _vaultSymbol;
}
/// @notice Returns the decimal precision matching the underlying asset
function decimals() public view override(IERC20Metadata, ERC20) returns (uint8) {
return _assetDecimals;
}
/// @inheritdoc IERC4626
function asset() public view returns (address) {
return address(_asset);
}
/// @inheritdoc IERC4626
/// @dev Uses try-catch for emergency resilience - prevents vault bricking if strategy fails
function totalAssets() public view returns (uint256) {
uint256 vaultBalance = _asset.balanceOf(address(this));
// Try to get strategy balance
try strategy.totalAssets() returns (uint256 strategyBalance) {
// Normal operation - return full vault value
return vaultBalance + strategyBalance;
} catch {
// DEGRADED MODE: Strategy totalAssets() failed
// This enables emergency recovery - users can withdraw vault balance
// Admin should monitor for StrategyTotalAssetsFailed events and take action
// Note: Can't emit event from view function, will be emitted during next state change
return vaultBalance; // Return only vault balance (strategy balance hidden)
}
}
/// @inheritdoc IERC4626
function convertToShares(uint256 assets) public view returns (uint256) {
return _convertToShares(assets, Math.Rounding.Floor);
}
/// @inheritdoc IERC4626
function convertToAssets(uint256 shares) public view returns (uint256) {
return _convertToAssets(shares, Math.Rounding.Floor);
}
/// @inheritdoc IERC4626
function maxDeposit(address) public view returns (uint256) {
return active ? type(uint256).max : 0;
}
/// @inheritdoc IERC4626
function maxMint(address) public view returns (uint256) {
return active ? type(uint256).max : 0;
}
/// @inheritdoc IERC4626
function maxWithdraw(address account) public view returns (uint256) {
return _convertToAssets(balanceOf(account), Math.Rounding.Floor);
}
/// @inheritdoc IERC4626
function maxRedeem(address account) public view returns (uint256) {
return balanceOf(account);
}
/// @inheritdoc IERC4626
function previewDeposit(uint256 assets) public view returns (uint256) {
return _convertToShares(assets, Math.Rounding.Floor);
}
/// @inheritdoc IERC4626
function previewMint(uint256 shares) public view returns (uint256) {
return _convertToAssets(shares, Math.Rounding.Ceil);
}
/// @inheritdoc IERC4626
function previewWithdraw(uint256 assets) public view returns (uint256) {
return _convertToShares(assets, Math.Rounding.Ceil);
}
/// @inheritdoc IERC4626
function previewRedeem(uint256 shares) public view returns (uint256) {
return _convertToAssets(shares, Math.Rounding.Floor);
}
/// @inheritdoc IERC4626
/// @dev PROTECTED: Includes donation attack protection on first deposit + fee-on-transfer support
function deposit(uint256 assets, address receiver) public nonReentrant whenActive returns (uint256 shares) {
uint256 maxAssets = maxDeposit(receiver);
if (assets > maxAssets) {
revert ERC4626ExceededMaxDeposit(receiver, assets, maxAssets);
}
// === GAS OPTIMIZATION: Cache state variables ===
uint256 currentTotalAssets = totalAssets();
uint256 currentTotalSupply = totalSupply();
// DONATION ATTACK PROTECTION: Mint dead shares on first deposit
if (currentTotalSupply == 0) {
_mint(DEAD_ADDRESS, DEAD_SHARES);
emit DonationProtectionActivated(DEAD_SHARES);
currentTotalSupply = DEAD_SHARES; // Update for conversion
}
// FEE-ON-TRANSFER PROTECTION: Measure actual balance change
uint256 balanceBefore = _asset.balanceOf(address(this));
_asset.safeTransferFrom(_msgSender(), address(this), assets);
uint256 balanceAfter = _asset.balanceOf(address(this));
uint256 actualAssetsReceived = balanceAfter - balanceBefore;
// Calculate shares based on vault state BEFORE deposit (ERC4626 standard)
// For first real deposit (after dead shares), use 1:1 conversion
if (currentTotalAssets == 0 && currentTotalSupply == DEAD_SHARES) {
shares = actualAssetsReceived;
} else {
shares = _convertToShares(actualAssetsReceived, currentTotalSupply, currentTotalAssets, Math.Rounding.Floor);
}
// Update total assets for controller reporting
uint256 updatedTotalAssets = currentTotalAssets + actualAssetsReceived;
// Mint shares and emit event with actual amounts
_mint(receiver, shares);
emit Deposit(_msgSender(), receiver, actualAssetsReceived, shares);
emit UserDeposited(receiver, address(this), actualAssetsReceived, block.timestamp);
_investInStrategy();
}
/// @inheritdoc IERC4626
/// @dev PROTECTED: Includes donation attack protection on first mint + fee-on-transfer protection
/// @notice For fee-on-transfer tokens, this function will revert to maintain ERC4626 compliance
/// (must mint exact shares requested). Use deposit() instead for FOT support, or ensure no fee is deducted.
/// Example: If previewMint(100) returns 100 assets but token deducts 1% fee, it reverts.
function mint(uint256 shares, address receiver) public nonReentrant whenActive returns (uint256 assets) {
uint256 maxShares = maxMint(receiver);
if (shares > maxShares) {
revert ERC4626ExceededMaxMint(receiver, shares, maxShares);
}
// === GAS OPTIMIZATION: Cache state variables ===
uint256 currentTotalAssets = totalAssets();
uint256 currentTotalSupply = totalSupply();
// DONATION ATTACK PROTECTION: Mint dead shares on first deposit
if (currentTotalSupply == 0) {
_mint(DEAD_ADDRESS, DEAD_SHARES);
emit DonationProtectionActivated(DEAD_SHARES);
currentTotalSupply = DEAD_SHARES; // Update for conversion
}
// Calculate expected assets needed (rounded up for safety)
// For first real deposit (after dead shares), use 1:1 conversion
if (currentTotalAssets == 0 && currentTotalSupply == DEAD_SHARES) {
assets = shares;
} else {
assets = _convertToAssets(shares, currentTotalSupply, currentTotalAssets, Math.Rounding.Ceil);
}
// FEE-ON-TRANSFER PROTECTION: Ensure exact amount received
uint256 balanceBefore = _asset.balanceOf(address(this));
_asset.safeTransferFrom(_msgSender(), address(this), assets);
uint256 balanceAfter = _asset.balanceOf(address(this));
uint256 actualAssetsReceived = balanceAfter - balanceBefore;
// CRITICAL: mint() must mint exact shares requested or revert (ERC4626 compliance)
if (actualAssetsReceived != assets) {
revert FeeOnTransferNotSupportedInMint();
}
// Update total assets for controller reporting
uint256 updatedTotalAssets = currentTotalAssets + actualAssetsReceived;
// Mint exact shares requested and emit event
_mint(receiver, shares);
emit Deposit(_msgSender(), receiver, assets, shares);
emit UserDeposited(receiver, address(this), actualAssetsReceived, block.timestamp);
_investInStrategy();
}
/// @inheritdoc IERC4626
/// @dev PROTECTED: Includes fee-on-transfer support
/// @notice For fee-on-transfer tokens, user may receive slightly less than requested due to token fees
function withdraw(
uint256 assets,
address receiver,
address shareOwner
)
public
nonReentrant
returns (uint256 shares)
{
uint256 maxAssets = maxWithdraw(shareOwner);
if (assets > maxAssets) {
revert ERC4626ExceededMaxWithdraw(shareOwner, assets, maxAssets);
}
uint256 currentTotalAssets = totalAssets();
uint256 currentTotalSupply = totalSupply();
// Calculate shares to burn for requested assets
shares = _convertToShares(assets, currentTotalSupply, currentTotalAssets, Math.Rounding.Ceil);
// Execute withdrawal with proper allowance handling
if (_msgSender() != shareOwner) {
_spendAllowance(shareOwner, _msgSender(), shares);
}
// Ensure we have enough assets
uint256 vaultBalance = _asset.balanceOf(address(this));
if (vaultBalance < assets) {
strategy.withdraw(assets - vaultBalance);
}
// FEE-ON-TRANSFER TRACKING: Measure actual amount sent for accurate events
uint256 balanceBefore = _asset.balanceOf(address(this));
_asset.safeTransfer(receiver, assets);
uint256 balanceAfter = _asset.balanceOf(address(this));
uint256 actualAssetsSent = balanceBefore - balanceAfter;
// Burn the calculated shares and emit with actual amounts
_burn(shareOwner, shares);
emit Withdraw(_msgSender(), receiver, shareOwner, actualAssetsSent, shares);
}
/// @inheritdoc IERC4626
/// @dev PROTECTED: Includes fee-on-transfer support
/// @notice For fee-on-transfer tokens, user may receive slightly less than expected due to token fees
function redeem(
uint256 shares,
address receiver,
address shareOwner
)
public
nonReentrant
returns (uint256 assets)
{
uint256 maxShares = maxRedeem(shareOwner);
if (shares > maxShares) {
revert ERC4626ExceededMaxRedeem(shareOwner, shares, maxShares);
}
uint256 currentTotalAssets = totalAssets();
uint256 currentTotalSupply = totalSupply();
// Calculate assets to send for the shares being redeemed
assets = _convertToAssets(shares, currentTotalSupply, currentTotalAssets, Math.Rounding.Floor);
// Execute redemption with proper allowance handling
if (_msgSender() != shareOwner) {
_spendAllowance(shareOwner, _msgSender(), shares);
}
// Ensure we have enough assets
uint256 vaultBalance = _asset.balanceOf(address(this));
if (vaultBalance < assets) {
strategy.withdraw(assets - vaultBalance);
}
// FEE-ON-TRANSFER TRACKING: Measure actual amount sent for accurate events
uint256 balanceBefore = _asset.balanceOf(address(this));
_asset.safeTransfer(receiver, assets);
uint256 balanceAfter = _asset.balanceOf(address(this));
uint256 actualAssetsSent = balanceBefore - balanceAfter;
// Burn the exact shares requested and emit with actual amounts
_burn(shareOwner, shares);
emit Withdraw(_msgSender(), receiver, shareOwner, actualAssetsSent, shares);
// Return actual assets sent (may be less than calculated for fee-on-transfer tokens)
assets = actualAssetsSent;
}
// ============ INTERNAL FUNCTIONS ============
/**
* @notice Convert asset amount to vault shares using current exchange rate
* @dev Standard ERC4626 conversion with configurable rounding for different operations
*/
function _convertToShares(uint256 assets, Math.Rounding rounding) internal view returns (uint256) {
uint256 supply = totalSupply();
return supply == 0 ? assets : assets.mulDiv(supply, totalAssets(), rounding);
}
/**
* @notice Convert vault shares to asset amount using current exchange rate
* @dev Standard ERC4626 conversion with configurable rounding for different operations
*/
function _convertToAssets(uint256 shares, Math.Rounding rounding) internal view returns (uint256) {
uint256 supply = totalSupply();
return supply == 0 ? shares : shares.mulDiv(totalAssets(), supply, rounding);
}
/**
* @notice Gas-optimized share conversion using pre-calculated totals
* @dev Avoids redundant external calls when totals are already cached in memory
*/
function _convertToShares(
uint256 assets,
uint256 totalSupply_,
uint256 totalAssets_,
Math.Rounding rounding
)
internal
pure
returns (uint256)
{
return totalSupply_ == 0 ? assets : assets.mulDiv(totalSupply_, totalAssets_, rounding);
}
/**
* @notice Gas-optimized asset conversion using pre-calculated totals
* @dev Avoids redundant external calls when totals are already cached in memory
*/
function _convertToAssets(
uint256 shares,
uint256 totalSupply_,
uint256 totalAssets_,
Math.Rounding rounding
)
internal
pure
returns (uint256)
{
return totalSupply_ == 0 ? shares : shares.mulDiv(totalAssets_, totalSupply_, rounding);
}
/**
* @notice Deploy idle vault assets into the yield strategy for compounding
* @dev Called after deposits to ensure all assets are actively earning yield
*/
function _investInStrategy() internal {
uint256 balance = _asset.balanceOf(address(this));
if (balance > 0) {
_asset.safeTransfer(address(strategy), balance);
strategy.deposit();
}
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "../00_libraries/types.sol";
import "../../interfaces/common/IStrategyFactory.sol";
import "../../interfaces/routing/RouterTypes.sol";
/**
* @title PetalsStorageLayout
* @notice Storage layout library for the upgradeable PetalsVaultController
* @dev This library defines the storage layout that will be used by all versions
* of the controller implementation. It uses the diamond storage pattern to
* prevent storage collisions and ensure upgrade compatibility.
*/
library PetalsStorageLayout {
/// @notice Unique storage slot identifier to prevent collisions
/// @dev Using a unique namespace for this protocol's storage
bytes32 constant STORAGE_SLOT = keccak256("com.petals.protocol.storage.main");
/**
* @notice Complete storage layout for the Petals Protocol
* @dev All state variables from PetalsVaultController are defined here
* This struct represents the entire persistent state of the protocol
* that will be preserved across all logic contract upgrades
*/
struct AppStorage {
// ============ Strategy Registry ============
/// @notice Mapping from strategy to vault (reverse lookup)
/// @dev Forward lookup (vault => strategy) is in vaultData[vault].strategy.strategyAddress
mapping(address => address) strategyToVault;
// ============ Access Control & Permission Registry ============
/// @notice Contract-specific role assignments: contractAddr => role => account => hasRole
mapping(address => mapping(uint64 => mapping(address => bool))) contractRoles;
// ============ Core Infrastructure ============
/// @notice The master vault implementation used for all vault clones
address masterVault;
/// @notice The data provider contract for aggregated queries
address dataProvider;
/// @notice Price oracle contract for USD valuations
address priceOracle;
/// @notice Wrapped native token address for this chain
address wrappedNativeToken;
/// @notice Fee manager contract for all fee-related operations
address feeManager;
/// @notice Access manager contract for all permission-related operations
address accessManager;
/// @notice The master address that receives ownership of registered vaults and strategies
address masterAddress;
/// @notice Timelock controller for critical operations (optional, address(0) = no timelock)
address timelockController;
// ============ Vault Registry ============
/// @notice Array of all deployed vault addresses
address[] allVaults;
/// @notice Quick lookup to verify if an address is a registered vault
mapping(address => bool) isVault;
/// @notice Comprehensive data storage for each vault
/// @dev Stores all persistent vault data (identity, metadata, metrics, strategy, UI)
mapping(address => VaultStoredData) vaultData;
// ============ Indexing System ============
/// @notice Vaults organized by underlying asset for efficient discovery
mapping(address => address[]) vaultsByAsset;
/// @notice Vaults organized by fee recipient for management interfaces
mapping(address => address[]) vaultsByFeeRecipient;
/// @notice Array of retired vault addresses for archiving
address[] retiredVaults;
/// @notice Quick check if a vault is retired
mapping(address => bool) isRetired;
// ============ Performance Tracking ============
/// @notice Running count of total vaults deployed through this controller
uint256 totalVaultsDeployed;
// ============ Duplicate Prevention ============
/// @notice Prevents duplicate registrations of the same asset+strategyType combination
/// @dev Key: [asset][strategyType] → vault
/// @dev Allows multiple strategy types per asset (e.g., USDC with Shadow-V1, Shadow-V2, Aave)
mapping(address => mapping(bytes32 => address)) assetStrategyTypeVault;
// ============ Protocol-Wide Operations ============
/// @notice Direct mapping from base protocol to all vaults using it
/// @dev Enables O(1) protocol-wide operations (panic, analytics)
mapping(bytes32 => address[]) vaultsByProtocol;
/// @notice Index mapping for efficient vault removal from protocol array
mapping(bytes32 => mapping(address => uint256)) vaultsByProtocolIndex;
// ============ Deployment Management ============
/// @notice Vault deployments queued for admin approval before registration
/// @dev Mapping-only design (no array) to prevent DOS attacks via queue spam
/// @dev Admin discovers vaults via off-chain events/indexer, approves by direct address lookup
/// @dev Multiple vaults can queue for same asset - admin chooses best during approval
mapping(address => VaultStoredData) queuedVaults;
// ============ Configurable Protocol Constants ============
/// @notice Standard basis points denominator (configurable)
uint256 basisPoints;
/// @notice Maximum slippage tolerance for strategy operations (configurable)
uint256 maxSlippage;
/// @notice Minimum delay between harvests (configurable)
uint256 minHarvestDelay;
/// @notice Default performance fee for new vaults (configurable)
uint256 defaultPerformanceFee;
/// @notice Default slippage tolerance for strategies (configurable)
uint256 defaultSlippageTolerance;
uint256 defaultCollateralFactor; // Default collateral factor for lending strategies in basis points
// ============ Essential Indexing System ============
mapping(address => uint256) allVaultsIndex;
mapping(address => mapping(address => uint256)) vaultsByAssetIndex; // asset => vault => index
// ============ Fee Config Storage ============
/// @notice Vault-specific fee configurations stored in the diamond
mapping(address => VaultFeeConfig) vaultFeeConfigs;
/// @notice Universal fee configuration used as default when no override
UniversalFeeConfig universalFeeConfig;
/// @notice Claimable fees per recipient address
/// @dev Fees accumulate here instead of direct transfer for better composability
mapping(address => uint256) claimableFees;
// ============ Routing System ============
/// @notice Registry of router libraries: RouterType => library address
mapping(RouterType => address) routerLibraries;
/// @notice Centralized fees library for all strategies
address feesLibrary;
/// @notice Last route change timestamp per strategy
mapping(address => uint256) strategyLastRouteChange;
/// @notice Total route updates per strategy
mapping(address => uint256) strategyRouteUpdateCount;
// ============ Metadata Registry (NEW) ============
/// @notice Chain metadata for this deployment (single static struct)
ChainMetadata chainMetadata;
/// @notice Token category information (dynamic registry)
mapping(bytes32 => TokenCategoryInfo) tokenCategories;
bytes32[] registeredCategories;
/// @notice Token metadata registry for UI display
mapping(address => TokenMetadata) tokenMetadata;
address[] registeredTokens;
/// @notice Tokens organized by category for filtering
mapping(bytes32 => address[]) tokensByCategory; // categoryId => tokens[]
// ============ Vault Tag Registry ============
/// @notice Vault tag definitions
mapping(bytes32 => VaultTagInfo) vaultTags;
bytes32[] registeredTags;
/// @notice Reverse index: tagId => vault addresses (for filtering)
mapping(bytes32 => address[]) vaultsByTag;
// ============ Universal Factory Registry ============
/// @notice Protocol registry: baseProtocol => registration data
/// @dev Primary access by bytes32 name (stable, readable API)
mapping(bytes32 => ProtocolRegistration) universalFactoryProtocols;
/// @notice All registered protocols (for enumeration)
/// @dev Array indices match ProtocolRegistration.protocolIndex
bytes32[] universalFactoryRegisteredProtocols;
/// @notice Strategy type registry: baseProtocol => strategyType => registration data
/// @dev Two-level mapping for protocol → type hierarchy
mapping(bytes32 => mapping(bytes32 => StrategyTypeRegistration)) universalFactoryStrategyTypes;
/// @notice Protocol strategy types (for enumeration): baseProtocol => strategyType[]
/// @dev Array indices match StrategyTypeRegistration.typeIndex
mapping(bytes32 => bytes32[]) universalFactoryProtocolStrategyTypes;
/// @notice Tracks all strategies deployed by UniversalFactory for O(1) validation
/// @dev Only UniversalFactory can set this to true, making it unspoofable
mapping(address => bool) universalFactoryDeployedStrategies;
// ============ Oracle Storage ============
/// @notice Chainlink price feeds: asset => feed address
mapping(address => address) chainlinkFeeds;
/// @notice DEX routers with their types for price discovery
OracleRouterInfo[] dexRouters;
mapping(address => bool) approvedRouters;
/// @notice Base tokens for routing (USDC, WETH, etc.)
address[] baseTokens;
mapping(address => bool) isBaseToken;
mapping(address => uint256) baseTokenPriority;
/// @notice Cached price data: asset => PriceData
mapping(address => PriceData) cachedPrices;
/// @notice LP token detection cache
mapping(address => bool) isLPTokenCache;
mapping(address => bool) isLPTokenSet;
/// @notice Manual price overrides (emergency)
mapping(address => PriceData) manualPrices;
mapping(address => bool) useManualPrice;
/// @notice Custom price staleness per asset
mapping(address => uint256) maxPriceAge;
// ============ Asset Registry Storage ============
/// @notice Asset metadata registry (LP tokens, complex assets)
/// @dev Populated by ChainRegistryFacet, queried by OracleFacet and ControllerFacet
mapping(address => AssetMetadata) assetRegistry;
/// @notice Quick lookup: Is this address a registered asset?
mapping(address => bool) isRegisteredAsset;
/// @notice Enumeration: All registered assets
address[] registeredAssets;
/// @notice Index by RouterType (for Oracle optimization)
/// @dev Allows O(1) lookup of all assets for a given DEX type
mapping(RouterType => address[]) assetsByRouterType;
// ============ Storage Gap ============
/// @notice Storage gap for future upgrades - reserves 100 slots
/// @dev This prevents storage collisions when adding new state variables in future versions
/// @dev Increased to 100 for better long-term flexibility
uint256[100] __gap;
}
/**
* @notice Get a storage pointer to the AppStorage struct
* @dev Uses assembly to return a storage pointer at the designated slot
* This is the standard diamond storage pattern for upgradeable contracts
* @return s Storage pointer to the AppStorage struct
*/
function getStorage() internal pure returns (AppStorage storage s) {
bytes32 slot = STORAGE_SLOT;
assembly {
s.slot := slot
}
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "../../interfaces/common/IStrategyFactory.sol";
import "../../interfaces/routing/RouterTypes.sol";
/**
* ╔══════════════════════════════════════════════════════════════════════════════╗
* ║ PETALS PROTOCOL DATA ARCHITECTURE ║
* ╚══════════════════════════════════════════════════════════════════════════════╝
*
* This file defines the complete data structure hierarchy for the Petals Protocol.
*
* ┌─────────────────────────────────────────────────────────────────────────────┐
* │ TWO MAIN DATA STRUCTURES │
* └─────────────────────────────────────────────────────────────────────────────┘
*
* 1. VaultRowData
* ├─ Purpose: Lightweight data for vault list display (/vaults page)
* ├─ Usage: Batch queries of 500+ vaults
* ├─ Contains: Essential metrics + UI branding
* └─ Returned by: DataProviderFacet.getVaultRowsBatch()
*
* 2. VaultCompleteData
* ├─ Purpose: Complete vault data for detail pages (/vaults/[id])
* ├─ Usage: Single vault detailed view
* ├─ Contains: ALL vault data in one call (stored + computed + derived)
* └─ Returned by: DataProviderFacet.getVaultData()
*
* ┌─────────────────────────────────────────────────────────────────────────────┐
* │ DATA LAYER ORGANIZATION │
* └─────────────────────────────────────────────────────────────────────────────┘
*
* LAYER 1: STORED DATA (Persisted in Diamond Storage)
* ────────────────────────────────────────────────────
* VaultStoredData
* ├─ VaultIdentity → Who/what/when (addresses, timestamps)
* ├─ VaultMetadata → Name, protocol, category, branding
* ├─ VaultMetrics → Performance history (APY, harvests)
* ├─ StrategyData → Strategy configuration
* └─ VaultUIMetadata → Logos, links, LP token info
*
* LAYER 2: COMPUTED DATA (Calculated On-Demand from Contracts)
* ────────────────────────────────────────────────────────────
* ├─ VaultStateData → Real-time vault state (totalAssets, sharePrice)
* ├─ UserPortfolioData → User-specific balances and allowances
* ├─ VaultFeeData → Fee configuration from FeeManager
* └─ HarvestData → Harvest readiness and pending rewards
*
* LAYER 3: DERIVED DATA (Computed from Logic)
* ────────────────────────────────────────────
* └─ VaultStatus → Active/Paused/Retired (enum)
*
* ┌─────────────────────────────────────────────────────────────────────────────┐
* │ DATA FLOW DIAGRAM │
* └─────────────────────────────────────────────────────────────────────────────┘
*
* Diamond Storage: vaultData[address] → VaultStoredData
* │
* ├─► VaultIdentity
* ├─► VaultMetadata
* ├─► VaultMetrics
* ├─► StrategyData
* └─► VaultUIMetadata
*
* DataProviderFacet._getVaultCompleteData() reads storage + computes real-time:
*
* VaultCompleteData
* ├─ [STORED] identity, metadata, metrics, strategy, ui
* ├─ [COMPUTED] state ──────► Query vault.totalAssets(), vault.totalSupply()
* ├─ [COMPUTED] user ───────► Query vault.balanceOf(user), asset.balanceOf(user)
* ├─ [COMPUTED] fees ───────► Query feeManager.getVaultFeeConfig(vault)
* ├─ [COMPUTED] harvest ────► Query strategy.totalRewardsAvailable()
* └─ [DERIVED] status ──────► Compute from vault.active() + strategy.paused()
*
* ┌─────────────────────────────────────────────────────────────────────────────┐
* │ FRONTEND USAGE GUIDE │
* └─────────────────────────────────────────────────────────────────────────────┘
*
* For Vault List Page (/vaults):
* ────────────────────────────────
* const rows = await dataProvider.getVaultRowsBatch(vaults, user);
* // Access: row.name, row.protocol, row.estAPY, row.vaultLogoURI
*
* For Vault Detail Page (/vaults/[id]):
* ───────────────────────────────────────
* const data = await dataProvider.getVaultData(vault, user);
* // Access all fields:
* // - data.identity.vaultAddress
* // - data.metadata.name
* // - data.ui.vaultLogoURI, data.ui.websiteURI
* // - data.state.totalAssets, data.state.sharePrice
* // - data.user.userBalance
* // - data.harvest.canHarvest
*/
// ════════════════════════════════════════════════════════════════════════════════
// MAIN DATA STRUCTURES
// ════════════════════════════════════════════════════════════════════════════════
/**
* @notice Lightweight vault data optimized for list display
* @dev Used by: Frontend /vaults page for displaying 500+ vaults efficiently
* @dev Returned by: DataProviderFacet.getVaultRowsBatch()
*
* Contains:
* - Essential identification (address, name, protocol)
* - Key metrics (APY, TVL, risk level)
* - User portfolio (balances)
* - UI branding (logos)
* - Status indicator
*/
struct VaultRowData {
// === IDENTITY ===
address vaultAddress; // Vault contract address
bytes name; // Vault name (full length, no truncation)
bytes32 protocol; // Protocol name (e.g., "Shadow", "Aave")
bytes32 category; // Category (e.g., "Stable", "Volatile")
// === KEY METRICS ===
uint256 estAPY; // Last APY in basis points (10000 = 100%)
uint256 tvlUSD; // TVL estimate in USD (6 decimals)
uint8 riskLevel; // Risk level 1-10
uint8 status; // 0=Active, 1=Paused, 2=Retired
// === USER PORTFOLIO ===
uint256 userAvailable; // User's underlying asset balance
uint256 userHoldings; // User's vault share balance
uint256 userPositionUSD; // User's vault position in USD (6 decimals) - 0 if unavailable
uint256 userAvailableUSD; // User's available balance in USD (6 decimals) - 0 if unavailable
// === USD PRICING ===
uint256 assetPriceUSD; // Asset price in USD (18 decimals) - 0 if unavailable
uint8 priceConfidence; // Oracle confidence (0-100) - 0 if no oracle
// === UI METADATA ===
bytes vaultLogoURI; // Vault logo (IPFS/HTTP) - bytes for gas efficiency
bytes protocolLogoURI; // Protocol logo (IPFS/HTTP) - bytes for gas efficiency
}
/**
* @notice Complete vault data with all information in a single structure
* @dev Used by: Frontend /vaults/[id] detail page
* @dev Returned by: DataProviderFacet.getVaultData()
*
* Architecture:
* ├─ STORED DATA (from Diamond storage - VaultStoredData)
* │ ├─ identity: Basic vault identity
* │ ├─ metadata: Name, description, branding
* │ ├─ metrics: Performance history
* │ ├─ strategy: Strategy configuration
* │ └─ ui: Logos, links, LP token info
* │
* ├─ COMPUTED DATA (from contracts - calculated on-demand)
* │ ├─ state: Real-time vault state
* │ ├─ user: User-specific portfolio data
* │ ├─ fees: Fee configuration
* │ └─ harvest: Harvest readiness
* │
* └─ DERIVED DATA (from logic)
* └─ status: Active/Paused/Retired
*/
struct VaultCompleteData {
// ═══════════════════════════════════════════════════════════════════════════
// STORED DATA (Persisted in Diamond Storage)
// ═══════════════════════════════════════════════════════════════════════════
/// @notice Basic vault identity (addresses, IDs, timestamps)
VaultIdentity identity;
/// @notice Vault metadata (name, protocol, category, descriptions)
VaultMetadata metadata;
/// @notice Performance metrics (APY history, harvest counts)
VaultMetrics metrics;
/// @notice Strategy configuration
StrategyData strategy;
/// @notice UI metadata (logos, links, LP token info)
VaultUIMetadata ui;
// ═══════════════════════════════════════════════════════════════════════════
// COMPUTED DATA (Calculated On-Demand from Contracts)
// ═══════════════════════════════════════════════════════════════════════════
/// @notice Real-time vault state (totalAssets, sharePrice, etc.)
VaultStateData state;
/// @notice User-specific portfolio data (balances, allowances)
UserPortfolioData user;
/// @notice Fee configuration (performance, withdrawal, deposit fees)
VaultFeeData fees;
/// @notice Harvest data (pending rewards, readiness)
HarvestData harvest;
// ═══════════════════════════════════════════════════════════════════════════
// DERIVED DATA (Computed from Logic)
// ═══════════════════════════════════════════════════════════════════════════
/// @notice Computed vault status
VaultStatus status;
}
// ════════════════════════════════════════════════════════════════════════════════
// STORED SUB-STRUCTURES (Layer 1: Persisted in Diamond Storage)
// ════════════════════════════════════════════════════════════════════════════════
/**
* @notice Complete stored vault data (what's actually in Diamond storage)
* @dev This is what gets stored in: PetalsStorageLayout.vaultData[address]
* @dev Contains all persistent vault information that survives between transactions
*
* Used internally by:
* - ControllerFacet (for registration and updates)
* - DataProviderFacet (for reading and building VaultCompleteData)
*
* ┌──────────────────────────────────────────────────────────────────────────────┐
* │ STORAGE OWNERSHIP - CRITICAL: DO NOT VIOLATE THIS SEPARATION │
* ├──────────────┬───────────────────────┬────────────────────────────────────────┤
* │ Field │ Written By │ When │
* ├──────────────┼───────────────────────┼────────────────────────────────────────┤
* │ identity │ ControllerFacet │ Registration (once) │
* │ metadata │ VaultMetadataFacet │ Initialization & updates │
* │ metrics │ ControllerFacet │ Registration + after harvests │
* │ strategy │ ControllerFacet │ Registration (once) │
* │ ui │ VaultMetadataFacet │ Initialization & updates │
* └──────────────┴───────────────────────┴────────────────────────────────────────┘
*
* IMPORTANT RULES:
* 1. ControllerFacet writes: identity, strategy (immutable after registration)
* 2. ControllerFacet writes: metrics (updated after harvests)
* 3. VaultMetadataFacet writes: metadata, ui (mutable, admin-controlled)
* 4. NO OTHER FACETS should write to these fields
* 5. Initialization order: ControllerFacet (core) → VaultMetadataFacet (properties)
*
* Violating this can cause:
* - Data corruption (two facets writing same field)
* - Broken initialization (properties set before core data)
* - Audit failures (unclear ownership boundaries)
*/
struct VaultStoredData {
VaultIdentity identity; // ControllerFacet ONLY - immutable after registration
VaultMetadata metadata; // VaultMetadataFacet ONLY - mutable
VaultMetrics metrics; // ControllerFacet ONLY - updated after harvests
StrategyData strategy; // ControllerFacet ONLY - immutable after registration
VaultUIMetadata ui; // VaultMetadataFacet ONLY - mutable
}
/**
* @notice Basic vault identity information
* @dev Core identification fields for vault tracking
*/
struct VaultIdentity {
address vaultAddress; // Vault contract address
bytes32 vaultId; // Unique vault identifier
uint256 createdAt; // Vault creation timestamp
uint256 registeredAt; // Registration timestamp in controller
address deployer; // Address that deployed the vault
}
/**
* @notice Vault metadata for display and categorization
* @dev Human-readable information about the vault
*/
struct VaultMetadata {
bytes name; // Vault name - dynamic length for complex multi-token pools (e.g., "BeethovenX USDC-DAI-USDT Stable Pool")
bytes32 symbol; // Vault symbol (e.g., "P-wS-SHADOW") - always short, keep bytes32
bytes32 protocol; // Protocol name (e.g., "Shadow", "Aave") - always short, keep bytes32
bytes32 category; // Category (e.g., "Stable", "Volatile", "Blue-chip") - always short, keep bytes32
uint8 riskLevel; // Risk level 1-10
bytes description; // Vault description
bytes strategyDescription; // Strategy description
}
/**
* @notice Performance metrics tracked over time
* @dev Updated after each harvest to maintain historical performance data
*/
struct VaultMetrics {
uint256 lastAPY; // APY from most recent harvest (basis points)
uint256 totalHarvests; // Total number of harvests executed
uint64 lastHarvest; // Timestamp of last harvest
uint256 supplyApy; // Supply APY for lending strategies
uint256 borrowApy; // Borrow APY for lending strategies
uint256 _reserved1; // Reserved for future metrics
uint256 _reserved2; // Reserved for future metrics
}
/**
* @notice Strategy configuration and deployment info
* @dev Static information about the strategy contract
*/
struct StrategyData {
address strategyAddress; // Strategy contract address
address underlyingAsset; // Asset the strategy manages
bytes32 strategyType; // Strategy type identifier (e.g., "Shadow-Volatile-V1")
uint64 registeredAt; // When strategy was registered
address deployer; // Who deployed the strategy
uint256 collateralFactor; // Collateral factor for lending (basis points)
uint16 slippageTolerance; // Slippage tolerance in basis points (0-1000 = 0-10%)
}
/**
* @notice UI metadata for frontend display
* @dev All data needed for rich vault UI (logos, links, LP token info)
* @dev Uses bytes instead of string for gas efficiency (~50% savings)
* @dev Frontend decodes with ethers.toUtf8String(bytesData)
*
* Contains:
* - Branding: Vault and protocol logos
* - Links: Website, docs, social media (in socials array)
* - LP Info: Underlying token addresses and metadata (supports N tokens for Curve/Balancer/BeethovenX)
*
* Use Cases:
* - Display vault branding on list and detail pages
* - Provide direct links to protocol websites/docs
* - Show LP token composition without additional RPC calls
* - Enable token selection dropdowns with proper symbols and logos
* - Support multi-token pools (2+ tokens)
*
* Socials Array Convention:
* - socials[0] = website
* - socials[1] = docs
* - socials[2] = discord
* - socials[3] = twitter
*
* Multi-Token Pool Support:
* - For UniV2/Solidly pairs: lpTokens.length = 2
* - For Curve 3pool: lpTokens.length = 3
* - For Balancer weighted pools: lpTokens.length = 2-8
* - Arrays are parallel: lpTokens[i], lpTokenSymbols[i], lpTokenLogos[i]
*/
struct VaultUIMetadata {
// === BRANDING ===
bytes vaultLogoURI; // Vault-specific logo (IPFS/HTTP)
bytes protocolLogoURI; // Protocol logo
// === LINKS (Array for gas efficiency) ===
bytes[] socials; // [website, docs, discord, twitter]
// === LP TOKEN INFO (flexible for multi-token pools) ===
address[] lpTokens; // Underlying token addresses (2+ for multi-token pools)
bytes32[] lpTokenSymbols; // Cached symbols (parallel to lpTokens)
bytes[] lpTokenLogos; // Logo URIs (parallel to lpTokens)
// === TAGS (for filtering and discovery) ===
bytes32[] tags; // Tag IDs applied to this vault (e.g., [TAG_LP_STRATEGY, TAG_AUDITED])
}
// ════════════════════════════════════════════════════════════════════════════════
// COMPUTED SUB-STRUCTURES (Layer 2: Calculated On-Demand from Contracts)
// ════════════════════════════════════════════════════════════════════════════════
/**
* @notice Real-time vault state data
* @dev Computed by querying vault and strategy contracts
* @dev NOT stored - calculated fresh on each DataProviderFacet.getVaultData() call
*
* Data Sources:
* - vault.totalAssets()
* - vault.totalSupply()
* - strategy.totalAssets()
* - vault.maxDeposit(user)
* - oracle.getPrice(asset)
*/
struct VaultStateData {
uint256 totalAssets; // Total assets in vault (underlying asset)
uint256 totalSupply; // Total vault token supply
uint256 strategyBalance; // Assets deployed in strategy
uint256 sharePrice; // Current share price (18 decimals)
uint256 tvlEstimateUSD; // Oracle-based TVL estimate (6 decimals)
uint256 maxDeposit; // Maximum deposit allowed (ERC4626)
uint256 maxWithdraw; // Maximum withdrawal allowed (ERC4626)
uint256 maxRedeem; // Maximum redemption allowed (ERC4626)
bytes32 assetSymbol; // Asset symbol (gas-efficient bytes32)
uint8 assetDecimals; // Asset decimal places
bool vaultActive; // Vault operational status
bool strategyPaused; // Strategy pause status
uint256 assetPriceUSD; // Asset price in USD (18 decimals) - 0 if unavailable
uint8 priceConfidence; // Oracle confidence level (0-100) - 0 if no oracle
}
/**
* @notice User-specific portfolio data
* @dev Computed by querying vault and asset contracts for user balances
* @dev Pass address(0) to skip user-specific data
*
* Data Sources:
* - vault.balanceOf(user)
* - asset.balanceOf(user)
* - asset.allowance(user, vault)
*/
struct UserPortfolioData {
uint256 userBalance; // User's vault share balance
uint256 userAssetBalance; // User's underlying asset balance
uint256 userAllowance; // User's asset allowance to vault
uint256 positionValueUSD; // User's vault position value in USD (6 decimals) - 0 if unavailable
uint256 availableValueUSD; // User's available asset balance in USD (6 decimals) - 0 if unavailable
}
/**
* @notice Fee configuration data
* @dev Computed by querying fee configuration from Diamond storage
* @dev Only performance fees are charged - deposit/withdrawal fees removed
*
* Data Sources:
* - s.vaultFeeConfigs[vault] or s.universalFeeConfig
* - controller.defaultPerformanceFee (fallback)
*/
struct VaultFeeData {
uint256 performanceFee; // Performance fee in basis points (only fee charged)
uint256 supplyApy; // Supply APY for lending strategies
uint256 borrowApy; // Borrow APY for lending strategies
uint256 collateralFactor; // Collateral factor for lending (basis points)
}
/**
* @notice Harvest readiness and reward data
* @dev Computed by querying strategy contract for pending rewards
* @dev Used to determine if harvest() can be called profitably
*
* Data Sources:
* - strategy.totalRewardsAvailable()
* - strategy.lastHarvest()
* - strategy.paused()
*/
struct HarvestData {
uint256 pendingRewards; // Total pending rewards available
uint256 lastHarvestTime; // Timestamp of last harvest
uint256 timeSinceLastHarvest; // Calculated time since last harvest
uint256 totalHarvests; // Total number of harvests executed
address[] rewardTokens; // Array of reward token addresses
uint256[] rewardAmounts; // Array of pending reward amounts
bool canHarvest; // Whether harvest can be called now
uint256 callRewardValueUSD; // Harvester reward value in USD (6 decimals) - 0 if unavailable
uint256 pendingRewardsValueUSD; // Total pending rewards value in USD (6 decimals) - 0 if unavailable
}
// ════════════════════════════════════════════════════════════════════════════════
// DERIVED DATA (Layer 3: Computed from Logic)
// ════════════════════════════════════════════════════════════════════════════════
/**
* @notice Vault status enumeration
* @dev Computed from vault.active() and strategy.paused()
*/
enum VaultStatus {
Active, // Vault is active and strategy is not paused
Paused, // Strategy is paused (deposits/withdrawals may be restricted)
Retired // Vault is retired (no longer operational)
}
// ════════════════════════════════════════════════════════════════════════════════
// METADATA REGISTRY STRUCTURES
// ════════════════════════════════════════════════════════════════════════════════
/**
* @notice Chain metadata for the current deployment
* @dev Each Diamond deployment is chain-specific, so only one ChainMetadata per deployment
* @dev Stored once per chain, provides UI with chain-specific information
*
* Use Cases:
* - Display chain name and logo in UI
* - Provide explorer links for contract addresses
* - Enable wallet RPC configuration
*/
struct ChainMetadata {
uint256 chainId; // Chain ID (e.g., 146 for Sonic)
bytes32 name; // Chain name (e.g., "Sonic")
bytes32 nativeCurrency; // Native currency symbol (e.g., "S")
bytes logoURI; // Chain logo (IPFS/HTTP)
bytes explorerBaseURL; // Block explorer base URL (e.g., "https://sonicscan.org")
bytes rpcURL; // RPC endpoint for wallet connections
bool isSet; // Whether metadata has been configured
}
/**
* @notice Dynamic token category information
* @dev Replaces enum to allow runtime category management
* @dev Categories can be added/updated without contract redeployment
*
* Use Cases:
* - Filter tokens by category in UI
* - Organize token selection dropdowns
* - Display category-specific metadata
*/
struct TokenCategoryInfo {
bytes32 categoryId; // Unique identifier (e.g., keccak256("STABLECOIN"))
bytes32 displayName; // UI display name (e.g., "Stablecoin")
bytes description; // Category description for UI
bool isActive; // Whether category is active
uint256 createdAt; // Creation timestamp
}
/**
* @notice Complete token metadata for UI display
* @dev Stored per token address in MetadataRegistry
* @dev Uses bytes instead of string for gas efficiency
*
* Use Cases:
* - Display token symbols and logos in vault list
* - Enable "Create Vault" UI with token dropdowns
* - Show rich token information in AssetsTab
* - Filter tokens by category
*/
struct TokenMetadata {
address tokenAddress; // Token contract address
bytes32 symbol; // Token symbol (e.g., "USDC") - bytes32 for gas efficiency
bytes32 name; // Token name (e.g., "USD Coin")
uint8 decimals; // Token decimals
bytes32 category; // References TokenCategoryInfo.categoryId
bytes logoURI; // Token logo (IPFS/HTTP) - bytes for flexibility
bytes description; // Rich description for AssetsTab (supports markdown)
bool isActive; // Whether token is active for new vaults
uint256 addedAt; // Timestamp when token was registered
}
// Default category constants for initialization
bytes32 constant CATEGORY_STABLECOIN = keccak256("STABLECOIN");
bytes32 constant CATEGORY_GOVERNANCE = keccak256("GOVERNANCE");
bytes32 constant CATEGORY_LP_TOKEN = keccak256("LP_TOKEN");
bytes32 constant CATEGORY_WRAPPED_NATIVE = keccak256("WRAPPED_NATIVE");
bytes32 constant CATEGORY_YIELD_BEARING = keccak256("YIELD_BEARING");
bytes32 constant CATEGORY_BRIDGE_TOKEN = keccak256("BRIDGE_TOKEN");
/**
* @notice Vault tag information for filtering and discovery
* @dev Tags are dynamic, reusable labels that can be applied to multiple vaults
* @dev Examples: "LP Strategy", "Single Asset", "Lending"
*
* Use Cases:
* - Filter vaults by strategy type
* - Display strategy badges in UI
* - Group vaults by characteristics
* - Enable advanced search and discovery
*/
struct VaultTagInfo {
bytes32 tagId; // Unique identifier (e.g., keccak256("LP_STRATEGY"))
bytes32 displayName; // UI display name (e.g., "LP Strategy")
bytes description; // Tag description for tooltips
bool isActive; // Whether tag is active
}
// Minimal tag constants for auto-tagging logic (used by ControllerFacet)
bytes32 constant TAG_LP_STRATEGY = keccak256("LP_STRATEGY");
bytes32 constant TAG_SINGLE_ASSET = keccak256("SINGLE_ASSET");
bytes32 constant TAG_LENDING = keccak256("LENDING");
// ════════════════════════════════════════════════════════════════════════════════
// FEE SYSTEM STRUCTURES
// ════════════════════════════════════════════════════════════════════════════════
/**
* @notice Fee configuration for a specific vault
* @dev Simplified to only performance fees - deposit/withdrawal fees removed (unused)
*/
struct VaultFeeConfig {
uint16 performanceFee; // Performance fee in basis points (only fee charged)
address[] recipients; // Fee recipients
uint256[] ratios; // Fee ratios (basis points, should sum to 10000)
bytes32[] labels; // Labels for identification
uint256 lastUpdated; // Last update timestamp
bool isOverride; // Whether this overrides universal config
}
/**
* @notice Universal fee configuration (default for all vaults)
* @dev Used when vault doesn't have a specific fee override
*/
struct UniversalFeeConfig {
address[] recipients; // Fee recipients
uint256[] ratios; // Fee ratios (basis points, should sum to 10000)
bytes32[] labels; // Labels for identification
uint256 lastUpdated; // Last update timestamp
}
// Note: ProtocolInfo struct removed - use UniversalFactory instead
// Migration: UniversalFactoryFacet.getProtocolRegistration(baseProtocol)
// ════════════════════════════════════════════════════════════════════════════════
// SHARED EVENTS
// ════════════════════════════════════════════════════════════════════════════════
/// @notice Vault operations
event VaultDeployed(
address indexed vault,
address indexed strategy,
address indexed asset,
bytes name, // Full-length name (no truncation)
bytes32 symbol,
bytes32 strategyType,
bytes32 baseProtocol
);
event VaultUpdated(address indexed vault, uint256 indexed updateType, bytes data);
event HarvestExecuted(address indexed vault, address indexed harvester, uint256 yield, uint256 lastAPY, uint256 totalAssets);
event FeeConfigUpdated(address indexed vault, VaultFeeConfig config, bool isUniversal);
event ProtocolConfigured(
bytes32 indexed protocolType, address indexed factory, address indexed implementation, bool isActive
);
event ProtocolConstantsUpdated(
uint256 basisPoints, uint256 maxSlippage, uint256 minHarvestDelay, uint256 defaultPerformanceFee, uint256 defaultSlippageTolerance
);
event RolesTransferredOnRegistration(
address indexed vault, address indexed strategy, bool managerRole, bool emergencyRole
);
event VaultUIMetadataUpdated(address indexed vault, VaultUIMetadata uiMetadata);
event VaultMetadataUpdated(
address indexed vault,
bytes name,
bytes32 protocol,
bytes32 category,
uint8 riskLevel
);
event VaultTagsUpdated(address indexed vault, bytes32[] oldTags, bytes32[] newTags);
/// @notice Strategy operations
event StrategyUpdated(address indexed newStrategy);
event StrategyConfigUpdated(uint8 indexed updateType, bytes data);
event StrategyDeployed(address indexed strategy, bytes32 indexed protocolType, address indexed deployer);
event StrategyDeployedDetailed(
address indexed strategy,
address indexed vault,
bytes32 indexed strategyType,
address deployer,
address asset,
uint256 timestamp
);
/// @notice Deployment queue operations
event DeploymentQueued(address indexed vault, address indexed strategy, address indexed asset, address deployer);
event DeploymentConfirmed(address indexed vault, bool managerRoleTransferred, bool emergencyRoleTransferred);
event DeploymentRejected(address indexed vault, address indexed strategy, address indexed asset);
/// @notice Permission system
event RoleCacheUpdated(bytes32 indexed role, address indexed account, bool granted);
event FeeRecipientUpdated(address indexed previousFeeRecipient, address indexed newFeeRecipient);
/// @notice Rewards and routing
event RewardTokensSet(address[] rewardTokens);
event RewardConfigurationUpdated(address[] rewardTokens, address[][] routes);
event NativeToLp0RouteSet(address[] route);
event NativeToLp1RouteSet(address[] route);
event EmergencyWithdrawFailed(bytes reason);
// ════════════════════════════════════════════════════════════════════════════════
// SHARED ERRORS
// ════════════════════════════════════════════════════════════════════════════════
/// @notice General errors
error ZeroAddress();
error InvalidAsset();
error InvalidRouter();
error InvalidStrategy(address strategy);
error InvalidVault(address vault);
error InvalidShadowToken();
error InvalidRecipient();
error OnlyVault();
error VaultNotFound(address vault);
error StrategyNotFound();
error ProtocolNotFound(bytes32 protocol);
error ProtocolInactive(bytes32 protocol);
error AlreadyInitialized();
error UnauthorizedUpdate();
error EmptyArray();
error NoRewardTokens();
error NativeTokenNotConfigured();
/// @notice Fee system errors
error FeeTooHigh(uint256 fee, uint256 maxFee);
error TotalFeesExceeded(uint256 totalFees, uint256 maxFees);
error InvalidConfiguration();
/// @notice Registration errors
error VaultAlreadyRegistered();
error VaultNotConnectedToStrategy();
error StrategyOwnershipTransferFailed();
error DuplicateRegistration(address asset, bytes32 strategyType);
/// @notice Queue system errors
error DeploymentAlreadyQueued();
error DeploymentNotQueued();
error DeploymentAlreadyRegistered();
error NotValidDeployment();
// ============================================================================
// UNIVERSAL FACTORY TYPES
// ============================================================================
/// @notice Protocol registration in UniversalFactory
struct ProtocolRegistration {
bytes32 baseProtocol; // Protocol identifier (e.g., "Shadow")
uint256 protocolIndex; // Index in enumeration array
bytes description; // Protocol description
bool isActive; // Whether protocol accepts new deployments
bool exists; // Whether protocol is registered
uint256 registeredAt; // Registration timestamp
uint256 totalDeployments; // Total strategies deployed across all types
bytes logoURI; // Protocol logo (IPFS/HTTP) for UI display
bytes[] socials; // Social links [website, docs, discord, twitter]
}
/// @notice Strategy type registration in UniversalFactory
struct StrategyTypeRegistration {
bytes32 strategyType; // Strategy type identifier (e.g., "Shadow-Volatile")
uint256 typeIndex; // Index within protocol's strategy types
address implementation; // Master implementation address
bytes name; // Human-readable name
bytes description; // Strategy description
bool isActive; // Whether type accepts new deployments
bool exists; // Whether type is registered
uint256 registeredAt; // Registration timestamp
uint256 deployCount; // Number of strategies deployed
}
// ============================================================================
// ORACLE TYPES
// ============================================================================
/// @notice Price data with metadata
struct PriceData {
uint256 price; // Price in USD (18 decimals)
uint8 confidence; // Confidence level (0-100)
uint256 lastUpdate; // Last update timestamp
bytes32 method; // Pricing method used
}
/// @notice Router info for Oracle price queries
struct OracleRouterInfo {
address routerAddress; // DEX router address
RouterType routerType; // Router type (SOLIDLY, UNISWAP_V2, etc.)
}
/// @notice LP token data structure (supports multi-token pools)
/// @dev Uses arrays to support 2-token pairs AND multi-token pools (Balancer, Curve)
struct LPTokenData {
bool isLP; // Is this an LP token?
address[] tokens; // ALL tokens (2 for UniV2/Solidly, 3+ for Balancer/Curve)
uint256[] reserves; // ALL reserves (parallel to tokens array)
uint256 totalSupply; // Total LP token supply
bool isStable; // Stable vs volatile pool
bytes metadata; // Protocol-specific data (poolId, fees, etc.)
}
/// @notice Asset type classification
enum AssetType {
STANDALONE_TOKEN, // Regular ERC20 (USDC, WETH, SHADOW)
LP_TOKEN_2, // 2-token LP (UniswapV2, Solidly pairs)
LP_TOKEN_MULTI, // Multi-token LP (Balancer, Curve pools with 3+ tokens)
YIELD_BEARING // Yield-bearing tokens (aUSDC, cDAI - future support)
}
/// @notice Complete asset metadata for registry
/// @dev Used by ChainRegistryFacet for explicit asset registration
struct AssetMetadata {
address assetAddress; // Asset contract address
AssetType assetType; // Type classification
RouterType routerType; // For LP tokens: which DEX/router type
// Composition (for LP tokens)
address[] componentTokens; // Underlying tokens (e.g., [SHADOW, wSONIC])
// Display metadata
bytes32 symbol; // Asset symbol (e.g., "SHADOW-wSONIC-LP")
bytes name; // Full name for UI display
bytes logoURI; // Asset logo URI (IPFS/HTTP)
// Categorization & Status
bytes32 category; // Category ID (references TokenCategoryInfo)
bool isActive; // Whether asset can be used for new vaults
uint256 registeredAt; // Registration timestamp
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "../storage/PetalsStorageLayout.sol";
/**
* @title RoleChecker
* @author Petals Protocol
* @notice Shared access control library for all Diamond facets
* @dev Provides centralized role checking logic to avoid duplication across facets
*
* Named RoleChecker (not AccessControl) to avoid conflicts with OpenZeppelin's AccessControl contract
*
* Usage:
* import "../../00_libraries/RoleChecker.sol";
*
* modifier onlyRole(uint64 role) {
* if (!RoleChecker.hasRole(role, msg.sender)) {
* revert UnauthorizedUpdate();
* }
* _;
* }
*/
library RoleChecker {
/// @notice Master role constant (admin/owner role)
uint64 internal constant MASTER_ROLE = 0;
/// @notice Strategist role constant
uint64 internal constant STRATEGIST_ROLE = 1;
/// @notice Guardian role constant (protocol-wide emergency powers)
uint64 internal constant GUARDIAN_ROLE = 2;
/**
* @notice Check if an account has a specific role
* @dev Checks in order:
* 1. Is account the master address for MASTER_ROLE?
* 2. Does account have role on this contract (address(this))?
* 3. Does account have global role (address(0))?
* @param role Role ID to check
* @param account Account address to check
* @return Whether account has the role
*/
function hasRole(uint64 role, address account) internal view returns (bool) {
PetalsStorageLayout.AppStorage storage s = PetalsStorageLayout.getStorage();
// Master address always has MASTER_ROLE
if (role == MASTER_ROLE && account == s.masterAddress) return true;
// Check contract-specific role
if (s.contractRoles[address(this)][role][account]) return true;
// Check global role (address(0) = all contracts)
if (s.contractRoles[address(0)][role][account]) return true;
return false;
}
// Note: requireRole() function removed - use hasRole() with custom errors instead
// Example: if (!RoleChecker.hasRole(role, msg.sender)) revert UnauthorizedUpdate();
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/ERC20.sol)
pragma solidity ^0.8.20;
import {IERC20} from "./IERC20.sol";
import {IERC20Metadata} from "./extensions/IERC20Metadata.sol";
import {Context} from "../../utils/Context.sol";
import {IERC20Errors} from "../../interfaces/draft-IERC6093.sol";
/**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
*
* TIP: For a detailed writeup see our guide
* https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* The default value of {decimals} is 18. To change this, you should override
* this function so it returns a different value.
*
* We have followed general OpenZeppelin Contracts guidelines: functions revert
* instead returning `false` on failure. This behavior is nonetheless
* conventional and does not conflict with the expectations of ERC-20
* applications.
*/
abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors {
mapping(address account => uint256) private _balances;
mapping(address account => mapping(address spender => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {symbol}.
*
* Both values are immutable: they can only be set once during construction.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual returns (string memory) {
return _symbol;
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5.05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the default value returned by this function, unless
* it's overridden.
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual returns (uint8) {
return 18;
}
/// @inheritdoc IERC20
function totalSupply() public view virtual returns (uint256) {
return _totalSupply;
}
/// @inheritdoc IERC20
function balanceOf(address account) public view virtual returns (uint256) {
return _balances[account];
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - the caller must have a balance of at least `value`.
*/
function transfer(address to, uint256 value) public virtual returns (bool) {
address owner = _msgSender();
_transfer(owner, to, value);
return true;
}
/// @inheritdoc IERC20
function allowance(address owner, address spender) public view virtual returns (uint256) {
return _allowances[owner][spender];
}
/**
* @dev See {IERC20-approve}.
*
* NOTE: If `value` is the maximum `uint256`, the allowance is not updated on
* `transferFrom`. This is semantically equivalent to an infinite approval.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 value) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, value);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Skips emitting an {Approval} event indicating an allowance update. This is not
* required by the ERC. See {xref-ERC20-_approve-address-address-uint256-bool-}[_approve].
*
* NOTE: Does not update the allowance if the current allowance
* is the maximum `uint256`.
*
* Requirements:
*
* - `from` and `to` cannot be the zero address.
* - `from` must have a balance of at least `value`.
* - the caller must have allowance for ``from``'s tokens of at least
* `value`.
*/
function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, value);
_transfer(from, to, value);
return true;
}
/**
* @dev Moves a `value` amount of tokens from `from` to `to`.
*
* This internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* NOTE: This function is not virtual, {_update} should be overridden instead.
*/
function _transfer(address from, address to, uint256 value) internal {
if (from == address(0)) {
revert ERC20InvalidSender(address(0));
}
if (to == address(0)) {
revert ERC20InvalidReceiver(address(0));
}
_update(from, to, value);
}
/**
* @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`
* (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding
* this function.
*
* Emits a {Transfer} event.
*/
function _update(address from, address to, uint256 value) internal virtual {
if (from == address(0)) {
// Overflow check required: The rest of the code assumes that totalSupply never overflows
_totalSupply += value;
} else {
uint256 fromBalance = _balances[from];
if (fromBalance < value) {
revert ERC20InsufficientBalance(from, fromBalance, value);
}
unchecked {
// Overflow not possible: value <= fromBalance <= totalSupply.
_balances[from] = fromBalance - value;
}
}
if (to == address(0)) {
unchecked {
// Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.
_totalSupply -= value;
}
} else {
unchecked {
// Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.
_balances[to] += value;
}
}
emit Transfer(from, to, value);
}
/**
* @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).
* Relies on the `_update` mechanism
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* NOTE: This function is not virtual, {_update} should be overridden instead.
*/
function _mint(address account, uint256 value) internal {
if (account == address(0)) {
revert ERC20InvalidReceiver(address(0));
}
_update(address(0), account, value);
}
/**
* @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.
* Relies on the `_update` mechanism.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* NOTE: This function is not virtual, {_update} should be overridden instead
*/
function _burn(address account, uint256 value) internal {
if (account == address(0)) {
revert ERC20InvalidSender(address(0));
}
_update(account, address(0), value);
}
/**
* @dev Sets `value` as the allowance of `spender` over the `owner`'s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*
* Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
*/
function _approve(address owner, address spender, uint256 value) internal {
_approve(owner, spender, value, true);
}
/**
* @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.
*
* By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by
* `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any
* `Approval` event during `transferFrom` operations.
*
* Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to
* true using the following override:
*
* ```solidity
* function _approve(address owner, address spender, uint256 value, bool) internal virtual override {
* super._approve(owner, spender, value, true);
* }
* ```
*
* Requirements are the same as {_approve}.
*/
function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {
if (owner == address(0)) {
revert ERC20InvalidApprover(address(0));
}
if (spender == address(0)) {
revert ERC20InvalidSpender(address(0));
}
_allowances[owner][spender] = value;
if (emitEvent) {
emit Approval(owner, spender, value);
}
}
/**
* @dev Updates `owner`'s allowance for `spender` based on spent `value`.
*
* Does not update the allowance value in case of infinite allowance.
* Revert if not enough allowance is available.
*
* Does not emit an {Approval} event.
*/
function _spendAllowance(address owner, address spender, uint256 value) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance < type(uint256).max) {
if (currentAllowance < value) {
revert ERC20InsufficientAllowance(spender, currentAllowance, value);
}
unchecked {
_approve(owner, spender, currentAllowance - value, false);
}
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)
pragma solidity ^0.8.20;
import {Context} from "../utils/Context.sol";
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* The initial owner is set to the address provided by the deployer. This can
* later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract Ownable is Context {
address private _owner;
/**
* @dev The caller account is not authorized to perform an operation.
*/
error OwnableUnauthorizedAccount(address account);
/**
* @dev The owner is not a valid owner account. (eg. `address(0)`)
*/
error OwnableInvalidOwner(address owner);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the address provided by the deployer as the initial owner.
*/
constructor(address initialOwner) {
if (initialOwner == address(0)) {
revert OwnableInvalidOwner(address(0));
}
_transferOwnership(initialOwner);
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
_checkOwner();
_;
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
return _owner;
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
if (owner() != _msgSender()) {
revert OwnableUnauthorizedAccount(_msgSender());
}
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby disabling any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
if (newOwner == address(0)) {
revert OwnableInvalidOwner(address(0));
}
_transferOwnership(newOwner);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)
pragma solidity ^0.8.20;
import {IERC20} from "../IERC20.sol";
import {IERC1363} from "../../../interfaces/IERC1363.sol";
/**
* @title SafeERC20
* @dev Wrappers around ERC-20 operations that throw on failure (when the token
* contract returns false). Tokens that return no value (and instead revert or
* throw on failure) are also supported, non-reverting calls are assumed to be
* successful.
* To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
* which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
*/
library SafeERC20 {
/**
* @dev An operation with an ERC-20 token failed.
*/
error SafeERC20FailedOperation(address token);
/**
* @dev Indicates a failed `decreaseAllowance` request.
*/
error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);
/**
* @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
* non-reverting calls are assumed to be successful.
*/
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
}
/**
* @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
* calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
*/
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
}
/**
* @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.
*/
function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {
return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));
}
/**
* @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.
*/
function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {
return _callOptionalReturnBool(token, abi.encodeCall(token.transferFrom, (from, to, value)));
}
/**
* @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
* non-reverting calls are assumed to be successful.
*
* IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the "client"
* smart contract uses ERC-7674 to set temporary allowances, then the "client" smart contract should avoid using
* this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract
* that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.
*/
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 oldAllowance = token.allowance(address(this), spender);
forceApprove(token, spender, oldAllowance + value);
}
/**
* @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
* value, non-reverting calls are assumed to be successful.
*
* IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the "client"
* smart contract uses ERC-7674 to set temporary allowances, then the "client" smart contract should avoid using
* this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract
* that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.
*/
function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
unchecked {
uint256 currentAllowance = token.allowance(address(this), spender);
if (currentAllowance < requestedDecrease) {
revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
}
forceApprove(token, spender, currentAllowance - requestedDecrease);
}
}
/**
* @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
* non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
* to be set to zero before setting it to a non-zero value, such as USDT.
*
* NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function
* only sets the "standard" allowance. Any temporary allowance will remain active, in addition to the value being
* set here.
*/
function forceApprove(IERC20 token, address spender, uint256 value) internal {
bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));
if (!_callOptionalReturnBool(token, approvalCall)) {
_callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
_callOptionalReturn(token, approvalCall);
}
}
/**
* @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no
* code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
* targeting contracts.
*
* Reverts if the returned value is other than `true`.
*/
function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {
if (to.code.length == 0) {
safeTransfer(token, to, value);
} else if (!token.transferAndCall(to, value, data)) {
revert SafeERC20FailedOperation(address(token));
}
}
/**
* @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target
* has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
* targeting contracts.
*
* Reverts if the returned value is other than `true`.
*/
function transferFromAndCallRelaxed(
IERC1363 token,
address from,
address to,
uint256 value,
bytes memory data
) internal {
if (to.code.length == 0) {
safeTransferFrom(token, from, to, value);
} else if (!token.transferFromAndCall(from, to, value, data)) {
revert SafeERC20FailedOperation(address(token));
}
}
/**
* @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no
* code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
* targeting contracts.
*
* NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.
* Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}
* once without retrying, and relies on the returned value to be true.
*
* Reverts if the returned value is other than `true`.
*/
function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {
if (to.code.length == 0) {
forceApprove(token, to, value);
} else if (!token.approveAndCall(to, value, data)) {
revert SafeERC20FailedOperation(address(token));
}
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*
* This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.
*/
function _callOptionalReturn(IERC20 token, bytes memory data) private {
uint256 returnSize;
uint256 returnValue;
assembly ("memory-safe") {
let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)
// bubble errors
if iszero(success) {
let ptr := mload(0x40)
returndatacopy(ptr, 0, returndatasize())
revert(ptr, returndatasize())
}
returnSize := returndatasize()
returnValue := mload(0)
}
if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {
revert SafeERC20FailedOperation(address(token));
}
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*
* This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.
*/
function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
bool success;
uint256 returnSize;
uint256 returnValue;
assembly ("memory-safe") {
success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)
returnSize := returndatasize()
returnValue := mload(0)
}
return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.3.0) (interfaces/IERC4626.sol)
pragma solidity >=0.6.2;
import {IERC20} from "../token/ERC20/IERC20.sol";
import {IERC20Metadata} from "../token/ERC20/extensions/IERC20Metadata.sol";
/**
* @dev Interface of the ERC-4626 "Tokenized Vault Standard", as defined in
* https://eips.ethereum.org/EIPS/eip-4626[ERC-4626].
*/
interface IERC4626 is IERC20, IERC20Metadata {
event Deposit(address indexed sender, address indexed owner, uint256 assets, uint256 shares);
event Withdraw(
address indexed sender,
address indexed receiver,
address indexed owner,
uint256 assets,
uint256 shares
);
/**
* @dev Returns the address of the underlying token used for the Vault for accounting, depositing, and withdrawing.
*
* - MUST be an ERC-20 token contract.
* - MUST NOT revert.
*/
function asset() external view returns (address assetTokenAddress);
/**
* @dev Returns the total amount of the underlying asset that is “managed” by Vault.
*
* - SHOULD include any compounding that occurs from yield.
* - MUST be inclusive of any fees that are charged against assets in the Vault.
* - MUST NOT revert.
*/
function totalAssets() external view returns (uint256 totalManagedAssets);
/**
* @dev Returns the amount of shares that the Vault would exchange for the amount of assets provided, in an ideal
* scenario where all the conditions are met.
*
* - MUST NOT be inclusive of any fees that are charged against assets in the Vault.
* - MUST NOT show any variations depending on the caller.
* - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.
* - MUST NOT revert.
*
* NOTE: This calculation MAY NOT reflect the “per-user” price-per-share, and instead should reflect the
* “average-user’s” price-per-share, meaning what the average user should expect to see when exchanging to and
* from.
*/
function convertToShares(uint256 assets) external view returns (uint256 shares);
/**
* @dev Returns the amount of assets that the Vault would exchange for the amount of shares provided, in an ideal
* scenario where all the conditions are met.
*
* - MUST NOT be inclusive of any fees that are charged against assets in the Vault.
* - MUST NOT show any variations depending on the caller.
* - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.
* - MUST NOT revert.
*
* NOTE: This calculation MAY NOT reflect the “per-user” price-per-share, and instead should reflect the
* “average-user’s” price-per-share, meaning what the average user should expect to see when exchanging to and
* from.
*/
function convertToAssets(uint256 shares) external view returns (uint256 assets);
/**
* @dev Returns the maximum amount of the underlying asset that can be deposited into the Vault for the receiver,
* through a deposit call.
*
* - MUST return a limited value if receiver is subject to some deposit limit.
* - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of assets that may be deposited.
* - MUST NOT revert.
*/
function maxDeposit(address receiver) external view returns (uint256 maxAssets);
/**
* @dev Allows an on-chain or off-chain user to simulate the effects of their deposit at the current block, given
* current on-chain conditions.
*
* - MUST return as close to and no more than the exact amount of Vault shares that would be minted in a deposit
* call in the same transaction. I.e. deposit should return the same or more shares as previewDeposit if called
* in the same transaction.
* - MUST NOT account for deposit limits like those returned from maxDeposit and should always act as though the
* deposit would be accepted, regardless if the user has enough tokens approved, etc.
* - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.
* - MUST NOT revert.
*
* NOTE: any unfavorable discrepancy between convertToShares and previewDeposit SHOULD be considered slippage in
* share price or some other type of condition, meaning the depositor will lose assets by depositing.
*/
function previewDeposit(uint256 assets) external view returns (uint256 shares);
/**
* @dev Mints shares Vault shares to receiver by depositing exactly amount of underlying tokens.
*
* - MUST emit the Deposit event.
* - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the
* deposit execution, and are accounted for during deposit.
* - MUST revert if all of assets cannot be deposited (due to deposit limit being reached, slippage, the user not
* approving enough underlying tokens to the Vault contract, etc).
*
* NOTE: most implementations will require pre-approval of the Vault with the Vault’s underlying asset token.
*/
function deposit(uint256 assets, address receiver) external returns (uint256 shares);
/**
* @dev Returns the maximum amount of the Vault shares that can be minted for the receiver, through a mint call.
* - MUST return a limited value if receiver is subject to some mint limit.
* - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of shares that may be minted.
* - MUST NOT revert.
*/
function maxMint(address receiver) external view returns (uint256 maxShares);
/**
* @dev Allows an on-chain or off-chain user to simulate the effects of their mint at the current block, given
* current on-chain conditions.
*
* - MUST return as close to and no fewer than the exact amount of assets that would be deposited in a mint call
* in the same transaction. I.e. mint should return the same or fewer assets as previewMint if called in the
* same transaction.
* - MUST NOT account for mint limits like those returned from maxMint and should always act as though the mint
* would be accepted, regardless if the user has enough tokens approved, etc.
* - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.
* - MUST NOT revert.
*
* NOTE: any unfavorable discrepancy between convertToAssets and previewMint SHOULD be considered slippage in
* share price or some other type of condition, meaning the depositor will lose assets by minting.
*/
function previewMint(uint256 shares) external view returns (uint256 assets);
/**
* @dev Mints exactly shares Vault shares to receiver by depositing amount of underlying tokens.
*
* - MUST emit the Deposit event.
* - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the mint
* execution, and are accounted for during mint.
* - MUST revert if all of shares cannot be minted (due to deposit limit being reached, slippage, the user not
* approving enough underlying tokens to the Vault contract, etc).
*
* NOTE: most implementations will require pre-approval of the Vault with the Vault’s underlying asset token.
*/
function mint(uint256 shares, address receiver) external returns (uint256 assets);
/**
* @dev Returns the maximum amount of the underlying asset that can be withdrawn from the owner balance in the
* Vault, through a withdraw call.
*
* - MUST return a limited value if owner is subject to some withdrawal limit or timelock.
* - MUST NOT revert.
*/
function maxWithdraw(address owner) external view returns (uint256 maxAssets);
/**
* @dev Allows an on-chain or off-chain user to simulate the effects of their withdrawal at the current block,
* given current on-chain conditions.
*
* - MUST return as close to and no fewer than the exact amount of Vault shares that would be burned in a withdraw
* call in the same transaction. I.e. withdraw should return the same or fewer shares as previewWithdraw if
* called
* in the same transaction.
* - MUST NOT account for withdrawal limits like those returned from maxWithdraw and should always act as though
* the withdrawal would be accepted, regardless if the user has enough shares, etc.
* - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.
* - MUST NOT revert.
*
* NOTE: any unfavorable discrepancy between convertToShares and previewWithdraw SHOULD be considered slippage in
* share price or some other type of condition, meaning the depositor will lose assets by depositing.
*/
function previewWithdraw(uint256 assets) external view returns (uint256 shares);
/**
* @dev Burns shares from owner and sends exactly assets of underlying tokens to receiver.
*
* - MUST emit the Withdraw event.
* - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the
* withdraw execution, and are accounted for during withdraw.
* - MUST revert if all of assets cannot be withdrawn (due to withdrawal limit being reached, slippage, the owner
* not having enough shares, etc).
*
* Note that some implementations will require pre-requesting to the Vault before a withdrawal may be performed.
* Those methods should be performed separately.
*/
function withdraw(uint256 assets, address receiver, address owner) external returns (uint256 shares);
/**
* @dev Returns the maximum amount of Vault shares that can be redeemed from the owner balance in the Vault,
* through a redeem call.
*
* - MUST return a limited value if owner is subject to some withdrawal limit or timelock.
* - MUST return balanceOf(owner) if owner is not subject to any withdrawal limit or timelock.
* - MUST NOT revert.
*/
function maxRedeem(address owner) external view returns (uint256 maxShares);
/**
* @dev Allows an on-chain or off-chain user to simulate the effects of their redemption at the current block,
* given current on-chain conditions.
*
* - MUST return as close to and no more than the exact amount of assets that would be withdrawn in a redeem call
* in the same transaction. I.e. redeem should return the same or more assets as previewRedeem if called in the
* same transaction.
* - MUST NOT account for redemption limits like those returned from maxRedeem and should always act as though the
* redemption would be accepted, regardless if the user has enough shares, etc.
* - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.
* - MUST NOT revert.
*
* NOTE: any unfavorable discrepancy between convertToAssets and previewRedeem SHOULD be considered slippage in
* share price or some other type of condition, meaning the depositor will lose assets by redeeming.
*/
function previewRedeem(uint256 shares) external view returns (uint256 assets);
/**
* @dev Burns exactly shares from owner and sends assets of underlying tokens to receiver.
*
* - MUST emit the Withdraw event.
* - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the
* redeem execution, and are accounted for during redeem.
* - MUST revert if all of shares cannot be redeemed (due to withdrawal limit being reached, slippage, the owner
* not having enough shares, etc).
*
* NOTE: some implementations will require pre-requesting to the Vault before a withdrawal may be performed.
* Those methods should be performed separately.
*/
function redeem(uint256 shares, address receiver, address owner) external returns (uint256 assets);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.3.0) (utils/math/Math.sol)
pragma solidity ^0.8.20;
import {Panic} from "../Panic.sol";
import {SafeCast} from "./SafeCast.sol";
/**
* @dev Standard math utilities missing in the Solidity language.
*/
library Math {
enum Rounding {
Floor, // Toward negative infinity
Ceil, // Toward positive infinity
Trunc, // Toward zero
Expand // Away from zero
}
/**
* @dev Return the 512-bit addition of two uint256.
*
* The result is stored in two 256 variables such that sum = high * 2²⁵⁶ + low.
*/
function add512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {
assembly ("memory-safe") {
low := add(a, b)
high := lt(low, a)
}
}
/**
* @dev Return the 512-bit multiplication of two uint256.
*
* The result is stored in two 256 variables such that product = high * 2²⁵⁶ + low.
*/
function mul512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {
// 512-bit multiply [high low] = x * y. Compute the product mod 2²⁵⁶ and mod 2²⁵⁶ - 1, then use
// the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
// variables such that product = high * 2²⁵⁶ + low.
assembly ("memory-safe") {
let mm := mulmod(a, b, not(0))
low := mul(a, b)
high := sub(sub(mm, low), lt(mm, low))
}
}
/**
* @dev Returns the addition of two unsigned integers, with a success flag (no overflow).
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
unchecked {
uint256 c = a + b;
success = c >= a;
result = c * SafeCast.toUint(success);
}
}
/**
* @dev Returns the subtraction of two unsigned integers, with a success flag (no overflow).
*/
function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
unchecked {
uint256 c = a - b;
success = c <= a;
result = c * SafeCast.toUint(success);
}
}
/**
* @dev Returns the multiplication of two unsigned integers, with a success flag (no overflow).
*/
function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
unchecked {
uint256 c = a * b;
assembly ("memory-safe") {
// Only true when the multiplication doesn't overflow
// (c / a == b) || (a == 0)
success := or(eq(div(c, a), b), iszero(a))
}
// equivalent to: success ? c : 0
result = c * SafeCast.toUint(success);
}
}
/**
* @dev Returns the division of two unsigned integers, with a success flag (no division by zero).
*/
function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
unchecked {
success = b > 0;
assembly ("memory-safe") {
// The `DIV` opcode returns zero when the denominator is 0.
result := div(a, b)
}
}
}
/**
* @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).
*/
function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
unchecked {
success = b > 0;
assembly ("memory-safe") {
// The `MOD` opcode returns zero when the denominator is 0.
result := mod(a, b)
}
}
}
/**
* @dev Unsigned saturating addition, bounds to `2²⁵⁶ - 1` instead of overflowing.
*/
function saturatingAdd(uint256 a, uint256 b) internal pure returns (uint256) {
(bool success, uint256 result) = tryAdd(a, b);
return ternary(success, result, type(uint256).max);
}
/**
* @dev Unsigned saturating subtraction, bounds to zero instead of overflowing.
*/
function saturatingSub(uint256 a, uint256 b) internal pure returns (uint256) {
(, uint256 result) = trySub(a, b);
return result;
}
/**
* @dev Unsigned saturating multiplication, bounds to `2²⁵⁶ - 1` instead of overflowing.
*/
function saturatingMul(uint256 a, uint256 b) internal pure returns (uint256) {
(bool success, uint256 result) = tryMul(a, b);
return ternary(success, result, type(uint256).max);
}
/**
* @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.
*
* IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.
* However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute
* one branch when needed, making this function more expensive.
*/
function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {
unchecked {
// branchless ternary works because:
// b ^ (a ^ b) == a
// b ^ 0 == b
return b ^ ((a ^ b) * SafeCast.toUint(condition));
}
}
/**
* @dev Returns the largest of two numbers.
*/
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return ternary(a > b, a, b);
}
/**
* @dev Returns the smallest of two numbers.
*/
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return ternary(a < b, a, b);
}
/**
* @dev Returns the average of two numbers. The result is rounded towards
* zero.
*/
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow.
return (a & b) + (a ^ b) / 2;
}
/**
* @dev Returns the ceiling of the division of two numbers.
*
* This differs from standard division with `/` in that it rounds towards infinity instead
* of rounding towards zero.
*/
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
if (b == 0) {
// Guarantee the same behavior as in a regular Solidity division.
Panic.panic(Panic.DIVISION_BY_ZERO);
}
// The following calculation ensures accurate ceiling division without overflow.
// Since a is non-zero, (a - 1) / b will not overflow.
// The largest possible result occurs when (a - 1) / b is type(uint256).max,
// but the largest value we can obtain is type(uint256).max - 1, which happens
// when a = type(uint256).max and b = 1.
unchecked {
return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);
}
}
/**
* @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or
* denominator == 0.
*
* 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 {
(uint256 high, uint256 low) = mul512(x, y);
// Handle non-overflow cases, 256 by 256 division.
if (high == 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 low / denominator;
}
// Make sure the result is less than 2²⁵⁶. Also prevents denominator == 0.
if (denominator <= high) {
Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));
}
///////////////////////////////////////////////
// 512 by 256 division.
///////////////////////////////////////////////
// Make division exact by subtracting the remainder from [high low].
uint256 remainder;
assembly ("memory-safe") {
// Compute remainder using mulmod.
remainder := mulmod(x, y, denominator)
// Subtract 256 bit number from 512 bit number.
high := sub(high, gt(remainder, low))
low := sub(low, remainder)
}
// Factor powers of two out of denominator and compute largest power of two divisor of denominator.
// Always >= 1. See https://cs.stackexchange.com/q/138556/92363.
uint256 twos = denominator & (0 - denominator);
assembly ("memory-safe") {
// Divide denominator by twos.
denominator := div(denominator, twos)
// Divide [high low] by twos.
low := div(low, twos)
// Flip twos such that it is 2²⁵⁶ / twos. If twos is zero, then it becomes one.
twos := add(div(sub(0, twos), twos), 1)
}
// Shift in bits from high into low.
low |= high * twos;
// Invert denominator mod 2²⁵⁶. Now that denominator is an odd number, it has an inverse modulo 2²⁵⁶ such
// that denominator * inv ≡ 1 mod 2²⁵⁶. Compute the inverse by starting with a seed that is correct for
// four bits. That is, denominator * inv ≡ 1 mod 2⁴.
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⁸
inverse *= 2 - denominator * inverse; // inverse mod 2¹⁶
inverse *= 2 - denominator * inverse; // inverse mod 2³²
inverse *= 2 - denominator * inverse; // inverse mod 2⁶⁴
inverse *= 2 - denominator * inverse; // inverse mod 2¹²⁸
inverse *= 2 - denominator * inverse; // inverse mod 2²⁵⁶
// 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²⁵⁶. Since the preconditions guarantee that the outcome is
// less than 2²⁵⁶, this is the final result. We don't need to compute the high bits of the result and high
// is no longer required.
result = low * inverse;
return result;
}
}
/**
* @dev 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) {
return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);
}
/**
* @dev Calculates floor(x * y >> n) with full precision. Throws if result overflows a uint256.
*/
function mulShr(uint256 x, uint256 y, uint8 n) internal pure returns (uint256 result) {
unchecked {
(uint256 high, uint256 low) = mul512(x, y);
if (high >= 1 << n) {
Panic.panic(Panic.UNDER_OVERFLOW);
}
return (high << (256 - n)) | (low >> n);
}
}
/**
* @dev Calculates x * y >> n with full precision, following the selected rounding direction.
*/
function mulShr(uint256 x, uint256 y, uint8 n, Rounding rounding) internal pure returns (uint256) {
return mulShr(x, y, n) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, 1 << n) > 0);
}
/**
* @dev Calculate the modular multiplicative inverse of a number in Z/nZ.
*
* If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.
* If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.
*
* If the input value is not inversible, 0 is returned.
*
* NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the
* inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.
*/
function invMod(uint256 a, uint256 n) internal pure returns (uint256) {
unchecked {
if (n == 0) return 0;
// The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)
// Used to compute integers x and y such that: ax + ny = gcd(a, n).
// When the gcd is 1, then the inverse of a modulo n exists and it's x.
// ax + ny = 1
// ax = 1 + (-y)n
// ax ≡ 1 (mod n) # x is the inverse of a modulo n
// If the remainder is 0 the gcd is n right away.
uint256 remainder = a % n;
uint256 gcd = n;
// Therefore the initial coefficients are:
// ax + ny = gcd(a, n) = n
// 0a + 1n = n
int256 x = 0;
int256 y = 1;
while (remainder != 0) {
uint256 quotient = gcd / remainder;
(gcd, remainder) = (
// The old remainder is the next gcd to try.
remainder,
// Compute the next remainder.
// Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd
// where gcd is at most n (capped to type(uint256).max)
gcd - remainder * quotient
);
(x, y) = (
// Increment the coefficient of a.
y,
// Decrement the coefficient of n.
// Can overflow, but the result is casted to uint256 so that the
// next value of y is "wrapped around" to a value between 0 and n - 1.
x - y * int256(quotient)
);
}
if (gcd != 1) return 0; // No inverse exists.
return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.
}
}
/**
* @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.
*
* From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is
* prime, then `a**(p-1) ≡ 1 mod p`. As a consequence, we have `a * a**(p-2) ≡ 1 mod p`, which means that
* `a**(p-2)` is the modular multiplicative inverse of a in Fp.
*
* NOTE: this function does NOT check that `p` is a prime greater than `2`.
*/
function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {
unchecked {
return Math.modExp(a, p - 2, p);
}
}
/**
* @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)
*
* Requirements:
* - modulus can't be zero
* - underlying staticcall to precompile must succeed
*
* IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make
* sure the chain you're using it on supports the precompiled contract for modular exponentiation
* at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,
* the underlying function will succeed given the lack of a revert, but the result may be incorrectly
* interpreted as 0.
*/
function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {
(bool success, uint256 result) = tryModExp(b, e, m);
if (!success) {
Panic.panic(Panic.DIVISION_BY_ZERO);
}
return result;
}
/**
* @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).
* It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying
* to operate modulo 0 or if the underlying precompile reverted.
*
* IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain
* you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in
* https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack
* of a revert, but the result may be incorrectly interpreted as 0.
*/
function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {
if (m == 0) return (false, 0);
assembly ("memory-safe") {
let ptr := mload(0x40)
// | Offset | Content | Content (Hex) |
// |-----------|------------|--------------------------------------------------------------------|
// | 0x00:0x1f | size of b | 0x0000000000000000000000000000000000000000000000000000000000000020 |
// | 0x20:0x3f | size of e | 0x0000000000000000000000000000000000000000000000000000000000000020 |
// | 0x40:0x5f | size of m | 0x0000000000000000000000000000000000000000000000000000000000000020 |
// | 0x60:0x7f | value of b | 0x<.............................................................b> |
// | 0x80:0x9f | value of e | 0x<.............................................................e> |
// | 0xa0:0xbf | value of m | 0x<.............................................................m> |
mstore(ptr, 0x20)
mstore(add(ptr, 0x20), 0x20)
mstore(add(ptr, 0x40), 0x20)
mstore(add(ptr, 0x60), b)
mstore(add(ptr, 0x80), e)
mstore(add(ptr, 0xa0), m)
// Given the result < m, it's guaranteed to fit in 32 bytes,
// so we can use the memory scratch space located at offset 0.
success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)
result := mload(0x00)
}
}
/**
* @dev Variant of {modExp} that supports inputs of arbitrary length.
*/
function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {
(bool success, bytes memory result) = tryModExp(b, e, m);
if (!success) {
Panic.panic(Panic.DIVISION_BY_ZERO);
}
return result;
}
/**
* @dev Variant of {tryModExp} that supports inputs of arbitrary length.
*/
function tryModExp(
bytes memory b,
bytes memory e,
bytes memory m
) internal view returns (bool success, bytes memory result) {
if (_zeroBytes(m)) return (false, new bytes(0));
uint256 mLen = m.length;
// Encode call args in result and move the free memory pointer
result = abi.encodePacked(b.length, e.length, mLen, b, e, m);
assembly ("memory-safe") {
let dataPtr := add(result, 0x20)
// Write result on top of args to avoid allocating extra memory.
success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)
// Overwrite the length.
// result.length > returndatasize() is guaranteed because returndatasize() == m.length
mstore(result, mLen)
// Set the memory pointer after the returned data.
mstore(0x40, add(dataPtr, mLen))
}
}
/**
* @dev Returns whether the provided byte array is zero.
*/
function _zeroBytes(bytes memory byteArray) private pure returns (bool) {
for (uint256 i = 0; i < byteArray.length; ++i) {
if (byteArray[i] != 0) {
return false;
}
}
return true;
}
/**
* @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded
* towards zero.
*
* This method is based on Newton's method for computing square roots; the algorithm is restricted to only
* using integer operations.
*/
function sqrt(uint256 a) internal pure returns (uint256) {
unchecked {
// Take care of easy edge cases when a == 0 or a == 1
if (a <= 1) {
return a;
}
// In this function, we use Newton's method to get a root of `f(x) := x² - a`. It involves building a
// sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between
// the current value as `ε_n = | x_n - sqrt(a) |`.
//
// For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root
// of the target. (i.e. `2**(e-1) ≤ sqrt(a) < 2**e`). We know that `e ≤ 128` because `(2¹²⁸)² = 2²⁵⁶` is
// bigger than any uint256.
//
// By noticing that
// `2**(e-1) ≤ sqrt(a) < 2**e → (2**(e-1))² ≤ a < (2**e)² → 2**(2*e-2) ≤ a < 2**(2*e)`
// we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar
// to the msb function.
uint256 aa = a;
uint256 xn = 1;
if (aa >= (1 << 128)) {
aa >>= 128;
xn <<= 64;
}
if (aa >= (1 << 64)) {
aa >>= 64;
xn <<= 32;
}
if (aa >= (1 << 32)) {
aa >>= 32;
xn <<= 16;
}
if (aa >= (1 << 16)) {
aa >>= 16;
xn <<= 8;
}
if (aa >= (1 << 8)) {
aa >>= 8;
xn <<= 4;
}
if (aa >= (1 << 4)) {
aa >>= 4;
xn <<= 2;
}
if (aa >= (1 << 2)) {
xn <<= 1;
}
// We now have x_n such that `x_n = 2**(e-1) ≤ sqrt(a) < 2**e = 2 * x_n`. This implies ε_n ≤ 2**(e-1).
//
// We can refine our estimation by noticing that the middle of that interval minimizes the error.
// If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to ε_n ≤ 2**(e-2).
// This is going to be our x_0 (and ε_0)
xn = (3 * xn) >> 1; // ε_0 := | x_0 - sqrt(a) | ≤ 2**(e-2)
// From here, Newton's method give us:
// x_{n+1} = (x_n + a / x_n) / 2
//
// One should note that:
// x_{n+1}² - a = ((x_n + a / x_n) / 2)² - a
// = ((x_n² + a) / (2 * x_n))² - a
// = (x_n⁴ + 2 * a * x_n² + a²) / (4 * x_n²) - a
// = (x_n⁴ + 2 * a * x_n² + a² - 4 * a * x_n²) / (4 * x_n²)
// = (x_n⁴ - 2 * a * x_n² + a²) / (4 * x_n²)
// = (x_n² - a)² / (2 * x_n)²
// = ((x_n² - a) / (2 * x_n))²
// ≥ 0
// Which proves that for all n ≥ 1, sqrt(a) ≤ x_n
//
// This gives us the proof of quadratic convergence of the sequence:
// ε_{n+1} = | x_{n+1} - sqrt(a) |
// = | (x_n + a / x_n) / 2 - sqrt(a) |
// = | (x_n² + a - 2*x_n*sqrt(a)) / (2 * x_n) |
// = | (x_n - sqrt(a))² / (2 * x_n) |
// = | ε_n² / (2 * x_n) |
// = ε_n² / | (2 * x_n) |
//
// For the first iteration, we have a special case where x_0 is known:
// ε_1 = ε_0² / | (2 * x_0) |
// ≤ (2**(e-2))² / (2 * (2**(e-1) + 2**(e-2)))
// ≤ 2**(2*e-4) / (3 * 2**(e-1))
// ≤ 2**(e-3) / 3
// ≤ 2**(e-3-log2(3))
// ≤ 2**(e-4.5)
//
// For the following iterations, we use the fact that, 2**(e-1) ≤ sqrt(a) ≤ x_n:
// ε_{n+1} = ε_n² / | (2 * x_n) |
// ≤ (2**(e-k))² / (2 * 2**(e-1))
// ≤ 2**(2*e-2*k) / 2**e
// ≤ 2**(e-2*k)
xn = (xn + a / xn) >> 1; // ε_1 := | x_1 - sqrt(a) | ≤ 2**(e-4.5) -- special case, see above
xn = (xn + a / xn) >> 1; // ε_2 := | x_2 - sqrt(a) | ≤ 2**(e-9) -- general case with k = 4.5
xn = (xn + a / xn) >> 1; // ε_3 := | x_3 - sqrt(a) | ≤ 2**(e-18) -- general case with k = 9
xn = (xn + a / xn) >> 1; // ε_4 := | x_4 - sqrt(a) | ≤ 2**(e-36) -- general case with k = 18
xn = (xn + a / xn) >> 1; // ε_5 := | x_5 - sqrt(a) | ≤ 2**(e-72) -- general case with k = 36
xn = (xn + a / xn) >> 1; // ε_6 := | x_6 - sqrt(a) | ≤ 2**(e-144) -- general case with k = 72
// Because e ≤ 128 (as discussed during the first estimation phase), we know have reached a precision
// ε_6 ≤ 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either
// sqrt(a) or sqrt(a) + 1.
return xn - SafeCast.toUint(xn > a / xn);
}
}
/**
* @dev 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 + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);
}
}
/**
* @dev Return the log in base 2 of a positive value rounded towards zero.
* Returns 0 if given 0.
*/
function log2(uint256 x) internal pure returns (uint256 r) {
// If value has upper 128 bits set, log2 result is at least 128
r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;
// If upper 64 bits of 128-bit half set, add 64 to result
r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;
// If upper 32 bits of 64-bit half set, add 32 to result
r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;
// If upper 16 bits of 32-bit half set, add 16 to result
r |= SafeCast.toUint((x >> r) > 0xffff) << 4;
// If upper 8 bits of 16-bit half set, add 8 to result
r |= SafeCast.toUint((x >> r) > 0xff) << 3;
// If upper 4 bits of 8-bit half set, add 4 to result
r |= SafeCast.toUint((x >> r) > 0xf) << 2;
// Shifts value right by the current result and use it as an index into this lookup table:
//
// | x (4 bits) | index | table[index] = MSB position |
// |------------|---------|-----------------------------|
// | 0000 | 0 | table[0] = 0 |
// | 0001 | 1 | table[1] = 0 |
// | 0010 | 2 | table[2] = 1 |
// | 0011 | 3 | table[3] = 1 |
// | 0100 | 4 | table[4] = 2 |
// | 0101 | 5 | table[5] = 2 |
// | 0110 | 6 | table[6] = 2 |
// | 0111 | 7 | table[7] = 2 |
// | 1000 | 8 | table[8] = 3 |
// | 1001 | 9 | table[9] = 3 |
// | 1010 | 10 | table[10] = 3 |
// | 1011 | 11 | table[11] = 3 |
// | 1100 | 12 | table[12] = 3 |
// | 1101 | 13 | table[13] = 3 |
// | 1110 | 14 | table[14] = 3 |
// | 1111 | 15 | table[15] = 3 |
//
// The lookup table is represented as a 32-byte value with the MSB positions for 0-15 in the last 16 bytes.
assembly ("memory-safe") {
r := or(r, byte(shr(r, x), 0x0000010102020202030303030303030300000000000000000000000000000000))
}
}
/**
* @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 + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);
}
}
/**
* @dev Return the log in base 10 of a positive value rounded towards zero.
* Returns 0 if given 0.
*/
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10 ** 64) {
value /= 10 ** 64;
result += 64;
}
if (value >= 10 ** 32) {
value /= 10 ** 32;
result += 32;
}
if (value >= 10 ** 16) {
value /= 10 ** 16;
result += 16;
}
if (value >= 10 ** 8) {
value /= 10 ** 8;
result += 8;
}
if (value >= 10 ** 4) {
value /= 10 ** 4;
result += 4;
}
if (value >= 10 ** 2) {
value /= 10 ** 2;
result += 2;
}
if (value >= 10 ** 1) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 10, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);
}
}
/**
* @dev Return the log in base 256 of a positive value rounded towards zero.
* Returns 0 if given 0.
*
* Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
*/
function log256(uint256 x) internal pure returns (uint256 r) {
// If value has upper 128 bits set, log2 result is at least 128
r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;
// If upper 64 bits of 128-bit half set, add 64 to result
r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;
// If upper 32 bits of 64-bit half set, add 32 to result
r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;
// If upper 16 bits of 32-bit half set, add 16 to result
r |= SafeCast.toUint((x >> r) > 0xffff) << 4;
// Add 1 if upper 8 bits of 16-bit half set, and divide accumulated result by 8
return (r >> 3) | SafeCast.toUint((x >> r) > 0xff);
}
/**
* @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 + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);
}
}
/**
* @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
*/
function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
return uint8(rounding) % 2 == 1;
}
}// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.9.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface IPetalsStrategy {
// ERC4626 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
);
// ERC4626 metadata functions
function name() external view returns (string memory);
function decimals() external view returns (uint8);
// ERC4626-aligned view functions
function asset() external view returns (address);
function totalAssets() external view returns (uint256);
function convertToShares(uint256 assets) external view returns (uint256);
function convertToAssets(uint256 shares) external view returns (uint256);
function maxDeposit(address receiver) external view returns (uint256);
function maxMint(address receiver) external view returns (uint256);
function maxWithdraw(address owner) external view returns (uint256);
function maxRedeem(address owner) external view returns (uint256);
function previewDeposit(uint256 assets) external view returns (uint256 shares);
function previewMint(uint256 shares) external view returns (uint256 assets);
function previewWithdraw(uint256 assets) external view returns (uint256 shares);
function previewRedeem(uint256 shares) external view returns (uint256 assets);
// Strategy-specific view functions
function balanceOfPool() external view returns (uint256);
function totalRewardsAvailable() external view returns (address[] memory tokens, uint256[] memory amounts);
function callReward() external view returns (uint256);
function lastHarvest() external view returns (uint256);
// Strategy metadata (for deployment validation)
function getFactory() external view returns (address);
function getProtocolType() external view returns (bytes32);
// Strategy-specific state-changing functions
function deposit() external;
function withdraw(uint256 assets) external;
function retireStrat() external;
function harvest(address harvester) external;
function panic() external;
function setVault(address vault) external;
function setFeeRecipient(address newFeeRecipient) external;
function setSlippageTolerance(uint256 tolerance) external;
function balanceOf(address account) external view returns (uint256);
function balanceOfWant() external view returns (uint256);
function beforeDeposit() external;
function pause() external;
function unpause() external;
function paused() external view returns (bool);
function vault() external view returns (address);
function want() external view returns (address);
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/// @title IPetalsVault
/// @notice Interface for PetalsVault contract used by strategies
interface IPetalsVault {
function controller() external view returns (address);
}
/// @title IPetalsController
/// @notice Interface for PetalsController contract used by vaults
interface IPetalsController {
function onVaultOperation(
address user,
uint256 newTotalAssets,
uint256 newTotalSupply,
uint256 depositAmount,
uint256 withdrawAmount,
bool isDeposit
)
external;
function onStrategyHarvest(address vault, uint256 rewardAmount, uint256 previousTotalAssets) external;
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "../../vaults/00_libraries/types.sol";
/// @title IPetalsControllerForStrategy
/// @notice Interface for PetalsController contract used by strategies
interface IPetalsControllerForStrategy {
function wrappedNativeToken() external view returns (address);
function updateStrategyRewardTokens(address vault, address[] calldata rewardTokens) external;
function onStrategyHarvest(address vault, uint256 harvestYield, uint256 totalAssets) external;
// Constants access for strategies
function BASIS_POINTS() external view returns (uint256);
function MAX_SLIPPAGE() external view returns (uint256);
function MIN_HARVEST_DELAY() external view returns (uint256);
function MAX_WITHDRAWAL_FEE() external view returns (uint256);
function DEFAULT_PERFORMANCE_FEE() external view returns (uint256);
function DEFAULT_SLIPPAGE_TOLERANCE() external view returns (uint256);
function DEFAULT_CALL_REWARD() external view returns (uint256);
// Fee management
function getVaultFeeRatios(address vault) external view returns (VaultFeeConfig memory config);
// Permission management for role-based access control
function hasContractRole(address contractAddr, uint64 role, address account) external view returns (bool);
// Route manager for universal DEX routing
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/// @title ICommonErrors
/// @notice Common error definitions used across multiple contracts
/// @dev Inherit this interface to access common errors and reduce code duplication
interface ICommonErrors {
// ============ COMMON ERRORS ============
error ZeroAddress();
error UnauthorizedUpdate();
error AlreadyInitialized();
error InvalidStrategy(address strategy);
error VaultNotFound();
error EmptyArray();
error InvalidAsset();
error InvalidRouter();
error NoRewardTokens();
error NativeTokenNotConfigured();
error InsufficientBalance();
// ============ COMMON ACCESS ERRORS ============
error OnlyVault();
error InvalidRecipient();
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/// @title ICommonEvents
/// @notice Common event definitions used across multiple contracts
/// @dev Inherit this interface to access common events and reduce code duplication
interface ICommonEvents {
// ============ ROLE MANAGEMENT EVENTS ============
event RoleCacheUpdated(bytes32 indexed role, address indexed account, bool granted);
event FeeRecipientUpdated(address indexed previousFeeRecipient, address indexed newFeeRecipient);
// ============ STRATEGY LIFECYCLE EVENTS ============
event StrategyUpdated(address indexed newStrategy);
event StrategySet(address indexed strategy, bool wasRegistered);
// ============ REWARD ROUTING EVENTS ============
event RewardConfigurationUpdated(address[] tokens, bytes[] routes);
event NativeToLp0RouteSet(bytes route);
event NativeToLp1RouteSet(bytes route);
// ============ FAILURE EVENTS (as events, not errors) ============
event EmergencyWithdrawFailed(bytes reason);
event SwapFailed(address indexed tokenIn, address indexed tokenOut, uint256 amountIn, string reason);
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/// @title IPermissionCache
/// @notice Interface for contracts that cache permissions from the central registry
interface IPermissionCache {
/**
* @notice Update cached role permissions (called by controller)
* @param role Role to update
* @param account Account to grant/revoke role
* @param granted Whether to grant or revoke the role
*/
function updateRoleCache(bytes32 role, address account, bool granted) external;
/**
* @notice Check if account has role (uses cached permissions)
* @param role Role to check
* @param account Account to check
* @return hasRole Whether account has role
*/
function hasRole(bytes32 role, address account) external view returns (bool);
/// @notice Permission cache events
event RoleCacheUpdated(bytes32 indexed role, address indexed account, bool granted);
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/// @notice Strategy factory interface for clone deployment
/// @dev Extended to support multi-type factories and Universal Factory pattern
interface IStrategyFactory {
// ============ DEPLOYMENT ============
/**
* @notice Deploy a strategy clone with custom configuration
* @param config ABI-encoded configuration (format depends on factory implementation)
* @param owner Strategy owner address
* @return strategy Deployed strategy address
*/
function createStrategy(bytes calldata config, address owner) external returns (address strategy);
// ============ LEGACY FUNCTIONS (for backward compatibility) ============
/**
* @notice Get master implementation address
* @dev For single-type factories, returns the implementation
* @dev For multi-type factories, may return address(0) or primary implementation
* @return Implementation address
*/
function implementation() external view returns (address);
/**
* @notice Get estimated gas cost for strategy deployment
* @return Estimated gas cost
*/
function getStrategyCreationGas() external view returns (uint256);
// ============ MULTI-TYPE FACTORY SUPPORT (NEW) ============
/**
* @notice Get base protocol this factory serves
* @dev Used by Universal Factory pattern to identify factory type
* @return baseProtocol Base protocol identifier (e.g., bytes32("Shadow"))
*/
function getBaseProtocol() external view returns (bytes32 baseProtocol);
/**
* @notice Get all strategy types this factory can deploy
* @dev Used for enumeration and UI display
* @return strategyTypes Array of strategy type identifiers
*/
function getSupportedStrategyTypes() external view returns (bytes32[] memory strategyTypes);
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
* @title RouterTypes
* @notice Shared type definitions for the extensible routing system
* @dev Enums and structs used across routing libraries and facets
*/
/// @notice Supported router types for different DEX protocols
enum RouterType {
SOLIDLY, // Shadow, Velodrome, Aerodrome, Thena (Solidly forks)
UNIV2, // UniswapV2, SushiSwap, PancakeSwap
UNIV3, // UniswapV3, PancakeSwap V3
UNIVERSAL, // Uniswap Universal Router
CURVE, // Curve Finance
BALANCER // Balancer
}
/// @notice Metadata about a route configuration update
struct RouteUpdateMetadata {
uint256 timestamp; // When the routes were last updated
address updatedBy; // Who updated the routes
uint256 updateCount; // Number of times routes have been updated
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/IERC20.sol)
pragma solidity >=0.4.16;
/**
* @dev Interface of the ERC-20 standard as defined in the ERC.
*/
interface IERC20 {
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Returns the value of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the value of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves a `value` amount of tokens from the caller's account to `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address to, uint256 value) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets a `value` amount of tokens as the allowance of `spender` over the
* caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 value) external returns (bool);
/**
* @dev Moves a `value` amount of tokens from `from` to `to` using the
* allowance mechanism. `value` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address from, address to, uint256 value) external returns (bool);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/extensions/IERC20Metadata.sol)
pragma solidity >=0.6.2;
import {IERC20} from "../IERC20.sol";
/**
* @dev Interface for the optional metadata functions from the ERC-20 standard.
*/
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)
pragma solidity ^0.8.20;
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
function _contextSuffixLength() internal view virtual returns (uint256) {
return 0;
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/draft-IERC6093.sol)
pragma solidity >=0.8.4;
/**
* @dev Standard ERC-20 Errors
* Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-20 tokens.
*/
interface IERC20Errors {
/**
* @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
* @param sender Address whose tokens are being transferred.
* @param balance Current balance for the interacting account.
* @param needed Minimum amount required to perform a transfer.
*/
error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);
/**
* @dev Indicates a failure with the token `sender`. Used in transfers.
* @param sender Address whose tokens are being transferred.
*/
error ERC20InvalidSender(address sender);
/**
* @dev Indicates a failure with the token `receiver`. Used in transfers.
* @param receiver Address to which tokens are being transferred.
*/
error ERC20InvalidReceiver(address receiver);
/**
* @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
* @param spender Address that may be allowed to operate on tokens without being their owner.
* @param allowance Amount of tokens a `spender` is allowed to operate with.
* @param needed Minimum amount required to perform a transfer.
*/
error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);
/**
* @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
* @param approver Address initiating an approval operation.
*/
error ERC20InvalidApprover(address approver);
/**
* @dev Indicates a failure with the `spender` to be approved. Used in approvals.
* @param spender Address that may be allowed to operate on tokens without being their owner.
*/
error ERC20InvalidSpender(address spender);
}
/**
* @dev Standard ERC-721 Errors
* Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-721 tokens.
*/
interface IERC721Errors {
/**
* @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-20.
* Used in balance queries.
* @param owner Address of the current owner of a token.
*/
error ERC721InvalidOwner(address owner);
/**
* @dev Indicates a `tokenId` whose `owner` is the zero address.
* @param tokenId Identifier number of a token.
*/
error ERC721NonexistentToken(uint256 tokenId);
/**
* @dev Indicates an error related to the ownership over a particular token. Used in transfers.
* @param sender Address whose tokens are being transferred.
* @param tokenId Identifier number of a token.
* @param owner Address of the current owner of a token.
*/
error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);
/**
* @dev Indicates a failure with the token `sender`. Used in transfers.
* @param sender Address whose tokens are being transferred.
*/
error ERC721InvalidSender(address sender);
/**
* @dev Indicates a failure with the token `receiver`. Used in transfers.
* @param receiver Address to which tokens are being transferred.
*/
error ERC721InvalidReceiver(address receiver);
/**
* @dev Indicates a failure with the `operator`’s approval. Used in transfers.
* @param operator Address that may be allowed to operate on tokens without being their owner.
* @param tokenId Identifier number of a token.
*/
error ERC721InsufficientApproval(address operator, uint256 tokenId);
/**
* @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
* @param approver Address initiating an approval operation.
*/
error ERC721InvalidApprover(address approver);
/**
* @dev Indicates a failure with the `operator` to be approved. Used in approvals.
* @param operator Address that may be allowed to operate on tokens without being their owner.
*/
error ERC721InvalidOperator(address operator);
}
/**
* @dev Standard ERC-1155 Errors
* Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-1155 tokens.
*/
interface IERC1155Errors {
/**
* @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
* @param sender Address whose tokens are being transferred.
* @param balance Current balance for the interacting account.
* @param needed Minimum amount required to perform a transfer.
* @param tokenId Identifier number of a token.
*/
error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);
/**
* @dev Indicates a failure with the token `sender`. Used in transfers.
* @param sender Address whose tokens are being transferred.
*/
error ERC1155InvalidSender(address sender);
/**
* @dev Indicates a failure with the token `receiver`. Used in transfers.
* @param receiver Address to which tokens are being transferred.
*/
error ERC1155InvalidReceiver(address receiver);
/**
* @dev Indicates a failure with the `operator`’s approval. Used in transfers.
* @param operator Address that may be allowed to operate on tokens without being their owner.
* @param owner Address of the current owner of a token.
*/
error ERC1155MissingApprovalForAll(address operator, address owner);
/**
* @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
* @param approver Address initiating an approval operation.
*/
error ERC1155InvalidApprover(address approver);
/**
* @dev Indicates a failure with the `operator` to be approved. Used in approvals.
* @param operator Address that may be allowed to operate on tokens without being their owner.
*/
error ERC1155InvalidOperator(address operator);
/**
* @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
* Used in batch transfers.
* @param idsLength Length of the array of token identifiers
* @param valuesLength Length of the array of token amounts
*/
error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/IERC1363.sol)
pragma solidity >=0.6.2;
import {IERC20} from "./IERC20.sol";
import {IERC165} from "./IERC165.sol";
/**
* @title IERC1363
* @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].
*
* Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract
* after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.
*/
interface IERC1363 is IERC20, IERC165 {
/*
* Note: the ERC-165 identifier for this interface is 0xb0202a11.
* 0xb0202a11 ===
* bytes4(keccak256('transferAndCall(address,uint256)')) ^
* bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^
* bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^
* bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^
* bytes4(keccak256('approveAndCall(address,uint256)')) ^
* bytes4(keccak256('approveAndCall(address,uint256,bytes)'))
*/
/**
* @dev Moves a `value` amount of tokens from the caller's account to `to`
* and then calls {IERC1363Receiver-onTransferReceived} on `to`.
* @param to The address which you want to transfer to.
* @param value The amount of tokens to be transferred.
* @return A boolean value indicating whether the operation succeeded unless throwing.
*/
function transferAndCall(address to, uint256 value) external returns (bool);
/**
* @dev Moves a `value` amount of tokens from the caller's account to `to`
* and then calls {IERC1363Receiver-onTransferReceived} on `to`.
* @param to The address which you want to transfer to.
* @param value The amount of tokens to be transferred.
* @param data Additional data with no specified format, sent in call to `to`.
* @return A boolean value indicating whether the operation succeeded unless throwing.
*/
function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);
/**
* @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
* and then calls {IERC1363Receiver-onTransferReceived} on `to`.
* @param from The address which you want to send tokens from.
* @param to The address which you want to transfer to.
* @param value The amount of tokens to be transferred.
* @return A boolean value indicating whether the operation succeeded unless throwing.
*/
function transferFromAndCall(address from, address to, uint256 value) external returns (bool);
/**
* @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
* and then calls {IERC1363Receiver-onTransferReceived} on `to`.
* @param from The address which you want to send tokens from.
* @param to The address which you want to transfer to.
* @param value The amount of tokens to be transferred.
* @param data Additional data with no specified format, sent in call to `to`.
* @return A boolean value indicating whether the operation succeeded unless throwing.
*/
function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);
/**
* @dev Sets a `value` amount of tokens as the allowance of `spender` over the
* caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
* @param spender The address which will spend the funds.
* @param value The amount of tokens to be spent.
* @return A boolean value indicating whether the operation succeeded unless throwing.
*/
function approveAndCall(address spender, uint256 value) external returns (bool);
/**
* @dev Sets a `value` amount of tokens as the allowance of `spender` over the
* caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
* @param spender The address which will spend the funds.
* @param value The amount of tokens to be spent.
* @param data Additional data with no specified format, sent in call to `spender`.
* @return A boolean value indicating whether the operation succeeded unless throwing.
*/
function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol)
pragma solidity ^0.8.20;
/**
* @dev Helper library for emitting standardized panic codes.
*
* ```solidity
* contract Example {
* using Panic for uint256;
*
* // Use any of the declared internal constants
* function foo() { Panic.GENERIC.panic(); }
*
* // Alternatively
* function foo() { Panic.panic(Panic.GENERIC); }
* }
* ```
*
* Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].
*
* _Available since v5.1._
*/
// slither-disable-next-line unused-state
library Panic {
/// @dev generic / unspecified error
uint256 internal constant GENERIC = 0x00;
/// @dev used by the assert() builtin
uint256 internal constant ASSERT = 0x01;
/// @dev arithmetic underflow or overflow
uint256 internal constant UNDER_OVERFLOW = 0x11;
/// @dev division or modulo by zero
uint256 internal constant DIVISION_BY_ZERO = 0x12;
/// @dev enum conversion error
uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;
/// @dev invalid encoding in storage
uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;
/// @dev empty array pop
uint256 internal constant EMPTY_ARRAY_POP = 0x31;
/// @dev array out of bounds access
uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;
/// @dev resource error (too large allocation or too large array)
uint256 internal constant RESOURCE_ERROR = 0x41;
/// @dev calling invalid internal function
uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;
/// @dev Reverts with a panic code. Recommended to use with
/// the internal constants with predefined codes.
function panic(uint256 code) internal pure {
assembly ("memory-safe") {
mstore(0x00, 0x4e487b71)
mstore(0x20, code)
revert(0x1c, 0x24)
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)
// This file was procedurally generated from scripts/generate/templates/SafeCast.js.
pragma solidity ^0.8.20;
/**
* @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow
* checks.
*
* Downcasting from uint256/int256 in Solidity does not revert on overflow. This can
* easily result in undesired exploitation or bugs, since developers usually
* assume that overflows raise errors. `SafeCast` restores this intuition by
* reverting the transaction when such an operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/
library SafeCast {
/**
* @dev Value doesn't fit in an uint of `bits` size.
*/
error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);
/**
* @dev An int value doesn't fit in an uint of `bits` size.
*/
error SafeCastOverflowedIntToUint(int256 value);
/**
* @dev Value doesn't fit in an int of `bits` size.
*/
error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);
/**
* @dev An uint value doesn't fit in an int of `bits` size.
*/
error SafeCastOverflowedUintToInt(uint256 value);
/**
* @dev Returns the downcasted uint248 from uint256, reverting on
* overflow (when the input is greater than largest uint248).
*
* Counterpart to Solidity's `uint248` operator.
*
* Requirements:
*
* - input must fit into 248 bits
*/
function toUint248(uint256 value) internal pure returns (uint248) {
if (value > type(uint248).max) {
revert SafeCastOverflowedUintDowncast(248, value);
}
return uint248(value);
}
/**
* @dev Returns the downcasted uint240 from uint256, reverting on
* overflow (when the input is greater than largest uint240).
*
* Counterpart to Solidity's `uint240` operator.
*
* Requirements:
*
* - input must fit into 240 bits
*/
function toUint240(uint256 value) internal pure returns (uint240) {
if (value > type(uint240).max) {
revert SafeCastOverflowedUintDowncast(240, value);
}
return uint240(value);
}
/**
* @dev Returns the downcasted uint232 from uint256, reverting on
* overflow (when the input is greater than largest uint232).
*
* Counterpart to Solidity's `uint232` operator.
*
* Requirements:
*
* - input must fit into 232 bits
*/
function toUint232(uint256 value) internal pure returns (uint232) {
if (value > type(uint232).max) {
revert SafeCastOverflowedUintDowncast(232, value);
}
return uint232(value);
}
/**
* @dev Returns the downcasted uint224 from uint256, reverting on
* overflow (when the input is greater than largest uint224).
*
* Counterpart to Solidity's `uint224` operator.
*
* Requirements:
*
* - input must fit into 224 bits
*/
function toUint224(uint256 value) internal pure returns (uint224) {
if (value > type(uint224).max) {
revert SafeCastOverflowedUintDowncast(224, value);
}
return uint224(value);
}
/**
* @dev Returns the downcasted uint216 from uint256, reverting on
* overflow (when the input is greater than largest uint216).
*
* Counterpart to Solidity's `uint216` operator.
*
* Requirements:
*
* - input must fit into 216 bits
*/
function toUint216(uint256 value) internal pure returns (uint216) {
if (value > type(uint216).max) {
revert SafeCastOverflowedUintDowncast(216, value);
}
return uint216(value);
}
/**
* @dev Returns the downcasted uint208 from uint256, reverting on
* overflow (when the input is greater than largest uint208).
*
* Counterpart to Solidity's `uint208` operator.
*
* Requirements:
*
* - input must fit into 208 bits
*/
function toUint208(uint256 value) internal pure returns (uint208) {
if (value > type(uint208).max) {
revert SafeCastOverflowedUintDowncast(208, value);
}
return uint208(value);
}
/**
* @dev Returns the downcasted uint200 from uint256, reverting on
* overflow (when the input is greater than largest uint200).
*
* Counterpart to Solidity's `uint200` operator.
*
* Requirements:
*
* - input must fit into 200 bits
*/
function toUint200(uint256 value) internal pure returns (uint200) {
if (value > type(uint200).max) {
revert SafeCastOverflowedUintDowncast(200, value);
}
return uint200(value);
}
/**
* @dev Returns the downcasted uint192 from uint256, reverting on
* overflow (when the input is greater than largest uint192).
*
* Counterpart to Solidity's `uint192` operator.
*
* Requirements:
*
* - input must fit into 192 bits
*/
function toUint192(uint256 value) internal pure returns (uint192) {
if (value > type(uint192).max) {
revert SafeCastOverflowedUintDowncast(192, value);
}
return uint192(value);
}
/**
* @dev Returns the downcasted uint184 from uint256, reverting on
* overflow (when the input is greater than largest uint184).
*
* Counterpart to Solidity's `uint184` operator.
*
* Requirements:
*
* - input must fit into 184 bits
*/
function toUint184(uint256 value) internal pure returns (uint184) {
if (value > type(uint184).max) {
revert SafeCastOverflowedUintDowncast(184, value);
}
return uint184(value);
}
/**
* @dev Returns the downcasted uint176 from uint256, reverting on
* overflow (when the input is greater than largest uint176).
*
* Counterpart to Solidity's `uint176` operator.
*
* Requirements:
*
* - input must fit into 176 bits
*/
function toUint176(uint256 value) internal pure returns (uint176) {
if (value > type(uint176).max) {
revert SafeCastOverflowedUintDowncast(176, value);
}
return uint176(value);
}
/**
* @dev Returns the downcasted uint168 from uint256, reverting on
* overflow (when the input is greater than largest uint168).
*
* Counterpart to Solidity's `uint168` operator.
*
* Requirements:
*
* - input must fit into 168 bits
*/
function toUint168(uint256 value) internal pure returns (uint168) {
if (value > type(uint168).max) {
revert SafeCastOverflowedUintDowncast(168, value);
}
return uint168(value);
}
/**
* @dev Returns the downcasted uint160 from uint256, reverting on
* overflow (when the input is greater than largest uint160).
*
* Counterpart to Solidity's `uint160` operator.
*
* Requirements:
*
* - input must fit into 160 bits
*/
function toUint160(uint256 value) internal pure returns (uint160) {
if (value > type(uint160).max) {
revert SafeCastOverflowedUintDowncast(160, value);
}
return uint160(value);
}
/**
* @dev Returns the downcasted uint152 from uint256, reverting on
* overflow (when the input is greater than largest uint152).
*
* Counterpart to Solidity's `uint152` operator.
*
* Requirements:
*
* - input must fit into 152 bits
*/
function toUint152(uint256 value) internal pure returns (uint152) {
if (value > type(uint152).max) {
revert SafeCastOverflowedUintDowncast(152, value);
}
return uint152(value);
}
/**
* @dev Returns the downcasted uint144 from uint256, reverting on
* overflow (when the input is greater than largest uint144).
*
* Counterpart to Solidity's `uint144` operator.
*
* Requirements:
*
* - input must fit into 144 bits
*/
function toUint144(uint256 value) internal pure returns (uint144) {
if (value > type(uint144).max) {
revert SafeCastOverflowedUintDowncast(144, value);
}
return uint144(value);
}
/**
* @dev Returns the downcasted uint136 from uint256, reverting on
* overflow (when the input is greater than largest uint136).
*
* Counterpart to Solidity's `uint136` operator.
*
* Requirements:
*
* - input must fit into 136 bits
*/
function toUint136(uint256 value) internal pure returns (uint136) {
if (value > type(uint136).max) {
revert SafeCastOverflowedUintDowncast(136, value);
}
return uint136(value);
}
/**
* @dev Returns the downcasted uint128 from uint256, reverting on
* overflow (when the input is greater than largest uint128).
*
* Counterpart to Solidity's `uint128` operator.
*
* Requirements:
*
* - input must fit into 128 bits
*/
function toUint128(uint256 value) internal pure returns (uint128) {
if (value > type(uint128).max) {
revert SafeCastOverflowedUintDowncast(128, value);
}
return uint128(value);
}
/**
* @dev Returns the downcasted uint120 from uint256, reverting on
* overflow (when the input is greater than largest uint120).
*
* Counterpart to Solidity's `uint120` operator.
*
* Requirements:
*
* - input must fit into 120 bits
*/
function toUint120(uint256 value) internal pure returns (uint120) {
if (value > type(uint120).max) {
revert SafeCastOverflowedUintDowncast(120, value);
}
return uint120(value);
}
/**
* @dev Returns the downcasted uint112 from uint256, reverting on
* overflow (when the input is greater than largest uint112).
*
* Counterpart to Solidity's `uint112` operator.
*
* Requirements:
*
* - input must fit into 112 bits
*/
function toUint112(uint256 value) internal pure returns (uint112) {
if (value > type(uint112).max) {
revert SafeCastOverflowedUintDowncast(112, value);
}
return uint112(value);
}
/**
* @dev Returns the downcasted uint104 from uint256, reverting on
* overflow (when the input is greater than largest uint104).
*
* Counterpart to Solidity's `uint104` operator.
*
* Requirements:
*
* - input must fit into 104 bits
*/
function toUint104(uint256 value) internal pure returns (uint104) {
if (value > type(uint104).max) {
revert SafeCastOverflowedUintDowncast(104, value);
}
return uint104(value);
}
/**
* @dev Returns the downcasted uint96 from uint256, reverting on
* overflow (when the input is greater than largest uint96).
*
* Counterpart to Solidity's `uint96` operator.
*
* Requirements:
*
* - input must fit into 96 bits
*/
function toUint96(uint256 value) internal pure returns (uint96) {
if (value > type(uint96).max) {
revert SafeCastOverflowedUintDowncast(96, value);
}
return uint96(value);
}
/**
* @dev Returns the downcasted uint88 from uint256, reverting on
* overflow (when the input is greater than largest uint88).
*
* Counterpart to Solidity's `uint88` operator.
*
* Requirements:
*
* - input must fit into 88 bits
*/
function toUint88(uint256 value) internal pure returns (uint88) {
if (value > type(uint88).max) {
revert SafeCastOverflowedUintDowncast(88, value);
}
return uint88(value);
}
/**
* @dev Returns the downcasted uint80 from uint256, reverting on
* overflow (when the input is greater than largest uint80).
*
* Counterpart to Solidity's `uint80` operator.
*
* Requirements:
*
* - input must fit into 80 bits
*/
function toUint80(uint256 value) internal pure returns (uint80) {
if (value > type(uint80).max) {
revert SafeCastOverflowedUintDowncast(80, value);
}
return uint80(value);
}
/**
* @dev Returns the downcasted uint72 from uint256, reverting on
* overflow (when the input is greater than largest uint72).
*
* Counterpart to Solidity's `uint72` operator.
*
* Requirements:
*
* - input must fit into 72 bits
*/
function toUint72(uint256 value) internal pure returns (uint72) {
if (value > type(uint72).max) {
revert SafeCastOverflowedUintDowncast(72, value);
}
return uint72(value);
}
/**
* @dev Returns the downcasted uint64 from uint256, reverting on
* overflow (when the input is greater than largest uint64).
*
* Counterpart to Solidity's `uint64` operator.
*
* Requirements:
*
* - input must fit into 64 bits
*/
function toUint64(uint256 value) internal pure returns (uint64) {
if (value > type(uint64).max) {
revert SafeCastOverflowedUintDowncast(64, value);
}
return uint64(value);
}
/**
* @dev Returns the downcasted uint56 from uint256, reverting on
* overflow (when the input is greater than largest uint56).
*
* Counterpart to Solidity's `uint56` operator.
*
* Requirements:
*
* - input must fit into 56 bits
*/
function toUint56(uint256 value) internal pure returns (uint56) {
if (value > type(uint56).max) {
revert SafeCastOverflowedUintDowncast(56, value);
}
return uint56(value);
}
/**
* @dev Returns the downcasted uint48 from uint256, reverting on
* overflow (when the input is greater than largest uint48).
*
* Counterpart to Solidity's `uint48` operator.
*
* Requirements:
*
* - input must fit into 48 bits
*/
function toUint48(uint256 value) internal pure returns (uint48) {
if (value > type(uint48).max) {
revert SafeCastOverflowedUintDowncast(48, value);
}
return uint48(value);
}
/**
* @dev Returns the downcasted uint40 from uint256, reverting on
* overflow (when the input is greater than largest uint40).
*
* Counterpart to Solidity's `uint40` operator.
*
* Requirements:
*
* - input must fit into 40 bits
*/
function toUint40(uint256 value) internal pure returns (uint40) {
if (value > type(uint40).max) {
revert SafeCastOverflowedUintDowncast(40, value);
}
return uint40(value);
}
/**
* @dev Returns the downcasted uint32 from uint256, reverting on
* overflow (when the input is greater than largest uint32).
*
* Counterpart to Solidity's `uint32` operator.
*
* Requirements:
*
* - input must fit into 32 bits
*/
function toUint32(uint256 value) internal pure returns (uint32) {
if (value > type(uint32).max) {
revert SafeCastOverflowedUintDowncast(32, value);
}
return uint32(value);
}
/**
* @dev Returns the downcasted uint24 from uint256, reverting on
* overflow (when the input is greater than largest uint24).
*
* Counterpart to Solidity's `uint24` operator.
*
* Requirements:
*
* - input must fit into 24 bits
*/
function toUint24(uint256 value) internal pure returns (uint24) {
if (value > type(uint24).max) {
revert SafeCastOverflowedUintDowncast(24, value);
}
return uint24(value);
}
/**
* @dev Returns the downcasted uint16 from uint256, reverting on
* overflow (when the input is greater than largest uint16).
*
* Counterpart to Solidity's `uint16` operator.
*
* Requirements:
*
* - input must fit into 16 bits
*/
function toUint16(uint256 value) internal pure returns (uint16) {
if (value > type(uint16).max) {
revert SafeCastOverflowedUintDowncast(16, value);
}
return uint16(value);
}
/**
* @dev Returns the downcasted uint8 from uint256, reverting on
* overflow (when the input is greater than largest uint8).
*
* Counterpart to Solidity's `uint8` operator.
*
* Requirements:
*
* - input must fit into 8 bits
*/
function toUint8(uint256 value) internal pure returns (uint8) {
if (value > type(uint8).max) {
revert SafeCastOverflowedUintDowncast(8, value);
}
return uint8(value);
}
/**
* @dev Converts a signed int256 into an unsigned uint256.
*
* Requirements:
*
* - input must be greater than or equal to 0.
*/
function toUint256(int256 value) internal pure returns (uint256) {
if (value < 0) {
revert SafeCastOverflowedIntToUint(value);
}
return uint256(value);
}
/**
* @dev Returns the downcasted int248 from int256, reverting on
* overflow (when the input is less than smallest int248 or
* greater than largest int248).
*
* Counterpart to Solidity's `int248` operator.
*
* Requirements:
*
* - input must fit into 248 bits
*/
function toInt248(int256 value) internal pure returns (int248 downcasted) {
downcasted = int248(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(248, value);
}
}
/**
* @dev Returns the downcasted int240 from int256, reverting on
* overflow (when the input is less than smallest int240 or
* greater than largest int240).
*
* Counterpart to Solidity's `int240` operator.
*
* Requirements:
*
* - input must fit into 240 bits
*/
function toInt240(int256 value) internal pure returns (int240 downcasted) {
downcasted = int240(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(240, value);
}
}
/**
* @dev Returns the downcasted int232 from int256, reverting on
* overflow (when the input is less than smallest int232 or
* greater than largest int232).
*
* Counterpart to Solidity's `int232` operator.
*
* Requirements:
*
* - input must fit into 232 bits
*/
function toInt232(int256 value) internal pure returns (int232 downcasted) {
downcasted = int232(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(232, value);
}
}
/**
* @dev Returns the downcasted int224 from int256, reverting on
* overflow (when the input is less than smallest int224 or
* greater than largest int224).
*
* Counterpart to Solidity's `int224` operator.
*
* Requirements:
*
* - input must fit into 224 bits
*/
function toInt224(int256 value) internal pure returns (int224 downcasted) {
downcasted = int224(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(224, value);
}
}
/**
* @dev Returns the downcasted int216 from int256, reverting on
* overflow (when the input is less than smallest int216 or
* greater than largest int216).
*
* Counterpart to Solidity's `int216` operator.
*
* Requirements:
*
* - input must fit into 216 bits
*/
function toInt216(int256 value) internal pure returns (int216 downcasted) {
downcasted = int216(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(216, value);
}
}
/**
* @dev Returns the downcasted int208 from int256, reverting on
* overflow (when the input is less than smallest int208 or
* greater than largest int208).
*
* Counterpart to Solidity's `int208` operator.
*
* Requirements:
*
* - input must fit into 208 bits
*/
function toInt208(int256 value) internal pure returns (int208 downcasted) {
downcasted = int208(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(208, value);
}
}
/**
* @dev Returns the downcasted int200 from int256, reverting on
* overflow (when the input is less than smallest int200 or
* greater than largest int200).
*
* Counterpart to Solidity's `int200` operator.
*
* Requirements:
*
* - input must fit into 200 bits
*/
function toInt200(int256 value) internal pure returns (int200 downcasted) {
downcasted = int200(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(200, value);
}
}
/**
* @dev Returns the downcasted int192 from int256, reverting on
* overflow (when the input is less than smallest int192 or
* greater than largest int192).
*
* Counterpart to Solidity's `int192` operator.
*
* Requirements:
*
* - input must fit into 192 bits
*/
function toInt192(int256 value) internal pure returns (int192 downcasted) {
downcasted = int192(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(192, value);
}
}
/**
* @dev Returns the downcasted int184 from int256, reverting on
* overflow (when the input is less than smallest int184 or
* greater than largest int184).
*
* Counterpart to Solidity's `int184` operator.
*
* Requirements:
*
* - input must fit into 184 bits
*/
function toInt184(int256 value) internal pure returns (int184 downcasted) {
downcasted = int184(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(184, value);
}
}
/**
* @dev Returns the downcasted int176 from int256, reverting on
* overflow (when the input is less than smallest int176 or
* greater than largest int176).
*
* Counterpart to Solidity's `int176` operator.
*
* Requirements:
*
* - input must fit into 176 bits
*/
function toInt176(int256 value) internal pure returns (int176 downcasted) {
downcasted = int176(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(176, value);
}
}
/**
* @dev Returns the downcasted int168 from int256, reverting on
* overflow (when the input is less than smallest int168 or
* greater than largest int168).
*
* Counterpart to Solidity's `int168` operator.
*
* Requirements:
*
* - input must fit into 168 bits
*/
function toInt168(int256 value) internal pure returns (int168 downcasted) {
downcasted = int168(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(168, value);
}
}
/**
* @dev Returns the downcasted int160 from int256, reverting on
* overflow (when the input is less than smallest int160 or
* greater than largest int160).
*
* Counterpart to Solidity's `int160` operator.
*
* Requirements:
*
* - input must fit into 160 bits
*/
function toInt160(int256 value) internal pure returns (int160 downcasted) {
downcasted = int160(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(160, value);
}
}
/**
* @dev Returns the downcasted int152 from int256, reverting on
* overflow (when the input is less than smallest int152 or
* greater than largest int152).
*
* Counterpart to Solidity's `int152` operator.
*
* Requirements:
*
* - input must fit into 152 bits
*/
function toInt152(int256 value) internal pure returns (int152 downcasted) {
downcasted = int152(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(152, value);
}
}
/**
* @dev Returns the downcasted int144 from int256, reverting on
* overflow (when the input is less than smallest int144 or
* greater than largest int144).
*
* Counterpart to Solidity's `int144` operator.
*
* Requirements:
*
* - input must fit into 144 bits
*/
function toInt144(int256 value) internal pure returns (int144 downcasted) {
downcasted = int144(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(144, value);
}
}
/**
* @dev Returns the downcasted int136 from int256, reverting on
* overflow (when the input is less than smallest int136 or
* greater than largest int136).
*
* Counterpart to Solidity's `int136` operator.
*
* Requirements:
*
* - input must fit into 136 bits
*/
function toInt136(int256 value) internal pure returns (int136 downcasted) {
downcasted = int136(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(136, value);
}
}
/**
* @dev Returns the downcasted int128 from int256, reverting on
* overflow (when the input is less than smallest int128 or
* greater than largest int128).
*
* Counterpart to Solidity's `int128` operator.
*
* Requirements:
*
* - input must fit into 128 bits
*/
function toInt128(int256 value) internal pure returns (int128 downcasted) {
downcasted = int128(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(128, value);
}
}
/**
* @dev Returns the downcasted int120 from int256, reverting on
* overflow (when the input is less than smallest int120 or
* greater than largest int120).
*
* Counterpart to Solidity's `int120` operator.
*
* Requirements:
*
* - input must fit into 120 bits
*/
function toInt120(int256 value) internal pure returns (int120 downcasted) {
downcasted = int120(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(120, value);
}
}
/**
* @dev Returns the downcasted int112 from int256, reverting on
* overflow (when the input is less than smallest int112 or
* greater than largest int112).
*
* Counterpart to Solidity's `int112` operator.
*
* Requirements:
*
* - input must fit into 112 bits
*/
function toInt112(int256 value) internal pure returns (int112 downcasted) {
downcasted = int112(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(112, value);
}
}
/**
* @dev Returns the downcasted int104 from int256, reverting on
* overflow (when the input is less than smallest int104 or
* greater than largest int104).
*
* Counterpart to Solidity's `int104` operator.
*
* Requirements:
*
* - input must fit into 104 bits
*/
function toInt104(int256 value) internal pure returns (int104 downcasted) {
downcasted = int104(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(104, value);
}
}
/**
* @dev Returns the downcasted int96 from int256, reverting on
* overflow (when the input is less than smallest int96 or
* greater than largest int96).
*
* Counterpart to Solidity's `int96` operator.
*
* Requirements:
*
* - input must fit into 96 bits
*/
function toInt96(int256 value) internal pure returns (int96 downcasted) {
downcasted = int96(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(96, value);
}
}
/**
* @dev Returns the downcasted int88 from int256, reverting on
* overflow (when the input is less than smallest int88 or
* greater than largest int88).
*
* Counterpart to Solidity's `int88` operator.
*
* Requirements:
*
* - input must fit into 88 bits
*/
function toInt88(int256 value) internal pure returns (int88 downcasted) {
downcasted = int88(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(88, value);
}
}
/**
* @dev Returns the downcasted int80 from int256, reverting on
* overflow (when the input is less than smallest int80 or
* greater than largest int80).
*
* Counterpart to Solidity's `int80` operator.
*
* Requirements:
*
* - input must fit into 80 bits
*/
function toInt80(int256 value) internal pure returns (int80 downcasted) {
downcasted = int80(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(80, value);
}
}
/**
* @dev Returns the downcasted int72 from int256, reverting on
* overflow (when the input is less than smallest int72 or
* greater than largest int72).
*
* Counterpart to Solidity's `int72` operator.
*
* Requirements:
*
* - input must fit into 72 bits
*/
function toInt72(int256 value) internal pure returns (int72 downcasted) {
downcasted = int72(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(72, value);
}
}
/**
* @dev Returns the downcasted int64 from int256, reverting on
* overflow (when the input is less than smallest int64 or
* greater than largest int64).
*
* Counterpart to Solidity's `int64` operator.
*
* Requirements:
*
* - input must fit into 64 bits
*/
function toInt64(int256 value) internal pure returns (int64 downcasted) {
downcasted = int64(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(64, value);
}
}
/**
* @dev Returns the downcasted int56 from int256, reverting on
* overflow (when the input is less than smallest int56 or
* greater than largest int56).
*
* Counterpart to Solidity's `int56` operator.
*
* Requirements:
*
* - input must fit into 56 bits
*/
function toInt56(int256 value) internal pure returns (int56 downcasted) {
downcasted = int56(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(56, value);
}
}
/**
* @dev Returns the downcasted int48 from int256, reverting on
* overflow (when the input is less than smallest int48 or
* greater than largest int48).
*
* Counterpart to Solidity's `int48` operator.
*
* Requirements:
*
* - input must fit into 48 bits
*/
function toInt48(int256 value) internal pure returns (int48 downcasted) {
downcasted = int48(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(48, value);
}
}
/**
* @dev Returns the downcasted int40 from int256, reverting on
* overflow (when the input is less than smallest int40 or
* greater than largest int40).
*
* Counterpart to Solidity's `int40` operator.
*
* Requirements:
*
* - input must fit into 40 bits
*/
function toInt40(int256 value) internal pure returns (int40 downcasted) {
downcasted = int40(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(40, value);
}
}
/**
* @dev Returns the downcasted int32 from int256, reverting on
* overflow (when the input is less than smallest int32 or
* greater than largest int32).
*
* Counterpart to Solidity's `int32` operator.
*
* Requirements:
*
* - input must fit into 32 bits
*/
function toInt32(int256 value) internal pure returns (int32 downcasted) {
downcasted = int32(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(32, value);
}
}
/**
* @dev Returns the downcasted int24 from int256, reverting on
* overflow (when the input is less than smallest int24 or
* greater than largest int24).
*
* Counterpart to Solidity's `int24` operator.
*
* Requirements:
*
* - input must fit into 24 bits
*/
function toInt24(int256 value) internal pure returns (int24 downcasted) {
downcasted = int24(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(24, value);
}
}
/**
* @dev Returns the downcasted int16 from int256, reverting on
* overflow (when the input is less than smallest int16 or
* greater than largest int16).
*
* Counterpart to Solidity's `int16` operator.
*
* Requirements:
*
* - input must fit into 16 bits
*/
function toInt16(int256 value) internal pure returns (int16 downcasted) {
downcasted = int16(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(16, value);
}
}
/**
* @dev Returns the downcasted int8 from int256, reverting on
* overflow (when the input is less than smallest int8 or
* greater than largest int8).
*
* Counterpart to Solidity's `int8` operator.
*
* Requirements:
*
* - input must fit into 8 bits
*/
function toInt8(int256 value) internal pure returns (int8 downcasted) {
downcasted = int8(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(8, value);
}
}
/**
* @dev Converts an unsigned uint256 into a signed int256.
*
* Requirements:
*
* - input must be less than or equal to maxInt256.
*/
function toInt256(uint256 value) internal pure returns (int256) {
// Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive
if (value > uint256(type(int256).max)) {
revert SafeCastOverflowedUintToInt(value);
}
return int256(value);
}
/**
* @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.
*/
function toUint(bool b) internal pure returns (uint256 u) {
assembly ("memory-safe") {
u := iszero(iszero(b))
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC20.sol)
pragma solidity >=0.4.16;
import {IERC20} from "../token/ERC20/IERC20.sol";// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC165.sol)
pragma solidity >=0.4.16;
import {IERC165} from "../utils/introspection/IERC165.sol";// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/IERC165.sol)
pragma solidity >=0.4.16;
/**
* @dev Interface of the ERC-165 standard, as defined in the
* https://eips.ethereum.org/EIPS/eip-165[ERC].
*
* 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[ERC 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": [
"@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/",
"@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
"ds-test/=lib/openzeppelin-contracts-upgradeable/lib/forge-std/lib/ds-test/src/",
"erc4626-tests/=lib/openzeppelin-contracts-upgradeable/lib/erc4626-tests/",
"forge-std/=lib/forge-std/src/",
"halmos-cheatcodes/=lib/openzeppelin-contracts-upgradeable/lib/halmos-cheatcodes/src/",
"openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/",
"openzeppelin-contracts/=lib/openzeppelin-contracts/"
],
"optimizer": {
"enabled": true,
"runs": 200
},
"metadata": {
"useLiteralContent": false,
"bytecodeHash": "ipfs",
"appendCBOR": true
},
"outputSelection": {
"*": {
"*": [
"evm.bytecode",
"evm.deployedBytecode",
"abi"
]
}
},
"evmVersion": "cancun",
"viaIR": true
}Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
Contract ABI
API[{"inputs":[{"internalType":"bytes32","name":"protocol","type":"bytes32"}],"name":"ProtocolNotFound","type":"error"},{"inputs":[],"name":"ReentrancyGuardReentrantCall","type":"error"},{"inputs":[],"name":"UnauthorizedUpdate","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"baseProtocol","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"totalVaults","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"successCount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"failureCount","type":"uint256"}],"name":"ProtocolPanicInitiated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"baseProtocol","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"totalVaults","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"successCount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"failureCount","type":"uint256"}],"name":"ProtocolUnpaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"vault","type":"address"},{"indexed":false,"internalType":"bytes","name":"reason","type":"bytes"}],"name":"VaultPanicFailed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"vault","type":"address"},{"indexed":false,"internalType":"bytes","name":"reason","type":"bytes"}],"name":"VaultUnpauseFailed","type":"event"},{"inputs":[{"internalType":"bytes32","name":"baseProtocol","type":"bytes32"}],"name":"panicProtocol","outputs":[{"internalType":"uint256","name":"totalVaults","type":"uint256"},{"internalType":"uint256","name":"successCount","type":"uint256"},{"internalType":"uint256","name":"failureCount","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"baseProtocol","type":"bytes32"}],"name":"unpauseProtocol","outputs":[{"internalType":"uint256","name":"totalVaults","type":"uint256"},{"internalType":"uint256","name":"successCount","type":"uint256"},{"internalType":"uint256","name":"failureCount","type":"uint256"}],"stateMutability":"nonpayable","type":"function"}]Contract Creation Code
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
Deployed Bytecode
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
Deployed Bytecode Sourcemap
912:4133:27:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;912:4133:27;;;;;;1065:37;1091:10;1065:37;:::i;:::-;1064:38;1060:96;;2466:103:12;;:::i;:::-;912:4133:27;2313:1262;912:4133;;;;2759:18;912:4133;;;;;;;;2889:16;;;2885:59;;912:4133;3037:15;;;;;;912:4133;;;;;3433:135;912:4133;;3433:135;;;;;;912:4133;;;;;;;;;;;;;;;;;;3433:135;;;;912:4133;;1899:1:12;912:4133:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;3022:13;3085:17;;;;:::i;:::-;912:4133;;;;;;;;-1:-1:-1;;;;;912:4133:27;3172:26;;;;;912:4133;;-1:-1:-1;;;3172:26:27;;912:4133;;;;;3172:26;;;;;;;3022:13;-1:-1:-1;3168:208:27;;3247:129;912:4133;3247:129;3330:31;;3293:14;3247:129;;:::i;:::-;3293:14;;:::i;:::-;912:4133;;;3330:31;;;;;:::i;:::-;;;;3168:208;912:4133;3022:13;;3168:208;3217:14;;;912:4133;3217:14;;:::i;:::-;3168:208;;;3172:26;912:4133;3172:26;;;:::i;:::-;;;;;912:4133;;;2885:59;4497:30;;;;912:4133;2914:30;912:4133;;;;2914:30;1060:96;1125:20;;;912:4133;1125:20;912:4133;;1125:20;912:4133;;;;;;-1:-1:-1;;912:4133:27;;;;;;1065:37;1091:10;1065:37;:::i;:::-;1064:38;1060:96;;2466:103:12;;:::i;:::-;912:4133:27;3990:1053;912:4133;;;;4380:18;912:4133;;;;;;;;4472:16;;;4468:59;;912:4133;4558:15;;;;;;912:4133;;;;;4907:129;912:4133;;4907:129;;;;;;912:4133;;;;;;;;;;;;;;;;;;4543:13;4606:17;;;;:::i;:::-;912:4133;;;;;;;;-1:-1:-1;;;;;912:4133:27;4642:28;;;;;912:4133;;-1:-1:-1;;;4642:28:27;;912:4133;;;;;4642:28;;;;;;;4543:13;-1:-1:-1;4638:212:27;;4719:131;912:4133;4719:131;4802:33;;4765:14;4719:131;;:::i;4802:33::-;;;;4638:212;912:4133;4543:13;;4638:212;4689:14;;;912:4133;4689:14;;:::i;:::-;4638:212;;;4642:28;912:4133;4642:28;;;:::i;:::-;;;;912:4133;;;;;;;;-1:-1:-1;912:4133:27;;-1:-1:-1;912:4133:27;;;-1:-1:-1;912:4133:27;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;-1:-1:-1;912:4133:27;;;;;-1:-1:-1;912:4133:27;;-1:-1:-1;;912:4133:27;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;912:4133:27;;;;;:::i;:::-;;;;-1:-1:-1;912:4133:27;;;;:::o;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;912:4133:27;;;;:::o;1429:590:24:-;1696:15;912:4133:27;-1:-1:-1;;;;;912:4133:27;;;;;1685:26:24;1658:66;;1811:4;-1:-1:-1;912:4133:27;;;1787:15:24;912:4133:27;;;;;;;;;;;;;;;;-1:-1:-1;;;;;912:4133:27;;;;;;;;;;;;1783:62:24;;-1:-1:-1;;;;;912:4133:27;-1:-1:-1;912:4133:27;;;;;;;;;;;;1922:59:24;;912:4133:27;1429:590:24;:::o;1922:59::-;1662:19;1970:11;:::o;1783:62::-;1834:11;1662:19;1834:11;:::o;2575:307:12:-;1899:1;2702:7;912:4133:27;2702:18:12;2698:86;;1899:1;2702:7;1899:1;2575:307::o;2698:86::-;2743:30;;;2702:7;2743:30;;2702:7;2743:30
Swarm Source
ipfs://715059d56d3de20888a3499e01a25fb1e624dd4898396974e67ae1bb0107733d
Loading...
Loading
Loading...
Loading
Loading...
Loading
0x744552b3358B55874F6F9455a8a51AB9a1BAe4e1
Net Worth in USD
$0.00
Net Worth in S
0
Multichain Portfolio | 35 Chains
| Chain | Token | Portfolio % | Price | Amount | Value |
|---|
Loading...
Loading
Loading...
Loading
Loading...
Loading
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.