Feature Tip: Add private address tag to any address under My Name Tag !
Overview
ETH Balance
0.552068445358745164 ETH
Eth Value
$1,881.74 (@ $3,408.54/ETH)More Info
Private Name Tags
ContractCreator
Latest 13 from a total of 13 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Add Message Rout... | 20133828 | 28 days ago | IN | 0 ETH | 0.00089733 | ||||
Transfer | 20133516 | 28 days ago | IN | 0.5 ETH | 0.00032903 | ||||
Set Gas For Rout... | 20062095 | 38 days ago | IN | 0 ETH | 0.00062657 | ||||
Set Gas For Rout... | 20062094 | 38 days ago | IN | 0 ETH | 0.0006222 | ||||
Set Gas For Rout... | 20062093 | 38 days ago | IN | 0 ETH | 0.00060956 | ||||
Add Message Rout... | 20035076 | 42 days ago | IN | 0 ETH | 0.00226 | ||||
Add Message Rout... | 20034308 | 42 days ago | IN | 0 ETH | 0.00237028 | ||||
Transfer | 20033672 | 42 days ago | IN | 0.1 ETH | 0.00057273 | ||||
Add Message Rout... | 20033607 | 42 days ago | IN | 0 ETH | 0.00152227 | ||||
Add Message Rout... | 20033606 | 42 days ago | IN | 0 ETH | 0.001503 | ||||
Add Message Rout... | 20033605 | 42 days ago | IN | 0 ETH | 0.0015307 | ||||
Set Destination ... | 20033604 | 42 days ago | IN | 0 ETH | 0.00105054 | ||||
0x60e06040 | 20028250 | 43 days ago | IN | Create: MessageProxy | 0 ETH | 0.05070524 |
Latest 25 internal transactions (View All)
Advanced mode:
Parent Transaction Hash | Block | From | To | |||
---|---|---|---|---|---|---|
20340560 | 18 mins ago | 0.00015045 ETH | ||||
20340560 | 18 mins ago | 0.00015045 ETH | ||||
20340432 | 44 mins ago | 0.00015045 ETH | ||||
20338713 | 6 hrs ago | 0.00014831 ETH | ||||
20337128 | 11 hrs ago | 0.00015049 ETH | ||||
20334464 | 20 hrs ago | 0.00015945 ETH | ||||
20334236 | 21 hrs ago | 0.00016526 ETH | ||||
20334236 | 21 hrs ago | 0.00016526 ETH | ||||
20334236 | 21 hrs ago | 0.00016526 ETH | ||||
20333829 | 22 hrs ago | 0.00015857 ETH | ||||
20333390 | 24 hrs ago | 0.00015507 ETH | ||||
20333390 | 24 hrs ago | 0.00015507 ETH | ||||
20331545 | 30 hrs ago | 0.0001536 ETH | ||||
20330394 | 34 hrs ago | 0.00015318 ETH | ||||
20328171 | 41 hrs ago | 0.00017105 ETH | ||||
20327320 | 44 hrs ago | 0.00015272 ETH | ||||
20327143 | 45 hrs ago | 0.00015194 ETH | ||||
20326230 | 2 days ago | 0.00015144 ETH | ||||
20326230 | 2 days ago | 0.00015144 ETH | ||||
20324377 | 2 days ago | 0.00014965 ETH | ||||
20323798 | 2 days ago | 0.00015016 ETH | ||||
20320400 | 2 days ago | 0.00015488 ETH | ||||
20320129 | 2 days ago | 0.00015488 ETH | ||||
20319053 | 3 days ago | 0.00015454 ETH | ||||
20319053 | 3 days ago | 0.00015454 ETH |
Loading...
Loading
Contract Name:
MessageProxy
Compiler Version
v0.8.17+commit.8df45f5f
Optimization Enabled:
Yes with 200 runs
Other Settings:
london EvmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { Roles } from "src/libs/Roles.sol"; import { Errors } from "src/utils/Errors.sol"; import { SecurityBase } from "src/security/SecurityBase.sol"; import { ISystemRegistry } from "src/interfaces/ISystemRegistry.sol"; import { IMessageProxy } from "src/interfaces/messageProxy/IMessageProxy.sol"; import { SystemComponent } from "src/SystemComponent.sol"; import { Client } from "src/external/chainlink/ccip/Client.sol"; import { CrossChainMessagingUtilities as CCUtils, IRouterClient } from "src/libs/CrossChainMessagingUtilities.sol"; /// @title Proxy contract, sits in from of Chainlink CCIP and routes messages to various chains contract MessageProxy is IMessageProxy, SecurityBase, SystemComponent { /// ===================================================== /// Immutable Vars /// ===================================================== /// @notice Chainlink router instance. IRouterClient public immutable routerClient; /// ===================================================== /// Public Vars /// ===================================================== /// @notice Receiver contracts on the destination chains /// @dev mapping is destinationChainSelector -> our receiver contract mapping(uint64 => address) public destinationChainReceivers; /// @notice Hashing of last message sent for sender address and messageType /// @dev mapping is msg.sender -> messageType -> messageHash. mapping(address => mapping(bytes32 => bytes32)) public lastMessageSent; /// ===================================================== /// Private Vars /// ===================================================== /// @notice Routes configured for a message and sender /// @dev mapping is msg.sender -> messageType -> routes. Exposed via getMessageRoutes() mapping(address => mapping(bytes32 => MessageRouteConfig[])) private _messageRoutes; /// ===================================================== /// Structs /// ===================================================== /// @notice Destination chain to send a message to and the gas required for that chain struct MessageRouteConfig { uint64 destinationChainSelector; uint192 gas; } /// @notice Arguments used to resend the last message for a sender + type struct ResendArgsSendingChain { address msgSender; bytes32 messageType; uint256 messageRetryTimestamp; // Timestamp of original message, emitted in `MessageData` event. bytes message; MessageRouteConfig[] configs; } /// ===================================================== /// Errors /// ===================================================== /// @notice Thrown when not enough fee is left for send. error NotEnoughFee(uint256 available, uint256 needed); /// ===================================================== /// Events /// ===================================================== /// @notice Emitted when message is built to be sent for message sender and type. event MessageData( bytes32 indexed messageHash, uint256 messageTimestamp, address sender, bytes32 messageType, bytes message ); /// @notice Emitted when a message is sent. event MessageSent(uint64 destChainSelector, bytes32 messageHash, bytes32 ccipMessageId); /// @notice Emitted when a receiver contract is set for a destination chain event ReceiverSet(uint64 destChainSelector, address destinationChainReceiver); /// @notice Emitted when a receiver contract is removed event ReceiverRemoved(uint64 destChainSelector, address destinationChainReceiver); /// @notice Emitted when a message route is added event MessageRouteAdded(address sender, bytes32 messageType, uint64 destChainSelector); /// @notice Emitted when a message route is removed event MessageRouteDeleted(address sender, bytes32 messageType, uint64 destChainSelector); /// @notice Emitted when we update the gas sent for a message to a chain event GasUpdated(address sender, bytes32 messageType, uint64 destChainSelector, uint192 gas); /// ===================================================== /// Events - Failure /// @dev All below events emitted upon message failure in `sendMessage()` /// ===================================================== /// @notice Emitted when `Router.getFee()` call fails event GetFeeFailed(uint64 destChainSelector, bytes32 messageHash); /// @notice Emitted when a message fails in try-catch. event MessageFailed(uint64 destChainId, bytes32 messageHash); /// @notice Emitted when message fails due to fee. event MessageFailedFee(uint64 destChainId, bytes32 messageHash, uint256 currentBalance, uint256 feeNeeded); /// @notice Emitted when a destination chain is not registered event DestinationChainNotRegisteredEvent(uint256 destChainId, bytes32 messageHash); /// @notice Emitted when message sent in by calculator does not exist event MessageZeroLength(address messageSender, bytes32 messageType); /// ===================================================== /// Functions - Constructor /// ===================================================== constructor( ISystemRegistry _systemRegistry, IRouterClient ccipRouter ) SystemComponent(_systemRegistry) SecurityBase(address(_systemRegistry.accessController())) { Errors.verifyNotZero(address(ccipRouter), "ccipRouter"); routerClient = ccipRouter; } /// ===================================================== /// Functions - External /// ===================================================== /// @notice Sends message to destination chain(s) /// @dev Can only be called by registered message sender. /// @dev Should not revert under normal circumstances, do not want ability to interrupt calculator snap-shotting /// @param messageType bytes32 message type /// @param message Bytes message to send to receiver contract function sendMessage(bytes32 messageType, bytes memory message) external override { // Lookup message routes from _messageRoutes MessageRouteConfig[] memory configs = _messageRoutes[msg.sender][messageType]; uint256 configsLength = configs.length; // If there are zero routes, then just return, nothing to do // Routes act as our security if (configsLength == 0) return; uint256 messageTimestamp = block.timestamp; // Encode and hash message, set hash to last message for sender and messageType bytes memory encodedMessage = CCUtils.encodeMessage(msg.sender, messageTimestamp, messageType, message); bytes32 messageHash = keccak256(encodedMessage); lastMessageSent[msg.sender][messageType] = messageHash; emit MessageData(messageHash, messageTimestamp, msg.sender, messageType, message); // Loop through configs, attempt to send message to each destination. for (uint256 i = 0; i < configsLength; ++i) { uint64 destChainSelector = configs[i].destinationChainSelector; address destChainReceiver = destinationChainReceivers[destChainSelector]; // Covers both selector and receiver, cannot set address for zero selector. if (destChainReceiver == address(0)) { emit DestinationChainNotRegisteredEvent(destChainSelector, messageHash); continue; } // Build ccip message Client.EVM2AnyMessage memory ccipMessage = _ccipBuild(destChainReceiver, configs[i].gas, encodedMessage); // Attempt to get fee destination chain send, emit event and break look on failure. uint256 fee = 0; try routerClient.getFee(destChainSelector, ccipMessage) returns (uint256 _fee) { fee = _fee; } catch { emit GetFeeFailed(destChainSelector, messageHash); break; } uint256 addressBalance = address(this).balance; // If we have the balance, try ccip message // slither-disable-next-line timestamp if (addressBalance >= fee) { // Catch any errors thrown from L1 ccip router, emit event with information on success or failure try routerClient.ccipSend{ value: fee }(destChainSelector, ccipMessage) returns (bytes32 ccipMessageId) { // slither-disable-next-line reentrancy-events emit MessageSent(destChainSelector, messageHash, ccipMessageId); } catch { emit MessageFailed(destChainSelector, messageHash); } } else { // If we do not have balance, emit event telling so. emit MessageFailedFee(destChainSelector, messageHash, addressBalance, fee); } } } /// @notice Retry for multiple messages to multiple destinations per message. /// @dev Caller must send in ETH to cover router fees. Cannot use contract balance /// @dev Excess ETH is not refunded, use getFee() to calculate needed amount /// @param args Array of ResendArgsSendingChain structs function resendLastMessage(ResendArgsSendingChain[] memory args) external payable hasRole(Roles.MESSAGE_PROXY_EXECUTOR) { // Tracking for fee uint256 feeLeft = msg.value; // Loop through ResendArgsSendingChain array. for (uint256 i = 0; i < args.length; ++i) { // Store vars with multiple usages locally ResendArgsSendingChain memory currentRetry = args[i]; address msgSender = currentRetry.msgSender; bytes32 messageType = currentRetry.messageType; uint256 messageRetryTimestamp = currentRetry.messageRetryTimestamp; bytes memory message = currentRetry.message; // Get hash from data passed in, hash from last message, revert if they are not equal. // solhint-disable-next-line max-line-length bytes memory encodedMessage = CCUtils.encodeMessage(msgSender, messageRetryTimestamp, messageType, message); bytes32 currentMessageHash = keccak256(encodedMessage); { bytes32 storedMessageHash = lastMessageSent[msgSender][messageType]; if (currentMessageHash != storedMessageHash) { revert CCUtils.MismatchMessageHash(storedMessageHash, currentMessageHash); } } // Loop through and send off to destinations in specific ResendArgsSendingChain struct, fee dependent. for (uint256 j = 0; j < currentRetry.configs.length; ++j) { uint64 currentDestChainSelector = currentRetry.configs[j].destinationChainSelector; address destChainReceiver = destinationChainReceivers[currentDestChainSelector]; // Covers destChainSelector being zero as well, cannot set 0 for selector, will always return address(0) Errors.verifyNotZero(destChainReceiver, "destChainReceiver"); Client.EVM2AnyMessage memory ccipMessage = _ccipBuild(destChainReceiver, currentRetry.configs[j].gas, encodedMessage); uint256 fee = routerClient.getFee(currentDestChainSelector, ccipMessage); // slither-disable-next-line timestamp if (feeLeft < fee) { revert NotEnoughFee(feeLeft, fee); } // Checked above unchecked { feeLeft -= fee; } // slither-disable-next-line arbitrary-send-eth bytes32 ccipMessageId = routerClient.ccipSend{ value: fee }(currentDestChainSelector, ccipMessage); // slither-disable-next-line reentrancy-events emit MessageSent(currentDestChainSelector, currentMessageHash, ccipMessageId); } } } /// @notice Sets our receiver on the destination chain /// @param destinationChainSelector CCIP chain id /// @param destinationChainReceiver Our receiver contract on the destination chain function setDestinationChainReceiver( uint64 destinationChainSelector, address destinationChainReceiver ) external hasRole(Roles.MESSAGE_PROXY_MANAGER) { // Check that we aren't doing cleanup if a chain is deprecated if (destinationChainReceiver != address(0)) { CCUtils.validateChain(routerClient, destinationChainSelector); } emit ReceiverSet(destinationChainSelector, destinationChainReceiver); destinationChainReceivers[destinationChainSelector] = destinationChainReceiver; } /// @notice Add message routes for sender / messageType /// @dev Reverts if route is duplicate /// @param sender Message sender for routes /// @param messageType Message type for routes /// @param routes Routes to set for sender and type pairing function addMessageRoutes( address sender, bytes32 messageType, MessageRouteConfig[] memory routes ) external hasRole(Roles.MESSAGE_PROXY_MANAGER) { Errors.verifyNotZero(sender, "sender"); Errors.verifyNotZero(messageType, "messageType"); uint256 routesLength = routes.length; Errors.verifyNotZero(routesLength, "routesLength"); for (uint256 i = 0; i < routesLength; ++i) { uint64 currentDestChainSelector = routes[i].destinationChainSelector; CCUtils.validateChain(routerClient, currentDestChainSelector); Errors.verifyNotZero(uint256(routes[i].gas), "gas"); // Check that overwrite is not happening. MessageRouteConfig[] memory currentStoredRoutes = _messageRoutes[sender][messageType]; uint256 currentLen = currentStoredRoutes.length; for (uint256 j = 0; j < currentLen; ++j) { if (currentStoredRoutes[j].destinationChainSelector == currentDestChainSelector) { revert Errors.ItemExists(); } } emit MessageRouteAdded(sender, messageType, currentDestChainSelector); _messageRoutes[sender][messageType].push(routes[i]); } } /// @notice Remove message routes for sender / messageType /// @dev Reverts if a route attempted to be deleted does not exist /// @param sender Message sender for routes /// @param messageType for routes /// @param chainSelectors Selectors for chains to be removed function removeMessageRoutes( address sender, bytes32 messageType, uint64[] calldata chainSelectors ) external hasRole(Roles.MESSAGE_PROXY_MANAGER) { Errors.verifyNotZero(sender, "sender"); Errors.verifyNotZero(messageType, "messageType"); uint256 chainLength = chainSelectors.length; Errors.verifyNotZero(chainLength, "chainLength"); MessageRouteConfig[] storage currentStoredRoutes = _messageRoutes[sender][messageType]; for (uint256 i = 0; i < chainLength; ++i) { uint256 currentLen = currentStoredRoutes.length; uint64 currentSelector = chainSelectors[i]; if (currentLen == 0) { revert Errors.ItemNotFound(); } // For each route we want to remove, loop through stored routes. uint256 j = 0; for (; j < currentLen; ++j) { // If route to add is equal to a stored route, remove. if (currentSelector == currentStoredRoutes[j].destinationChainSelector) { emit MessageRouteDeleted(sender, messageType, currentSelector); // For each route, record index of storage array that was deleted. currentStoredRoutes[j] = currentStoredRoutes[currentStoredRoutes.length - 1]; currentStoredRoutes.pop(); // Can only have one message route per dest chain selector, when we find it break for loop. break; } } // If we get to the end of the currentStoredRoutes array, item to be deleted does not exist. if (j == currentLen) { revert Errors.ItemNotFound(); } } } /// @notice Updates the gas we'll send for this message route /// @dev Reverts if chainId is not found for message sender and type combo /// @param messageSender Message sender for route to be updated /// @param messageType Message type for route to be updated /// @param chainId chainId for route to be updated /// @param gas Gas to update route receiving chain to function setGasForRoute( address messageSender, bytes32 messageType, uint64 chainId, uint192 gas ) external hasRole(Roles.MESSAGE_PROXY_MANAGER) { Errors.verifyNotZero(messageSender, "sender"); Errors.verifyNotZero(messageType, "messageType"); Errors.verifyNotZero(gas, "gas"); MessageRouteConfig[] storage currentStoredRoutes = _messageRoutes[messageSender][messageType]; uint256 routeLength = currentStoredRoutes.length; uint256 i = 0; for (; i < routeLength; ++i) { if (currentStoredRoutes[i].destinationChainSelector == chainId) { currentStoredRoutes[i].gas = gas; emit GasUpdated(messageSender, messageType, chainId, gas); break; } } if (i == routeLength) { revert Errors.ItemNotFound(); } } /// @notice Estimate fees off-chain for purpose of retries /// @param messageSender Address of the message sender for fee estimation /// @param messageType Message type for fee estimation /// @param message Message for fee estimation function getFee( address messageSender, bytes32 messageType, bytes memory message ) external view returns (uint64[] memory chains, uint256[] memory fees) { MessageRouteConfig[] memory configs = _messageRoutes[messageSender][messageType]; uint256 len = configs.length; chains = new uint64[](len); fees = new uint256[](len); bytes memory encodedMessage = CCUtils.encodeMessage(messageSender, block.timestamp, messageType, message); // Loop through configs and get fee by destination chain. for (uint256 i = 0; i < len; ++i) { uint64 destChainSelector = configs[i].destinationChainSelector; address destChainReceiver = destinationChainReceivers[destChainSelector]; Errors.verifyNotZero( destinationChainReceivers[destChainSelector], "destinationChainReceivers[destChainSelector]" ); // Build message for fee. Client.EVM2AnyMessage memory ccipFeeMessage = _ccipBuild(destChainReceiver, configs[i].gas, encodedMessage); chains[i] = destChainSelector; fees[i] = routerClient.getFee(destChainSelector, ccipFeeMessage); } } /// @notice Returns all message routes for sender and messageType. /// @param sender Message sender for routes /// @param messageType Message type for routes function getMessageRoutes( address sender, bytes32 messageType ) external view returns (MessageRouteConfig[] memory routes) { uint256 len = _messageRoutes[sender][messageType].length; routes = new MessageRouteConfig[](len); for (uint256 i = 0; i < len; ++i) { routes[i] = _messageRoutes[sender][messageType][i]; } } /// ===================================================== /// Functions - Receive /// ===================================================== /// @dev `sendMessage` requires contract to be funded with Eth receive() external payable { } /// ===================================================== /// Functions - Private / Internal Helpers /// ===================================================== /// @notice Builds Chainlink specified message to send to destination chain. function _ccipBuild( address destinationChainReceiver, uint256 gas, bytes memory message ) internal pure returns (Client.EVM2AnyMessage memory) { return Client.EVM2AnyMessage({ receiver: abi.encode(destinationChainReceiver), data: message, // Encoded Message struct tokenAmounts: new Client.EVMTokenAmount[](0), feeToken: address(0), // Native Eth extraArgs: Client._argsToBytes(Client.EVMExtraArgsV1({ gasLimit: gas })) }); } }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; library Roles { // -------------------------------------------------------------------- // Central roles list used by all contracts that call AccessController // -------------------------------------------------------------------- // TODO: Update the hash values to match the variable names for new deployments. // Naming Conventions: // - Use MANAGER, CREATOR, UPDATER, ..., for roles primarily managing on-chain activities. // - Use EXECUTOR for roles that trigger off-chain initiated actions. // - Group roles by functional area for clarity. // -------------------------------------------------------------------- // Destination Vault Management bytes32 public constant DESTINATION_VAULT_FACTORY_MANAGER = keccak256("CREATE_DESTINATION_VAULT_ROLE"); bytes32 public constant DESTINATION_VAULT_REGISTRY_MANAGER = keccak256("DESTINATION_VAULT_REGISTRY_MANAGER"); bytes32 public constant DESTINATION_VAULT_MANAGER = keccak256("DESTINATION_VAULT_MANAGER"); // Auto Pool Factory and Registry Management bytes32 public constant AUTO_POOL_REGISTRY_UPDATER = keccak256("REGISTRY_UPDATER"); bytes32 public constant AUTO_POOL_FACTORY_MANAGER = 0x00; // keccak256("LMP_VAULT_FACTORY_MANAGER"); bytes32 public constant AUTO_POOL_FACTORY_VAULT_CREATOR = keccak256("CREATE_POOL_ROLE"); // Auto Pool Management bytes32 public constant AUTO_POOL_DESTINATION_UPDATER = keccak256("DESTINATION_VAULTS_UPDATER"); bytes32 public constant AUTO_POOL_FEE_UPDATER = keccak256("AUTO_POOL_FEE_SETTER_ROLE"); bytes32 public constant AUTO_POOL_PERIODIC_FEE_UPDATER = keccak256("AUTO_POOL_PERIODIC_FEE_SETTER_ROLE"); bytes32 public constant AUTO_POOL_REWARD_MANAGER = keccak256("AUTO_POOL_REWARD_MANAGER_ROLE"); bytes32 public constant AUTO_POOL_MANAGER = keccak256("AUTO_POOL_ADMIN"); bytes32 public constant REBALANCER = keccak256("REBALANCER_ROLE"); // Reward Management bytes32 public constant LIQUIDATOR_MANAGER = keccak256("LIQUIDATOR_ROLE"); bytes32 public constant DV_REWARD_MANAGER = keccak256("DV_REWARD_MANAGER_ROLE"); bytes32 public constant REWARD_LIQUIDATION_MANAGER = keccak256("REWARD_LIQUIDATION_MANAGER"); bytes32 public constant EXTRA_REWARD_MANAGER = keccak256("EXTRA_REWARD_MANAGER_ROLE"); bytes32 public constant REWARD_LIQUIDATION_EXECUTOR = keccak256("REWARD_LIQUIDATION_EXECUTOR"); // Statistics and Reporting bytes32 public constant STATS_CALC_REGISTRY_MANAGER = 0x00; // keccak256("STATS_CALC_REGISTRY_MANAGER"); bytes32 public constant STATS_CALC_FACTORY_MANAGER = keccak256("CREATE_STATS_CALC_ROLE"); bytes32 public constant STATS_CALC_FACTORY_TEMPLATE_MANAGER = keccak256("STATS_CALC_TEMPLATE_MGMT_ROLE"); bytes32 public constant STATS_SNAPSHOT_EXECUTOR = keccak256("STATS_SNAPSHOT_ROLE"); bytes32 public constant STATS_INCENTIVE_TOKEN_UPDATER = keccak256("STATS_INCENTIVE_TOKEN_UPDATER"); bytes32 public constant STATS_GENERAL_MANAGER = keccak256("STATS_GENERAL_MANAGER"); bytes32 public constant STATS_LST_ETH_TOKEN_EXECUTOR = keccak256("STATS_LST_ETH_TOKEN_EXECUTOR"); // Emergency Management bytes32 public constant EMERGENCY_PAUSER = keccak256("EMERGENCY_PAUSER"); // Miscellaneous Roles bytes32 public constant SOLVER = keccak256("SOLVER_ROLE"); bytes32 public constant AUTO_POOL_REPORTING_EXECUTOR = keccak256("AUTO_POOL_UPDATE_DEBT_REPORTING_ROLE"); // Swapper Roles bytes32 public constant SWAP_ROUTER_MANAGER = 0x00; // keccak256("SWAP_ROUTER_MANAGER"); // Price Oracles Roles bytes32 public constant ORACLE_MANAGER = keccak256("ORACLE_MANAGER_ROLE"); bytes32 public constant CUSTOM_ORACLE_EXECUTOR = keccak256("CUSTOM_ORACLE_EXECUTOR"); bytes32 public constant MAVERICK_FEE_ORACLE_EXECUTOR = keccak256("MAVERICK_FEE_ORACLE_MANAGER"); // AccToke Roles bytes32 public constant ACC_TOKE_MANAGER = keccak256("ACC_TOKE_MANAGER"); // Admin Roles bytes32 public constant TOKEN_RECOVERY_MANAGER = keccak256("TOKEN_RECOVERY_ROLE"); bytes32 public constant INFRASTRUCTURE_MANAGER = keccak256("INFRASTRUCTURE_MANAGER"); // Cross chain communications roles bytes32 public constant MESSAGE_PROXY_MANAGER = keccak256("MESSAGE_PROXY_MANAGER"); bytes32 public constant MESSAGE_PROXY_EXECUTOR = keccak256("MESSAGE_PROXY_EXECUTOR"); bytes32 public constant RECEIVING_ROUTER_MANAGER = keccak256("RECEIVING_ROUTER_MANAGER"); bytes32 public constant RECEIVING_ROUTER_EXECUTOR = keccak256("RECEIVING_ROUTER_EXECUTOR"); }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { Address } from "openzeppelin-contracts/utils/Address.sol"; library Errors { using Address for address; /////////////////////////////////////////////////////////////////// // Set errors /////////////////////////////////////////////////////////////////// error AccessDenied(); error ZeroAddress(string paramName); error ZeroAmount(); error InsufficientBalance(address token); error AssetNotAllowed(address token); error NotImplemented(); error InvalidAddress(address addr); error InvalidParam(string paramName); error InvalidParams(); error UnsafePrice(address token, uint256 spotPrice, uint256 safePrice); error AlreadySet(string param); error AlreadyRegistered(address param); error SlippageExceeded(uint256 expected, uint256 actual); error ArrayLengthMismatch(uint256 length1, uint256 length2, string details); error ItemNotFound(); error ItemExists(); error MissingRole(bytes32 role, address user); error RegistryItemMissing(string item); error NotRegistered(); // Used to check storage slot is empty before setting. error MustBeZero(); // Used to check storage slot set before deleting. error MustBeSet(); error ApprovalFailed(address token); error FlashLoanFailed(address token, uint256 amount); error SystemMismatch(address source1, address source2); error InvalidToken(address token); error UnreachableError(); error InvalidSigner(address signer); error InvalidChainId(uint256 chainId); error SenderMismatch(address recipient, address sender); error UnsupportedMessage(bytes32 messageType, bytes message); error NotSupported(); function verifyNotZero(address addr, string memory paramName) internal pure { if (addr == address(0)) { revert ZeroAddress(paramName); } } function verifyNotZero(bytes32 key, string memory paramName) internal pure { if (key == bytes32(0)) { revert InvalidParam(paramName); } } function verifyNotEmpty(string memory val, string memory paramName) internal pure { if (bytes(val).length == 0) { revert InvalidParam(paramName); } } function verifyNotZero(uint256 num, string memory paramName) internal pure { if (num == 0) { revert InvalidParam(paramName); } } function verifySystemsMatch(address component1, address component2) internal view { bytes memory call = abi.encodeWithSignature("getSystemRegistry()"); address registry1 = abi.decode(component1.functionStaticCall(call), (address)); address registry2 = abi.decode(component2.functionStaticCall(call), (address)); if (registry1 != registry2) { revert SystemMismatch(component1, component2); } } function verifyArrayLengths(uint256 length1, uint256 length2, string memory details) internal pure { if (length1 != length2) { revert ArrayLengthMismatch(length1, length2, details); } } }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { IAccessController } from "src/interfaces/security/IAccessController.sol"; import { Errors } from "src/utils/Errors.sol"; contract SecurityBase { IAccessController public immutable accessController; error UndefinedAddress(); constructor(address _accessController) { if (_accessController == address(0)) revert UndefinedAddress(); accessController = IAccessController(_accessController); } modifier onlyOwner() { accessController.verifyOwner(msg.sender); _; } modifier hasRole(bytes32 role) { if (!accessController.hasRole(role, msg.sender)) revert Errors.AccessDenied(); _; } /////////////////////////////////////////////////////////////////// // // Forward all the regular methods to central security module // /////////////////////////////////////////////////////////////////// function _hasRole(bytes32 role, address account) internal view returns (bool) { return accessController.hasRole(role, account); } }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { IWETH9 } from "src/interfaces/utils/IWETH9.sol"; import { IAccToke } from "src/interfaces/staking/IAccToke.sol"; import { IAutopoolRegistry } from "src/interfaces/vault/IAutopoolRegistry.sol"; import { IAccessController } from "src/interfaces/security/IAccessController.sol"; import { ISwapRouter } from "src/interfaces/swapper/ISwapRouter.sol"; import { ICurveResolver } from "src/interfaces/utils/ICurveResolver.sol"; import { IAutopilotRouter } from "src/interfaces/vault/IAutopilotRouter.sol"; import { IAutopoolFactory } from "src/interfaces/vault/IAutopoolFactory.sol"; import { ISystemSecurity } from "src/interfaces/security/ISystemSecurity.sol"; import { IDestinationRegistry } from "src/interfaces/destinations/IDestinationRegistry.sol"; import { IRootPriceOracle } from "src/interfaces/oracles/IRootPriceOracle.sol"; import { IDestinationVaultRegistry } from "src/interfaces/vault/IDestinationVaultRegistry.sol"; import { IAccessController } from "src/interfaces/security/IAccessController.sol"; import { IStatsCalculatorRegistry } from "src/interfaces/stats/IStatsCalculatorRegistry.sol"; import { IAsyncSwapperRegistry } from "src/interfaces/liquidation/IAsyncSwapperRegistry.sol"; import { IERC20Metadata } from "openzeppelin-contracts/token/ERC20/extensions/IERC20Metadata.sol"; import { IIncentivesPricingStats } from "src/interfaces/stats/IIncentivesPricingStats.sol"; import { IMessageProxy } from "src/interfaces/messageProxy/IMessageProxy.sol"; /// @notice Root most registry contract for the system interface ISystemRegistry { /// @notice Get the TOKE contract for the system /// @return toke instance of TOKE used in the system function toke() external view returns (IERC20Metadata); /// @notice Get the referenced WETH contract for the system /// @return weth contract pointer function weth() external view returns (IWETH9); /// @notice Get the AccToke staking contract /// @return accToke instance of the accToke contract for the system function accToke() external view returns (IAccToke); /// @notice Get the AutopoolRegistry for this system /// @return registry instance of the registry for this system function autoPoolRegistry() external view returns (IAutopoolRegistry registry); /// @notice Get the destination Vault registry for this system /// @return registry instance of the registry for this system function destinationVaultRegistry() external view returns (IDestinationVaultRegistry registry); /// @notice Get the access Controller for this system /// @return controller instance of the access controller for this system function accessController() external view returns (IAccessController controller); /// @notice Get the destination template registry for this system /// @return registry instance of the registry for this system function destinationTemplateRegistry() external view returns (IDestinationRegistry registry); /// @notice Auto Pilot Router /// @return router instance of the system function autoPoolRouter() external view returns (IAutopilotRouter router); /// @notice Vault factory lookup by type /// @return vaultFactory instance of the vault factory for this vault type function getAutopoolFactoryByType(bytes32 vaultType) external view returns (IAutopoolFactory vaultFactory); /// @notice Get the stats calculator registry for this system /// @return registry instance of the registry for this system function statsCalculatorRegistry() external view returns (IStatsCalculatorRegistry registry); /// @notice Get the root price oracle for this system /// @return oracle instance of the root price oracle for this system function rootPriceOracle() external view returns (IRootPriceOracle oracle); /// @notice Get the async swapper registry for this system /// @return registry instance of the registry for this system function asyncSwapperRegistry() external view returns (IAsyncSwapperRegistry registry); /// @notice Get the swap router for this system /// @return router instance of the swap router for this system function swapRouter() external view returns (ISwapRouter router); /// @notice Get the curve resolver for this system /// @return resolver instance of the curve resolver for this system function curveResolver() external view returns (ICurveResolver resolver); /// @notice Verify if given address is registered as Reward Token /// @param rewardToken token address to verify /// @return bool that indicates true if token is registered and false if not function isRewardToken(address rewardToken) external view returns (bool); /// @notice Get the system security instance for this system /// @return security instance of system security for this system function systemSecurity() external view returns (ISystemSecurity security); /// @notice Get the Incentive Pricing Stats /// @return incentivePricing the incentive pricing contract function incentivePricing() external view returns (IIncentivesPricingStats); /// @notice Get the Messagy Proxy /// @return Message proxy contract function messageProxy() external view returns (IMessageProxy); /// @notice Get the receiving router contract. /// @return Receiving router contract function receivingRouter() external view returns (address); }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; /// @title Send messages to our systems on other chains interface IMessageProxy { function sendMessage(bytes32 messageType, bytes memory message) external; }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { ISystemComponent } from "src/interfaces/ISystemComponent.sol"; import { ISystemRegistry } from "src/interfaces/ISystemRegistry.sol"; import { Errors } from "src/utils/Errors.sol"; contract SystemComponent is ISystemComponent { ISystemRegistry internal immutable systemRegistry; constructor(ISystemRegistry _systemRegistry) { Errors.verifyNotZero(address(_systemRegistry), "_systemRegistry"); systemRegistry = _systemRegistry; } /// @inheritdoc ISystemComponent function getSystemRegistry() external view returns (address) { return address(systemRegistry); } }
// SPDX-License-Identifier: MIT pragma solidity 0.8.17; // End consumer library. library Client { /// @dev RMN depends on this struct, if changing, please notify the RMN maintainers. struct EVMTokenAmount { address token; // token address on the local chain. uint256 amount; // Amount of tokens. } /// @dev CCIP receivers use this struct to parse the received message struct Any2EVMMessage { bytes32 messageId; // MessageId corresponding to ccipSend on source. uint64 sourceChainSelector; // Source chain selector. bytes sender; // abi.decode(sender) if coming from an EVM chain. bytes data; // payload sent in original message. EVMTokenAmount[] destTokenAmounts; // Tokens and their amounts in their destination chain representation. } // If extraArgs is empty bytes, the default is 200k gas limit. /// @dev CCIP senders use this struct to build message. struct EVM2AnyMessage { bytes receiver; // abi.encode(receiver address) for dest EVM chains bytes data; // Data payload EVMTokenAmount[] tokenAmounts; // Token transfers. Empty array for no tokens transferred. address feeToken; // Address of feeToken. address(0) means you will send msg.value. bytes extraArgs; // Populate this with _argsToBytes(EVMExtraArgsV1) } // bytes4(keccak256("CCIP EVMExtraArgsV1")); bytes4 public constant EVM_EXTRA_ARGS_V1_TAG = 0x97a657c9; struct EVMExtraArgsV1 { uint256 gasLimit; } function _argsToBytes(EVMExtraArgsV1 memory extraArgs) internal pure returns (bytes memory bts) { return abi.encodeWithSelector(EVM_EXTRA_ARGS_V1_TAG, extraArgs); } }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { IRouterClient } from "src/interfaces/external/chainlink/IRouterClient.sol"; /// @title Contains some common errors, events, structs, functionality for cross chain comms. library CrossChainMessagingUtilities { /// ===================================================== /// Constants /// ===================================================== /// @notice Message struct version uint256 public constant VERSION = 1; /// ===================================================== /// Errors /// ===================================================== /// @notice Thrown when chain selector is not supported error ChainNotSupported(uint64 chainId); /// @notice Thrown when stored and supplied message hashes don't match in resend functions. error MismatchMessageHash(bytes32 storedHash, bytes32 currentHash); /// ===================================================== /// Structs /// ===================================================== /// @notice Message struct. Encoded and sent across chain. struct Message { address messageOrigin; uint256 version; uint256 messageTimestamp; bytes32 messageType; bytes message; } /// ===================================================== /// External Functions /// ===================================================== /// @notice Returns current version of Message struct. function getVersion() external pure returns (uint256) { return VERSION; } /// @notice Encodes message to be sent to receiving chain /// @param sender Message sender /// @param messageTimestamp Timestamp of message to be sent /// @param messageType message type to be sent /// @param message Bytes message to be processed on receiving chain function encodeMessage( address sender, uint256 messageTimestamp, bytes32 messageType, bytes memory message ) internal pure returns (bytes memory) { return abi.encode( Message({ messageOrigin: sender, version: VERSION, messageTimestamp: messageTimestamp, messageType: messageType, message: message }) ); } /// @notice Validates the chain selector with the ccip router function validateChain(IRouterClient routerClient, uint64 chain) internal view { if (!routerClient.isChainSupported(chain)) { revert ChainNotSupported(chain); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol) pragma solidity ^0.8.1; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== * * [IMPORTANT] * ==== * You shouldn't rely on `isContract` to protect against flash loan attacks! * * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract * constructor. * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize/address.code.length, which returns 0 // for contracts in construction, since the code is only stored at the end // of the constructor execution. return account.code.length > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); (bool success, ) = recipient.call{value: amount}(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain `call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value ) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value, string memory errorMessage ) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall( address target, bytes memory data, string memory errorMessage ) internal view returns (bytes memory) { (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract. * * _Available since v4.8._ */ function verifyCallResultFromTarget( address target, bool success, bytes memory returndata, string memory errorMessage ) internal view returns (bytes memory) { if (success) { if (returndata.length == 0) { // only check isContract if the call was successful and the return data is empty // otherwise we already know that it was a contract require(isContract(target), "Address: call to non-contract"); } return returndata; } else { _revert(returndata, errorMessage); } } /** * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason or using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal pure returns (bytes memory) { if (success) { return returndata; } else { _revert(returndata, errorMessage); } } function _revert(bytes memory returndata, string memory errorMessage) private pure { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly /// @solidity memory-safe-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { IAccessControlEnumerable } from "openzeppelin-contracts/access/IAccessControlEnumerable.sol"; interface IAccessController is IAccessControlEnumerable { error AccessDenied(); /** * @notice Setup a role for an account * @param role The role to setup * @param account The account to setup the role for */ function setupRole(bytes32 role, address account) external; /** * @notice Verify if an account is an owner. Reverts if not * @param account The account to verify */ function verifyOwner(address account) external view; }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.7; import { IERC20 } from "openzeppelin-contracts/token/ERC20/IERC20.sol"; interface IWETH9 is IERC20 { function symbol() external view returns (string memory); function deposit() external payable; function withdraw(uint256 amount) external; }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { IERC20Metadata } from "openzeppelin-contracts/token/ERC20/extensions/IERC20Metadata.sol"; interface IAccToke { /////////////////////////////////////////////////////////////////// // Variables /////////////////////////////////////////////////////////////////// function startEpoch() external view returns (uint256); function minStakeDuration() external view returns (uint256); struct Lockup { uint128 amount; uint128 end; uint256 points; } function getLockups(address user) external view returns (Lockup[] memory); function toke() external view returns (IERC20Metadata); /////////////////////////////////////////////////////////////////// // Errors /////////////////////////////////////////////////////////////////// error ZeroAddress(); error StakingDurationTooShort(); error StakingDurationTooLong(); error StakingPointsExceeded(); error IncorrectStakingAmount(); error InsufficientFunds(); error LockupDoesNotExist(); error NotUnlockableYet(); error AlreadyUnlocked(); error ExtendDurationTooShort(); error TransfersDisabled(); error TransferFailed(); error NoRewardsToClaim(); error InsufficientAmount(); error InvalidLockupIds(); error InvalidDurationLength(); /////////////////////////////////////////////////////////////////// // Events /////////////////////////////////////////////////////////////////// event SetMaxStakeDuration(uint256 oldDuration, uint256 newDuration); event Stake(address indexed user, uint256 lockupId, uint256 amount, uint256 end, uint256 points); event Unstake(address indexed user, uint256 lockupId, uint256 amount, uint256 end, uint256 points); event Extend( address indexed user, uint256 lockupId, uint256 amount, uint256 oldEnd, uint256 newEnd, uint256 oldPoints, uint256 newPoints ); event RewardsAdded(uint256 amount, uint256 accRewardPerShare); event RewardsCollected(address indexed user, uint256 amount); event RewardsClaimed(address indexed user, uint256 amount); /////////////////////////////////////////////////////////////////// // // Staking Methods // /////////////////////////////////////////////////////////////////// /** * @notice Stake TOKE to an address that may not be the same as the sender of the funds. This can be used to give * staked funds to someone else. * * If staking before the start of staking (epoch), then the lockup start and end dates are shifted forward so that * the lockup starts at the epoch. * * @param amount TOKE to lockup in the stake * @param duration in seconds for the stake * @param to address to receive ownership of the stake */ function stake(uint256 amount, uint256 duration, address to) external; /** * @notice Stake TOKE * * If staking before the start of staking (epoch), then the lockup start and end dates are shifted forward so that * the lockup starts at the epoch. * * @notice Stake TOKE for myself. * @param amount TOKE to lockup in the stake * @param duration in seconds for the stake */ function stake(uint256 amount, uint256 duration) external; /** * @notice Collect staked TOKE for a lockup and any earned rewards. * @param lockupIds the id of the lockup to unstake */ function unstake(uint256[] memory lockupIds) external; /** * @notice Extend a stake lockup for additional points. * * The stake end time is computed from the current time + duration, just like it is for new stakes. So a new stake * for seven days duration and an old stake extended with a seven days duration would have the same end. * * If an extend is made before the start of staking, the start time for the new stake is shifted forwards to the * start of staking, which also shifts forward the end date. * * @param lockupIds the id of the old lockup to extend * @param durations number of seconds from now to stake for */ function extend(uint256[] memory lockupIds, uint256[] memory durations) external; /////////////////////////////////////////////////////////////////// // // Rewards // /////////////////////////////////////////////////////////////////// /// @notice The total amount of rewards earned for all stakes function totalRewardsEarned() external returns (uint256); /// @notice Total rewards claimed by all stakers function totalRewardsClaimed() external returns (uint256); /// @notice Rewards claimed by a specific wallet /// @param user Address of the wallet to check function rewardsClaimed(address user) external returns (uint256); /** * @notice Preview the number of points that would be returned for the * given amount and duration. * * @param amount TOKE to be staked * @param duration number of seconds to stake for * @return points staking points that would be returned * @return end staking period end date */ function previewPoints(uint256 amount, uint256 duration) external view returns (uint256, uint256); /// @notice Preview the reward amount a caller can claim function previewRewards() external view returns (uint256); /// @notice Preview the reward amount a specified wallet can claim function previewRewards(address user) external view returns (uint256); /// @notice Claim rewards for the caller function collectRewards() external returns (uint256); /// @notice Check if amount can be staked function isStakeableAmount(uint256 amount) external pure returns (bool); }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; /// @title Keep track of Vaults created through the Vault Factory interface IAutopoolRegistry { /////////////////////////////////////////////////////////////////// // Errors /////////////////////////////////////////////////////////////////// error VaultNotFound(address vaultAddress); error VaultAlreadyExists(address vaultAddress); /////////////////////////////////////////////////////////////////// // Events /////////////////////////////////////////////////////////////////// event VaultAdded(address indexed asset, address indexed vault); event VaultRemoved(address indexed asset, address indexed vault); /////////////////////////////////////////////////////////////////// // Functions /////////////////////////////////////////////////////////////////// /// @notice Checks if an address is a valid vault /// @param vaultAddress Vault address to be added function isVault(address vaultAddress) external view returns (bool); /// @notice Registers a vault /// @param vaultAddress Vault address to be added function addVault(address vaultAddress) external; /// @notice Removes vault registration /// @param vaultAddress Vault address to be removed function removeVault(address vaultAddress) external; /// @notice Returns a list of all registered vaults function listVaults() external view returns (address[] memory); /// @notice Returns a list of all registered vaults for a given asset /// @param asset Asset address function listVaultsForAsset(address asset) external view returns (address[] memory); /// @notice Returns a list of all registered vaults for a given type /// @param _vaultType Vault type function listVaultsForType(bytes32 _vaultType) external view returns (address[] memory); }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { ISyncSwapper } from "src/interfaces/swapper/ISyncSwapper.sol"; interface ISwapRouter { struct SwapData { address token; address pool; ISyncSwapper swapper; bytes data; } error MaxSlippageExceeded(); error SwapRouteLookupFailed(address from, address to); error SwapFailed(); event SwapRouteSet(address indexed token, SwapData[] routes); event SwapForQuoteSuccessful( address indexed assetToken, uint256 sellAmount, address indexed quoteToken, uint256 minBuyAmount, uint256 buyAmount ); /** * @notice Sets a new swap route for a given asset token. * @param assetToken The asset token for which the swap route is being set. * @param _swapRoute The new swap route as an array of SwapData. The last element represents the quoteToken. * @dev Each 'hop' in the swap route is validated using the respective swapper's validate function. The validate * function ensures that the encoded data contains the correct 'fromAddress' and 'toAddress' (swapData.token), and * verifies that these tokens are in the pool. */ function setSwapRoute(address assetToken, SwapData[] calldata _swapRoute) external; /** * @notice Swaps the asset token for the quote token. * @dev We're adopting an "exact in, variable out" model for all our swaps. This ensures that the entire sellAmount * is used, eliminating the need for additional balance checks and refunds. This model is expected to be followed by * all swapper implementations to maintain consistency and to optimize for gas efficiency. * @param assetToken The address of the asset token to swap. * @param sellAmount The exact amount of the asset token to swap. * @param quoteToken The address of the quote token. * @param minBuyAmount The minimum amount of the quote token expected to be received from the swap. * @return The amount received from the swap. */ function swapForQuote( address assetToken, uint256 sellAmount, address quoteToken, uint256 minBuyAmount ) external returns (uint256); }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; interface ICurveResolver { /// @notice Resolve details of a Curve pool regardless of type or version /// @dev This resolves tokens without unwrapping to underlying in the case of meta pools. /// @param poolAddress pool address to lookup /// @return tokens tokens that make up the pool /// @return numTokens the number of tokens. tokens are not unwrapped. /// @return isStableSwap is this a StableSwap pool. false = CryptoSwap function resolve(address poolAddress) external view returns (address[8] memory tokens, uint256 numTokens, bool isStableSwap); /// @notice Resolve details of a Curve pool regardless of type or version /// @dev This resolves tokens without unwrapping to underlying in the case of meta pools. /// @dev Use the isStableSwap value to differentiate between StableSwap (V1) and CryptoSwap (V2) pools. /// @param poolAddress pool address to lookup /// @return tokens tokens that make up the pool /// @return numTokens the number of tokens. tokens are not unwrapped /// @return lpToken lp token of the pool /// @return isStableSwap is this a StableSwap pool. false = CryptoSwap function resolveWithLpToken(address poolAddress) external view returns (address[8] memory tokens, uint256 numTokens, address lpToken, bool isStableSwap); /// @notice Get the lp token of a Curve pool /// @param poolAddress pool address to lookup function getLpToken(address poolAddress) external view returns (address); /// @notice Get the reserves of a Curve pools' tokens /// @dev Actual balances length might differ from 8 and should be verified by the caller /// @param poolAddress pool address to lookup /// @return balances reserves of the pool tokens function getReservesInfo(address poolAddress) external view returns (uint256[8] memory balances); }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { IAutopool } from "src/interfaces/vault/IAutopool.sol"; import { IAutopilotRouterBase } from "src/interfaces/vault/IAutopilotRouterBase.sol"; import { IRewards } from "src/interfaces/rewarders/IRewards.sol"; import { SwapParams } from "src/interfaces/liquidation/IAsyncSwapper.sol"; /** * @title IAutopilotRouter Interface * @notice Extends the IAutopilotRouterBase with specific flows to save gas */ interface IAutopilotRouter is IAutopilotRouterBase { /** * *************************** Deposit ******************************** */ /** * @notice deposit available asset balance to a AutopoolETH. * @param vault The AutopoolETH to deposit assets to. * @param to The destination of ownership shares. * @param minSharesOut The min amount of `vault` shares received by `to`. * @return sharesOut the amount of shares received by `to`. * @dev throws MinSharesError */ function depositBalance(IAutopool vault, address to, uint256 minSharesOut) external returns (uint256 sharesOut); /** * @notice deposit max assets to a AutopoolETH. * @param vault The AutopoolETH to deposit assets to. * @param to The destination of ownership shares. * @param minSharesOut The min amount of `vault` shares received by `to`. * @return sharesOut the amount of shares received by `to`. * @dev throws MinSharesError */ function depositMax(IAutopool vault, address to, uint256 minSharesOut) external returns (uint256 sharesOut); /** * ************************* Withdraw ********************************** */ /** * @notice withdraw `amount` to a AutopoolETH. * @param fromVault The AutopoolETH to withdraw assets from. * @param toVault The AutopoolETH to deposit assets to. * @param to The destination of ownership shares. * @param amount The amount of assets to withdraw from fromVault. * @param maxSharesIn The max amount of fromVault shares withdrawn by caller. * @param minSharesOut The min amount of toVault shares received by `to`. * @return sharesOut the amount of shares received by `to`. * @dev throws MaxSharesError, MinSharesError */ function withdrawToDeposit( IAutopool fromVault, IAutopool toVault, address to, uint256 amount, uint256 maxSharesIn, uint256 minSharesOut ) external returns (uint256 sharesOut); /** * ************************* Redeem ******************************** */ /** * @notice redeem `shares` to a AutopoolETH. * @param fromVault The AutopoolETH to redeem shares from. * @param toVault The AutopoolETH to deposit assets to. * @param to The destination of ownership shares. * @param shares The amount of shares to redeem from fromVault. * @param minSharesOut The min amount of toVault shares received by `to`. * @return sharesOut the amount of shares received by `to`. * @dev throws MinAmountError, MinSharesError */ function redeemToDeposit( IAutopool fromVault, IAutopool toVault, address to, uint256 shares, uint256 minSharesOut ) external returns (uint256 sharesOut); /** * @notice redeem max shares to a AutopoolETH. * @param vault The AutopoolETH to redeem shares from. * @param to The destination of assets. * @param minAmountOut The min amount of assets received by `to`. * @return amountOut the amount of assets received by `to`. * @dev throws MinAmountError */ function redeemMax(IAutopool vault, address to, uint256 minAmountOut) external returns (uint256 amountOut); /** * @notice swaps token * @param swapper Address of the swapper to use * @param swapParams Parameters for the swap * @return amountReceived Swap output amount */ function swapToken(address swapper, SwapParams memory swapParams) external returns (uint256 amountReceived); /** * @notice claims vault token rewards * @param rewarder Address of the rewarder to claim from * @param recipient Struct containing recipient details * @return amountReceived Swap output amount */ function claimRewards( IRewards rewarder, IRewards.Recipient calldata recipient, uint8 v, bytes32 r, bytes32 s ) external returns (uint256); }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; interface IAutopoolFactory { /////////////////////////////////////////////////////////////////// // Vault Creation /////////////////////////////////////////////////////////////////// /** * @notice Spin up a new AutopoolETH * @param strategy Strategy template address * @param symbolSuffix Symbol suffix of the new token * @param descPrefix Description prefix of the new token * @param salt Vault creation salt * @param extraParams Any extra data needed for the vault */ function createVault( address strategy, string memory symbolSuffix, string memory descPrefix, bytes32 salt, bytes calldata extraParams ) external payable returns (address newVaultAddress); function addStrategyTemplate(address strategyTemplate) external; function removeStrategyTemplate(address strategyTemplate) external; }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; interface ISystemSecurity { /// @notice Get the number of NAV/share operations currently in progress /// @return Number of operations function navOpsInProgress() external view returns (uint256); /// @notice Called at the start of any NAV/share changing operation function enterNavOperation() external; /// @notice Called at the end of any NAV/share changing operation function exitNavOperation() external; /// @notice Whether or not the system as a whole is paused function isSystemPaused() external view returns (bool); }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { IDestinationAdapter } from "src/interfaces/destinations/IDestinationAdapter.sol"; interface IDestinationRegistry { event Register(bytes32[] indexed destinationTypes, address[] indexed targets); event Replace(bytes32[] indexed destinationTypes, address[] indexed targets); event Unregister(bytes32[] indexed destinationTypes); event Whitelist(bytes32[] indexed destinationTypes); event RemoveFromWhitelist(bytes32[] indexed destinationTypes); error InvalidAddress(address addr); error NotAllowedDestination(); error DestinationAlreadySet(); /** * @notice Adds a new addresses of the given destination types * @dev Fails if trying to overwrite previous value of the same destination type * @param destinationTypes Ones from the destination type whitelist * @param targets addresses of the deployed DestinationAdapters, cannot be 0 */ function register(bytes32[] calldata destinationTypes, address[] calldata targets) external; /** * @notice Replaces an addresses of the given destination types * @dev Fails if given destination type was not set previously * @param destinationTypes Ones from the destination type whitelist * @param targets addresses of the deployed DestinationAdapters, cannot be 0 */ function replace(bytes32[] calldata destinationTypes, address[] calldata targets) external; /** * @notice Removes an addresses of the given pre-registered destination types * @param destinationTypes Ones from the destination types whitelist */ function unregister(bytes32[] calldata destinationTypes) external; /** * @notice Gives an address of the given destination type * @dev Should revert on missing destination * @param destination One from the destination type whitelist */ function getAdapter(bytes32 destination) external returns (IDestinationAdapter); /** * @notice Adds given destination types to the whitelist * @param destinationTypes Types to whitelist */ function addToWhitelist(bytes32[] calldata destinationTypes) external; /** * @notice Removes given pre-whitelisted destination types * @param destinationTypes Ones from the destination type whitelist */ function removeFromWhitelist(bytes32[] calldata destinationTypes) external; /** * @notice Checks if the given destination type is whitelisted * @param destinationType Type to verify */ function isWhitelistedDestination(bytes32 destinationType) external view returns (bool); }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; /// @notice Retrieve a price for any token used in the system interface IRootPriceOracle { /// @notice Returns a fair price for the provided token in ETH /// @param token token to get the price of /// @return price the price of the token in ETH function getPriceInEth(address token) external returns (uint256 price); /// @notice Returns a spot price for the provided token in ETH, utilizing specified liquidity pool /// @param token token to get the spot price of /// @param pool liquidity pool to be used for price determination /// @return price the spot price of the token in ETH based on the provided pool function getSpotPriceInEth(address token, address pool) external returns (uint256); /// @notice Returns a price for base token in quote token. /// @dev Requires both tokens to be registered. /// @param base Address of base token. /// @param quote Address of quote token. /// @return price Price of the base token in quote token. function getPriceInQuote(address base, address quote) external returns (uint256 price); /// @notice Retrieve the price of LP token based on the reserves /// @param lpToken LP token to get the price of /// @param pool liquidity pool to be used for price determination /// @param quoteToken token to quote the price in function getRangePricesLP( address lpToken, address pool, address quoteToken ) external returns (uint256 spotPriceInQuote, uint256 safePriceInQuote, bool isSpotSafe); /// @notice Returns floor or ceiling price of the supplied lp token in terms of requested quote. /// @dev Floor price: the minimum price among all the spot prices and safe prices of the tokens in the pool. /// Ceiling price: the maximum price among all the spot prices and safe prices of the tokens in the pool. /// @param pool Address of pool to get spot pricing from. /// @param lpToken Address of the lp token to price. /// @param inQuote Address of desired quote token. /// @param ceiling Bool indicating whether to get floor or ceiling price. /// @return floorOrCeilingPerLpToken Floor or ceiling price of the lp token. function getFloorCeilingPrice( address pool, address lpToken, address inQuote, bool ceiling ) external returns (uint256 floorOrCeilingPerLpToken); function getFloorPrice(address, address, address) external returns (uint256 price); function getCeilingPrice(address, address, address) external returns (uint256 price); }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { IDestinationVaultFactory } from "src/interfaces/vault/IDestinationVaultFactory.sol"; /// @notice Tracks valid Destination Vaults for the system interface IDestinationVaultRegistry { /// @notice Determines if a given address is a valid Destination Vault in the system /// @param destinationVault address to check /// @return True if vault is registered function isRegistered(address destinationVault) external view returns (bool); /// @notice Registers a new Destination Vault /// @dev Should be locked down to only a factory /// @param newDestinationVault Address of the new vault function register(address newDestinationVault) external; /// @notice Checks if an address is a valid Destination Vault and reverts if not /// @param destinationVault Destination Vault address to checked function verifyIsRegistered(address destinationVault) external view; /// @notice Returns a list of all registered vaults function listVaults() external view returns (address[] memory); /// @notice Factory that is allowed to create and registry Destination Vaults function factory() external view returns (IDestinationVaultFactory); }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { IStatsCalculator } from "src/interfaces/stats/IStatsCalculator.sol"; /// @notice Track stat calculators for this instance of the system interface IStatsCalculatorRegistry { /// @notice Get a registered calculator /// @dev Should revert if missing /// @param aprId key of the calculator to get /// @return calculator instance of the calculator function getCalculator(bytes32 aprId) external view returns (IStatsCalculator calculator); /// @notice Register a new stats calculator /// @param calculator address of the calculator function register(address calculator) external; /// @notice Set the factory that can register calculators /// @param factory address of the factory function setCalculatorFactory(address factory) external; }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; interface IAsyncSwapperRegistry { event SwapperAdded(address indexed item); event SwapperRemoved(address indexed item); /// @notice Registers an item /// @param item Item address to be added function register(address item) external; /// @notice Removes item registration /// @param item Item address to be removed function unregister(address item) external; /// @notice Returns a list of all registered items function list() external view returns (address[] memory); /// @notice Checks if an address is a valid item /// @param item Item address to be checked function isRegistered(address item) external view returns (bool); /// @notice Checks if an address is a valid swapper and reverts if not /// @param item Swapper address to be checked function verifyIsRegistered(address item) external view; }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol) pragma solidity ^0.8.0; import "../IERC20.sol"; /** * @dev Interface for the optional metadata functions from the ERC20 standard. * * _Available since v4.1._ */ 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: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; /// @title EWMA pricing for incentive tokens interface IIncentivesPricingStats { event TokenAdded(address indexed token); event TokenRemoved(address indexed token); event TokenSnapshot( address indexed token, uint40 lastSnapshot, uint256 fastFilterPrice, uint256 slowFilterPrice, uint256 initCount, bool initComplete ); error TokenAlreadyRegistered(address token); error TokenNotFound(address token); error IncentiveTokenPriceStale(address token); error TokenSnapshotNotReady(address token); struct TokenSnapshotInfo { uint40 lastSnapshot; bool _initComplete; uint8 _initCount; uint256 _initAcc; uint256 fastFilterPrice; uint256 slowFilterPrice; } /// @notice add a token to snapshot /// @dev the token must be configured in the RootPriceOracle before adding here /// @param token the address of the token to add function setRegisteredToken(address token) external; /// @notice remove a token from being snapshot /// @param token the address of the token to remove function removeRegisteredToken(address token) external; /// @notice get the addresses for all currently registered tokens /// @return tokens all of the registered token addresses function getRegisteredTokens() external view returns (address[] memory tokens); /// @notice get all of the registered tokens with the latest snapshot info /// @return tokenAddresses token addresses in the same order as info /// @return info a list of snapshot info for the tokens function getTokenPricingInfo() external view returns (address[] memory tokenAddresses, TokenSnapshotInfo[] memory info); /// @notice update the snapshot for the specified tokens /// @dev if a token is not ready to be snapshot the entire call will fail function snapshot(address[] calldata tokensToSnapshot) external; /// @notice get the latest prices for an incentive token. Reverts if token is not registered /// @return fastPrice the price based on the faster filter (weighted toward current prices) /// @return slowPrice the price based on the slower filter (weighted toward older prices, relative to fast) function getPrice(address token, uint40 staleCheck) external view returns (uint256 fastPrice, uint256 slowPrice); /// @notice get the latest prices for an incentive token or zero if the token is not registered /// @return fastPrice the price based on the faster filter (weighted toward current prices) /// @return slowPrice the price based on the slower filter (weighted toward older prices, relative to fast) function getPriceOrZero( address token, uint40 staleCheck ) external view returns (uint256 fastPrice, uint256 slowPrice); }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; /// @notice Stores a reference to the registry for this system interface ISystemComponent { /// @notice The system instance this contract is tied to function getSystemRegistry() external view returns (address registry); }
// SPDX-License-Identifier: MIT pragma solidity 0.8.17; import { Client } from "src/external/chainlink/ccip/Client.sol"; interface IRouterClient { error UnsupportedDestinationChain(uint64 destChainSelector); error InsufficientFeeTokenAmount(); error InvalidMsgValue(); /// @notice Checks if the given chain ID is supported for sending/receiving. /// @param chainSelector The chain to check. /// @return supported is true if it is supported, false if not. function isChainSupported(uint64 chainSelector) external view returns (bool supported); /// @notice Gets a list of all supported tokens which can be sent or received /// to/from a given chain id. /// @param chainSelector The chainSelector. /// @return tokens The addresses of all tokens that are supported. function getSupportedTokens(uint64 chainSelector) external view returns (address[] memory tokens); /// @param destinationChainSelector The destination chainSelector /// @param message The cross-chain CCIP message including data and/or tokens /// @return fee returns execution fee for the message /// delivery to destination chain, denominated in the feeToken specified in the message. /// @dev Reverts with appropriate reason upon invalid message. function getFee( uint64 destinationChainSelector, Client.EVM2AnyMessage memory message ) external view returns (uint256 fee); /// @notice Request a message to be sent to the destination chain /// @param destinationChainSelector The destination chain ID /// @param message The cross-chain CCIP message including data and/or tokens /// @return messageId The message ID /// @dev Note if msg.value is larger than the required fee (from getFee) we accept /// the overpayment with no refund. /// @dev Reverts with appropriate reason upon invalid message. function ccipSend( uint64 destinationChainSelector, Client.EVM2AnyMessage calldata message ) external payable returns (bytes32); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (access/IAccessControlEnumerable.sol) pragma solidity ^0.8.0; import "./IAccessControl.sol"; /** * @dev External interface of AccessControlEnumerable declared to support ERC165 detection. */ interface IAccessControlEnumerable is IAccessControl { /** * @dev Returns one of the accounts that have `role`. `index` must be a * value between 0 and {getRoleMemberCount}, non-inclusive. * * Role bearers are not sorted in any particular way, and their ordering may * change at any point. * * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure * you perform all queries on the same block. See the following * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post] * for more information. */ function getRoleMember(bytes32 role, uint256 index) external view returns (address); /** * @dev Returns the number of accounts that have `role`. Can be used * together with {getRoleMember} to enumerate all bearers of a role. */ function getRoleMemberCount(bytes32 role) external view returns (uint256); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` 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 amount) 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 `amount` 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 amount) external returns (bool); /** * @dev Moves `amount` tokens from `from` to `to` using the * allowance mechanism. `amount` 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 amount ) external returns (bool); }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { ISwapRouter } from "src/interfaces/swapper/ISwapRouter.sol"; interface ISyncSwapper { error DataMismatch(string element); error InvalidIndex(); /** * @notice Swaps sellToken for buyToken * @param pool The address of the pool for the swapper * @param sellTokenAddress The address of the token to sell * @param sellAmount The amount of sellToken to sell * @param buyTokenAddress The address of the token to buy * @param minBuyAmount The minimum amount of buyToken expected * @param data Additional data used differently by the different swappers * @return actualBuyAmount The actual amount received from the swap */ function swap( address pool, address sellTokenAddress, uint256 sellAmount, address buyTokenAddress, uint256 minBuyAmount, bytes memory data ) external returns (uint256 actualBuyAmount); /** * @notice Validates that the swapData contains the correct information, ensuring that the encoded data contains the * correct 'fromAddress' and 'toAddress' (swapData.token), and verifies that these tokens are in the pool * @dev This function should revert with a DataMismatch error if the swapData is invalid * @param fromAddress The address from which the swap originates * @param swapData The data associated with the swap that needs to be validated */ function validate(address fromAddress, ISwapRouter.SwapData memory swapData) external view; }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { AutopoolDebt } from "src/vault/libs/AutopoolDebt.sol"; import { IERC4626 } from "src/interfaces/vault/IERC4626.sol"; import { Math } from "openzeppelin-contracts/utils/math/Math.sol"; import { IAutopoolStrategy } from "src/interfaces/strategy/IAutopoolStrategy.sol"; import { IMainRewarder } from "src/interfaces/rewarders/IMainRewarder.sol"; import { IERC20Permit } from "openzeppelin-contracts/token/ERC20/extensions/draft-IERC20Permit.sol"; interface IAutopool is IERC4626, IERC20Permit { enum VaultShutdownStatus { Active, Deprecated, Exploit } /// @param unlockPeriodInSeconds Time it takes for profit to unlock in seconds /// @param fullProfitUnlockTime Time at which all profit will have been unlocked /// @param lastProfitUnlockTime Last time profits were unlocked /// @param profitUnlockRate Per second rate at which profit shares unlocks. Rate when calculated is denominated in /// MAX_BPS_PROFIT. TODO: Get into uint112 struct ProfitUnlockSettings { uint48 unlockPeriodInSeconds; uint48 fullProfitUnlockTime; uint48 lastProfitUnlockTime; uint256 profitUnlockRate; } /// @param feeSink Where claimed fees are sent /// @param totalAssetsHighMark The last totalAssets amount we took fees at /// @param totalAssetsHighMarkTimestamp The last timestamp we updated the high water mark /// @param lastPeriodicFeeTake Timestamp of when the last periodic fee was taken. /// @param periodicFeeSink Address that receives periodic fee. /// @param periodicFeeBps Current periodic fee. 100% == 10000. /// @param streamingFeeBps Current streaming fee taken on profit. 100% == 10000 /// @param navPerShareLastFeeMark The last nav/share height we took fees at /// @param navPerShareLastFeeMarkTimestamp The last timestamp we took fees at /// @param rebalanceFeeHighWaterMarkEnabled Returns whether the nav/share high water mark is enabled for the /// rebalance fee struct AutopoolFeeSettings { address feeSink; uint256 totalAssetsHighMark; uint256 totalAssetsHighMarkTimestamp; uint256 lastPeriodicFeeTake; address periodicFeeSink; uint256 periodicFeeBps; uint256 streamingFeeBps; uint256 navPerShareLastFeeMark; uint256 navPerShareLastFeeMarkTimestamp; bool rebalanceFeeHighWaterMarkEnabled; } /// @param totalIdle The amount of baseAsset deposited into the contract pending deployment /// @param totalDebt The current (though cached) value of assets we've deployed /// @param totalDebtMin The current (though cached) value of assets we use for valuing during deposits /// @param totalDebtMax The current (though cached) value of assets we use for valuing during withdrawals struct AssetBreakdown { uint256 totalIdle; uint256 totalDebt; uint256 totalDebtMin; uint256 totalDebtMax; } enum TotalAssetPurpose { Global, Deposit, Withdraw } /* ******************************** */ /* Events */ /* ******************************** */ event TokensPulled(address[] tokens, uint256[] amounts, address[] destinations); event TokensRecovered(address[] tokens, uint256[] amounts, address[] destinations); event Nav(uint256 idle, uint256 debt, uint256 totalSupply); event RewarderSet(address newRewarder, address oldRewarder); event DestinationDebtReporting(address destination, uint256 debtValue, uint256 claimed, uint256 claimGasUsed); event FeeCollected(uint256 fees, address feeSink, uint256 mintedShares, uint256 profit, uint256 idle, uint256 debt); event PeriodicFeeCollected(uint256 fees, address feeSink, uint256 mintedShares); event Shutdown(VaultShutdownStatus reason); /* ******************************** */ /* Errors */ /* ******************************** */ error ERC4626MintExceedsMax(uint256 shares, uint256 maxMint); error ERC4626DepositExceedsMax(uint256 assets, uint256 maxDeposit); error ERC4626ExceededMaxWithdraw(address owner, uint256 assets, uint256 max); error ERC4626ExceededMaxRedeem(address owner, uint256 shares, uint256 max); error InvalidShutdownStatus(VaultShutdownStatus status); error WithdrawalFailed(); error DepositFailed(); error InsufficientFundsInDestinations(uint256 deficit); error WithdrawalIncomplete(); error ValueSharesMismatch(uint256 value, uint256 shares); /// @notice A full unit of this pool // solhint-disable-next-line func-name-mixedcase function ONE() external view returns (uint256); /// @notice Query the type of vault function vaultType() external view returns (bytes32); /// @notice Strategy governing the pools rebalances function autoPoolStrategy() external view returns (IAutopoolStrategy); /// @notice Allow token recoverer to collect dust / unintended transfers (non-tracked assets only) function recover(address[] calldata tokens, uint256[] calldata amounts, address[] calldata destinations) external; /// @notice Set the order of destination vaults used for withdrawals // NOTE: will be done going directly to strategy (IStrategy) vault points to. // How it'll delegate is still being decided // function setWithdrawalQueue(address[] calldata destinations) external; /// @notice Get a list of destination vaults with pending assets to clear out function getRemovalQueue() external view returns (address[] memory); function getFeeSettings() external view returns (AutopoolFeeSettings memory); /// @notice Initiate the shutdown procedures for this vault function shutdown(VaultShutdownStatus reason) external; /// @notice True if the vault has been shutdown function isShutdown() external view returns (bool); /// @notice Returns the reason for shutdown (or `Active` if not shutdown) function shutdownStatus() external view returns (VaultShutdownStatus); /// @notice gets the list of supported destination vaults for the Autopool/Strategy /// @return _destinations List of supported destination vaults function getDestinations() external view returns (address[] memory _destinations); function convertToShares( uint256 assets, uint256 totalAssetsForPurpose, uint256 supply, Math.Rounding rounding ) external view returns (uint256 shares); function convertToAssets( uint256 shares, uint256 totalAssetsForPurpose, uint256 supply, Math.Rounding rounding ) external view returns (uint256 assets); function totalAssets(TotalAssetPurpose purpose) external view returns (uint256); function getAssetBreakdown() external view returns (AssetBreakdown memory); /// @notice get a destinations last reported debt value /// @param destVault the address of the target destination /// @return destinations last reported debt value function getDestinationInfo(address destVault) external view returns (AutopoolDebt.DestinationInfo memory); /// @notice check if a destination is registered with the vault function isDestinationRegistered(address destination) external view returns (bool); /// @notice get if a destinationVault is queued for removal by the AutopoolETH function isDestinationQueuedForRemoval(address destination) external view returns (bool); /// @notice Returns instance of vault rewarder. function rewarder() external view returns (IMainRewarder); /// @notice Returns all past rewarders. function getPastRewarders() external view returns (address[] memory _pastRewarders); /// @notice Returns boolean telling whether address passed in is past rewarder. function isPastRewarder(address _pastRewarder) external view returns (bool); }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity >=0.8.7; import { IAutopool } from "src/interfaces/vault/IAutopool.sol"; import { IMainRewarder } from "src/interfaces/rewarders/IMainRewarder.sol"; import { IERC20 } from "openzeppelin-contracts/token/ERC20/IERC20.sol"; /** * @title AutopoolETH Router Base Interface * @notice A canonical router between AutopoolETHs * * The base router is a multicall style router inspired by Uniswap v3 with built-in features for permit, * WETH9 wrap/unwrap, and ERC20 token pulling/sweeping/approving. It includes methods for the four mutable * ERC4626 functions deposit/mint/withdraw/redeem as well. * * These can all be arbitrarily composed using the multicall functionality of the router. * * NOTE the router is capable of pulling any approved token from your wallet. This is only possible when * your address is msg.sender, but regardless be careful when interacting with the router or ERC4626 Vaults. * The router makes no special considerations for unique ERC20 implementations such as fee on transfer. * There are no built in protections for unexpected behavior beyond enforcing the minSharesOut is received. */ interface IAutopilotRouterBase { /// @notice thrown when amount of assets received is below the min set by caller error MinAmountError(); /// @notice thrown when amount of shares received is below the min set by caller error MinSharesError(); /// @notice thrown when amount of assets received is above the max set by caller error MaxAmountError(); /// @notice thrown when amount of shares received is above the max set by caller error MaxSharesError(); /** * @notice mint `shares` from an ERC4626 vault. * @param vault The AutopoolETH to mint shares from. * @param to The destination of ownership shares. * @param shares The amount of shares to mint from `vault`. * @param maxAmountIn The max amount of assets used to mint. * @return amountIn the amount of assets used to mint by `to`. * @dev throws MaxAmountError */ function mint( IAutopool vault, address to, uint256 shares, uint256 maxAmountIn ) external payable returns (uint256 amountIn); /** * @notice deposit `amount` to an ERC4626 vault. * @param vault The AutopoolETH to deposit assets to. * @param to The destination of ownership shares. * @param amount The amount of assets to deposit to `vault`. * @param minSharesOut The min amount of `vault` shares received by `to`. * @return sharesOut the amount of shares received by `to`. * @dev throws MinSharesError */ function deposit( IAutopool vault, address to, uint256 amount, uint256 minSharesOut ) external payable returns (uint256 sharesOut); /** * @notice withdraw `amount` from an ERC4626 vault. * @param vault The AutopoolETH to withdraw assets from. * @param to The destination of assets. * @param amount The amount of assets to withdraw from vault. * @param maxSharesOut The max amount of shares burned for assets requested. * @return sharesOut the amount of shares received by `to`. * @dev throws MaxSharesError */ function withdraw( IAutopool vault, address to, uint256 amount, uint256 maxSharesOut ) external payable returns (uint256 sharesOut); /** * @notice redeem `shares` shares from a AutopoolETH * @param vault The AutopoolETH to redeem shares from. * @param to The destination of assets. * @param shares The amount of shares to redeem from vault. * @param minAmountOut The min amount of assets received by `to`. * @return amountOut the amount of assets received by `to`. * @dev throws MinAmountError */ function redeem( IAutopool vault, address to, uint256 shares, uint256 minAmountOut ) external payable returns (uint256 amountOut); /// @notice Stakes vault token to corresponding rewarder. /// @param vault IERC20 instance of an Autopool to stake to. /// @param maxAmount Maximum amount for user to stake. Amount > balanceOf(user) will stake all present tokens. /// @return staked Returns total amount staked. function stakeVaultToken(IERC20 vault, uint256 maxAmount) external returns (uint256 staked); /// @notice Unstakes vault token from corresponding rewarder. /// @param vault IAutopool instance of the vault token to withdraw. /// @param rewarder Rewarder to withdraw from. /// @param maxAmount Amount of vault token to withdraw Amount > balanceOf(user) will withdraw all owned tokens. /// @param claim Claiming rewards or not on unstaking. /// @return withdrawn Amount of vault token withdrawn. function withdrawVaultToken( IAutopool vault, IMainRewarder rewarder, uint256 maxAmount, bool claim ) external returns (uint256 withdrawn); /// @notice Claims rewards on user stake of vault token. /// @param vault IAutopool instance of vault token to claim rewards for. /// @param rewarder Rewarder to claim rewards from. function claimAutopoolRewards(IAutopool vault, IMainRewarder rewarder) external; }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2024 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { IERC20 } from "openzeppelin-contracts/token/ERC20/IERC20.sol"; /** * @title Validates and distributes Vault token rewards based on the * the signed and submitted payloads */ interface IRewards { struct Recipient { uint256 chainId; uint256 cycle; address wallet; uint256 amount; } event SignerSet(address newSigner); event Claimed(uint256 cycle, address recipient, uint256 amount); /// @notice Get the underlying token rewards are paid in /// @return Token address function vaultToken() external view returns (IERC20); /// @notice Get the current payload signer; /// @return Signer address function rewardsSigner() external view returns (address); /// @notice Check the amount an account has already claimed /// @param account Account to check /// @return Amount already claimed function claimedAmounts(address account) external view returns (uint256); /// @notice Get the amount that is claimable based on the provided payload /// @param recipient Published rewards payload /// @return Amount claimable if the payload is signed function getClaimableAmount(Recipient calldata recipient) external view returns (uint256); /// @notice Change the signer used to validate payloads /// @param newSigner The new address that will be signing rewards payloads function setSigner(address newSigner) external; /// @notice Claim your rewards /// @param recipient Published rewards payload /// @param v v component of the payload signature /// @param r r component of the payload signature /// @param s s component of the payload signature function claim(Recipient calldata recipient, uint8 v, bytes32 r, bytes32 s) external returns (uint256); /// @notice Claim rewards on behalf of another account , invoked primarily by the router /// @param recipient Published rewards payload /// @param v v component of the payload signature /// @param r r component of the payload signature /// @param s s component of the payload signature function claimFor(Recipient calldata recipient, uint8 v, bytes32 r, bytes32 s) external returns (uint256); /// @notice Generate the hash of the payload /// @param recipient Published rewards payload /// @return Hash of the payload function genHash(Recipient memory recipient) external view returns (bytes32); }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; struct SwapParams { /// @dev The address of the token to be sold. address sellTokenAddress; /// @dev The amount of tokens to be sold. uint256 sellAmount; /// @dev The address of the token to be bought. address buyTokenAddress; /// @dev The expected minimum amount of tokens to be bought. uint256 buyAmount; /// @dev Data payload to be used for complex swap operations. bytes data; /// @dev Extra data payload reserved for future development. This field allows for additional information /// or functionality to be added without changing the struct and interface. bytes extraData; } interface IAsyncSwapper { error TokenAddressZero(); error SwapFailed(); error InsufficientBuyAmountReceived(uint256 buyTokenAmountReceived, uint256 buyAmount); error InsufficientSellAmount(); error InsufficientBuyAmount(); error InsufficientBalance(uint256 balanceNeeded, uint256 balanceAvailable); event Swapped( address indexed sellTokenAddress, address indexed buyTokenAddress, uint256 sellAmount, uint256 buyAmount, uint256 buyTokenAmountReceived ); /** * @notice Swaps sellToken for buyToken * @param swapParams Encoded swap data * @return buyTokenAmountReceived The amount of buyToken received from the swap */ function swap(SwapParams memory swapParams) external returns (uint256 buyTokenAmountReceived); }
// SPDX-License-Identifier: MIT pragma solidity 0.8.17; /** * @title IDestinationAdapter * @dev This is a super-interface to unify different types of adapters to be registered in Destination Registry. * Specific interface type is defined by extending from this interface. */ interface IDestinationAdapter { error MustBeMoreThanZero(); error ArraysLengthMismatch(); error BalanceMustIncrease(); error MinLpAmountNotReached(); error LpTokenAmountMismatch(); error NoNonZeroAmountProvided(); error InvalidBalanceChange(); error InvalidAddress(address); }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { ISystemComponent } from "src/interfaces/ISystemComponent.sol"; /// @notice Creates and registers Destination Vaults for the system interface IDestinationVaultFactory is ISystemComponent { /// @notice Creates a vault of the specified type /// @dev vaultType will be bytes32 encoded and checked that a template is registered /// @param vaultType human readable key of the vault template /// @param baseAsset Base asset of the system. WETH/USDC/etc /// @param underlyer Underlying asset the vault will wrap /// @param incentiveCalculator Incentive calculator of the vault /// @param additionalTrackedTokens Any tokens in addition to base and underlyer that should be tracked /// @param salt Contracts are created via CREATE2 with this value /// @param params params to be passed to vaults initialize function /// @return vault address of the newly created destination vault function create( string memory vaultType, address baseAsset, address underlyer, address incentiveCalculator, address[] memory additionalTrackedTokens, bytes32 salt, bytes memory params ) external returns (address vault); /// @notice Sets the default reward ratio /// @param rewardRatio new default reward ratio function setDefaultRewardRatio(uint256 rewardRatio) external; /// @notice Sets the default reward block duration /// @param blockDuration new default reward block duration function setDefaultRewardBlockDuration(uint256 blockDuration) external; }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; /// @title Capture information about a pool or destination interface IStatsCalculator { /// @notice thrown when no snapshot is taken error NoSnapshotTaken(); /// @notice The id for this instance of a calculator function getAprId() external view returns (bytes32); /// @notice The id of the underlying asset/pool/destination this calculator represents /// @dev This may be a generated address function getAddressId() external view returns (address); /// @notice Setup the calculator after it has been copied /// @dev Should only be executed one time /// @param dependentAprIds apr ids that cover the dependencies of this calculator /// @param initData setup data specific to this type of calculator function initialize(bytes32[] calldata dependentAprIds, bytes calldata initData) external; /// @notice Capture stat data about this setup function snapshot() external; /// @notice Indicates if a snapshot should be taken /// @return takeSnapshot if true then a snapshot should be taken. If false, calling snapshot will do nothing function shouldSnapshot() external view returns (bool takeSnapshot); /// @dev Enum representing the snapshot status for a given rewarder (Convex and Aura) or reward token (Maverick) enum SnapshotStatus { noSnapshot, // Indicates that no snapshot has been taken yet for the rewarder. tooSoon, // Indicates that it's too soon to take another snapshot since the last one. shouldFinalize, // Indicates that the conditions are met for finalizing a snapshot. shouldRestart // Indicates that the conditions are met for restarting a snapshot. } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol) pragma solidity ^0.8.0; /** * @dev External interface of AccessControl declared to support ERC165 detection. */ interface IAccessControl { /** * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole` * * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite * {RoleAdminChanged} not being emitted signaling this. * * _Available since v3.1._ */ event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole); /** * @dev Emitted when `account` is granted `role`. * * `sender` is the account that originated the contract call, an admin role * bearer except when using {AccessControl-_setupRole}. */ event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender); /** * @dev Emitted when `account` is revoked `role`. * * `sender` is the account that originated the contract call: * - if using `revokeRole`, it is the admin role bearer * - if using `renounceRole`, it is the role bearer (i.e. `account`) */ event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender); /** * @dev Returns `true` if `account` has been granted `role`. */ function hasRole(bytes32 role, address account) external view returns (bool); /** * @dev Returns the admin role that controls `role`. See {grantRole} and * {revokeRole}. * * To change a role's admin, use {AccessControl-_setRoleAdmin}. */ function getRoleAdmin(bytes32 role) external view returns (bytes32); /** * @dev Grants `role` to `account`. * * If `account` had not been already granted `role`, emits a {RoleGranted} * event. * * Requirements: * * - the caller must have ``role``'s admin role. */ function grantRole(bytes32 role, address account) external; /** * @dev Revokes `role` from `account`. * * If `account` had been granted `role`, emits a {RoleRevoked} event. * * Requirements: * * - the caller must have ``role``'s admin role. */ function revokeRole(bytes32 role, address account) external; /** * @dev Revokes `role` from the calling account. * * Roles are often managed via {grantRole} and {revokeRole}: this function's * purpose is to provide a mechanism for accounts to lose their privileges * if they are compromised (such as when a trusted device is misplaced). * * If the calling account had been granted `role`, emits a {RoleRevoked} * event. * * Requirements: * * - the caller must be `account`. */ function renounceRole(bytes32 role, address account) external; }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { Errors } from "src/utils/Errors.sol"; import { LibAdapter } from "src/libs/LibAdapter.sol"; import { IDestinationVault } from "src/interfaces/vault/IDestinationVault.sol"; import { Math } from "openzeppelin-contracts/utils/math/Math.sol"; import { EnumerableSet } from "openzeppelin-contracts/utils/structs/EnumerableSet.sol"; import { IStrategy } from "src/interfaces/strategy/IStrategy.sol"; import { SafeERC20 } from "openzeppelin-contracts/token/ERC20/utils/SafeERC20.sol"; import { IERC20Metadata as IERC20 } from "openzeppelin-contracts/token/ERC20/extensions/IERC20Metadata.sol"; import { IERC3156FlashBorrower } from "openzeppelin-contracts/interfaces/IERC3156FlashBorrower.sol"; import { IAutopoolStrategy } from "src/interfaces/strategy/IAutopoolStrategy.sol"; import { StructuredLinkedList } from "src/strategy/StructuredLinkedList.sol"; import { WithdrawalQueue } from "src/strategy/WithdrawalQueue.sol"; import { IAutopool } from "src/interfaces/vault/IAutopool.sol"; import { IMainRewarder } from "src/interfaces/rewarders/IMainRewarder.sol"; import { AutopoolToken } from "src/vault/libs/AutopoolToken.sol"; library AutopoolDebt { using Math for uint256; using SafeERC20 for IERC20; using WithdrawalQueue for StructuredLinkedList.List; using EnumerableSet for EnumerableSet.AddressSet; using AutopoolToken for AutopoolToken.TokenData; /// @notice Max time a cached debt report can be used uint256 public constant MAX_DEBT_REPORT_AGE_SECONDS = 1 days; error VaultShutdown(); error WithdrawShareCalcInvalid(uint256 currentShares, uint256 cachedShares); error RebalanceDestinationsMatch(address destinationVault); error RebalanceFailed(string message); error InvalidPrices(); error InvalidTotalAssetPurpose(); error InvalidDestination(address destination); error TooFewAssets(uint256 requested, uint256 actual); error SharesAndAssetsReceived(uint256 assets, uint256 shares); error AmountExceedsAllowance(uint256 shares, uint256 allowed); event DestinationDebtReporting( address destination, AutopoolDebt.IdleDebtUpdates debtInfo, uint256 claimed, uint256 claimGasUsed ); event NewNavShareFeeMark(uint256 navPerShare, uint256 timestamp); event Nav(uint256 idle, uint256 debt, uint256 totalSupply); event Withdraw( address indexed sender, address indexed receiver, address indexed owner, uint256 assets, uint256 shares ); struct DestinationInfo { /// @notice Current underlying value at the destination vault /// @dev Used for calculating totalDebt, mid point of min and max uint256 cachedDebtValue; /// @notice Current minimum underlying value at the destination vault /// @dev Used for calculating totalDebt during withdrawal uint256 cachedMinDebtValue; /// @notice Current maximum underlying value at the destination vault /// @dev Used for calculating totalDebt of the deposit uint256 cachedMaxDebtValue; /// @notice Last block timestamp this info was updated uint256 lastReport; /// @notice How many shares of the destination vault we owned at last report uint256 ownedShares; } struct IdleDebtUpdates { bool pricesWereSafe; uint256 totalIdleDecrease; uint256 totalIdleIncrease; uint256 totalDebtIncrease; uint256 totalDebtDecrease; uint256 totalMinDebtIncrease; uint256 totalMinDebtDecrease; uint256 totalMaxDebtIncrease; uint256 totalMaxDebtDecrease; } struct RebalanceOutParams { /// Address that will received the withdrawn underlyer address receiver; /// The "out" destination vault address destinationOut; /// The amount of tokenOut that will be withdrawn uint256 amountOut; /// The underlyer for destinationOut address tokenOut; IERC20 _baseAsset; bool _shutdown; } /// @dev In memory struct only for managing vars in _withdraw struct WithdrawInfo { uint256 currentIdle; uint256 assetsFromIdle; uint256 totalAssetsToPull; uint256 assetsToPull; uint256 assetsPulled; uint256 idleIncrease; uint256 debtDecrease; uint256 debtMinDecrease; uint256 debtMaxDecrease; uint256 totalMinDebt; uint256 destinationRound; uint256 lastRoundSlippage; uint256 expectedAssets; } struct FlashRebalanceParams { uint256 totalIdle; uint256 totalDebt; IERC20 baseAsset; bool shutdown; } struct FlashResultInfo { uint256 tokenInBalanceBefore; uint256 tokenInBalanceAfter; bytes32 flashResult; } function flashRebalance( DestinationInfo storage destInfoOut, DestinationInfo storage destInfoIn, IERC3156FlashBorrower receiver, IStrategy.RebalanceParams memory params, IStrategy.SummaryStats memory destSummaryOut, IAutopoolStrategy autoPoolStrategy, FlashRebalanceParams memory flashParams, bytes calldata data ) external returns (IdleDebtUpdates memory result) { // Handle decrease (shares going "Out", cashing in shares and sending underlying back to swapper) // If the tokenOut is _asset we assume they are taking idle // which is already in the contract result = _handleRebalanceOut( AutopoolDebt.RebalanceOutParams({ receiver: address(receiver), destinationOut: params.destinationOut, amountOut: params.amountOut, tokenOut: params.tokenOut, _baseAsset: flashParams.baseAsset, _shutdown: flashParams.shutdown }), destInfoOut ); if (!result.pricesWereSafe) { revert InvalidPrices(); } // Handle increase (shares coming "In", getting underlying from the swapper and trading for new shares) if (params.amountIn > 0) { FlashResultInfo memory flashResultInfo; // get "before" counts flashResultInfo.tokenInBalanceBefore = IERC20(params.tokenIn).balanceOf(address(this)); // Give control back to the solver so they can make use of the "out" assets // and get our "in" asset flashResultInfo.flashResult = receiver.onFlashLoan(msg.sender, params.tokenIn, params.amountIn, 0, data); // We assume the solver will send us the assets flashResultInfo.tokenInBalanceAfter = IERC20(params.tokenIn).balanceOf(address(this)); // Make sure the call was successful and verify we have at least the assets we think // we were getting if ( flashResultInfo.flashResult != keccak256("ERC3156FlashBorrower.onFlashLoan") || flashResultInfo.tokenInBalanceAfter < flashResultInfo.tokenInBalanceBefore + params.amountIn ) { revert Errors.FlashLoanFailed(params.tokenIn, params.amountIn); } { // make sure we have a valid path (bool success, string memory message) = autoPoolStrategy.verifyRebalance(params, destSummaryOut); if (!success) { revert RebalanceFailed(message); } } if (params.tokenIn != address(flashParams.baseAsset)) { IdleDebtUpdates memory inDebtResult = _handleRebalanceIn( destInfoIn, IDestinationVault(params.destinationIn), params.tokenIn, flashResultInfo.tokenInBalanceAfter ); if (!inDebtResult.pricesWereSafe) { revert InvalidPrices(); } result.totalDebtDecrease += inDebtResult.totalDebtDecrease; result.totalDebtIncrease += inDebtResult.totalDebtIncrease; result.totalMinDebtDecrease += inDebtResult.totalMinDebtDecrease; result.totalMinDebtIncrease += inDebtResult.totalMinDebtIncrease; result.totalMaxDebtDecrease += inDebtResult.totalMaxDebtDecrease; result.totalMaxDebtIncrease += inDebtResult.totalMaxDebtIncrease; } else { result.totalIdleIncrease += flashResultInfo.tokenInBalanceAfter - flashResultInfo.tokenInBalanceBefore; } } } /// @notice Perform deposit and debt info update for the "in" destination during a rebalance /// @dev This "in" function performs less validations than its "out" version /// @param dvIn The "in" destination vault /// @param tokenIn The underlyer for dvIn /// @param depositAmount The amount of tokenIn that will be deposited /// @return result Changes in debt values function _handleRebalanceIn( DestinationInfo storage destInfo, IDestinationVault dvIn, address tokenIn, uint256 depositAmount ) private returns (IdleDebtUpdates memory result) { LibAdapter._approve(IERC20(tokenIn), address(dvIn), depositAmount); // Snapshot our current shares so we know how much to back out uint256 originalShareBal = dvIn.balanceOf(address(this)); // deposit to dv uint256 newShares = dvIn.depositUnderlying(depositAmount); // Update the debt info snapshot result = _recalculateDestInfo(destInfo, dvIn, originalShareBal, originalShareBal + newShares); } /** * @notice Perform withdraw and debt info update for the "out" destination during a rebalance * @dev This "out" function performs more validations and handles idle as opposed to "in" which does not * debtDecrease The previous amount of debt destinationOut accounted for in totalDebt * debtIncrease The current amount of debt destinationOut should account for in totalDebt * idleDecrease Amount of baseAsset that was sent from the vault. > 0 only when tokenOut == baseAsset * idleIncrease Amount of baseAsset that was claimed from Destination Vault * @param params Rebalance out params * @param destOutInfo The "out" destination vault info * @return assetChange debt and idle change data */ function _handleRebalanceOut( RebalanceOutParams memory params, DestinationInfo storage destOutInfo ) private returns (IdleDebtUpdates memory assetChange) { // Handle decrease (shares going "Out", cashing in shares and sending underlying back to swapper) // If the tokenOut is _asset we assume they are taking idle // which is already in the contract if (params.amountOut > 0) { if (params.tokenOut != address(params._baseAsset)) { IDestinationVault dvOut = IDestinationVault(params.destinationOut); // Snapshot our current shares so we know how much to back out uint256 originalShareBal = dvOut.balanceOf(address(this)); // Burning our shares will claim any pending baseAsset // rewards and send them to us. // Get our starting balance uint256 beforeBaseAssetBal = params._baseAsset.balanceOf(address(this)); // Withdraw underlying from the destination vault // Shares are sent directly to the flashRebalance receiver // slither-disable-next-line unused-return dvOut.withdrawUnderlying(params.amountOut, params.receiver); // Update the debt info snapshot assetChange = _recalculateDestInfo(destOutInfo, dvOut, originalShareBal, originalShareBal - params.amountOut); // Capture any rewards we may have claimed as part of withdrawing assetChange.totalIdleIncrease = params._baseAsset.balanceOf(address(this)) - beforeBaseAssetBal; } else { // If we are shutdown then the only operations we should be performing are those that get // the base asset back to the vault. We shouldn't be sending out more if (params._shutdown) { revert VaultShutdown(); } // Working with idle baseAsset which should be in the vault already // Just send it out IERC20(params.tokenOut).safeTransfer(params.receiver, params.amountOut); assetChange.totalIdleDecrease = params.amountOut; // We weren't dealing with any debt or pricing, just idle, so we can just mark // it as safe assetChange.pricesWereSafe = true; } } } function recalculateDestInfo( DestinationInfo storage destInfo, IDestinationVault destVault, uint256 originalShares, uint256 currentShares ) external returns (IdleDebtUpdates memory result) { result = _recalculateDestInfo(destInfo, destVault, originalShares, currentShares); } /// @dev Will not revert on unsafe prices. Up to the caller. function _recalculateDestInfo( DestinationInfo storage destInfo, IDestinationVault destVault, uint256 originalShares, uint256 currentShares ) private returns (IdleDebtUpdates memory result) { // TODO: Trace the use of this fn and ensure that every is handling is pricesWereSafe // Figure out what to back out of our totalDebt number. // We could have had withdraws since the last snapshot which means our // cached currentDebt number should be decreased based on the remaining shares // totalDebt is decreased using the same proportion of shares method during withdrawals // so this should represent whatever is remaining. // Prices are per LP token and whether or not the prices are safe to use // If they aren't safe then just continue and we'll get it on the next go around (uint256 spotPrice, uint256 safePrice, bool isSpotSafe) = destVault.getRangePricesLP(); // Calculate what we're backing out based on the original shares uint256 minPrice = spotPrice > safePrice ? safePrice : spotPrice; uint256 maxPrice = spotPrice > safePrice ? spotPrice : safePrice; // If we previously had shares, calculate how much of our cached numbers // still remain as this will be deducted from the overall debt numbers // TODO: Evaluate whether to round these up so we don't accumulate small amounts // over time uint256 prevOwnedShares = destInfo.ownedShares; if (prevOwnedShares > 0) { result.totalDebtDecrease = (destInfo.cachedDebtValue * originalShares) / prevOwnedShares; result.totalMinDebtDecrease = (destInfo.cachedMinDebtValue * originalShares) / prevOwnedShares; result.totalMaxDebtDecrease = (destInfo.cachedMaxDebtValue * originalShares) / prevOwnedShares; } // The overall debt value is the mid point of min and max uint256 div = 10 ** destVault.decimals(); uint256 newDebtValue = (minPrice * currentShares + maxPrice * currentShares) / (div * 2); result.pricesWereSafe = isSpotSafe; result.totalDebtIncrease = newDebtValue; result.totalMinDebtIncrease = minPrice * currentShares / div; result.totalMaxDebtIncrease = maxPrice * currentShares / div; // Save our current new values destInfo.cachedDebtValue = newDebtValue; destInfo.cachedMinDebtValue = result.totalMinDebtIncrease; destInfo.cachedMaxDebtValue = result.totalMaxDebtIncrease; destInfo.lastReport = block.timestamp; destInfo.ownedShares = currentShares; } function totalAssetsTimeChecked( StructuredLinkedList.List storage debtReportQueue, mapping(address => AutopoolDebt.DestinationInfo) storage destinationInfo, IAutopool.TotalAssetPurpose purpose ) external returns (uint256) { IDestinationVault destVault = IDestinationVault(debtReportQueue.peekHead()); uint256 recalculatedTotalAssets = IAutopool(address(this)).totalAssets(purpose); while (address(destVault) != address(0)) { uint256 lastReport = destinationInfo[address(destVault)].lastReport; if (lastReport + MAX_DEBT_REPORT_AGE_SECONDS > block.timestamp) { // Its not stale // This report is OK, we don't need to recalculate anything break; } else { // It is stale, recalculate //slither-disable-next-line unused-return uint256 currentShares = destVault.balanceOf(address(this)); uint256 staleDebt; uint256 extremePrice; // Figure out exactly which price to use based on its purpose if (purpose == IAutopool.TotalAssetPurpose.Deposit) { // We use max value so that anything deposited is worth less extremePrice = destVault.getUnderlyerCeilingPrice(); // Round down. We are subtracting this value out of the total so some left // behind just increases the value which is what we want staleDebt = destinationInfo[address(destVault)].cachedMaxDebtValue.mulDiv( currentShares, destinationInfo[address(destVault)].ownedShares, Math.Rounding.Down ); } else if (purpose == IAutopool.TotalAssetPurpose.Withdraw) { // We use min value so that we value the shares as worth less extremePrice = destVault.getUnderlyerFloorPrice(); // Round up. We are subtracting this value out of the total so if we take a little // extra it just decreases the value which is what we want staleDebt = destinationInfo[address(destVault)].cachedMinDebtValue.mulDiv( currentShares, destinationInfo[address(destVault)].ownedShares, Math.Rounding.Up ); } else { revert InvalidTotalAssetPurpose(); } // Back out our stale debt, add in its new value // Our goal is to find the most conservative value in each situation. If the current // value we have represents that, then use it. Otherwise, use the new one. uint256 newValue = (currentShares * extremePrice) / destVault.ONE(); if (purpose == IAutopool.TotalAssetPurpose.Deposit && staleDebt > newValue) { newValue = staleDebt; } else if (purpose == IAutopool.TotalAssetPurpose.Withdraw && staleDebt < newValue) { newValue = staleDebt; } recalculatedTotalAssets = recalculatedTotalAssets + newValue - staleDebt; } destVault = IDestinationVault(debtReportQueue.getAdjacent(address(destVault), true)); } return recalculatedTotalAssets; } function _updateDebtReporting( StructuredLinkedList.List storage debtReportQueue, mapping(address => AutopoolDebt.DestinationInfo) storage destinationInfo, uint256 numToProcess ) external returns (IdleDebtUpdates memory result) { numToProcess = Math.min(numToProcess, debtReportQueue.sizeOf()); for (uint256 i = 0; i < numToProcess; ++i) { IDestinationVault destVault = IDestinationVault(debtReportQueue.popHead()); // Get the reward value we've earned. DV rewards are always in terms of base asset // We track the gas used purely for off-chain stats purposes // Main rewarder on DV's store the earned and liquidated rewards // Extra rewarders are disabled at the DV level uint256 claimGasUsed = gasleft(); uint256 beforeBaseAsset = IERC20(IAutopool(address(this)).asset()).balanceOf(address(this)); IMainRewarder(destVault.rewarder()).getReward(address(this), false); uint256 claimedRewardValue = IERC20(IAutopool(address(this)).asset()).balanceOf(address(this)) - beforeBaseAsset; result.totalIdleIncrease += claimedRewardValue; // Recalculate the debt info figuring out the change in // total debt value we can roll up later uint256 currentShareBalance = destVault.balanceOf(address(this)); AutopoolDebt.IdleDebtUpdates memory debtResult = _recalculateDestInfo( destinationInfo[address(destVault)], destVault, currentShareBalance, currentShareBalance ); result.totalDebtDecrease += debtResult.totalDebtDecrease; result.totalDebtIncrease += debtResult.totalDebtIncrease; result.totalMinDebtDecrease += debtResult.totalMinDebtDecrease; result.totalMinDebtIncrease += debtResult.totalMinDebtIncrease; result.totalMaxDebtDecrease += debtResult.totalMaxDebtDecrease; result.totalMaxDebtIncrease += debtResult.totalMaxDebtIncrease; // If we no longer have shares, then there's no reason to continue reporting on the destination. // The strategy will only call for the info if its moving "out" of the destination // and that will only happen if we have shares. // A rebalance where we move "in" to the position will refresh the data at that time if (currentShareBalance > 0) { debtReportQueue.addToTail(address(destVault)); } claimGasUsed -= gasleft(); emit DestinationDebtReporting(address(destVault), debtResult, claimedRewardValue, claimGasUsed); } } function _initiateWithdrawInfo( uint256 assets, IAutopool.AssetBreakdown storage assetBreakdown ) private view returns (WithdrawInfo memory) { uint256 idle = assetBreakdown.totalIdle; WithdrawInfo memory info = WithdrawInfo({ currentIdle: idle, // If idle can cover the full amount, then we want to pull all assets from there // Otherwise, we want to pull from the market and only get idle if we exhaust the market assetsFromIdle: assets > idle ? 0 : assets, totalAssetsToPull: 0, assetsToPull: 0, assetsPulled: 0, idleIncrease: 0, debtDecrease: 0, debtMinDecrease: 0, debtMaxDecrease: 0, totalMinDebt: assetBreakdown.totalDebtMin, destinationRound: 0, lastRoundSlippage: 0, expectedAssets: 0 }); info.totalAssetsToPull = assets - info.assetsFromIdle; // This var we use to track our progress later info.assetsToPull = assets - info.assetsFromIdle; // Idle + minDebt is the maximum amount of assets/debt we could burn during a withdraw. // If the user is request more than that (like during a withdraw) we can just revert // early without trying if (info.totalAssetsToPull > info.currentIdle + info.totalMinDebt) { revert TooFewAssets(assets, info.currentIdle + info.totalMinDebt); } return info; } function withdraw( uint256 assets, uint256 applicableTotalAssets, IAutopool.AssetBreakdown storage assetBreakdown, StructuredLinkedList.List storage withdrawalQueue, mapping(address => AutopoolDebt.DestinationInfo) storage destinationInfo ) public returns (uint256 actualAssets, uint256 actualShares, uint256 debtBurned) { WithdrawInfo memory info = _initiateWithdrawInfo(assets, assetBreakdown); // Pull the market if there aren't enough funds in idle to cover the entire amount // This flow is not bounded by a set number of shares. The user has requested X assets // and a variable number of shares to burn so we don't have easy break out points like we do // during redeem (like using debt burned). When we get slippage here and don't meet the requested assets // we need to keep going if we can. This is tricky if we consider that (most of) our destinations are // LP positions and we'll be swapping assets, so we can expect some slippage. Even // if our minDebtValue numbers are up to date and perfectly accurate slippage could ensure we // are always receiving less than we expect/calculate and we never hit the requested assets // even though the owner would have shares to cover it. Under normal/expected conditions, our // minDebtValue is lower than actual and we expect overall value to be going up, so we burn a tad // more than we should and receive a tad more than we expect. This should cover us. However, // in other conditions we have to be sure we aren't endlessly trying to approach 0 so we are tracking // the slippage we received on the last pull, repricing, and applying an increasing multiplier until we either // pull enough to cover or pull them all and/or move to the next destination. uint256 dvSharesToBurn; while (info.assetsToPull > 0) { IDestinationVault destVault = IDestinationVault(withdrawalQueue.peekHead()); if (address(destVault) == address(0)) { // TODO: This may be some NULL value too, check the underlying library break; } uint256 dvShares = destVault.balanceOf(address(this)); { uint256 dvSharesValue; if (info.destinationRound == 0) { // First time pulling // We use the min debt value here because its a withdrawal and we're trying to cover an amount // of assets. Undervaluing the shares may mean we pull more but given that we expect slippage // that is desirable. dvSharesValue = destinationInfo[address(destVault)].cachedMinDebtValue * dvShares / destinationInfo[address(destVault)].ownedShares; } else { // When we've pulled from this destination before, i.e. destinationRound > 0, then we // know a more accurate exchange rate and its worse than we were expecting. // We even will pad it a bit as we want to account for any additional slippage we // may receive by say being farther down an AMM curve. // dvSharesToBurn is the last value we used when pulling from this destination // info.expectedAssets is how much we expected to get on that last pull // info.expectedAssets - info.lastRoundSlippage is how much we actually received uint256 paddedSlippage = info.lastRoundSlippage * (info.destinationRound + 10_000) / 10_000; if (paddedSlippage < info.expectedAssets) { dvSharesValue = (info.expectedAssets - paddedSlippage) * dvShares / dvSharesToBurn; } else { // This will just mean we pull all shares dvSharesValue = 0; } } if (dvSharesValue > info.assetsToPull) { dvSharesToBurn = (dvShares * info.assetsToPull) / dvSharesValue; // Only need to set it here because the only time we'll use it is if // we don't exhaust all shares and have to try the destination again info.expectedAssets = info.assetsToPull; } else { dvSharesToBurn = dvShares; } } // Destination Vaults always burn the exact amount we instruct them to uint256 pulledAssets = destVault.withdrawBaseAsset(dvSharesToBurn, address(this)); info.assetsPulled += pulledAssets; // Calculate the totalDebt we'll need to remove based on the shares we're burning // We're rounding up here so take care when actually applying to totalDebt // The assets we calculated to pull are from the minDebt number we track so // we'll use that one to ensure we properly account for slippage (the `pulled` var below) // The other two debt numbers we just need to keep up to date. uint256 debtMinDecrease = destinationInfo[address(destVault)].cachedMinDebtValue.mulDiv( dvSharesToBurn, destinationInfo[address(destVault)].ownedShares, Math.Rounding.Up ); info.debtMinDecrease += debtMinDecrease; info.debtDecrease += destinationInfo[address(destVault)].cachedDebtValue.mulDiv( dvSharesToBurn, destinationInfo[address(destVault)].ownedShares, Math.Rounding.Up ); info.debtMaxDecrease += destinationInfo[address(destVault)].cachedMaxDebtValue.mulDiv( dvSharesToBurn, destinationInfo[address(destVault)].ownedShares, Math.Rounding.Up ); // If we've exhausted all shares we can remove the withdrawal from the queue // We need to leave it in the debt report queue though so that our destination specific // debt tracking values can be updated if (dvShares == dvSharesToBurn) { withdrawalQueue.popAddress(address(destVault)); info.destinationRound = 0; info.lastRoundSlippage = 0; } else { // If we didn't burn all the shares and we received enough to cover our // expected that means we'll break out below as we've hit our target unchecked { if (pulledAssets < info.expectedAssets) { info.lastRoundSlippage = info.expectedAssets - pulledAssets; if (info.destinationRound == 0) { info.destinationRound = 100; } else { info.destinationRound *= 2; } } } } // It's possible we'll get back more assets than we anticipate from a swap // so if we do, throw it in idle and stop processing. You don't get more than we've calculated if (info.assetsPulled >= info.totalAssetsToPull) { info.idleIncrease += info.assetsPulled - info.totalAssetsToPull; info.assetsPulled = info.totalAssetsToPull; break; } info.assetsToPull -= pulledAssets; } // info.assetsToPull isn't safe to use past this point. // It may or may not be accurate from the previous loop // We didn't get enough assets from the debt pull // See if we can get the rest from idle if (info.assetsPulled < assets && info.currentIdle > 0) { uint256 remaining = assets - info.assetsPulled; if (remaining <= info.currentIdle) { info.assetsFromIdle = remaining; } // We don't worry about the else case because if currentIdle can't // cover remaining then we'll fail the `actualAssets < assets` // check below and revert } debtBurned = info.assetsFromIdle + info.debtMinDecrease; actualAssets = info.assetsFromIdle + info.assetsPulled; if (actualAssets < assets) { revert TooFewAssets(assets, actualAssets); } actualShares = IAutopool(address(this)).convertToShares( Math.max(actualAssets, debtBurned), applicableTotalAssets, IAutopool(address(this)).totalSupply(), Math.Rounding.Up ); // Subtract what's taken out of idle from totalIdle // We may also have some increase to account for it we over pulled // or received better execution than we were anticipating // slither-disable-next-line events-maths assetBreakdown.totalIdle = info.currentIdle + info.idleIncrease - info.assetsFromIdle; // Save off our various debt numbers if (info.debtDecrease > assetBreakdown.totalDebt) { assetBreakdown.totalDebt = 0; } else { assetBreakdown.totalDebt -= info.debtDecrease; } if (info.debtMinDecrease > info.totalMinDebt) { assetBreakdown.totalDebtMin = 0; } else { assetBreakdown.totalDebtMin -= info.debtMinDecrease; } if (info.debtMaxDecrease > assetBreakdown.totalDebtMax) { assetBreakdown.totalDebtMax = 0; } else { assetBreakdown.totalDebtMax -= info.debtMaxDecrease; } } /// @notice Perform a removal of assets via the redeem path where the shares are the limiting factor. /// This means we break out whenever we reach either `assets` retrieved or debt value equivalent to `assets` burned function redeem( uint256 assets, uint256 applicableTotalAssets, IAutopool.AssetBreakdown storage assetBreakdown, StructuredLinkedList.List storage withdrawalQueue, mapping(address => AutopoolDebt.DestinationInfo) storage destinationInfo ) public returns (uint256 actualAssets, uint256 actualShares, uint256 debtBurned) { WithdrawInfo memory info = _initiateWithdrawInfo(assets, assetBreakdown); // If not enough funds in idle, then pull what we need from destinations bool exhaustedDestinations = false; while (info.assetsToPull > 0) { IDestinationVault destVault = IDestinationVault(withdrawalQueue.peekHead()); if (address(destVault) == address(0)) { exhaustedDestinations = true; break; } uint256 dvShares = destVault.balanceOf(address(this)); uint256 dvSharesToBurn = dvShares; { // Valuing these shares higher, rounding up, will result in us burning less of them // in the event we don't burn all of them. Good thing. uint256 dvSharesValue = destinationInfo[address(destVault)].cachedMinDebtValue.mulDiv( dvSharesToBurn, destinationInfo[address(destVault)].ownedShares, Math.Rounding.Up ); // If the dv shares we own are worth more than we need, limit the shares to burn // Any extra we get will be dropped into idle if (dvSharesValue > info.assetsToPull) { uint256 limitedShares = (dvSharesToBurn * info.assetsToPull) / dvSharesValue; // Final set for the actual shares we'll burn later dvSharesToBurn = limitedShares; } } // Destination Vaults always burn the exact amount we instruct them to uint256 pulledAssets = destVault.withdrawBaseAsset(dvSharesToBurn, address(this)); info.assetsPulled += pulledAssets; // Calculate the totalDebt we'll need to remove based on the shares we're burning // We're rounding up here so take care when actually applying to totalDebt // The assets we calculated to pull are from the minDebt number we track so // we'll use that one to ensure we properly account for slippage (the `pulled` var below) // The other two debt numbers we just need to keep up to date. uint256 debtMinDecrease = destinationInfo[address(destVault)].cachedMinDebtValue.mulDiv( dvSharesToBurn, destinationInfo[address(destVault)].ownedShares, Math.Rounding.Up ); info.debtMinDecrease += debtMinDecrease; info.debtDecrease += destinationInfo[address(destVault)].cachedDebtValue.mulDiv( dvSharesToBurn, destinationInfo[address(destVault)].ownedShares, Math.Rounding.Up ); info.debtMaxDecrease += destinationInfo[address(destVault)].cachedMaxDebtValue.mulDiv( dvSharesToBurn, destinationInfo[address(destVault)].ownedShares, Math.Rounding.Up ); // If we've exhausted all shares we can remove the withdrawal from the queue // We need to leave it in the debt report queue though so that our destination specific // debt tracking values can be updated if (dvShares == dvSharesToBurn) { withdrawalQueue.popAddress(address(destVault)); } // It's possible we'll get back more assets than we anticipate from a swap // so if we do, throw it in idle and stop processing. You don't get more than we've calculated if (info.assetsPulled >= info.totalAssetsToPull) { info.idleIncrease += info.assetsPulled - info.totalAssetsToPull; info.assetsPulled = info.totalAssetsToPull; break; } // Any deficiency in the amount we received is slippage. debtDecrease is what we expected // to receive. If we received any extra, that's great we'll roll it forward so we burn // less on the next loop. uint256 pulled = Math.max(debtMinDecrease, pulledAssets); if (pulled >= info.assetsToPull) { // We either have enough assets, or we've burned the max debt we're allowed break; } else { info.assetsToPull -= pulled; } // If we didn't exhaust all of the shares from the destination it means we // assume we will get everything we need from there and everything else is slippage if (dvShares != dvSharesToBurn) { break; } } // info.assetsToPull isn't safe to use past this point. // It may or may not be accurate from the previous loop // We didn't get enough assets from the debt pull // See if we can get the rest from idle // Check the debt burned though to ensure that we don't try to make up // slippage incurred out of idle if ( info.assetsPulled < assets && info.debtMinDecrease < assets && info.currentIdle > 0 && exhaustedDestinations ) { uint256 remaining = assets - Math.max(info.assetsPulled, info.debtMinDecrease); if (remaining < info.currentIdle) { info.assetsFromIdle = remaining; } else { info.assetsFromIdle = info.currentIdle; } } debtBurned = info.assetsFromIdle + info.debtMinDecrease; actualAssets = info.assetsFromIdle + info.assetsPulled; actualShares = IAutopool(address(this)).convertToShares( debtBurned, applicableTotalAssets, IAutopool(address(this)).totalSupply(), Math.Rounding.Up ); // Subtract what's taken out of idle from totalIdle // We may also have some increase to account for it we over pulled // or received better execution than we were anticipating // slither-disable-next-line events-maths assetBreakdown.totalIdle = info.currentIdle + info.idleIncrease - info.assetsFromIdle; // Save off our various debt numbers if (info.debtDecrease > assetBreakdown.totalDebt) { assetBreakdown.totalDebt = 0; } else { assetBreakdown.totalDebt -= info.debtDecrease; } if (info.debtMinDecrease > info.totalMinDebt) { assetBreakdown.totalDebtMin = 0; } else { assetBreakdown.totalDebtMin -= info.debtMinDecrease; } if (info.debtMaxDecrease > assetBreakdown.totalDebtMax) { assetBreakdown.totalDebtMax = 0; } else { assetBreakdown.totalDebtMax -= info.debtMaxDecrease; } } /** * @notice Function to complete a withdrawal or redeem. This runs after shares to be burned and assets to be * transferred are calculated. * @param assets Amount of assets to be transferred to receiver. * @param shares Amount of shares to be burned from owner. * @param owner Owner of shares, user to burn shares from. * @param receiver The receiver of the baseAsset. * @param baseAsset Base asset of the Autopool. * @param assetBreakdown Asset breakdown for the Autopool. * @param tokenData Token data for the Autopool. */ function completeWithdrawal( uint256 assets, uint256 shares, address owner, address receiver, IERC20 baseAsset, IAutopool.AssetBreakdown storage assetBreakdown, AutopoolToken.TokenData storage tokenData ) external { if (msg.sender != owner) { uint256 allowed = IAutopool(address(this)).allowance(owner, msg.sender); if (allowed != type(uint256).max) { if (shares > allowed) revert AmountExceedsAllowance(shares, allowed); unchecked { tokenData.approve(owner, msg.sender, allowed - shares); } } } tokenData.burn(owner, shares); uint256 ts = IAutopool(address(this)).totalSupply(); emit Withdraw(msg.sender, receiver, owner, assets, shares); emit Nav(assetBreakdown.totalIdle, assetBreakdown.totalDebt, ts); baseAsset.safeTransfer(receiver, assets); } /** * @notice A helper function to get estimates of what would happen on a withdraw or redeem. * @dev Reverts all changing state. * @param previewWithdraw Bool denoting whether to preview a redeem or withdrawal. * @param assets Assets to be withdrawn or redeemed. * @param applicableTotalAssets Operation dependent assets in the Autopool. * @param functionCallEncoded Abi encoded function signature for recursive call. * @param assetBreakdown Breakdown of vault assets from Autopool storage. * @param withdrawalQueue Destination vault withdrawal queue from Autopool storage. * @param destinationInfo Mapping of information for destinations. * @return assetsAmount Preview of amount of assets to send to receiver. * @return sharesAmount Preview of amount of assets to burn from owner. */ function preview( bool previewWithdraw, uint256 assets, uint256 applicableTotalAssets, bytes memory functionCallEncoded, IAutopool.AssetBreakdown storage assetBreakdown, StructuredLinkedList.List storage withdrawalQueue, mapping(address => AutopoolDebt.DestinationInfo) storage destinationInfo ) external returns (uint256 assetsAmount, uint256 sharesAmount) { if (msg.sender != address(this)) { // Perform a recursive call the function in `funcCallEncoded`. This will result in a call back to // the Autopool, and then this function. The intention is to reach the "else" block in this function. // solhint-disable avoid-low-level-calls // slither-disable-next-line missing-zero-check,low-level-calls (bool success, bytes memory returnData) = address(this).call(functionCallEncoded); // solhint-enable avoid-low-level-calls // If the recursive call is successful, it means an unintended code path was taken. if (success) { revert Errors.UnreachableError(); } bytes4 sharesAmountSig = bytes4(keccak256("SharesAndAssetsReceived(uint256,uint256)")); // Extract the error signature (first 4 bytes) from the revert reason. bytes4 errorSignature; // solhint-disable no-inline-assembly assembly { errorSignature := mload(add(returnData, 0x20)) } // If the error matches the expected signature, extract the amount from the revert reason and return. if (errorSignature == sharesAmountSig) { // Extract subsequent bytes for uint256. assembly { assetsAmount := mload(add(returnData, 0x24)) sharesAmount := mload(add(returnData, 0x44)) } } else { // If the error is not the expected one, forward the original revert reason. assembly { revert(add(32, returnData), mload(returnData)) } } // solhint-enable no-inline-assembly } // This branch is taken during the recursive call. else { // Perform the actual withdrawal or redeem logic to compute the amount. This will be reverted to // simulate the action. uint256 previewAssets; uint256 previewShares; if (previewWithdraw) { (previewAssets, previewShares,) = withdraw(assets, applicableTotalAssets, assetBreakdown, withdrawalQueue, destinationInfo); } else { (previewAssets, previewShares,) = redeem(assets, applicableTotalAssets, assetBreakdown, withdrawalQueue, destinationInfo); } // Revert with the computed amount as an error. revert SharesAndAssetsReceived(previewAssets, previewShares); } } }
// SPDX-License-Identifier: MIT pragma solidity 0.8.17; import { IERC20Metadata } from "openzeppelin-contracts/token/ERC20/extensions/IERC20Metadata.sol"; /// @dev Interface of the ERC4626 "Tokenized Vault Standard", as defined in https://eips.ethereum.org/EIPS/eip-4626 /// @dev Due to the nature of obtaining estimates for previewing withdraws and redeems, a few functions are not /// view and therefore do not conform to eip 4626. These functions use state changing operations /// to get accurate estimates, reverting after the preview amounts have been obtained. interface IERC4626 is 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 ); /// @notice Returns the address of the underlying token used for the Vault for accounting, depositing, and /// withdrawing. /// @dev /// - MUST be an ERC-20 token contract. /// - MUST NOT revert. function asset() external view returns (address assetTokenAddress); /// @notice Returns the total amount of the underlying asset that is “managed” by Vault. /// @dev /// - 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); /// @notice 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. /// @dev /// - 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); /// @notice 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. /// @dev /// - 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); /// @notice Returns the maximum amount of the underlying asset that can be deposited into the Vault for the /// receiver, /// through a deposit call. /// @dev /// - 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 returns (uint256 maxAssets); /// @notice Allows an on-chain or off-chain user to simulate the effects of their deposit at the current block, /// given /// current on-chain conditions. /// @dev /// - 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 returns (uint256 shares); /// @notice Mints shares Vault shares to receiver by depositing exactly amount of underlying tokens. /// @dev /// - 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); /// @notice Returns the maximum amount of the Vault shares that can be minted for the receiver, through a mint call. /// @dev /// - 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 returns (uint256 maxShares); /// @notice Allows an on-chain or off-chain user to simulate the effects of their mint at the current block, given /// current on-chain conditions. /// @dev /// - 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 returns (uint256 assets); /// @notice Mints exactly shares Vault shares to receiver by depositing amount of underlying tokens. /// @dev /// - 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); /// @notice Returns the maximum amount of the underlying asset that can be withdrawn from the owner balance in the /// Vault, through a withdraw call. /// @dev /// - MUST return a limited value if owner is subject to some withdrawal limit or timelock. /// - MUST NOT revert. function maxWithdraw(address owner) external returns (uint256 maxAssets); /// @notice Allows an on-chain or off-chain user to simulate the effects of their withdrawal at the current block, /// given current on-chain conditions. /// @dev /// - 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 returns (uint256 shares); /// @notice Burns shares from owner and sends exactly assets of underlying tokens to receiver. /// @dev /// - 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); /// @notice Returns the maximum amount of Vault shares that can be redeemed from the owner balance in the Vault, /// through a redeem call. /// @dev /// - 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 returns (uint256 maxShares); /// @notice Allows an on-chain or off-chain user to simulate the effects of their redeemption at the current block, /// given current on-chain conditions. /// @dev /// - 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 returns (uint256 assets); /// @notice Burns exactly shares from owner and sends assets of underlying tokens to receiver. /// @dev /// - 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 v4.8.0) (utils/math/Math.sol) pragma solidity ^0.8.0; /** * @dev Standard math utilities missing in the Solidity language. */ library Math { enum Rounding { Down, // Toward negative infinity Up, // Toward infinity Zero // Toward zero } /** * @dev Returns the largest of two numbers. */ function max(uint256 a, uint256 b) internal pure returns (uint256) { return a > b ? a : b; } /** * @dev Returns the smallest of two numbers. */ function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } /** * @dev Returns the average of two numbers. The result is rounded towards * zero. */ function average(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b) / 2 can overflow. return (a & b) + (a ^ b) / 2; } /** * @dev Returns the ceiling of the division of two numbers. * * This differs from standard division with `/` in that it rounds up instead * of rounding down. */ function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b - 1) / b can overflow on addition, so we distribute. return a == 0 ? 0 : (a - 1) / b + 1; } /** * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0 * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) * with further edits by Uniswap Labs also under MIT license. */ function mulDiv( uint256 x, uint256 y, uint256 denominator ) internal pure returns (uint256 result) { unchecked { // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256 // variables such that product = prod1 * 2^256 + prod0. uint256 prod0; // Least significant 256 bits of the product uint256 prod1; // Most significant 256 bits of the product assembly { let mm := mulmod(x, y, not(0)) prod0 := mul(x, y) prod1 := sub(sub(mm, prod0), lt(mm, prod0)) } // Handle non-overflow cases, 256 by 256 division. if (prod1 == 0) { return prod0 / denominator; } // Make sure the result is less than 2^256. Also prevents denominator == 0. require(denominator > prod1); /////////////////////////////////////////////// // 512 by 256 division. /////////////////////////////////////////////// // Make division exact by subtracting the remainder from [prod1 prod0]. uint256 remainder; assembly { // Compute remainder using mulmod. remainder := mulmod(x, y, denominator) // Subtract 256 bit number from 512 bit number. prod1 := sub(prod1, gt(remainder, prod0)) prod0 := sub(prod0, remainder) } // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1. // See https://cs.stackexchange.com/q/138556/92363. // Does not overflow because the denominator cannot be zero at this stage in the function. uint256 twos = denominator & (~denominator + 1); assembly { // Divide denominator by twos. denominator := div(denominator, twos) // Divide [prod1 prod0] by twos. prod0 := div(prod0, twos) // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one. twos := add(div(sub(0, twos), twos), 1) } // Shift in bits from prod1 into prod0. prod0 |= prod1 * twos; // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for // four bits. That is, denominator * inv = 1 mod 2^4. uint256 inverse = (3 * denominator) ^ 2; // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works // in modular arithmetic, doubling the correct bits in each step. inverse *= 2 - denominator * inverse; // inverse mod 2^8 inverse *= 2 - denominator * inverse; // inverse mod 2^16 inverse *= 2 - denominator * inverse; // inverse mod 2^32 inverse *= 2 - denominator * inverse; // inverse mod 2^64 inverse *= 2 - denominator * inverse; // inverse mod 2^128 inverse *= 2 - denominator * inverse; // inverse mod 2^256 // Because the division is now exact we can divide by multiplying with the modular inverse of denominator. // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1 // is no longer required. result = prod0 * inverse; return result; } } /** * @notice Calculates x * y / denominator with full precision, following the selected rounding direction. */ function mulDiv( uint256 x, uint256 y, uint256 denominator, Rounding rounding ) internal pure returns (uint256) { uint256 result = mulDiv(x, y, denominator); if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) { result += 1; } return result; } /** * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down. * * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11). */ function sqrt(uint256 a) internal pure returns (uint256) { if (a == 0) { return 0; } // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target. // // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`. // // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)` // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))` // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)` // // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit. uint256 result = 1 << (log2(a) >> 1); // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128, // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision // into the expected uint128 result. unchecked { result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; return min(result, a / result); } } /** * @notice Calculates sqrt(a), following the selected rounding direction. */ function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = sqrt(a); return result + (rounding == Rounding.Up && result * result < a ? 1 : 0); } } /** * @dev Return the log in base 2, rounded down, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 128; } if (value >> 64 > 0) { value >>= 64; result += 64; } if (value >> 32 > 0) { value >>= 32; result += 32; } if (value >> 16 > 0) { value >>= 16; result += 16; } if (value >> 8 > 0) { value >>= 8; result += 8; } if (value >> 4 > 0) { value >>= 4; result += 4; } if (value >> 2 > 0) { value >>= 2; result += 2; } if (value >> 1 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 2, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log2(value); return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0); } } /** * @dev Return the log in base 10, rounded down, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >= 10**64) { value /= 10**64; result += 64; } if (value >= 10**32) { value /= 10**32; result += 32; } if (value >= 10**16) { value /= 10**16; result += 16; } if (value >= 10**8) { value /= 10**8; result += 8; } if (value >= 10**4) { value /= 10**4; result += 4; } if (value >= 10**2) { value /= 10**2; result += 2; } if (value >= 10**1) { result += 1; } } return result; } /** * @dev Return the log in base 10, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log10(value); return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0); } } /** * @dev Return the log in base 256, rounded down, of a positive value. * Returns 0 if given 0. * * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string. */ function log256(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 16; } if (value >> 64 > 0) { value >>= 64; result += 8; } if (value >> 32 > 0) { value >>= 32; result += 4; } if (value >> 16 > 0) { value >>= 16; result += 2; } if (value >> 8 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 10, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log256(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log256(value); return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0); } } }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { IStrategy } from "src/interfaces/strategy/IStrategy.sol"; interface IAutopoolStrategy { enum RebalanceDirection { In, Out } /// @notice verify that a rebalance (swap between destinations) meets all the strategy constraints /// @dev Signature identical to IStrategy.verifyRebalance function verifyRebalance( IStrategy.RebalanceParams memory, IStrategy.SummaryStats memory ) external returns (bool, string memory message); /// @notice called by the Autopool when NAV is updated /// @dev can only be called by the strategy's registered Autopool /// @param navPerShare The navPerShare to record function navUpdate(uint256 navPerShare) external; /// @notice called by the Autopool when a rebalance is completed /// @dev can only be called by the strategy's registered Autopool /// @param rebalanceParams The parameters for the rebalance that was executed function rebalanceSuccessfullyExecuted(IStrategy.RebalanceParams memory rebalanceParams) external; /// @notice called by the Autopool during rebalance process /// @param rebalanceParams The parameters for the rebalance that was executed function getRebalanceOutSummaryStats(IStrategy.RebalanceParams memory rebalanceParams) external returns (IStrategy.SummaryStats memory outSummary); /// @notice the number of days to pause rebalancing due to NAV decay function pauseRebalancePeriodInDays() external view returns (uint16); /// @notice the number of seconds gap between consecutive rebalances function rebalanceTimeGapInSeconds() external view returns (uint256); /// @notice destinations trading a premium above maxPremium will be blocked from new capital deployments function maxPremium() external view returns (int256); // 100% = 1e18 /// @notice destinations trading a discount above maxDiscount will be blocked from new capital deployments function maxDiscount() external view returns (int256); // 100% = 1e18 /// @notice the allowed staleness of stats data before a revert occurs function staleDataToleranceInSeconds() external view returns (uint40); /// @notice the swap cost offset period to initialize the strategy with function swapCostOffsetInitInDays() external view returns (uint16); /// @notice the number of violations required to trigger a tightening of the swap cost offset period (1 to 10) function swapCostOffsetTightenThresholdInViolations() external view returns (uint16); /// @notice the number of days to decrease the swap offset period for each tightening step function swapCostOffsetTightenStepInDays() external view returns (uint16); /// @notice the number of days since a rebalance required to trigger a relaxing of the swap cost offset period function swapCostOffsetRelaxThresholdInDays() external view returns (uint16); /// @notice the number of days to increase the swap offset period for each relaxing step function swapCostOffsetRelaxStepInDays() external view returns (uint16); // slither-disable-start similar-names /// @notice the maximum the swap cost offset period can reach. This is the loosest the strategy will be function swapCostOffsetMaxInDays() external view returns (uint16); /// @notice the minimum the swap cost offset period can reach. This is the most conservative the strategy will be function swapCostOffsetMinInDays() external view returns (uint16); /// @notice the number of days for the first NAV decay comparison (e.g., 30 days) function navLookback1InDays() external view returns (uint8); /// @notice the number of days for the second NAV decay comparison (e.g., 60 days) function navLookback2InDays() external view returns (uint8); /// @notice the number of days for the third NAV decay comparison (e.g., 90 days) function navLookback3InDays() external view returns (uint8); // slither-disable-end similar-names /// @notice the maximum slippage that is allowed for a normal rebalance function maxNormalOperationSlippage() external view returns (uint256); // 100% = 1e18 /// @notice the maximum amount of slippage to allow when a destination is trimmed due to constraint violations /// recommend setting this higher than maxNormalOperationSlippage function maxTrimOperationSlippage() external view returns (uint256); // 100% = 1e18 /// @notice the maximum amount of slippage to allow when a destinationVault has been shutdown /// shutdown for a vault is abnormal and means there is an issue at that destination /// recommend setting this higher than maxNormalOperationSlippage function maxEmergencyOperationSlippage() external view returns (uint256); // 100% = 1e18 /// @notice the maximum amount of slippage to allow when the Autopool has been shutdown function maxShutdownOperationSlippage() external view returns (uint256); // 100% = 1e18 /// @notice the maximum discount used for price return function maxAllowedDiscount() external view returns (int256); // 18 precision /// @notice model weight used for LSTs base yield, 1e6 is the highest function weightBase() external view returns (uint256); /// @notice model weight used for DEX fee yield, 1e6 is the highest function weightFee() external view returns (uint256); /// @notice model weight used for incentive yield function weightIncentive() external view returns (uint256); /// @notice model weight used slashing costs function weightSlashing() external view returns (uint256); /// @notice model weight applied to an LST discount when exiting the position function weightPriceDiscountExit() external view returns (int256); /// @notice model weight applied to an LST discount when entering the position function weightPriceDiscountEnter() external view returns (int256); /// @notice model weight applied to an LST premium when entering or exiting the position function weightPricePremium() external view returns (int256); /// @notice initial value of the swap cost offset to use function swapCostOffsetInit() external view returns (uint16); /// @notice initial lst price gap tolerance function defaultLstPriceGapTolerance() external view returns (uint256); }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { IBaseRewarder } from "src/interfaces/rewarders/IBaseRewarder.sol"; import { IExtraRewarder } from "src/interfaces/rewarders/IExtraRewarder.sol"; interface IMainRewarder is IBaseRewarder { error ExtraRewardsNotAllowed(); event ExtraRewardAdded(address reward); event ExtraRewardsCleared(); event ExtraRewardRemoved(address reward); /** * @notice Adds an ExtraRewarder contract address to the extraRewards array. * @param reward The address of the ExtraRewarder contract. */ function addExtraReward(address reward) external; /** * @notice Removes a list of ExtraRewarder contract addresses from the extraRewards array. */ function removeExtraRewards(address[] calldata _rewards) external; /** * @notice Withdraws the specified amount of tokens from the vault for the specified account, and transfers all * rewards for the account from this contract and any linked extra reward contracts. * @param account The address of the account to withdraw tokens and claim rewards for. * @param amount The amount of tokens to withdraw. * @param claim If true, claims all rewards for the account from this contract and any linked extra reward * contracts. */ function withdraw(address account, uint256 amount, bool claim) external; /** * @notice Clears the extraRewards array. */ function clearExtraRewards() external; /** * @notice Claims and transfers all rewards for the specified account from this contract and any linked extra reward * contracts. * @dev If claimExtras is true, also claims all rewards from linked extra reward contracts. * @param account The address of the account to claim rewards for. * @param claimExtras If true, claims rewards from linked extra reward contracts. */ function getReward(address account, bool claimExtras) external; /** * @notice Number of extra rewards currently registered */ function extraRewardsLength() external view returns (uint256); /** * @notice Get the extra rewards array values */ function extraRewards() external view returns (address[] memory); /** * @notice Get the rewarder at the specified index */ function getExtraRewarder(uint256 index) external view returns (IExtraRewarder); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612]. * * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't * need to send a transaction, and thus is not required to hold Ether at all. */ interface IERC20Permit { /** * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens, * given ``owner``'s signed approval. * * IMPORTANT: The same issues {IERC20-approve} has related to transaction * ordering also apply here. * * Emits an {Approval} event. * * Requirements: * * - `spender` cannot be the zero address. * - `deadline` must be a timestamp in the future. * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner` * over the EIP712-formatted function arguments. * - the signature must use ``owner``'s current nonce (see {nonces}). * * For more information on the signature format, see the * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP * section]. */ function permit( address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) external; /** * @dev Returns the current nonce for `owner`. This value must be * included whenever a signature is generated for {permit}. * * Every successful call to {permit} increases ``owner``'s nonce by one. This * prevents a signature from being used multiple times. */ function nonces(address owner) external view returns (uint256); /** * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}. */ // solhint-disable-next-line func-name-mixedcase function DOMAIN_SEPARATOR() external view returns (bytes32); }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { IERC20 } from "openzeppelin-contracts/token/ERC20/IERC20.sol"; import { SafeERC20 } from "openzeppelin-contracts/token/ERC20/utils/SafeERC20.sol"; library LibAdapter { using SafeERC20 for IERC20; address public constant CURVE_REGISTRY_ETH_ADDRESS_POINTER = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE; error MinLpAmountNotReached(); error LpTokenAmountMismatch(); error NoNonZeroAmountProvided(); error InvalidBalanceChange(); // Utils function _approve(IERC20 token, address spender, uint256 amount) internal { uint256 currentAllowance = token.allowance(address(this), spender); if (currentAllowance > 0) { token.safeDecreaseAllowance(spender, currentAllowance); } token.safeIncreaseAllowance(spender, amount); } }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { IERC20Metadata as IERC20 } from "openzeppelin-contracts/token/ERC20/extensions/IERC20Metadata.sol"; import { IBaseAssetVault } from "src/interfaces/vault/IBaseAssetVault.sol"; import { IMainRewarder } from "src/interfaces/rewarders/IMainRewarder.sol"; import { IDexLSTStats } from "src/interfaces/stats/IDexLSTStats.sol"; interface IDestinationVault is IBaseAssetVault, IERC20 { enum VaultShutdownStatus { Active, Deprecated, Exploit } error LogicDefect(); error BaseAmountReceived(uint256 amount); /* ******************************** */ /* View */ /* ******************************** */ /// @notice A full unit of this vault // solhint-disable-next-line func-name-mixedcase function ONE() external view returns (uint256); /// @notice The asset that is deposited into the vault function underlying() external view returns (address); /// @notice The asset that rewards and withdrawals to the Autopool are denominated in /// @inheritdoc IBaseAssetVault function baseAsset() external view override returns (address); /// @notice Debt balance of underlying asset that is in contract. This /// value includes only assets that are known as debt by the rest of the /// system (i.e. transferred in on rebalance), and does not include /// extraneous amounts of underlyer that may have ended up in this contract. function internalDebtBalance() external view returns (uint256); /// @notice Debt balance of underlyering asset staked externally. This value only /// includes assets known as debt to the rest of the system, and does not include /// any assets staked on behalf of the DV in external contracts. function externalDebtBalance() external view returns (uint256); /// @notice Returns true value of _underlyer in DV. Debt + tokens that may have /// been transferred into the contract outside of rebalance. function internalQueriedBalance() external view returns (uint256); /// @notice Returns true value of staked _underlyer in external contract. This /// will include any _underlyer that has been staked on behalf of the DV. function externalQueriedBalance() external view returns (uint256); /// @notice Balance of underlying debt, sum of `externalDebtBalance()` and `internalDebtBalance()`. function balanceOfUnderlyingDebt() external view returns (uint256); /// @notice Rewarder for this vault function rewarder() external view returns (address); /// @notice Exchange this destination vault points to function exchangeName() external view returns (string memory); /// @notice The type of pool associated with this vault function poolType() external view returns (string memory); /// @notice If the pool only deals in ETH when adding or removing liquidity function poolDealInEth() external view returns (bool); /// @notice Tokens that base asset can be swapped into function underlyingTokens() external view returns (address[] memory); /* ******************************** */ /* Events */ /* ******************************** */ event Donated(address sender, uint256 amount); event Withdraw( uint256 target, uint256 actual, uint256 debtLoss, uint256 claimLoss, uint256 fromIdle, uint256 fromDebt ); event UpdateSignedMessage(bytes32 hash, bool flag); /* ******************************** */ /* Errors */ /* ******************************** */ error ZeroAddress(string paramName); error InvalidShutdownStatus(VaultShutdownStatus status); /* ******************************** */ /* Functions */ /* ******************************** */ /// @notice Setup the contract. These will be cloned so no constructor /// @param baseAsset_ Base asset of the system. WETH/USDC/etc /// @param underlyer_ Underlying asset the vault will wrap /// @param rewarder_ Reward tracker for this vault /// @param incentiveCalculator_ Incentive calculator for this vault /// @param additionalTrackedTokens_ Additional tokens that should be considered 'tracked' /// @param params_ Any extra parameters needed to setup the contract function initialize( IERC20 baseAsset_, IERC20 underlyer_, IMainRewarder rewarder_, address incentiveCalculator_, address[] memory additionalTrackedTokens_, bytes memory params_ ) external; function getRangePricesLP() external returns (uint256 spotPrice, uint256 safePrice, bool isSpotSafe); /// @notice Calculates the current value of a portion of the debt based on shares /// @dev Queries the current value of all tokens we have deployed, whether its a single place, multiple, staked, etc /// @param shares The number of shares to value /// @return value The current value of our debt in terms of the baseAsset function debtValue(uint256 shares) external returns (uint256 value); /// @notice Collects any earned rewards from staking, incentives, etc. Transfers to sender /// @dev Should be limited to LIQUIDATOR_MANAGER. Rewards must be collected before claimed /// @return amounts amount of rewards claimed for each token /// @return tokens tokens claimed function collectRewards() external returns (uint256[] memory amounts, address[] memory tokens); /// @notice Pull any non-tracked token to the specified destination /// @dev Should be limited to TOKEN_RECOVERY_MANAGER function recover(address[] calldata tokens, uint256[] calldata amounts, address[] calldata destinations) external; /// @notice Recovers any extra underlying both in DV and staked externally not tracked as debt. /// @dev Should be limited to TOKEN_SAVER_ROLE. /// @param destination The address to send excess underlyer to. function recoverUnderlying(address destination) external; /// @notice Deposit underlying to receive destination vault shares /// @param amount amount of base lp asset to deposit function depositUnderlying(uint256 amount) external returns (uint256 shares); /// @notice Withdraw underlying by burning destination vault shares /// @param shares amount of destination vault shares to burn /// @param to destination of the underlying asset /// @return amount underlyer amount 'to' received function withdrawUnderlying(uint256 shares, address to) external returns (uint256 amount); /// @notice Burn specified shares for underlyer swapped to base asset /// @param shares amount of vault shares to burn /// @param to destination of the base asset /// @return amount base asset amount 'to' received function withdrawBaseAsset(uint256 shares, address to) external returns (uint256 amount); /// @notice Mark this vault as shutdown so that autoPools can react function shutdown(VaultShutdownStatus reason) external; /// @notice True if the vault has been shutdown function isShutdown() external view returns (bool); /// @notice Returns the reason for shutdown (or `Active` if not shutdown) function shutdownStatus() external view returns (VaultShutdownStatus); /// @notice Stats contract for this vault function getStats() external view returns (IDexLSTStats); /// @notice get the marketplace rewards /// @return rewardTokens list of reward token addresses /// @return rewardRates list of reward rates function getMarketplaceRewards() external returns (uint256[] memory rewardTokens, uint256[] memory rewardRates); /// @notice Get the address of the underlying pool the vault points to /// @return poolAddress address of the underlying pool function getPool() external view returns (address poolAddress); /// @notice Gets the spot price of the underlying LP token /// @dev Price validated to be inside our tolerance against safe price. Will revert if outside. /// @return price Value of 1 unit of the underlying LP token in terms of the base asset function getValidatedSpotPrice() external returns (uint256 price); /// @notice Gets the safe price of the underlying LP token /// @dev Price validated to be inside our tolerance against spot price. Will revert if outside. /// @return price Value of 1 unit of the underlying LP token in terms of the base asset function getValidatedSafePrice() external returns (uint256 price); /// @notice Get the lowest price we can get for the LP token /// @dev This price can be attacked is not validate to be in any range /// @return price Value of 1 unit of the underlying LP token in terms of the base asset function getUnderlyerFloorPrice() external returns (uint256 price); /// @notice Get the highest price we can get for the LP token /// @dev This price can be attacked is not validate to be in any range /// @return price Value of 1 unit of the underlying LP token in terms of the base asset function getUnderlyerCeilingPrice() external returns (uint256 price); /// @notice Set or unset a hash as a signed message /// @dev Should be limited to DESTINATION_VAULTS_UPDATER. The set hash is used to vaildate a signature. /// This signature can be potentially used to claim offchain rewards earned by Destination Vaults. /// @param hash bytes32 hash of a payload /// @param flag boolean flag to indicate a validity of hash function setMessage(bytes32 hash, bool flag) external; }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (utils/structs/EnumerableSet.sol) // This file was procedurally generated from scripts/generate/templates/EnumerableSet.js. pragma solidity ^0.8.0; /** * @dev Library for managing * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive * types. * * Sets have the following properties: * * - Elements are added, removed, and checked for existence in constant time * (O(1)). * - Elements are enumerated in O(n). No guarantees are made on the ordering. * * ``` * contract Example { * // Add the library methods * using EnumerableSet for EnumerableSet.AddressSet; * * // Declare a set state variable * EnumerableSet.AddressSet private mySet; * } * ``` * * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`) * and `uint256` (`UintSet`) are supported. * * [WARNING] * ==== * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure * unusable. * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info. * * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an * array of EnumerableSet. * ==== */ library EnumerableSet { // To implement this library for multiple types with as little code // repetition as possible, we write it in terms of a generic Set type with // bytes32 values. // The Set implementation uses private functions, and user-facing // implementations (such as AddressSet) are just wrappers around the // underlying Set. // This means that we can only create new EnumerableSets for types that fit // in bytes32. struct Set { // Storage of set values bytes32[] _values; // Position of the value in the `values` array, plus 1 because index 0 // means a value is not in the set. mapping(bytes32 => uint256) _indexes; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function _add(Set storage set, bytes32 value) private returns (bool) { if (!_contains(set, value)) { set._values.push(value); // The value is stored at length-1, but we add 1 to all indexes // and use 0 as a sentinel value set._indexes[value] = set._values.length; return true; } else { return false; } } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function _remove(Set storage set, bytes32 value) private returns (bool) { // We read and store the value's index to prevent multiple reads from the same storage slot uint256 valueIndex = set._indexes[value]; if (valueIndex != 0) { // Equivalent to contains(set, value) // To delete an element from the _values array in O(1), we swap the element to delete with the last one in // the array, and then remove the last element (sometimes called as 'swap and pop'). // This modifies the order of the array, as noted in {at}. uint256 toDeleteIndex = valueIndex - 1; uint256 lastIndex = set._values.length - 1; if (lastIndex != toDeleteIndex) { bytes32 lastValue = set._values[lastIndex]; // Move the last value to the index where the value to delete is set._values[toDeleteIndex] = lastValue; // Update the index for the moved value set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex } // Delete the slot where the moved value was stored set._values.pop(); // Delete the index for the deleted slot delete set._indexes[value]; return true; } else { return false; } } /** * @dev Returns true if the value is in the set. O(1). */ function _contains(Set storage set, bytes32 value) private view returns (bool) { return set._indexes[value] != 0; } /** * @dev Returns the number of values on the set. O(1). */ function _length(Set storage set) private view returns (uint256) { return set._values.length; } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function _at(Set storage set, uint256 index) private view returns (bytes32) { return set._values[index]; } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function _values(Set storage set) private view returns (bytes32[] memory) { return set._values; } // Bytes32Set struct Bytes32Set { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _add(set._inner, value); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _remove(set._inner, value); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) { return _contains(set._inner, value); } /** * @dev Returns the number of values in the set. O(1). */ function length(Bytes32Set storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) { return _at(set._inner, index); } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function values(Bytes32Set storage set) internal view returns (bytes32[] memory) { bytes32[] memory store = _values(set._inner); bytes32[] memory result; /// @solidity memory-safe-assembly assembly { result := store } return result; } // AddressSet struct AddressSet { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(AddressSet storage set, address value) internal returns (bool) { return _add(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(AddressSet storage set, address value) internal returns (bool) { return _remove(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(AddressSet storage set, address value) internal view returns (bool) { return _contains(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Returns the number of values in the set. O(1). */ function length(AddressSet storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(AddressSet storage set, uint256 index) internal view returns (address) { return address(uint160(uint256(_at(set._inner, index)))); } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function values(AddressSet storage set) internal view returns (address[] memory) { bytes32[] memory store = _values(set._inner); address[] memory result; /// @solidity memory-safe-assembly assembly { result := store } return result; } // UintSet struct UintSet { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(UintSet storage set, uint256 value) internal returns (bool) { return _add(set._inner, bytes32(value)); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(UintSet storage set, uint256 value) internal returns (bool) { return _remove(set._inner, bytes32(value)); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(UintSet storage set, uint256 value) internal view returns (bool) { return _contains(set._inner, bytes32(value)); } /** * @dev Returns the number of values in the set. O(1). */ function length(UintSet storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(UintSet storage set, uint256 index) internal view returns (uint256) { return uint256(_at(set._inner, index)); } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function values(UintSet storage set) internal view returns (uint256[] memory) { bytes32[] memory store = _values(set._inner); uint256[] memory result; /// @solidity memory-safe-assembly assembly { result := store } return result; } }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { IERC3156FlashBorrower } from "openzeppelin-contracts/interfaces/IERC3156FlashBorrower.sol"; interface IStrategy { /* ******************************** */ /* Events */ /* ******************************** */ event DestinationVaultAdded(address destination); event DestinationVaultRemoved(address destination); event WithdrawalQueueSet(address[] destinations); event AddedToRemovalQueue(address destination); event RemovedFromRemovalQueue(address destination); error InvalidDestinationVault(); error RebalanceFailed(string message); /// @notice gets the list of supported destination vaults for the Autopool/Strategy /// @return _destinations List of supported destination vaults function getDestinations() external view returns (address[] memory _destinations); /// @notice add supported destination vaults for the Autopool/Strategy /// @param _destinations The list of destination vaults to add function addDestinations(address[] calldata _destinations) external; /// @notice remove supported destination vaults for the Autopool/Strategy /// @param _destinations The list of destination vaults to remove function removeDestinations(address[] calldata _destinations) external; /// @param destinationIn The address / lp token of the destination vault that will increase /// @param tokenIn The address of the underlyer token that will be provided by the swapper /// @param amountIn The amount of the underlying LP tokens that will be received /// @param destinationOut The address of the destination vault that will decrease /// @param tokenOut The address of the underlyer token that will be received by the swapper /// @param amountOut The amount of the tokenOut that will be received by the swapper struct RebalanceParams { address destinationIn; address tokenIn; uint256 amountIn; address destinationOut; address tokenOut; uint256 amountOut; } /// @param destination The address / lp token of the destination vault /// @param baseApr Base Apr is the yield generated by staking rewards /// @param feeApr Yield for pool trading fees /// @param incentiveApr Incentives for LP /// @param safeTotalSupply Safe supply for LP tokens /// @param priceReturn Return from price movement to & away from peg /// @param maxDiscount Max discount to peg /// @param maxPremium Max premium to peg /// @param ownedShares Shares owned for this destination /// @param compositeReturn Total return combined from the individual yield components /// @param pricePerShare Price per share /// @param slashingCost The loss due to slashing of the backing struct SummaryStats { address destination; uint256 baseApr; uint256 feeApr; uint256 incentiveApr; uint256 safeTotalSupply; int256 priceReturn; int256 maxDiscount; int256 maxPremium; uint256 ownedShares; int256 compositeReturn; uint256 pricePerShare; uint256 slashingCost; } /// @notice rebalance the Autopool from the tokenOut (decrease) to the tokenIn (increase) /// This uses a flash loan to receive the tokenOut to reduce the working capital requirements of the swapper /// @param receiver The contract receiving the tokens, needs to implement the /// `onFlashLoan(address user, address token, uint256 amount, uint256 fee, bytes calldata)` interface /// @param params Parameters by which to perform the rebalance /// @param data A data parameter to be passed on to the `receiver` for any custom use function flashRebalance( IERC3156FlashBorrower receiver, RebalanceParams calldata params, bytes calldata data ) external; }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/utils/SafeERC20.sol) pragma solidity ^0.8.0; import "../IERC20.sol"; import "../extensions/draft-IERC20Permit.sol"; import "../../../utils/Address.sol"; /** * @title SafeERC20 * @dev Wrappers around ERC20 operations that throw on failure (when the token * contract returns false). Tokens that return no value (and instead revert or * throw on failure) are also supported, non-reverting calls are assumed to be * successful. * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract, * which allows you to call the safe operations as `token.safeTransfer(...)`, etc. */ library SafeERC20 { using Address for address; function safeTransfer( IERC20 token, address to, uint256 value ) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom( IERC20 token, address from, address to, uint256 value ) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } /** * @dev Deprecated. This function has issues similar to the ones found in * {IERC20-approve}, and its usage is discouraged. * * Whenever possible, use {safeIncreaseAllowance} and * {safeDecreaseAllowance} instead. */ function safeApprove( IERC20 token, address spender, uint256 value ) internal { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' require( (value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance" ); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function safeIncreaseAllowance( IERC20 token, address spender, uint256 value ) internal { uint256 newAllowance = token.allowance(address(this), spender) + value; _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance( IERC20 token, address spender, uint256 value ) internal { unchecked { uint256 oldAllowance = token.allowance(address(this), spender); require(oldAllowance >= value, "SafeERC20: decreased allowance below zero"); uint256 newAllowance = oldAllowance - value; _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } } function safePermit( IERC20Permit token, address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) internal { uint256 nonceBefore = token.nonces(owner); token.permit(owner, spender, value, deadline, v, r, s); uint256 nonceAfter = token.nonces(owner); require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed"); } /** * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement * on the return value: the return value is optional (but if data is returned, it must not be false). * @param token The token targeted by the call. * @param data The call data (encoded using abi.encode or one of its variants). */ function _callOptionalReturn(IERC20 token, bytes memory data) private { // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that // the target address contains contract code and also asserts for success in the low-level call. bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed"); if (returndata.length > 0) { // Return data is optional require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.7.0) (interfaces/IERC3156FlashBorrower.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC3156 FlashBorrower, as defined in * https://eips.ethereum.org/EIPS/eip-3156[ERC-3156]. * * _Available since v4.1._ */ interface IERC3156FlashBorrower { /** * @dev Receive a flash loan. * @param initiator The initiator of the loan. * @param token The loan currency. * @param amount The amount of tokens lent. * @param fee The additional amount of tokens to repay. * @param data Arbitrary data structure, intended to contain user-defined parameters. * @return The keccak256 hash of "IERC3156FlashBorrower.onFlashLoan" */ function onFlashLoan( address initiator, address token, uint256 amount, uint256 fee, bytes calldata data ) external returns (bytes32); }
// SPDX-License-Identifier: MIT pragma solidity =0.8.17; /** * @title StructuredLinkedList * @author Vittorio Minacori (https://github.com/vittominacori) * @dev An utility library for using sorted linked list data structures in your Solidity project. * @notice Adapted from * https://github.com/Layr-Labs/eigenlayer-contracts/blob/master/src/contracts/libraries/StructuredLinkedList.sol */ library StructuredLinkedList { uint256 private constant _NULL = 0; uint256 private constant _HEAD = 0; bool private constant _PREV = false; bool private constant _NEXT = true; struct List { uint256 size; mapping(uint256 => mapping(bool => uint256)) list; } /** * @dev Checks if the list exists * @param self stored linked list from contract * @return bool true if list exists, false otherwise */ function listExists(List storage self) public view returns (bool) { // if the head nodes previous or next pointers both point to itself, then there are no items in the list if (self.list[_HEAD][_PREV] != _HEAD || self.list[_HEAD][_NEXT] != _HEAD) { return true; } else { return false; } } /** * @dev Checks if the node exists * @param self stored linked list from contract * @param _node a node to search for * @return bool true if node exists, false otherwise */ function nodeExists(List storage self, uint256 _node) public view returns (bool) { if (self.list[_node][_PREV] == _HEAD && self.list[_node][_NEXT] == _HEAD) { if (self.list[_HEAD][_NEXT] == _node) { return true; } else { return false; } } else { return true; } } /** * @dev Returns the number of elements in the list * @param self stored linked list from contract * @return uint256 */ // slither-disable-next-line dead-code function sizeOf(List storage self) public view returns (uint256) { return self.size; } /** * @dev Gets the head of the list * @param self stored linked list from contract * @return uint256 the head of the list */ function getHead(List storage self) public view returns (uint256) { return self.list[_HEAD][_NEXT]; } /** * @dev Gets the head of the list * @param self stored linked list from contract * @return uint256 the head of the list */ function getTail(List storage self) public view returns (uint256) { return self.list[_HEAD][_PREV]; } /** * @dev Returns the links of a node as a tuple * @param self stored linked list from contract * @param _node id of the node to get * @return bool, uint256, uint256 true if node exists or false otherwise, previous node, next node */ // slither-disable-next-line dead-code function getNode(List storage self, uint256 _node) public view returns (bool, uint256, uint256) { if (!nodeExists(self, _node)) { return (false, 0, 0); } else { return (true, self.list[_node][_PREV], self.list[_node][_NEXT]); } } /** * @dev Returns the link of a node `_node` in direction `_direction`. * @param self stored linked list from contract * @param _node id of the node to step from * @param _direction direction to step in * @return bool, uint256 true if node exists or false otherwise, node in _direction */ // slither-disable-next-line dead-code function getAdjacent(List storage self, uint256 _node, bool _direction) public view returns (bool, uint256) { if (!nodeExists(self, _node)) { return (false, 0); } else { uint256 adjacent = self.list[_node][_direction]; return (adjacent != _HEAD, adjacent); } } /** * @dev Returns the link of a node `_node` in direction `_NEXT`. * @param self stored linked list from contract * @param _node id of the node to step from * @return bool, uint256 true if node exists or false otherwise, next node */ // slither-disable-next-line dead-code function getNextNode(List storage self, uint256 _node) public view returns (bool, uint256) { return getAdjacent(self, _node, _NEXT); } /** * @dev Returns the link of a node `_node` in direction `_PREV`. * @param self stored linked list from contract * @param _node id of the node to step from * @return bool, uint256 true if node exists or false otherwise, previous node */ // slither-disable-next-line dead-code function getPreviousNode(List storage self, uint256 _node) public view returns (bool, uint256) { return getAdjacent(self, _node, _PREV); } /** * @dev Insert node `_new` beside existing node `_node` in direction `_NEXT`. * @param self stored linked list from contract * @param _node existing node * @param _new new node to insert * @return bool true if success, false otherwise */ // slither-disable-next-line dead-code function insertAfter(List storage self, uint256 _node, uint256 _new) public returns (bool) { return _insert(self, _node, _new, _NEXT); } /** * @dev Insert node `_new` beside existing node `_node` in direction `_PREV`. * @param self stored linked list from contract * @param _node existing node * @param _new new node to insert * @return bool true if success, false otherwise */ // slither-disable-next-line dead-code function insertBefore(List storage self, uint256 _node, uint256 _new) public returns (bool) { return _insert(self, _node, _new, _PREV); } /** * @dev Removes an entry from the linked list * @param self stored linked list from contract * @param _node node to remove from the list * @return uint256 the removed node */ function remove(List storage self, uint256 _node) public returns (uint256) { if ((_node == _NULL) || (!nodeExists(self, _node))) { return 0; } _createLink(self, self.list[_node][_PREV], self.list[_node][_NEXT], _NEXT); delete self.list[_node][_PREV]; delete self.list[_node][_NEXT]; self.size -= 1; return _node; } /** * @dev Pushes an entry to the head of the linked list * @param self stored linked list from contract * @param _node new entry to push to the head * @return bool true if success, false otherwise */ function pushFront(List storage self, uint256 _node) public returns (bool) { return _push(self, _node, _NEXT); } /** * @dev Pushes an entry to the tail of the linked list * @param self stored linked list from contract * @param _node new entry to push to the tail * @return bool true if success, false otherwise */ function pushBack(List storage self, uint256 _node) public returns (bool) { return _push(self, _node, _PREV); } /** * @dev Pops the first entry from the head of the linked list * @param self stored linked list from contract * @return uint256 the removed node */ // slither-disable-next-line dead-code function popFront(List storage self) public returns (uint256) { return _pop(self, _NEXT); } /** * @dev Pops the first entry from the tail of the linked list * @param self stored linked list from contract * @return uint256 the removed node */ // slither-disable-next-line dead-code function popBack(List storage self) public returns (uint256) { return _pop(self, _PREV); } /** * @dev Pushes an entry to the head of the linked list * @param self stored linked list from contract * @param _node new entry to push to the head * @param _direction push to the head (_NEXT) or tail (_PREV) * @return bool true if success, false otherwise */ function _push(List storage self, uint256 _node, bool _direction) private returns (bool) { return _insert(self, _HEAD, _node, _direction); } /** * @dev Pops the first entry from the linked list * @param self stored linked list from contract * @param _direction pop from the head (_NEXT) or the tail (_PREV) * @return uint256 the removed node */ // slither-disable-next-line dead-code function _pop(List storage self, bool _direction) private returns (uint256) { uint256 adj; (, adj) = getAdjacent(self, _HEAD, _direction); return remove(self, adj); } /** * @dev Insert node `_new` beside existing node `_node` in direction `_direction`. * @param self stored linked list from contract * @param _node existing node * @param _new new node to insert * @param _direction direction to insert node in * @return bool true if success, false otherwise */ function _insert(List storage self, uint256 _node, uint256 _new, bool _direction) private returns (bool) { if (!nodeExists(self, _new) && nodeExists(self, _node)) { uint256 c = self.list[_node][_direction]; _createLink(self, _node, _new, _direction); _createLink(self, _new, c, _direction); self.size += 1; return true; } return false; } /** * @dev Creates a bidirectional link between two nodes on direction `_direction` * @param self stored linked list from contract * @param _node existing node * @param _link node to link to in the _direction * @param _direction direction to insert node in */ function _createLink(List storage self, uint256 _node, uint256 _link, bool _direction) private { self.list[_link][!_direction] = _node; self.list[_node][_direction] = _link; } }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; // their version was using 8.12? import { StructuredLinkedList } from "src/strategy/StructuredLinkedList.sol"; // https://github.com/Layr-Labs/eigenlayer-contracts/blob/master/src/contracts/libraries/StructuredLinkedList.sol library WithdrawalQueue { using StructuredLinkedList for StructuredLinkedList.List; error CannotInsertZeroAddress(); error UnexpectedNodeRemoved(); error AddToHeadFailed(); error AddToTailFailed(); error NodeDoesNotExist(); /// @notice Returns true if the address is in the queue. function addressExists(StructuredLinkedList.List storage queue, address addr) public view returns (bool) { return StructuredLinkedList.nodeExists(queue, _addressToUint(addr)); } /// @notice Returns the current head. function peekHead(StructuredLinkedList.List storage queue) public view returns (address) { return _uintToAddress(StructuredLinkedList.getHead(queue)); } /// @notice Returns the current tail. function peekTail(StructuredLinkedList.List storage queue) public view returns (address) { return _uintToAddress(StructuredLinkedList.getTail(queue)); } /// @notice Returns the number of items in the queue function sizeOf(StructuredLinkedList.List storage queue) public view returns (uint256) { return StructuredLinkedList.sizeOf(queue); } /// @notice Return all items in the queue /// @dev Enumerates from head to tail function getList(StructuredLinkedList.List storage self) public view returns (address[] memory list) { uint256 size = self.sizeOf(); list = new address[](size); if (size > 0) { uint256 lastNode = self.getHead(); list[0] = _uintToAddress(lastNode); for (uint256 i = 1; i < size; ++i) { (bool exists, uint256 node) = self.getAdjacent(lastNode, true); if (!exists) { revert NodeDoesNotExist(); } list[i] = _uintToAddress(node); lastNode = node; } } } /// @notice Returns the current tail. function popHead(StructuredLinkedList.List storage queue) public returns (address) { return _uintToAddress(StructuredLinkedList.popFront(queue)); } /// @notice remove address toRemove from queue if it exists. function popAddress(StructuredLinkedList.List storage queue, address toRemove) public { uint256 addrAsUint = _addressToUint(toRemove); uint256 _removedNode = StructuredLinkedList.remove(queue, addrAsUint); if (!((_removedNode == addrAsUint) || (_removedNode == 0))) { revert UnexpectedNodeRemoved(); } } /// @notice returns true if there are no addresses in queue. function isEmpty(StructuredLinkedList.List storage queue) public view returns (bool) { return !StructuredLinkedList.listExists(queue); } /// @notice if addr in queue, move it to the top // if addr not in queue, add it to the top of the queue. // if queue is empty, make a new queue with addr as the only node function addToHead(StructuredLinkedList.List storage queue, address addr) public { if (addr == address(0)) { revert CannotInsertZeroAddress(); } popAddress(queue, addr); bool success = StructuredLinkedList.pushFront(queue, _addressToUint(addr)); if (!success) { revert AddToHeadFailed(); } } function getAdjacent( StructuredLinkedList.List storage queue, address addr, bool direction ) public view returns (address) { (bool exists, uint256 addrNum) = queue.getAdjacent(_addressToUint(addr), direction); if (!exists) { return address(0); } return _uintToAddress(addrNum); } /// @notice if addr in queue, move it to the end // if addr not in queue, add it to the end of the queue. // if queue is empty, make a new queue with addr as the only node function addToTail(StructuredLinkedList.List storage queue, address addr) public { if (addr == address(0)) { revert CannotInsertZeroAddress(); } popAddress(queue, addr); bool success = StructuredLinkedList.pushBack(queue, _addressToUint(addr)); if (!success) { revert AddToTailFailed(); } } function _addressToUint(address addr) private pure returns (uint256) { return uint256(uint160(addr)); } function _uintToAddress(uint256 x) private pure returns (address) { return address(uint160(x)); } }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { ECDSA } from "openzeppelin-contracts/utils/cryptography/ECDSA.sol"; import { IERC20Permit } from "openzeppelin-contracts/token/ERC20/extensions/draft-IERC20Permit.sol"; /// @notice ERC20 token functionality converted into a library. Based on OZ's v5 /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.0.1/contracts/token/ERC20/ERC20.sol library AutopoolToken { struct TokenData { /// @notice Token balances /// @dev account => balance mapping(address => uint256) balances; /// @notice Account spender allowances /// @dev account => spender => allowance mapping(address => mapping(address => uint256)) allowances; /// @notice Total supply of the pool. Be careful when using this directly from the struct. The pool itself /// modifies this number based on unlocked profited shares uint256 totalSupply; /// @notice ERC20 Permit nonces /// @dev account -> nonce. Exposed via `nonces(owner)` mapping(address => uint256) nonces; } /// @notice EIP2612 permit type hash bytes32 public constant PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"); /// @notice EIP712 domain type hash bytes32 public constant TYPE_HASH = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"); /// @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 Permit deadline has expired. error ERC2612ExpiredSignature(uint256 deadline); /// @dev Mismatched signature. error ERC2612InvalidSigner(address signer, address owner); /// @dev The nonce used for an `account` is not the expected current nonce. error InvalidAccountNonce(address account, uint256 currentNonce); /// @dev Emitted when `value` tokens are moved from one account `from` to another `to`. 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 Sets a `value` amount of tokens as the allowance of `spender` over the caller's tokens. function approve(TokenData storage data, address spender, uint256 value) external returns (bool) { address owner = msg.sender; approve(data, owner, spender, value); return true; } /// @dev Sets `value` as the allowance of `spender` over the `owner` s tokens. function approve(TokenData storage data, address owner, address spender, uint256 value) public { _approve(data, owner, spender, value, true); } function transfer(TokenData storage data, address to, uint256 value) external returns (bool) { address owner = msg.sender; _transfer(data, owner, to, value); return true; } /// @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism. /// value` is then deducted from the caller's allowance. function transferFrom(TokenData storage data, address from, address to, uint256 value) external returns (bool) { address spender = msg.sender; _spendAllowance(data, from, spender, value); _transfer(data, from, to, value); return true; } /// @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0). function mint(TokenData storage data, address account, uint256 value) external { if (account == address(0)) { revert ERC20InvalidReceiver(address(0)); } _update(data, address(0), account, value); } /// @dev Destroys a `value` amount of tokens from `account`, lowering the total supply. function burn(TokenData storage data, address account, uint256 value) external { if (account == address(0)) { revert ERC20InvalidSender(address(0)); } _update(data, account, address(0), value); } function permit( TokenData storage data, address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) external { if (block.timestamp > deadline) { revert ERC2612ExpiredSignature(deadline); } uint256 nonce; // For each account, the nonce has an initial value of 0, can only be incremented by one, and cannot be // decremented or reset. This guarantees that the nonce never overflows. unchecked { // It is important to do x++ and not ++x here. Nonces starts at 0 nonce = data.nonces[owner]++; } bytes32 structHash = keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, nonce, deadline)); bytes32 hash = ECDSA.toTypedDataHash(IERC20Permit(address(this)).DOMAIN_SEPARATOR(), structHash); address signer = ECDSA.recover(hash, v, r, s); if (signer != owner) { revert ERC2612InvalidSigner(signer, owner); } approve(data, owner, spender, value); } /// @dev Moves a `value` amount of tokens from `from` to `to`. function _transfer(TokenData storage data, address from, address to, uint256 value) private { if (from == address(0)) { revert ERC20InvalidSender(address(0)); } if (to == address(0)) { revert ERC20InvalidReceiver(address(0)); } _update(data, from, to, value); } /// @dev Updates `owner` s allowance for `spender` based on spent `value`. function _spendAllowance(TokenData storage data, address owner, address spender, uint256 value) private { uint256 currentAllowance = data.allowances[owner][spender]; if (currentAllowance != type(uint256).max) { if (currentAllowance < value) { revert ERC20InsufficientAllowance(spender, currentAllowance, value); } unchecked { _approve(data, owner, spender, currentAllowance - value, false); } } } /// @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from` /// (or `to`) is the zero address. function _update(TokenData storage data, address from, address to, uint256 value) private { if (from == address(0)) { // Overflow check required: The rest of the code assumes that totalSupply never overflows data.totalSupply += value; } else { uint256 fromBalance = data.balances[from]; if (fromBalance < value) { revert ERC20InsufficientBalance(from, fromBalance, value); } unchecked { // Overflow not possible: value <= fromBalance <= totalSupply. data.balances[from] = fromBalance - value; } } if (to == address(0)) { unchecked { // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply. data.totalSupply -= value; } } else { unchecked { // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256. data.balances[to] += value; } } emit Transfer(from, to, value); } /// @dev Variant of `_approve` with an optional flag to enable or disable the Approval event. function _approve(TokenData storage data, address owner, address spender, uint256 value, bool emitEvent) private { if (owner == address(0)) { revert ERC20InvalidApprover(address(0)); } if (spender == address(0)) { revert ERC20InvalidSpender(address(0)); } data.allowances[owner][spender] = value; if (emitEvent) { emit Approval(owner, spender, value); } } }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; interface IBaseRewarder { event RewardAdded( uint256 reward, uint256 rewardRate, uint256 lastUpdateBlock, uint256 periodInBlockFinish, uint256 historicalRewards ); event UserRewardUpdated( address indexed user, uint256 amount, uint256 rewardPerTokenStored, uint256 lastUpdateBlock ); event Staked(address indexed user, uint256 amount); event Withdrawn(address indexed user, uint256 amount); event RewardPaid(address indexed user, uint256 reward); event QueuedRewardsUpdated(uint256 startingQueuedRewards, uint256 startingNewRewards, uint256 queuedRewards); event AddedToWhitelist(address indexed wallet); event RemovedFromWhitelist(address indexed wallet); event TokeLockDurationUpdated(uint256 newDuration); /** * @notice Claims and transfers all rewards for the specified account */ function getReward() external; /** * @notice Stakes the specified amount of tokens for the specified account. * @param account The address of the account to stake tokens for. * @param amount The amount of tokens to stake. */ function stake(address account, uint256 amount) external; /** * @notice Calculate the earned rewards for an account. * @param account Address of the account. * @return The earned rewards for the given account. */ function earned(address account) external view returns (uint256); /** * @notice Calculates the rewards per token for the current block. * @dev The total amount of rewards available in the system is fixed, and it needs to be distributed among the users * based on their token balances and staking duration. * Rewards per token represent the amount of rewards that each token is entitled to receive at the current block. * The calculation takes into account the reward rate, the time duration since the last update, * and the total supply of tokens in the staking pool. * @return The updated rewards per token value for the current block. */ function rewardPerToken() external view returns (uint256); /** * @notice Get the current reward rate per block. * @return The current reward rate per block. */ function rewardRate() external view returns (uint256); /** * @notice Get the current TOKE lock duration. * @return The current TOKE lock duration. */ function tokeLockDuration() external view returns (uint256); /** * @notice Get the last block where rewards are applicable. * @return The last block number where rewards are applicable. */ function lastBlockRewardApplicable() external view returns (uint256); /** * @notice The total amount of tokens staked */ function totalSupply() external view returns (uint256); /** * @notice The amount of tokens staked for the specified account * @param account The address of the account to get the balance of */ function balanceOf(address account) external view returns (uint256); /** * @notice Queue new rewards to be distributed. * @param newRewards The amount of new rewards to be queued. */ function queueNewRewards(uint256 newRewards) external; /** * @notice Token distributed as rewards * @return reward token address */ function rewardToken() external view returns (address); /** * @notice Add an address to the whitelist. * @param wallet The address to be added to the whitelist. */ function addToWhitelist(address wallet) external; /** * @notice Remove an address from the whitelist. * @param wallet The address to be removed from the whitelist. */ function removeFromWhitelist(address wallet) external; /** * @notice Check if an address is whitelisted. * @param wallet The address to be checked. * @return bool indicating if the address is whitelisted. */ function isWhitelisted(address wallet) external view returns (bool); }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { IBaseRewarder } from "src/interfaces/rewarders/IBaseRewarder.sol"; interface IExtraRewarder is IBaseRewarder { /** * @notice Withdraws the specified amount of tokens from the vault for the specified account. * @param account The address of the account to withdraw tokens for. * @param amount The amount of tokens to withdraw. */ function withdraw(address account, uint256 amount) external; /** * @notice Claims and transfers all rewards for the specified account from this contract. * @param account The address of the account to claim rewards for. */ function getReward(address account) external; }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; interface IBaseAssetVault { /// @notice Asset that this Vault primarily manages /// @dev Vault decimals should be the same as the baseAsset function baseAsset() external view returns (address); }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; import { ILSTStats } from "src/interfaces/stats/ILSTStats.sol"; /// @title Return stats DEXs with LSTs interface IDexLSTStats { event DexSnapshotTaken(uint256 snapshotTimestamp, uint256 priorFeeApr, uint256 newFeeApr, uint256 unfilteredFeeApr); struct StakingIncentiveStats { // time-weighted average total supply to prevent spikes/attacks from impacting rebalancing uint256 safeTotalSupply; // rewardTokens, annualizedRewardAmounts, and periodFinishForRewards will match indexes // they are split to workaround an issue with forge having nested structs // address of the reward tokens address[] rewardTokens; // the annualized reward rate for the reward token uint256[] annualizedRewardAmounts; // the timestamp for when the rewards are set to terminate uint40[] periodFinishForRewards; // incentive rewards score. max 48, min 0 uint8 incentiveCredits; } struct DexLSTStatsData { uint256 lastSnapshotTimestamp; uint256 feeApr; uint256[] reservesInEth; StakingIncentiveStats stakingIncentiveStats; ILSTStats.LSTStatsData[] lstStatsData; } /// @notice Get the current stats for the DEX with underlying LST tokens /// @dev Returned data is a combination of current data and filtered snapshots /// @return dexLSTStatsData current data on the DEX function current() external returns (DexLSTStatsData memory dexLSTStatsData); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/ECDSA.sol) pragma solidity ^0.8.0; import "../Strings.sol"; /** * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations. * * These functions can be used to verify that a message was signed by the holder * of the private keys of a given address. */ library ECDSA { enum RecoverError { NoError, InvalidSignature, InvalidSignatureLength, InvalidSignatureS, InvalidSignatureV // Deprecated in v4.8 } function _throwError(RecoverError error) private pure { if (error == RecoverError.NoError) { return; // no error: do nothing } else if (error == RecoverError.InvalidSignature) { revert("ECDSA: invalid signature"); } else if (error == RecoverError.InvalidSignatureLength) { revert("ECDSA: invalid signature length"); } else if (error == RecoverError.InvalidSignatureS) { revert("ECDSA: invalid signature 's' value"); } } /** * @dev Returns the address that signed a hashed message (`hash`) with * `signature` or error string. This address can then be used for verification purposes. * * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures: * this function rejects them by requiring the `s` value to be in the lower * half order, and the `v` value to be either 27 or 28. * * IMPORTANT: `hash` _must_ be the result of a hash operation for the * verification to be secure: it is possible to craft signatures that * recover to arbitrary addresses for non-hashed data. A safe way to ensure * this is by receiving a hash of the original message (which may otherwise * be too long), and then calling {toEthSignedMessageHash} on it. * * Documentation for signature generation: * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js] * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers] * * _Available since v4.3._ */ function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) { if (signature.length == 65) { bytes32 r; bytes32 s; uint8 v; // ecrecover takes the signature parameters, and the only way to get them // currently is to use assembly. /// @solidity memory-safe-assembly assembly { r := mload(add(signature, 0x20)) s := mload(add(signature, 0x40)) v := byte(0, mload(add(signature, 0x60))) } return tryRecover(hash, v, r, s); } else { return (address(0), RecoverError.InvalidSignatureLength); } } /** * @dev Returns the address that signed a hashed message (`hash`) with * `signature`. This address can then be used for verification purposes. * * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures: * this function rejects them by requiring the `s` value to be in the lower * half order, and the `v` value to be either 27 or 28. * * IMPORTANT: `hash` _must_ be the result of a hash operation for the * verification to be secure: it is possible to craft signatures that * recover to arbitrary addresses for non-hashed data. A safe way to ensure * this is by receiving a hash of the original message (which may otherwise * be too long), and then calling {toEthSignedMessageHash} on it. */ function recover(bytes32 hash, bytes memory signature) internal pure returns (address) { (address recovered, RecoverError error) = tryRecover(hash, signature); _throwError(error); return recovered; } /** * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately. * * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures] * * _Available since v4.3._ */ function tryRecover( bytes32 hash, bytes32 r, bytes32 vs ) internal pure returns (address, RecoverError) { bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); uint8 v = uint8((uint256(vs) >> 255) + 27); return tryRecover(hash, v, r, s); } /** * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately. * * _Available since v4.2._ */ function recover( bytes32 hash, bytes32 r, bytes32 vs ) internal pure returns (address) { (address recovered, RecoverError error) = tryRecover(hash, r, vs); _throwError(error); return recovered; } /** * @dev Overload of {ECDSA-tryRecover} that receives the `v`, * `r` and `s` signature fields separately. * * _Available since v4.3._ */ function tryRecover( bytes32 hash, uint8 v, bytes32 r, bytes32 s ) internal pure returns (address, RecoverError) { // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most // signatures from current libraries generate a unique signature with an s-value in the lower half order. // // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept // these malleable signatures as well. if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) { return (address(0), RecoverError.InvalidSignatureS); } // If the signature is valid (and not malleable), return the signer address address signer = ecrecover(hash, v, r, s); if (signer == address(0)) { return (address(0), RecoverError.InvalidSignature); } return (signer, RecoverError.NoError); } /** * @dev Overload of {ECDSA-recover} that receives the `v`, * `r` and `s` signature fields separately. */ function recover( bytes32 hash, uint8 v, bytes32 r, bytes32 s ) internal pure returns (address) { (address recovered, RecoverError error) = tryRecover(hash, v, r, s); _throwError(error); return recovered; } /** * @dev Returns an Ethereum Signed Message, created from a `hash`. This * produces hash corresponding to the one signed with the * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] * JSON-RPC method as part of EIP-191. * * See {recover}. */ function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) { // 32 is the length in bytes of hash, // enforced by the type signature above return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash)); } /** * @dev Returns an Ethereum Signed Message, created from `s`. This * produces hash corresponding to the one signed with the * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] * JSON-RPC method as part of EIP-191. * * See {recover}. */ function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) { return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s)); } /** * @dev Returns an Ethereum Signed Typed Data, created from a * `domainSeparator` and a `structHash`. This produces hash corresponding * to the one signed with the * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`] * JSON-RPC method as part of EIP-712. * * See {recover}. */ function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) { return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash)); } }
// SPDX-License-Identifier: UNLICENSED // Copyright (c) 2023 Tokemak Foundation. All rights reserved. pragma solidity 0.8.17; /// @title Return stats on base LSTs interface ILSTStats { struct LSTStatsData { uint256 lastSnapshotTimestamp; uint256 baseApr; int256 discount; // positive number is a discount, negative is a premium uint24[10] discountHistory; // 7 decimal precision uint40[5] discountTimestampByPercent; // each index is the timestamp that the token reached that discount uint256[] slashingCosts; uint256[] slashingTimestamps; } /// @notice Get the current stats for the LST /// @dev Returned data is a combination of current data and filtered snapshots /// @return lstStatsData current data on the LST function current() external returns (LSTStatsData memory lstStatsData); /// @notice Get the EthPerToken (or Share) for the LST /// @return ethPerShare the backing eth for the LST function calculateEthPerToken() external view returns (uint256 ethPerShare); /// @notice Get if the underlying LST token is rebasing /// @return rebasing is true if the lst is a rebasing token function isRebasing() external view returns (bool rebasing); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol) pragma solidity ^0.8.0; import "./math/Math.sol"; /** * @dev String operations. */ library Strings { bytes16 private constant _SYMBOLS = "0123456789abcdef"; uint8 private constant _ADDRESS_LENGTH = 20; /** * @dev Converts a `uint256` to its ASCII `string` decimal representation. */ function toString(uint256 value) internal pure returns (string memory) { unchecked { uint256 length = Math.log10(value) + 1; string memory buffer = new string(length); uint256 ptr; /// @solidity memory-safe-assembly assembly { ptr := add(buffer, add(32, length)) } while (true) { ptr--; /// @solidity memory-safe-assembly assembly { mstore8(ptr, byte(mod(value, 10), _SYMBOLS)) } value /= 10; if (value == 0) break; } return buffer; } } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation. */ function toHexString(uint256 value) internal pure returns (string memory) { unchecked { return toHexString(value, Math.log256(value) + 1); } } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length. */ function toHexString(uint256 value, uint256 length) internal pure returns (string memory) { bytes memory buffer = new bytes(2 * length + 2); buffer[0] = "0"; buffer[1] = "x"; for (uint256 i = 2 * length + 1; i > 1; --i) { buffer[i] = _SYMBOLS[value & 0xf]; value >>= 4; } require(value == 0, "Strings: hex length insufficient"); return string(buffer); } /** * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation. */ function toHexString(address addr) internal pure returns (string memory) { return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH); } }
{ "remappings": [ "forge-std/=lib/forge-std/src/", "ds-test/=lib/forge-std/lib/ds-test/src/", "src/=src/", "test/=test/", "openzeppelin-contracts/=lib/openzeppelin-contracts/contracts/", "erc4626-tests/=lib/erc4626-tests/", "prb-math/=lib/prb-math/", "crytic/properties/=lib/properties/", "ERC4626/=lib/properties/lib/ERC4626/contracts/", "properties/=lib/properties/contracts/", "solmate/=lib/properties/lib/solmate/src/", "usingtellor/=lib/usingtellor/contracts/" ], "optimizer": { "enabled": true, "runs": 200 }, "metadata": { "useLiteralContent": false, "bytecodeHash": "ipfs" }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "devdoc", "userdoc", "metadata", "abi" ] } }, "evmVersion": "london", "viaIR": false, "libraries": {} }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"contract ISystemRegistry","name":"_systemRegistry","type":"address"},{"internalType":"contract IRouterClient","name":"ccipRouter","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AccessDenied","type":"error"},{"inputs":[{"internalType":"uint64","name":"chainId","type":"uint64"}],"name":"ChainNotSupported","type":"error"},{"inputs":[{"internalType":"string","name":"paramName","type":"string"}],"name":"InvalidParam","type":"error"},{"inputs":[],"name":"ItemExists","type":"error"},{"inputs":[],"name":"ItemNotFound","type":"error"},{"inputs":[{"internalType":"bytes32","name":"storedHash","type":"bytes32"},{"internalType":"bytes32","name":"currentHash","type":"bytes32"}],"name":"MismatchMessageHash","type":"error"},{"inputs":[{"internalType":"uint256","name":"available","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"NotEnoughFee","type":"error"},{"inputs":[],"name":"UndefinedAddress","type":"error"},{"inputs":[{"internalType":"string","name":"paramName","type":"string"}],"name":"ZeroAddress","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"destChainId","type":"uint256"},{"indexed":false,"internalType":"bytes32","name":"messageHash","type":"bytes32"}],"name":"DestinationChainNotRegisteredEvent","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"bytes32","name":"messageType","type":"bytes32"},{"indexed":false,"internalType":"uint64","name":"destChainSelector","type":"uint64"},{"indexed":false,"internalType":"uint192","name":"gas","type":"uint192"}],"name":"GasUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint64","name":"destChainSelector","type":"uint64"},{"indexed":false,"internalType":"bytes32","name":"messageHash","type":"bytes32"}],"name":"GetFeeFailed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"messageHash","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"messageTimestamp","type":"uint256"},{"indexed":false,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"bytes32","name":"messageType","type":"bytes32"},{"indexed":false,"internalType":"bytes","name":"message","type":"bytes"}],"name":"MessageData","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint64","name":"destChainId","type":"uint64"},{"indexed":false,"internalType":"bytes32","name":"messageHash","type":"bytes32"}],"name":"MessageFailed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint64","name":"destChainId","type":"uint64"},{"indexed":false,"internalType":"bytes32","name":"messageHash","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"currentBalance","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"feeNeeded","type":"uint256"}],"name":"MessageFailedFee","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"bytes32","name":"messageType","type":"bytes32"},{"indexed":false,"internalType":"uint64","name":"destChainSelector","type":"uint64"}],"name":"MessageRouteAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"bytes32","name":"messageType","type":"bytes32"},{"indexed":false,"internalType":"uint64","name":"destChainSelector","type":"uint64"}],"name":"MessageRouteDeleted","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint64","name":"destChainSelector","type":"uint64"},{"indexed":false,"internalType":"bytes32","name":"messageHash","type":"bytes32"},{"indexed":false,"internalType":"bytes32","name":"ccipMessageId","type":"bytes32"}],"name":"MessageSent","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"messageSender","type":"address"},{"indexed":false,"internalType":"bytes32","name":"messageType","type":"bytes32"}],"name":"MessageZeroLength","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint64","name":"destChainSelector","type":"uint64"},{"indexed":false,"internalType":"address","name":"destinationChainReceiver","type":"address"}],"name":"ReceiverRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint64","name":"destChainSelector","type":"uint64"},{"indexed":false,"internalType":"address","name":"destinationChainReceiver","type":"address"}],"name":"ReceiverSet","type":"event"},{"inputs":[],"name":"accessController","outputs":[{"internalType":"contract IAccessController","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"bytes32","name":"messageType","type":"bytes32"},{"components":[{"internalType":"uint64","name":"destinationChainSelector","type":"uint64"},{"internalType":"uint192","name":"gas","type":"uint192"}],"internalType":"struct MessageProxy.MessageRouteConfig[]","name":"routes","type":"tuple[]"}],"name":"addMessageRoutes","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint64","name":"","type":"uint64"}],"name":"destinationChainReceivers","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"messageSender","type":"address"},{"internalType":"bytes32","name":"messageType","type":"bytes32"},{"internalType":"bytes","name":"message","type":"bytes"}],"name":"getFee","outputs":[{"internalType":"uint64[]","name":"chains","type":"uint64[]"},{"internalType":"uint256[]","name":"fees","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"bytes32","name":"messageType","type":"bytes32"}],"name":"getMessageRoutes","outputs":[{"components":[{"internalType":"uint64","name":"destinationChainSelector","type":"uint64"},{"internalType":"uint192","name":"gas","type":"uint192"}],"internalType":"struct MessageProxy.MessageRouteConfig[]","name":"routes","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getSystemRegistry","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"lastMessageSent","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"bytes32","name":"messageType","type":"bytes32"},{"internalType":"uint64[]","name":"chainSelectors","type":"uint64[]"}],"name":"removeMessageRoutes","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"msgSender","type":"address"},{"internalType":"bytes32","name":"messageType","type":"bytes32"},{"internalType":"uint256","name":"messageRetryTimestamp","type":"uint256"},{"internalType":"bytes","name":"message","type":"bytes"},{"components":[{"internalType":"uint64","name":"destinationChainSelector","type":"uint64"},{"internalType":"uint192","name":"gas","type":"uint192"}],"internalType":"struct MessageProxy.MessageRouteConfig[]","name":"configs","type":"tuple[]"}],"internalType":"struct MessageProxy.ResendArgsSendingChain[]","name":"args","type":"tuple[]"}],"name":"resendLastMessage","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"routerClient","outputs":[{"internalType":"contract IRouterClient","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"messageType","type":"bytes32"},{"internalType":"bytes","name":"message","type":"bytes"}],"name":"sendMessage","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint64","name":"destinationChainSelector","type":"uint64"},{"internalType":"address","name":"destinationChainReceiver","type":"address"}],"name":"setDestinationChainReceiver","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"messageSender","type":"address"},{"internalType":"bytes32","name":"messageType","type":"bytes32"},{"internalType":"uint64","name":"chainId","type":"uint64"},{"internalType":"uint192","name":"gas","type":"uint192"}],"name":"setGasForRoute","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]
Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
000000000000000000000000b20193f43c9a7184f3cbed9bad59154da01488b400000000000000000000000080226fc0ee2b096224eeac085bb9a8cba1146f7d
-----Decoded View---------------
Arg [0] : _systemRegistry (address): 0xB20193f43C9a7184F3cbeD9bAD59154da01488b4
Arg [1] : ccipRouter (address): 0x80226fc0Ee2b096224EeAc085Bb9a8cba1146f7D
-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000b20193f43c9a7184f3cbed9bad59154da01488b4
Arg [1] : 00000000000000000000000080226fc0ee2b096224eeac085bb9a8cba1146f7d
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 26 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|---|---|---|---|---|
ETH | Ether (ETH) | 100.00% | $3,408.54 | 0.5521 | $1,881.74 |
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.