Description:
Multi-signature wallet contract requiring multiple confirmations for transaction execution.
Blockchain: Ethereum
Source Code: View Code On The Blockchain
Solidity Source Code:
{{
"language": "Solidity",
"sources": {
"src/main/strategies/aave/StrategyAaveHorizonRWA.sol": {
"content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.25;
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "../../../interfaces/aave/v3/IPoolV3.sol";
import "../../../interfaces/ISuperStateOracle.sol";
import "../base/StrategyBase.sol";
/**
* @title StrategyAave contract
* @author Naturelab
*/
contract StrategyAaveHorizonRWA is StrategyBase {
using SafeERC20 for IERC20;
// The version of the contract
string public constant VERSION = "1.0";
// The maximum allowable ratio for the protocol, set to 73%
uint256 public constant MAX_PROTOCOL_RATIO = 0.73e18;
// The address of the AAVE Horizon Rwa Market Pool contract
IPoolV3 internal constant POOL_AAVEV3 = IPoolV3(0xAe05Cd22df81871bc7cC2a04BeCfb516bFe332C8);
// The address of the AAVE aToken of USCC
address internal constant aUSCC = 0x08b798c40b9AB931356d9aB4235F548325C4cb80; // decimals: 6
// The address of the AAVE dToken of USDC
address internal constant dUSDC = 0x4139EcBe83d78ef5EFF0A6eDA6f894Be9D590FC7; // decimals: 6
// The oracle contract of uscc
ISuperStateOracle internal constant USCC_ORACLE = ISuperStateOracle(0xAfFd8F5578E8590665de561bdE9E7BAdb99300d9);
// The address of superstate's USDC deposit
address internal constant usccDepositAddress = 0x3734da03B21b079b9ffB6f5f5108b40103613d7A;
// The safe collateral rate for the protocol
uint256 public safeProtocolRatio;
// record of we submitted to superstate for mingting in leverage
uint256 public mintingUSDCAmount;
// record of we submitted to superstate for redeeming in deleverage
uint256 public redeemingUSCCAmount;
// The uscc balance of current strategy
uint256 public usccBalance;
// The usdc balance of current strategy
uint256 public usdcBalance;
// The net assets when we receive
event Deposit(uint256 amount);
event Withdraw(uint256 amount);
event Borrow(address token, uint256 amount);
event Repay(uint256 amount);
event UpdateSafeProtocolRatio(uint256 oldRatio, uint256 newRatio);
event MintRequestSubmitted(uint256 usdcAmount);
event RedeemRequestSubmitted(uint256 usccAmount);
event MintRequestConfirmed();
event RedeemRequestConfirmed();
/**
* @dev Initialize the strategy with given parameters.
* @param _initBytes Initialization data
*/
function initialize(bytes calldata _initBytes) external override initializer {
(uint256 safeProtocolRatio_, address admin_, address rebalancer_) =
abi.decode(_initBytes, (uint256, address, address));
if (admin_ == address(0)) revert Errors.InvalidAdmin();
if (rebalancer_ == address(0)) revert Errors.InvalidRebalancer();
if (safeProtocolRatio_ > MAX_PROTOCOL_RATIO) revert Errors.InvalidSafeProtocolRatio();
__Ownable_init(admin_);
safeProtocolRatio = safeProtocolRatio_;
rebalancer = rebalancer_;
vault = msg.sender;
_enterProtocol();
}
/**
* @dev Transfers funds from the vault contract to this contract.
* This function is called by the vault to move tokens into this contract.
* It uses the `safeTransferFrom` function from the SafeERC20 library to ensure the transfer is successful.
* @param _token The address of the token to be transferred.
* @param _amount The amount of tokens to be transferred.
* @return A boolean indicating whether the transfer was successful.
*/
function onTransferIn(address _token, uint256 _amount) external onlyVault returns (bool) {
if (_token == USCC) {
usccBalance += _amount;
} else if (_token == USDC) {
usdcBalance += _amount;
} else {
revert Errors.UnSupportedOperation();
}
IERC20(_token).safeTransferFrom(msg.sender, address(this), _amount);
emit OnTransferIn(_token, _amount);
return true;
}
/**
* @dev Transfer tokens to the Vault.
* @param _token The address of the token to transfer.
* @param _amount The amount of tokens to transfer.
*/
function transferToVault(address _token, uint256 _amount) external override onlyRebalancer {
if (_token != USDC) revert Errors.UnSupportedOperation();
usdcBalance -= _amount;
IERC20(_token).safeTransfer(vault, _amount);
emit TransferToVault(_token, _amount);
}
/**
* @dev update the safe collateral rate for the protocol.
* @param _newRatio The new safe collateral rate for the protocol.
*/
function updateSafeProtocolRatio(uint256 _newRatio) external onlyOwner {
if (_newRatio > MAX_PROTOCOL_RATIO) revert Errors.InvalidSafeProtocolRatio();
emit UpdateSafeProtocolRatio(safeProtocolRatio, _newRatio);
safeProtocolRatio = _newRatio;
}
/**
* @dev deposit USCC to the AAVE Horizon Rwa Market Pool.
* @param _amount The amount of USCC to deposit.
*/
function deposit(uint256 _amount) external onlyRebalancer {
if (_amount == type(uint256).max) {
_amount = usccBalance;
}
POOL_AAVEV3.supply(USCC, _amount, address(this), 0);
usccBalance -= _amount;
emit Deposit(_amount);
}
/**
* @dev withdraw USCC from the AAVE Horizon Rwa Market Pool.
* @param _amount The amount of USCC to withdraw.
*/
function withdraw(uint256 _amount) external onlyRebalancer {
POOL_AAVEV3.withdraw(USCC, _amount, address(this));
_checkProtocolRatio();
usccBalance += _amount;
emit Withdraw(_amount);
}
/**
* @dev Borrow from the AAVE Horizon Rwa Market Pool.
* @param _amount The amount of USCC to borrow.
*/
function borrow(uint256 _amount) external onlyRebalancer {
POOL_AAVEV3.borrow(USDC, _amount, 2, 0, address(this));
_checkProtocolRatio();
usdcBalance += _amount;
emit Borrow(USDC, _amount);
}
/**
* @dev Repay the AAVE Horizon Rwa Market Pool.
* @param _amount The amount of tokens to repay.
*/
function repay(uint256 _amount) external onlyRebalancer {
POOL_AAVEV3.repay(USDC, _amount, 2, address(this));
usdcBalance -= _amount;
emit Repay(_amount);
}
/**
* @dev transfer USDC to the superstate's USDC deposit address for minting uscc.
* @param _amount The amount of USDC to transfer.
*/
function submitMintRequest(uint256 _amount) external onlyRebalancer {
if (mintingUSDCAmount > 0) revert Errors.MintingInProgress();
if (_amount == type(uint256).max) {
_amount = usdcBalance;
}
IERC20(USDC).safeTransfer(usccDepositAddress, _amount);
mintingUSDCAmount = _amount;
usdcBalance -= _amount;
emit MintRequestSubmitted(_amount);
}
/**
* @dev transfer USCC to the uscc contract for redeeming USDC.
* @param _amount The amount of USCC to transfer.
*/
function submitRedeemRequest(uint256 _amount) external onlyRebalancer {
if (redeemingUSCCAmount > 0) revert Errors.RedeemingInProgress();
if (_amount == type(uint256).max) {
_amount = usccBalance;
}
IERC20(USCC).safeTransfer(USCC, _amount);
redeemingUSCCAmount = _amount;
usccBalance -= _amount;
emit RedeemRequestSubmitted(_amount);
}
/**
* @dev Confirm the minting request
*/
function confirmMintRequest() external onlyRebalancer {
if (mintingUSDCAmount == 0) revert Errors.NoMintRequest();
mintingUSDCAmount = 0;
usccBalance = IERC20(USCC).balanceOf(address(this));
emit MintRequestConfirmed();
}
/**
* @dev Confirm the redeem request
*/
function confirmRedeemRequest() external onlyRebalancer {
if (redeemingUSCCAmount == 0) revert Errors.NoRedeemRequest();
redeemingUSCCAmount = 0;
usdcBalance = IERC20(USDC).balanceOf(address(this));
emit RedeemRequestConfirmed();
}
/**
* @dev Get the collateral ratio and its status.
* @return collateralRatio_ The collateral ratio.
* @return isOK_ Boolean indicating whether the ratio is within safe limits.
*/
function getCollateralRatio() public view returns (uint256 collateralRatio_, bool isOK_) {
(uint256 totalCollateralBase_, uint256 totalDebtBase_,,,,) = POOL_AAVEV3.getUserAccountData(address(this));
collateralRatio_ = totalCollateralBase_ == 0 ? 0 : totalDebtBase_ * 1e18 / totalCollateralBase_;
isOK_ = safeProtocolRatio > collateralRatio_;
}
function _enterProtocol() internal {
IERC20(USCC).safeIncreaseAllowance(address(POOL_AAVEV3), type(uint256).max);
IERC20(USDC).safeIncreaseAllowance(address(POOL_AAVEV3), type(uint256).max);
}
/**
* @dev Check the health status of a specific protocol after an operation
* to prevent the strategy pool from being in a risky position.
*/
function _checkProtocolRatio() internal view {
(, bool isOK_) = getCollateralRatio();
if (!isOK_) revert Errors.RatioOutOfRange();
}
/**
* @dev Get the amount of assets in all lending protocols involved in this contract for the strategy pool.
* @return netAssets The total amount of net assets.
*/
function getNetAssets() public view returns (uint256) {
uint8 usccPriceDecimals_ = USCC_ORACLE.decimals();
(, uint256 usccPrice_,,uint256 latestUpdateAt_,) = USCC_ORACLE.latestRoundData(); // answer with usccPriceDecimals_
if (latestUpdateAt_ + MAX_ORACLE_PRICE_UPDATED_PERIOD < block.timestamp) {
revert Errors.OraclePriceTooOld();
}
uint256 totalUSCC_ = IERC20(aUSCC).balanceOf(address(this)) + usccBalance + redeemingUSCCAmount;
uint256 totalUSDC_ = usdcBalance + mintingUSDCAmount;
uint256 totalDebt_ = IERC20(dUSDC).balanceOf(address(this));
return totalUSDC_ + totalUSCC_ * usccPrice_ / (10 ** usccPriceDecimals_) - totalDebt_;
}
}
"
},
"dependencies/@openzeppelin-contracts-5.0.2/token/ERC20/utils/SafeERC20.sol": {
"content": "// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/utils/SafeERC20.sol)
pragma solidity ^0.8.20;
import {IERC20} from "../IERC20.sol";
import {IERC20Permit} from "../extensions/IERC20Permit.sol";
import {Address} from "../../../utils/Address.sol";
/**
* @title SafeERC20
* @dev Wrappers around ERC20 operations that throw on failure (when the token
* contract returns false). Tokens that return no value (and instead revert or
* throw on failure) are also supported, non-reverting calls are assumed to be
* successful.
* To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
* which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
*/
library SafeERC20 {
using Address for address;
/**
* @dev An operation with an ERC20 token failed.
*/
error SafeERC20FailedOperation(address token);
/**
* @dev Indicates a failed `decreaseAllowance` request.
*/
error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);
/**
* @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
* non-reverting calls are assumed to be successful.
*/
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
}
/**
* @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
* calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
*/
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
}
/**
* @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
* non-reverting calls are assumed to be successful.
*/
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 oldAllowance = token.allowance(address(this), spender);
forceApprove(token, spender, oldAllowance + value);
}
/**
* @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
* value, non-reverting calls are assumed to be successful.
*/
function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
unchecked {
uint256 currentAllowance = token.allowance(address(this), spender);
if (currentAllowance < requestedDecrease) {
revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
}
forceApprove(token, spender, currentAllowance - requestedDecrease);
}
}
/**
* @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
* non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
* to be set to zero before setting it to a non-zero value, such as USDT.
*/
function forceApprove(IERC20 token, address spender, uint256 value) internal {
bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));
if (!_callOptionalReturnBool(token, approvalCall)) {
_callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
_callOptionalReturn(token, approvalCall);
}
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*/
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
// we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data);
if (returndata.length != 0 && !abi.decode(returndata, (bool))) {
revert SafeERC20FailedOperation(address(token));
}
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*
* This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
*/
function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
// We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
// we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false
// and not revert is the subcall reverts.
(bool success, bytes memory returndata) = address(token).call(data);
return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0;
}
}
"
},
"dependencies/@openzeppelin-contracts-5.0.2/utils/structs/EnumerableSet.sol": {
"content": "// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/structs/EnumerableSet.sol)
// This file was procedurally generated from scripts/generate/templates/EnumerableSet.js.
pragma solidity ^0.8.20;
/**
* @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.
*
* ```solidity
* 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 is the index of the value in the `values` array plus 1.
// Position 0 is used to mean a value is not in the set.
mapping(bytes32 value => uint256) _positions;
}
/**
* @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._positions[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 cache the value's position to prevent multiple reads from the same storage slot
uint256 position = set._positions[value];
if (position != 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 valueIndex = position - 1;
uint256 lastIndex = set._values.length - 1;
if (valueIndex != lastIndex) {
bytes32 lastValue = set._values[lastIndex];
// Move the lastValue to the index where the value to delete is
set._values[valueIndex] = lastValue;
// Update the tracked position of the lastValue (that was just moved)
set._positions[lastValue] = position;
}
// Delete the slot where the moved value was stored
set._values.pop();
// Delete the tracked position for the deleted slot
delete set._positions[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._positions[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;
}
}
"
},
"src/interfaces/aave/v3/IPoolV3.sol": {
"content": "// SPDX-License-Identifier: AGPL-3.0
pragma solidity ^0.8.0;
import "./libraries/types/DataTypes.sol";
/**
* @title IPool
* @author Aave
* @notice Defines the basic interface for an Aave Pool.
*/
interface IPoolV3 {
function supply(address asset, uint256 amount, address onBehalfOf, uint16 referralCode) external;
function withdraw(address asset, uint256 amount, address to) external returns (uint256);
function borrow(address asset, uint256 amount, uint256 interestRateMode, uint16 referralCode, address onBehalfOf)
external;
function repay(address asset, uint256 amount, uint256 interestRateMode, address onBehalfOf)
external
returns (uint256);
function getUserAccountData(address user)
external
view
returns (
uint256 totalCollateralBase,
uint256 totalDebtBase,
uint256 availableBorrowsBase,
uint256 currentLiquidationThreshold,
uint256 ltv,
uint256 healthFactor
);
function setUserEMode(uint8 categoryId) external;
function setUserUseReserveAsCollateral(address asset, bool useAsCollateral) external;
function getUserEMode(address user) external view returns (uint256);
function deposit(address asset, uint256 amount, address onBehalfOf, uint16 referralCode) external;
function getReserveData(address asset) external view returns (DataTypes.ReserveData memory);
function getReserveAToken(address asset) external view returns (address);
function getReserveVariableDebtToken(address asset) external view returns (address);
}
"
},
"src/interfaces/ISuperStateOracle.sol": {
"content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.25;
interface ISuperStateOracle {
function decimals() external view returns (uint8);
function latestRoundData() external view returns (uint80 roundId, uint256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);
}"
},
"src/main/strategies/base/StrategyBase.sol": {
"content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.25;
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "../../../interfaces/IStrategy.sol";
import "../../libraries/Errors.sol";
import "../../common/Constants.sol";
abstract contract StrategyBase is IStrategy, Constants, OwnableUpgradeable {
using SafeERC20 for IERC20;
address public vault;
address public rebalancer;
event UpdateRebalancer(address oldRebalancer, address newRebalancer);
event OnTransferIn(address token, uint256 amount);
event TransferToVault(address token, uint256 amount);
/**
* @dev Ensure that this method is only called by the Vault contract.
*/
modifier onlyVault() {
if (msg.sender != vault) revert Errors.CallerNotVault();
_;
}
/**
* @dev Ensure that this method is only called by authorized portfolio managers.
*/
modifier onlyRebalancer() {
if (msg.sender != rebalancer) revert Errors.CallerNotRebalancer();
_;
}
/**
* @dev Initialize the strategy with given parameters.
* @param _initBytes Initialization data
*/
function initialize(bytes calldata _initBytes) external virtual initializer {
(address admin_, address rebalancer_) = abi.decode(_initBytes, (address, address));
if (admin_ == address(0)) revert Errors.InvalidAdmin();
if (rebalancer_ == address(0)) revert Errors.InvalidRebalancer();
__Ownable_init(admin_);
rebalancer = rebalancer_;
vault = msg.sender;
}
/**
* @dev Add a new address to the position adjustment whitelist.
* @param _newRebalancer The new address to be added.
*/
function updateRebalancer(address _newRebalancer) external onlyOwner {
if (_newRebalancer == address(0)) revert Errors.InvalidRebalancer();
emit UpdateRebalancer(rebalancer, _newRebalancer);
rebalancer = _newRebalancer;
}
/**
* @dev Transfer tokens to the Vault.
* @param _token The address of the token to transfer.
* @param _amount The amount of tokens to transfer.
*/
function transferToVault(address _token, uint256 _amount) virtual external onlyRebalancer {
IERC20(_token).safeTransfer(vault, _amount);
emit TransferToVault(_token, _amount);
}
}
"
},
"dependencies/@openzeppelin-contracts-5.0.2/token/ERC20/IERC20.sol": {
"content": "// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)
pragma solidity ^0.8.20;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Returns the value of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the value of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves a `value` amount of tokens from the caller's account to `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address to, uint256 value) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets a `value` amount of tokens as the allowance of `spender` over the
* caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 value) external returns (bool);
/**
* @dev Moves a `value` amount of tokens from `from` to `to` using the
* allowance mechanism. `value` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address from, address to, uint256 value) external returns (bool);
}
"
},
"dependencies/@openzeppelin-contracts-5.0.2/token/ERC20/extensions/IERC20Permit.sol": {
"content": "// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Permit.sol)
pragma solidity ^0.8.20;
/**
* @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
* https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
*
* Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
* presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
* need to send a transaction, and thus is not required to hold Ether at all.
*
* ==== Security Considerations
*
* There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
* expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
* considered as an intention to spend the allowance in any specific way. The second is that because permits have
* built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
* take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
* generally recommended is:
*
* ```solidity
* function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
* try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
* doThing(..., value);
* }
*
* function doThing(..., uint256 value) public {
* token.safeTransferFrom(msg.sender, address(this), value);
* ...
* }
* ```
*
* Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
* `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
* {SafeERC20-safeTransferFrom}).
*
* Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
* contracts should have entry points that don't rely on permit.
*/
interface IERC20Permit {
/**
* @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
* given ``owner``'s signed approval.
*
* IMPORTANT: The same issues {IERC20-approve} has related to transaction
* ordering also apply here.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `deadline` must be a timestamp in the future.
* - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
* over the EIP712-formatted function arguments.
* - the signature must use ``owner``'s current nonce (see {nonces}).
*
* For more information on the signature format, see the
* https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
* section].
*
* CAUTION: See Security Considerations above.
*/
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
/**
* @dev Returns the current nonce for `owner`. This value must be
* included whenever a signature is generated for {permit}.
*
* Every successful call to {permit} increases ``owner``'s nonce by one. This
* prevents a signature from being used multiple times.
*/
function nonces(address owner) external view returns (uint256);
/**
* @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
*/
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
"
},
"dependencies/@openzeppelin-contracts-5.0.2/utils/Address.sol": {
"content": "// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)
pragma solidity ^0.8.20;
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev The ETH balance of the account is not enough to perform the operation.
*/
error AddressInsufficientBalance(address account);
/**
* @dev There's no code at `target` (it is not a contract).
*/
error AddressEmptyCode(address target);
/**
* @dev A call to an address target failed. The target may have reverted.
*/
error FailedInnerCall();
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
if (address(this).balance < amount) {
revert AddressInsufficientBalance(address(this));
}
(bool success, ) = recipient.call{value: amount}("");
if (!success) {
revert FailedInnerCall();
}
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason or custom error, it is bubbled
* up by this function (like regular Solidity function calls). However, if
* the call reverted with no returned reason, this function reverts with a
* {FailedInnerCall} error.
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
if (address(this).balance < value) {
revert AddressInsufficientBalance(address(this));
}
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata);
}
/**
* @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
* was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an
* unsuccessful call.
*/
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata
) internal view returns (bytes memory) {
if (!success) {
_revert(returndata);
} else {
// only check if target is a contract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
if (returndata.length == 0 && target.code.length == 0) {
revert AddressEmptyCode(target);
}
return returndata;
}
}
/**
* @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
* revert reason or with a default {FailedInnerCall} error.
*/
function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
if (!success) {
_revert(returndata);
} else {
return returndata;
}
}
/**
* @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.
*/
function _revert(bytes memory returndata) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert FailedInnerCall();
}
}
}
"
},
"src/interfaces/aave/v3/libraries/types/DataTypes.sol": {
"content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.0;
library DataTypes {
struct ReserveData {
//stores the reserve configuration
ReserveConfigurationMap configuration;
//the liquidity index. Expressed in ray
uint128 liquidityIndex;
//the current supply rate. Expressed in ray
uint128 currentLiquidityRate;
//variable borrow index. Expressed in ray
uint128 variableBorrowIndex;
//the current variable borrow rate. Expressed in ray
uint128 currentVariableBorrowRate;
//the current stable borrow rate. Expressed in ray
uint128 currentStableBorrowRate;
//timestamp of last update
uint40 lastUpdateTimestamp;
//the id of the reserve. Represents the position in the list of the active reserves
uint16 id;
//aToken address
address aTokenAddress;
//stableDebtToken address
address stableDebtTokenAddress;
//variableDebtToken address
address variableDebtTokenAddress;
//address of the interest rate strategy
address interestRateStrategyAddress;
//the current treasury balance, scaled
uint128 accruedToTreasury;
//the outstanding unbacked aTokens minted through the bridging feature
uint128 unbacked;
//the outstanding debt borrowed against this asset in isolation mode
uint128 isolationModeTotalDebt;
}
struct ReserveConfigurationMap {
//bit 0-15: LTV
//bit 16-31: Liq. threshold
//bit 32-47: Liq. bonus
//bit 48-55: Decimals
//bit 56: reserve is active
//bit 57: reserve is frozen
//bit 58: borrowing is enabled
//bit 59: stable rate borrowing enabled
//bit 60: asset is paused
//bit 61: borrowing in isolation mode is enabled
//bit 62-63: reserved
//bit 64-79: reserve factor
//bit 80-115 borrow cap in whole tokens, borrowCap == 0 => no cap
//bit 116-151 supply cap in whole tokens, supplyCap == 0 => no cap
//bit 152-167 liquidation protocol fee
//bit 168-175 eMode category
//bit 176-211 unbacked mint cap in whole tokens, unbackedMintCap == 0 => minting disabled
//bit 212-251 debt ceiling for isolation mode with (ReserveConfiguration::DEBT_CEILING_DECIMALS) decimals
//bit 252-255 unused
uint256 data;
}
struct UserConfigurationMap {
/**
* @dev Bitmap of the users collaterals and borrows. It is divided in pairs of bits, one pair per asset.
* The first bit indicates if an asset is used as collateral by the user, the second whether an
* asset is borrowed by the user.
*/
uint256 data;
}
struct EModeCategory {
// each eMode category has a custom ltv and liquidation threshold
uint16 ltv;
uint16 liquidationThreshold;
uint16 liquidationBonus;
// each eMode category may or may not have a custom oracle to override the individual assets price oracles
address priceSource;
string label;
}
enum InterestRateMode {
NONE,
STABLE,
VARIABLE
}
struct ReserveCache {
uint256 currScaledVariableDebt;
uint256 nextScaledVariableDebt;
uint256 currPrincipalStableDebt;
uint256 currAvgStableBorrowRate;
uint256 currTotalStableDebt;
uint256 nextAvgStableBorrowRate;
uint256 nextTotalStableDebt;
uint256 currLiquidityIndex;
uint256 nextLiquidityIndex;
uint256 currVariableBorrowIndex;
uint256 nextVariableBorrowIndex;
uint256 currLiquidityRate;
uint256 currVariableBorrowRate;
uint256 reserveFactor;
ReserveConfigurationMap reserveConfiguration;
address aTokenAddress;
address stableDebtTokenAddress;
address variableDebtTokenAddress;
uint40 reserveLastUpdateTimestamp;
uint40 stableDebtLastUpdateTimestamp;
}
struct ExecuteLiquidationCallParams {
uint256 reservesCount;
uint256 debtToCover;
address collateralAsset;
address debtAsset;
address user;
bool receiveAToken;
address priceOracle;
uint8 userEModeCategory;
address priceOracleSentinel;
}
struct ExecuteSupplyParams {
address asset;
uint256 amount;
address onBehalfOf;
uint16 referralCode;
}
struct ExecuteBorrowParams {
address asset;
address user;
address onBehalfOf;
uint256 amount;
InterestRateMode interestRateMode;
uint16 referralCode;
bool releaseUnderlying;
uint256 maxStableRateBorrowSizePercent;
uint256 reservesCount;
address oracle;
uint8 userEModeCategory;
address priceOracleSentinel;
}
struct ExecuteRepayParams {
address asset;
uint256 amount;
InterestRateMode interestRateMode;
address onBehalfOf;
bool useATokens;
}
struct ExecuteWithdrawParams {
address asset;
uint256 amount;
address to;
uint256 reservesCount;
address oracle;
uint8 userEModeCategory;
}
struct ExecuteSetUserEModeParams {
uint256 reservesCount;
address oracle;
uint8 categoryId;
}
struct FinalizeTransferParams {
address asset;
address from;
address to;
uint256 amount;
uint256 balanceFromBefore;
uint256 balanceToBefore;
uint256 reservesCount;
address oracle;
uint8 fromEModeCategory;
}
struct FlashloanParams {
address receiverAddress;
address[] assets;
uint256[] amounts;
uint256[] interestRateModes;
address onBehalfOf;
bytes params;
uint16 referralCode;
uint256 flashLoanPremiumToProtocol;
uint256 flashLoanPremiumTotal;
uint256 maxStableRateBorrowSizePercent;
uint256 reservesCount;
address addressesProvider;
uint8 userEModeCategory;
bool isAuthorizedFlashBorrower;
}
struct FlashloanSimpleParams {
address receiverAddress;
address asset;
uint256 amount;
bytes params;
uint16 referralCode;
uint256 flashLoanPremiumToProtocol;
uint256 flashLoanPremiumTotal;
}
struct FlashLoanRepaymentParams {
uint256 amount;
uint256 totalPremium;
uint256 flashLoanPremiumToProtocol;
address asset;
address receiverAddress;
uint16 referralCode;
}
struct CalculateUserAccountDataParams {
UserConfigurationMap userConfig;
uint256 reservesCount;
address user;
address oracle;
uint8 userEModeCategory;
}
struct ValidateBorrowParams {
ReserveCache reserveCache;
UserConfigurationMap userConfig;
address asset;
address userAddress;
uint256 amount;
InterestRateMode interestRateMode;
uint256 maxStableLoanPercent;
uint256 reservesCount;
address oracle;
uint8 userEModeCategory;
address priceOracleSentinel;
bool isolationModeActive;
address isolationModeCollateralAddress;
uint256 isolationModeDebtCeiling;
}
struct ValidateLiquidationCallParams {
ReserveCache debtReserveCache;
uint256 totalDebt;
uint256 healthFactor;
address priceOracleSentinel;
}
struct CalculateInterestRatesParams {
uint256 unbacked;
uint256 liquidityAdded;
uint256 liquidityTaken;
uint256 totalStableDebt;
uint256 totalVariableDebt;
uint256 averageStableBorrowRate;
uint256 reserveFactor;
address reserve;
address aToken;
}
struct InitReserveParams {
address asset;
address aTokenAddress;
address stableDebtAddress;
address variableDebtAddress;
address interestRateStrategyAddress;
uint16 reservesCount;
uint16 maxNumberReserves;
}
}
"
},
"dependencies/@openzeppelin-contracts-upgradeable-5.0.2/access/OwnableUpgradeable.sol": {
"content": "// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)
pragma solidity ^0.8.20;
import {ContextUpgradeable} from "../utils/ContextUpgradeable.sol";
import {Initializable} from "../proxy/utils/Initializable.sol";
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* The initial owner is set to the address provided by the deployer. This can
* later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
/// @custom:storage-location erc7201:openzeppelin.storage.Ownable
struct OwnableStorage {
address _owner;
}
// keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Ownable")) - 1)) & ~bytes32(uint256(0xff))
bytes32 private constant OwnableStorageLocation = 0x9016d09d72d40fdae2fd8ceac6b6234c7706214fd39c1cd1e609a0528c199300;
function _getOwnableStorage() private pure returns (OwnableStorage storage $) {
assembly {
$.slot := OwnableStorageLocation
}
}
/**
* @dev The caller account is not authorized to perform an operation.
*/
error OwnableUnauthorizedAccount(address account);
/**
* @dev The owner is not a valid owner account. (eg. `address(0)`)
*/
error OwnableInvalidOwner(address owner);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the address provided by the deployer as the initial owner.
*/
function __Ownable_init(address initialOwner) internal onlyInitializing {
__Ownable_init_unchained(initialOwner);
}
function __Ownable_init_unchained(address initialOwner) internal onlyInitializing {
if (initialOwner == address(0)) {
revert OwnableInvalidOwner(address(0));
}
_transferOwnership(initialOwner);
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
_checkOwner();
_;
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
OwnableStorage storage $ = _getOwnableStorage();
return $._owner;
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
if (owner() != _msgSender()) {
revert OwnableUnauthorizedAccount(_msgSender());
}
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby disabling any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
if (newOwner == address(0)) {
revert OwnableInvalidOwner(address(0));
}
_transferOwnership(newOwner);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
OwnableStorage storage $ = _getOwnableStorage();
address oldOwner = $._owner;
$._owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
"
},
"src/interfaces/IStrategy.sol": {
"content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.25;
interface IStrategy {
function getNetAssets() external returns (uint256);
function onTransferIn(address token, uint256 amount) external returns (bool);
}
"
},
"src/main/libraries/Errors.sol": {
"content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.25;
library Errors {
// Revert Errors:
error CallerNotOperator(); // 0xa5523ee5
error CallerNotRebalancer(); // 0xbd72e291
error CallerNotVault(); // 0xedd7338f
error CallerNotMinter(); // 0x5eee367a
error CallerNotWhiteList(); // 0xf37be7b6
error DepositAmountTooSmall(); // 0x67627d07
error ExitFeeRateTooHigh(); // 0xf4d1caab
error ExceededMaxDeposit(); // 0x3bc9ae09
error FlashloanInProgress(); // 0x772ac4e8
error IncorrectState(); // 0x508c9390
error InfoExpired(); // 0x4ddf4a65
error InvalidAccount(); // 0x6d187b28
error InvalidAdapter(); // 0xfbf66df1
error InvalidAdmin(); // 0xb5eba9f0
error InvalidAsset(); // 0xc891add2
error InvalidCaller(); // 0x48f5c3ed
error InvalidClaimTime(); // 0x1221b97b
error InvalidFeeReceiver(); // 0xd200485c
error InvalidFlashloanCall(); // 0xd2208d52
error InvalidFlashloanHelper(); // 0x8690f016
error InvalidFlashloanProvider(); // 0xb6b48551
error InvalidGasLimit(); // 0x98bdb2e0
error InvalidInitiator(); // 0xbfda1f28
error InvalidLength(); // 0x947d5a84
error InvalidLimit(); // 0xe55fb509
error InvalidManagementFeeClaimPeriod(); // 0x4022e4f6
error InvalidManagementFeeRate(); // 0x09aa66eb
error InvalidMarketCapacity(); // 0xc9034604
error InvalidNetAssets(); // 0x6da79d69
error InvalidNewOperator(); // 0xba0cdec5
error InvalidOperator(); // 0xccea9e6f
error InvalidOracle(); // 0x9589a27d
error InvalidRebalancer(); // 0xff288a8e
error InvalidRedeemOperator(); // 0xd214a597
error InvalidSafeProtocolRatio(); // 0x7c6b23d6
error InvalidShares(); // 0x6edcc523
error InvalidTarget(); // 0x82d5d76a
error InvalidToken(); // 0xc1ab6dc1
error InvalidTokenId(); // 0x3f6cc768
error InvalidUnderlyingToken(); // 0x2fb86f96
error InvalidVault(); // 0xd03a6320
error InvalidWithdrawalUser(); // 0x36c17319
error ManagementFeeRateTooHigh(); // 0x09aa66eb
error ManagementFeeClaimPeriodTooShort(); // 0x4022e4f6
error MarketCapacityTooLow(); // 0xc9034604
error MintingInProgress(); // 0x5067ce25
error NoMintRequest(); // 0x016df84c
error NoRedeemRequest(); // 0x4ef1d5c5
error NotSupportedYet(); // 0xfb89ba2a
error OraclePriceTooOld(); // 0xfc799379
error PriceNotUpdated(); // 0x1f4bcb2b
error PriceUpdatePeriodTooLong(); // 0xe88d3ecb
error RatioOutOfRange(); // 0x9179cbfa
error RedeemingInProgress(); // 0x24f44227
error RevenueFeeRateTooHigh(); // 0x0674143f
error UnSupportedOperation(); // 0xe9ec8129
error UnsupportedToken(); // 0x6a172882
error WithdrawZero(); // 0x7ea773a9
error DepositHalted(); // 0x3ddeeb34
// for 1inch swap
error OneInchInvalidReceiver(); // 0xd540519e
error OneInchInvalidToken(); // 0x8e7ad912
error OneInchInvalidInputAmount(); // 0x672b500f
error OneInchInvalidFunctionSignature(); // 0x247f51aa
error OneInchUnexpectedSpentAmount(); // 0x295ada05
error OneInchUnexpectedReturnAmount(); // 0x05e64ca8
error OneInchNotSupported(); // 0x04b2de78
}
"
},
"src/main/common/Constants.sol": {
"content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.25;
abstract contract Constants {
address public constant USCC = 0x14d60E7FDC0D71d8611742720E4C50E7a974020c; // decimals: 6
address public constant USDT = 0xdAC17F958D2ee523a2206206994597C13D831ec7; // decimals: 6
address public constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48; // decimals: 6
address public constant USDS = 0xdC035D45d973E3EC169d2276DDab16f1e407384F; // decimals: 18
address public constant DAI = 0x6B175474E89094C44Da98b954EedeAC495271d0F; // decimales: 18
// Time check for price update, 100 hours
uint256 public constant MAX_ORACLE_PRICE_UPDATED_PERIOD = 100 hours;
}
"
Submitted on: 2025-10-16 11:16:12
Comments
Log in to comment.
No comments yet.