Overview
S Balance
0 SS Value
$0.00More Info
Private Name Tags
ContractCreator
Loading...
Loading
This contract may be a proxy contract. Click on More Options and select Is this a proxy? to confirm and enable the "Read as Proxy" & "Write as Proxy" tabs.
Contract Source Code Verified (Exact Match)
Contract Name:
ALMShadowFarmStrategy
Compiler Version
v0.8.23+commit.f704f362
Optimization Enabled:
Yes with 200 runs
Other Settings:
shanghai EvmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import {ALMStrategyBase} from "./base/ALMStrategyBase.sol";
import {FarmingStrategyBase} from "./base/FarmingStrategyBase.sol";
import {StrategyBase} from "./base/StrategyBase.sol";
import {StrategyIdLib} from "./libs/StrategyIdLib.sol";
import {ALMLib} from "./libs/ALMLib.sol";
import {ALMRamsesV3Lib} from "./libs/ALMRamsesV3Lib.sol";
import {FarmMechanicsLib} from "./libs/FarmMechanicsLib.sol";
import {CommonLib} from "../core/libs/CommonLib.sol";
import {AmmAdapterIdLib} from "../adapters/libs/AmmAdapterIdLib.sol";
import {IControllable} from "../interfaces/IControllable.sol";
import {IFactory} from "../interfaces/IFactory.sol";
import {IAmmAdapter} from "../interfaces/IAmmAdapter.sol";
import {ILPStrategy} from "../interfaces/ILPStrategy.sol";
import {IFarmingStrategy} from "../interfaces/IFarmingStrategy.sol";
import {IStrategy} from "../interfaces/IStrategy.sol";
import {IPlatform} from "../interfaces/IPlatform.sol";
import {IXShadow} from "../integrations/shadow/IXShadow.sol";
/// @title Earn Shadow gauge rewards by Stability ALM
/// Changelog:
/// 1.1.1: LPStrategyBase._swapForDepositProportion use try..catch
/// 1.1.0: Fill-Up algo deposits to base range only; improved description
/// @author Alien Deployer (https://github.com/a17)
contract ALMShadowFarmStrategy is ALMStrategyBase, FarmingStrategyBase {
using SafeERC20 for IERC20;
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* CONSTANTS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @inheritdoc IControllable
string public constant VERSION = "1.1.1";
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* INITIALIZATION */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @inheritdoc IStrategy
function initialize(address[] memory addresses, uint[] memory nums, int24[] memory ticks) public initializer {
if (addresses.length != 2 || nums.length != 1 || ticks.length != 0) {
revert IControllable.IncorrectInitParams();
}
IFactory.Farm memory farm = _getFarm(addresses[0], nums[0]);
if (farm.addresses.length != 3 || farm.nums.length != 1 || farm.ticks.length != 2) {
revert IFarmingStrategy.BadFarm();
}
__ALMStrategyBase_init(
LPStrategyBaseInitParams({
id: StrategyIdLib.ALM_SHADOW_FARM,
platform: addresses[0],
vault: addresses[1],
pool: farm.pool,
underlying: address(0)
}),
ALMStrategyBaseInitParams({algoId: farm.nums[0], params: farm.ticks, nft: farm.addresses[1]})
);
__FarmingStrategyBase_init(addresses[0], nums[0]);
address[] memory _assets = assets();
IERC20(_assets[0]).forceApprove(farm.addresses[1], type(uint).max);
IERC20(_assets[1]).forceApprove(farm.addresses[1], type(uint).max);
address swapper = IPlatform(addresses[0]).swapper();
IERC20(IXShadow(farm.addresses[2]).SHADOW()).forceApprove(swapper, type(uint).max);
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* VIEW FUNCTIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @inheritdoc IERC165
function supportsInterface(bytes4 interfaceId)
public
view
override(ALMStrategyBase, FarmingStrategyBase)
returns (bool)
{
return super.supportsInterface(interfaceId);
}
/// @inheritdoc IFarmingStrategy
function canFarm() external view override returns (bool) {
IFactory.Farm memory farm = _getFarm();
return farm.status == 0;
}
/// @inheritdoc ILPStrategy
function ammAdapterId() public pure override returns (string memory) {
return AmmAdapterIdLib.UNISWAPV3;
}
/// @inheritdoc IStrategy
function getRevenue() external pure returns (address[] memory __assets, uint[] memory amounts) {
__assets = new address[](0);
amounts = new uint[](0);
}
/// @inheritdoc IStrategy
function initVariants(address platform_)
public
view
returns (string[] memory variants, address[] memory addresses, uint[] memory nums, int24[] memory ticks)
{
IAmmAdapter _ammAdapter = IAmmAdapter(IPlatform(platform_).ammAdapter(keccak256(bytes(ammAdapterId()))).proxy);
addresses = new address[](0);
ticks = new int24[](0);
IFactory.Farm[] memory farms = IFactory(IPlatform(platform_).factory()).farms();
uint len = farms.length;
//slither-disable-next-line uninitialized-local
uint localTtotal;
for (uint i; i < len; ++i) {
IFactory.Farm memory farm = farms[i];
if (farm.status == 0 && CommonLib.eq(farm.strategyLogicId, strategyLogicId())) {
++localTtotal;
}
}
variants = new string[](localTtotal);
nums = new uint[](localTtotal);
localTtotal = 0;
for (uint i; i < len; ++i) {
IFactory.Farm memory farm = farms[i];
if (farm.status == 0 && CommonLib.eq(farm.strategyLogicId, strategyLogicId())) {
nums[localTtotal] = i;
//slither-disable-next-line calls-loop
variants[localTtotal] = _generateDescription(farm, _ammAdapter);
++localTtotal;
}
}
}
/// @inheritdoc IStrategy
function isHardWorkOnDepositAllowed() external pure returns (bool allowed) {
allowed = true;
}
/// @inheritdoc IStrategy
function isReadyForHardWork() external view returns (bool) {
return total() != 0;
}
/// @inheritdoc IFarmingStrategy
function farmMechanics() external pure returns (string memory) {
return FarmMechanicsLib.AUTO;
}
/// @inheritdoc IStrategy
function strategyLogicId() public pure override returns (string memory) {
return StrategyIdLib.ALM_SHADOW_FARM;
}
/// @inheritdoc IStrategy
function extra() external pure returns (bytes32) {
//slither-disable-next-line too-many-digits
return CommonLib.bytesToBytes32(abi.encodePacked(bytes3(0xeeeeee), bytes3(0x000000)));
}
/// @inheritdoc IStrategy
function description() external view returns (string memory) {
IFarmingStrategy.FarmingStrategyBaseStorage storage $f = _getFarmingStrategyBaseStorage();
IPlatform _platform = IPlatform(platform());
IFactory.Farm memory farm = IFactory(_platform.factory()).farm($f.farmId);
IAmmAdapter _ammAdapter = IAmmAdapter(_platform.ammAdapter(keccak256(bytes(ammAdapterId()))).proxy);
return _generateDescription(farm, _ammAdapter);
}
/// @inheritdoc IStrategy
function getSpecificName() external view override returns (string memory, bool) {
IFactory.Farm memory farm = _getFarm();
string memory algo = ALMLib.getAlgoNamyById(farm.nums[0]);
string memory presetName = ALMLib.getPresetNameByAlgoAndParams(farm.nums[0], farm.ticks);
return (string.concat(algo, " ", presetName), false);
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* STRATEGY BASE */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @inheritdoc StrategyBase
function _depositAssets(uint[] memory amounts, bool) internal override returns (uint value) {
return ALMRamsesV3Lib.depositAssets(
amounts, _getALMStrategyBaseStorage(), _getLPStrategyBaseStorage(), _getStrategyBaseStorage()
);
}
/// @inheritdoc StrategyBase
function _withdrawAssets(uint value, address receiver) internal override returns (uint[] memory amountsOut) {
return ALMRamsesV3Lib.withdrawAssets(value, receiver, _getALMStrategyBaseStorage(), _getStrategyBaseStorage());
}
/// @inheritdoc StrategyBase
function _claimRevenue()
internal
override
returns (
address[] memory __assets,
uint[] memory __amounts,
address[] memory __rewardAssets,
uint[] memory __rewardAmounts
)
{
ALMStrategyBaseStorage storage $ = _getALMStrategyBaseStorage();
FarmingStrategyBaseStorage storage _$f_ = _getFarmingStrategyBaseStorage();
StrategyBaseStorage storage __$__ = _getStrategyBaseStorage();
__assets = __$__._assets;
__rewardAssets = _$f_._rewardAssets;
__amounts = new uint[](2);
ALMRamsesV3Lib.collectFarmRewards($, _$f_);
__rewardAmounts = _$f_._rewardsOnBalance;
uint len = __rewardAmounts.length;
for (uint i; i < len; ++i) {
_$f_._rewardsOnBalance[i] = 0;
}
// liquidate xSHADOW to SHADOW
IFactory.Farm memory farm = _getFarm();
address xShadow = farm.addresses[2];
address shadow = IXShadow(xShadow).SHADOW();
for (uint i; i < len; ++i) {
if (__rewardAssets[i] == xShadow) {
if (__rewardAmounts[i] > 0) {
__rewardAmounts[i] = IXShadow(xShadow).exit(__rewardAmounts[i]);
}
__rewardAssets[i] = shadow;
}
}
}
/// @inheritdoc StrategyBase
function _compound() internal override {
uint[] memory amountsToDeposit = _swapForDepositProportion(getAssetsProportions()[0]);
uint valueToReceive;
(amountsToDeposit, valueToReceive) = _previewDepositAssets(amountsToDeposit);
if (valueToReceive > 10) {
_depositAssets(amountsToDeposit, false);
}
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* ALM STRATEGY BASE */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
function _rebalance(bool[] memory burnOldPositions, NewPosition[] memory mintNewPositions) internal override {
ALMRamsesV3Lib.rebalance(
burnOldPositions,
mintNewPositions,
_getALMStrategyBaseStorage(),
_getLPStrategyBaseStorage(),
_getFarmingStrategyBaseStorage(),
_getStrategyBaseStorage()
);
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* INTERNAL LOGIC */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
function _generateDescription(
IFactory.Farm memory farm,
IAmmAdapter _ammAdapter
) internal view returns (string memory) {
string memory algo = ALMLib.getAlgoNamyById(farm.nums[0]);
string memory presetName = ALMLib.getPresetNameByAlgoAndParams(farm.nums[0], farm.ticks);
//slither-disable-next-line calls-loop
return string.concat(
"Earn ",
CommonLib.implode(CommonLib.getSymbols(farm.rewardAssets), ", "),
" in Shadow ",
CommonLib.implode(CommonLib.getSymbols(_ammAdapter.poolTokens(farm.pool)), "-"),
" pool by Stability ALM with ",
algo,
" algo and ",
presetName,
" preset (range: ",
CommonLib.u2s(uint(int(farm.ticks[0]))),
" ticks, re-balance trigger: ",
CommonLib.u2s(uint(int(farm.ticks[1]))),
" ticks)"
);
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)
pragma solidity ^0.8.20;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Returns the value of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the value of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves a `value` amount of tokens from the caller's account to `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address to, uint256 value) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets a `value` amount of tokens as the allowance of `spender` over the
* caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 value) external returns (bool);
/**
* @dev Moves a `value` amount of tokens from `from` to `to` using the
* allowance mechanism. `value` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address from, address to, uint256 value) external returns (bool);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/utils/SafeERC20.sol)
pragma solidity ^0.8.20;
import {IERC20} from "../IERC20.sol";
import {IERC20Permit} from "../extensions/IERC20Permit.sol";
import {Address} from "../../../utils/Address.sol";
/**
* @title SafeERC20
* @dev Wrappers around ERC20 operations that throw on failure (when the token
* contract returns false). Tokens that return no value (and instead revert or
* throw on failure) are also supported, non-reverting calls are assumed to be
* successful.
* To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
* which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
*/
library SafeERC20 {
using Address for address;
/**
* @dev An operation with an ERC20 token failed.
*/
error SafeERC20FailedOperation(address token);
/**
* @dev Indicates a failed `decreaseAllowance` request.
*/
error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);
/**
* @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
* non-reverting calls are assumed to be successful.
*/
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
}
/**
* @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
* calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
*/
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
}
/**
* @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
* non-reverting calls are assumed to be successful.
*/
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 oldAllowance = token.allowance(address(this), spender);
forceApprove(token, spender, oldAllowance + value);
}
/**
* @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
* value, non-reverting calls are assumed to be successful.
*/
function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
unchecked {
uint256 currentAllowance = token.allowance(address(this), spender);
if (currentAllowance < requestedDecrease) {
revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
}
forceApprove(token, spender, currentAllowance - requestedDecrease);
}
}
/**
* @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
* non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
* to be set to zero before setting it to a non-zero value, such as USDT.
*/
function forceApprove(IERC20 token, address spender, uint256 value) internal {
bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));
if (!_callOptionalReturnBool(token, approvalCall)) {
_callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
_callOptionalReturn(token, approvalCall);
}
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*/
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
// we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(data);
if (returndata.length != 0 && !abi.decode(returndata, (bool))) {
revert SafeERC20FailedOperation(address(token));
}
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*
* This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
*/
function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
// We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
// we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false
// and not revert is the subcall reverts.
(bool success, bytes memory returndata) = address(token).call(data);
return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0;
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/IERC165.sol)
pragma solidity ^0.8.20;
/**
* @dev Interface of the ERC165 standard, as defined in the
* https://eips.ethereum.org/EIPS/eip-165[EIP].
*
* Implementers can declare support of contract interfaces, which can then be
* queried by others ({ERC165Checker}).
*
* For an implementation, see {ERC165}.
*/
interface IERC165 {
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;
import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import {StrategyBase} from "./StrategyBase.sol";
import {LPStrategyBase} from "./LPStrategyBase.sol";
import {VaultTypeLib} from "../../core/libs/VaultTypeLib.sol";
import {ALMLib} from "../libs/ALMLib.sol";
import {IStrategy} from "../../interfaces/IStrategy.sol";
import {ILPStrategy} from "../../interfaces/ILPStrategy.sol";
import {IALM} from "../../interfaces/IALM.sol";
import {ICAmmAdapter} from "../../interfaces/ICAmmAdapter.sol";
import {IHardWorker} from "../../interfaces/IHardWorker.sol";
import {IPlatform} from "../../interfaces/IPlatform.sol";
import {IControllable} from "../../interfaces/IControllable.sol";
/// @title Stability ALM
/// Changelog:
/// 1.1.0: Fill-Up algo deposits to base range only
/// @author Alien Deployer (https://github.com/a17)
abstract contract ALMStrategyBase is LPStrategyBase, IALM {
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* CONSTANTS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @dev Version of ALMStrategyBase implementation
string public constant VERSION_ALM_STRATEGY_BASE = "1.1.0";
// keccak256(abi.encode(uint256(keccak256("erc7201:stability.ALMStrategyBase")) - 1)) & ~bytes32(uint256(0xff));
bytes32 private constant ALM_STRATEGY_BASE_STORAGE_LOCATION =
0xa7b5cf2e827fe3bcf3fe6a0f3315b77285780eac3248f46a43fc1c44c1d47900;
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* INITIALIZATION */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
//slither-disable-next-line naming-convention
function __ALMStrategyBase_init(
LPStrategyBaseInitParams memory lpParams,
ALMStrategyBaseInitParams memory almParams
) internal onlyInitializing {
__LPStrategyBase_init(lpParams);
ALMStrategyBaseStorage storage $ = _getALMStrategyBaseStorage();
$.nft = almParams.nft;
$.algoId = almParams.algoId;
$.params = almParams.params;
emit ALMParams(almParams.algoId, almParams.params);
$.priceChangeProtection = true;
$.twapInterval = 600;
$.priceThreshold = 10_000;
emit PriceChangeProtectionParams(true, 600, 10_000);
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* VIEW FUNCTIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @inheritdoc IERC165
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IALM).interfaceId || interfaceId == type(ILPStrategy).interfaceId
|| super.supportsInterface(interfaceId);
}
/// @inheritdoc IStrategy
function supportedVaultTypes() external view virtual override returns (string[] memory types) {
types = new string[](1);
types[0] = VaultTypeLib.COMPOUNDING;
}
/// @inheritdoc IStrategy
function getAssetsProportions() public view returns (uint[] memory proportions) {
return ALMLib.getAssetsProportions(
_getALMStrategyBaseStorage(), _getLPStrategyBaseStorage(), _getStrategyBaseStorage()
);
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* IALM */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @inheritdoc IALM
function positions() external view returns (Position[] memory) {
ALMStrategyBaseStorage storage $ = _getALMStrategyBaseStorage();
return $.positions;
}
/// @inheritdoc IALM
function preset()
external
view
returns (uint algoId, string memory algoName, string memory presetName, int24[] memory params)
{
//slither-disable-next-line unused-return
return ALMLib.preset(_getALMStrategyBaseStorage());
}
/// @inheritdoc IALM
function needRebalance() external view returns (bool) {
return ALMLib.needRebalance(_getALMStrategyBaseStorage(), _getLPStrategyBaseStorage());
}
/// @inheritdoc IALM
function rebalance(bool[] memory burnOldPositions, NewPosition[] memory mintNewPositions) external {
IPlatform _platform = IPlatform(platform());
IHardWorker hardworker = IHardWorker(_platform.hardWorker());
address rebalancer = _platform.rebalancer();
if (
msg.sender != rebalancer && !_platform.isOperator(msg.sender)
&& !hardworker.dedicatedServerMsgSender(msg.sender)
) {
revert IControllable.IncorrectMsgSender();
}
_rebalance(burnOldPositions, mintNewPositions);
}
/// @inheritdoc IALM
function setupPriceChangeProtection(bool enabled, uint32 twapInterval, uint priceThreshold) external onlyOperator {
ALMStrategyBaseStorage storage $ = _getALMStrategyBaseStorage();
$.priceChangeProtection = enabled;
$.twapInterval = twapInterval;
$.priceThreshold = priceThreshold;
emit PriceChangeProtectionParams(enabled, twapInterval, priceThreshold);
}
/// @inheritdoc IALM
function setupALMParams(uint algoId, int24[] memory params) external onlyOperator {
ALMStrategyBaseStorage storage $ = _getALMStrategyBaseStorage();
$.algoId = algoId;
$.params = params;
emit ALMParams(algoId, params);
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* STRATEGY BASE */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @inheritdoc StrategyBase
function _assetsAmounts() internal view override returns (address[] memory assets_, uint[] memory amounts_) {
//slither-disable-next-line unused-return
return
ALMLib.assetsAmounts(_getALMStrategyBaseStorage(), _getLPStrategyBaseStorage(), _getStrategyBaseStorage());
}
/// @inheritdoc StrategyBase
function _previewDepositAssets(uint[] memory amountsMax)
internal
view
virtual
override
returns (uint[] memory amountsConsumed, uint value)
{
//slither-disable-next-line unused-return
return ALMLib.previewDepositAssets(
amountsMax, _getALMStrategyBaseStorage(), _getLPStrategyBaseStorage(), _getStrategyBaseStorage()
);
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* Must be implemented by derived contracts */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
function _rebalance(bool[] memory burnOldPositions, NewPosition[] memory mintNewPositions) internal virtual;
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* INTERNAL LOGIC */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
function _getALMStrategyBaseStorage() internal pure returns (ALMStrategyBaseStorage storage $) {
//slither-disable-next-line assembly
assembly {
$.slot := ALM_STRATEGY_BASE_STORAGE_LOCATION
}
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;
import "./StrategyBase.sol";
import "../libs/StrategyLib.sol";
import "../../interfaces/IStrategy.sol";
import "../../interfaces/IFactory.sol";
import "../../interfaces/IFarmingStrategy.sol";
import "../../interfaces/ISwapper.sol";
/// @title Base farming strategy
/// @author Alien Deployer (https://github.com/a17)
/// Changelog:
/// 1.3.1: liquidateRewards fix
/// 1.3.0: use customPriceImpactTolerance
/// @author JodsMigel (https://github.com/JodsMigel)
abstract contract FarmingStrategyBase is StrategyBase, IFarmingStrategy {
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* CONSTANTS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @dev Version of FarmingStrategyBase implementation
string public constant VERSION_FARMING_STRATEGY_BASE = "1.3.1";
// keccak256(abi.encode(uint256(keccak256("erc7201:stability.FarmingStrategyBase")) - 1)) & ~bytes32(uint256(0xff));
bytes32 private constant FARMINGSTRATEGYBASE_STORAGE_LOCATION =
0xe61f0a7b2953b9e28e48cc07562ad7979478dcaee972e68dcf3b10da2cba6000;
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* INITIALIZATION */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
//slither-disable-next-line naming-convention
function __FarmingStrategyBase_init(address platform_, uint farmId_) internal onlyInitializing {
StrategyLib.FarmingStrategyBase_init(
_getFarmingStrategyBaseStorage(), _getStrategyBaseStorage()._id, platform_, farmId_
);
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* RESTRICTED ACTIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @inheritdoc IFarmingStrategy
function refreshFarmingAssets() external onlyOperator {
StrategyLib.updateFarmingAssets(_getFarmingStrategyBaseStorage(), platform());
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* VIEW FUNCTIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @inheritdoc IERC165
function supportsInterface(bytes4 interfaceId) public view virtual override(StrategyBase) returns (bool) {
return interfaceId == type(IFarmingStrategy).interfaceId || super.supportsInterface(interfaceId);
}
/// @inheritdoc IFarmingStrategy
function farmId() public view returns (uint) {
return _getFarmingStrategyBaseStorage().farmId;
}
/// @inheritdoc IFarmingStrategy
function farmingAssets() external view returns (address[] memory) {
return _getFarmingStrategyBaseStorage()._rewardAssets;
}
/// @inheritdoc IFarmingStrategy
function stakingPool() external view virtual returns (address) {
return address(0);
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* Providing farm data to derived contracts */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
function _getFarm() internal view returns (IFactory.Farm memory) {
return _getFarm(platform(), farmId());
}
function _getFarm(address platform_, uint farmId_) internal view returns (IFactory.Farm memory) {
return IFactory(IPlatform(platform_).factory()).farm(farmId_);
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* STRATEGY BASE */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @inheritdoc StrategyBase
function _liquidateRewards(
address exchangeAsset,
address[] memory rewardAssets_,
uint[] memory rewardAmounts_
) internal override returns (uint earnedExchangeAsset) {
return StrategyLib.liquidateRewards(
platform(), exchangeAsset, rewardAssets_, rewardAmounts_, customPriceImpactTolerance()
);
}
function _getFarmingStrategyBaseStorage() internal pure returns (FarmingStrategyBaseStorage storage $) {
//slither-disable-next-line assembly
assembly {
$.slot := FARMINGSTRATEGYBASE_STORAGE_LOCATION
}
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;
import "../../core/base/Controllable.sol";
import "../../core/libs/VaultTypeLib.sol";
import "../libs/StrategyLib.sol";
import "../../interfaces/IStrategy.sol";
import "../../interfaces/IVault.sol";
/// @dev Base universal strategy
/// Changelog:
/// 2.1.1: extractFees fixed
/// 2.1.0: customPriceImpactTolerance
/// 2.0.0: previewDepositAssetsWrite; use platform.getCustomVaultFee
/// 1.1.0: autoCompoundingByUnderlyingProtocol(), virtual total()
/// @author Alien Deployer (https://github.com/a17)
/// @author JodsMigel (https://github.com/JodsMigel)
abstract contract StrategyBase is Controllable, IStrategy {
using SafeERC20 for IERC20;
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* CONSTANTS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @dev Version of StrategyBase implementation
string public constant VERSION_STRATEGY_BASE = "2.1.1";
// keccak256(abi.encode(uint256(keccak256("erc7201:stability.StrategyBase")) - 1)) & ~bytes32(uint256(0xff));
bytes32 private constant STRATEGYBASE_STORAGE_LOCATION =
0xb14b643f49bed6a2c6693bbd50f68dc950245db265c66acadbfa51ccc8c3ba00;
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* INITIALIZATION */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
//slither-disable-next-line naming-convention
function __StrategyBase_init(
address platform_,
string memory id_,
address vault_,
address[] memory assets_,
address underlying_,
uint exchangeAssetIndex_
) internal onlyInitializing {
__Controllable_init(platform_);
StrategyBaseStorage storage $ = _getStrategyBaseStorage();
($._id, $.vault, $._assets, $._underlying, $._exchangeAssetIndex) =
(id_, vault_, assets_, underlying_, exchangeAssetIndex_);
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* RESTRICTED ACTIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
modifier onlyVault() {
_requireVault();
_;
}
/// @inheritdoc IStrategy
function depositAssets(uint[] memory amounts) external override onlyVault returns (uint value) {
StrategyBaseStorage storage $ = _getStrategyBaseStorage();
if ($.lastHardWork == 0) {
$.lastHardWork = block.timestamp;
}
_beforeDeposit();
return _depositAssets(amounts, true);
}
/// @inheritdoc IStrategy
function withdrawAssets(
address[] memory assets_,
uint value,
address receiver
) external virtual onlyVault returns (uint[] memory amountsOut) {
_beforeWithdraw();
return _withdrawAssets(assets_, value, receiver);
}
function depositUnderlying(uint amount)
external
virtual
override
onlyVault
returns (uint[] memory amountsConsumed)
{
_beforeDeposit();
return _depositUnderlying(amount);
}
function withdrawUnderlying(uint amount, address receiver) external virtual override onlyVault {
_beforeWithdraw();
_withdrawUnderlying(amount, receiver);
}
/// @inheritdoc IStrategy
function transferAssets(
uint amount,
uint total_,
address receiver
) external onlyVault returns (uint[] memory amountsOut) {
_beforeTransferAssets();
//slither-disable-next-line unused-return
return StrategyLib.transferAssets(_getStrategyBaseStorage(), amount, total_, receiver);
}
/// @inheritdoc IStrategy
function doHardWork() external onlyVault {
_beforeDoHardWork();
StrategyBaseStorage storage $ = _getStrategyBaseStorage();
address _vault = $.vault;
//slither-disable-next-line unused-return
(uint tvl,) = IVault(_vault).tvl();
if (tvl > 0) {
address _platform = platform();
uint exchangeAssetIndex = $._exchangeAssetIndex;
(
address[] memory __assets,
uint[] memory __amounts,
address[] memory __rewardAssets,
uint[] memory __rewardAmounts
) = _claimRevenue();
//slither-disable-next-line uninitialized-local
uint totalBefore;
if (!autoCompoundingByUnderlyingProtocol()) {
__amounts[exchangeAssetIndex] +=
_liquidateRewards(__assets[exchangeAssetIndex], __rewardAssets, __rewardAmounts);
uint[] memory amountsRemaining = StrategyLib.extractFees(_platform, _vault, $._id, __assets, __amounts);
bool needCompound = _processRevenue(__assets, amountsRemaining);
totalBefore = $.total;
if (needCompound) {
_compound();
}
} else {
// maybe this is not final logic
// vault shares as fees can be used not only for autoCompoundingByUnderlyingProtocol strategies,
// but for many strategies linked to CVault if this feature will be implemented
IVault(_vault).hardWorkMintFeeCallback(__assets, __amounts);
// call empty method only for coverage or them can be overriden
_liquidateRewards(__assets[0], __rewardAssets, __rewardAmounts);
_processRevenue(__assets, __amounts);
_compound();
}
StrategyLib.emitApr($, _platform, __assets, __amounts, tvl, totalBefore);
}
}
/// @inheritdoc IStrategy
function emergencyStopInvesting() external onlyGovernanceOrMultisig {
// slither-disable-next-line unused-return
_withdrawAssets(total(), address(this));
}
/// @inheritdoc IStrategy
function setCustomPriceImpactTolerance(uint priceImpactTolerance) external onlyOperator {
StrategyBaseStorage storage $ = _getStrategyBaseStorage();
$.customPriceImpactTolerance = priceImpactTolerance;
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* VIEW FUNCTIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @inheritdoc IERC165
function supportsInterface(bytes4 interfaceId) public view virtual override(Controllable, IERC165) returns (bool) {
return interfaceId == type(IStrategy).interfaceId || super.supportsInterface(interfaceId);
}
function strategyLogicId() public view virtual returns (string memory);
/// @inheritdoc IStrategy
function assets() public view virtual returns (address[] memory) {
return _getStrategyBaseStorage()._assets;
}
/// @inheritdoc IStrategy
function underlying() public view override returns (address) {
return _getStrategyBaseStorage()._underlying;
}
/// @inheritdoc IStrategy
function vault() public view override returns (address) {
return _getStrategyBaseStorage().vault;
}
/// @inheritdoc IStrategy
function total() public view virtual override returns (uint) {
return _getStrategyBaseStorage().total;
}
/// @inheritdoc IStrategy
function lastHardWork() public view override returns (uint) {
return _getStrategyBaseStorage().lastHardWork;
}
/// @inheritdoc IStrategy
function lastApr() public view override returns (uint) {
return _getStrategyBaseStorage().lastApr;
}
/// @inheritdoc IStrategy
function lastAprCompound() public view override returns (uint) {
return _getStrategyBaseStorage().lastAprCompound;
}
/// @inheritdoc IStrategy
function assetsAmounts() public view virtual returns (address[] memory assets_, uint[] memory amounts_) {
(assets_, amounts_) = _assetsAmounts();
//slither-disable-next-line unused-return
return StrategyLib.assetsAmountsWithBalances(assets_, amounts_);
}
/// @inheritdoc IStrategy
function previewDepositAssets(
address[] memory assets_,
uint[] memory amountsMax
) public view virtual returns (uint[] memory amountsConsumed, uint value) {
// nosemgrep
if (assets_.length == 1 && assets_[0] == _getStrategyBaseStorage()._underlying && assets_[0] != address(0)) {
if (amountsMax.length != 1) {
revert IControllable.IncorrectArrayLength();
}
value = amountsMax[0];
amountsConsumed = _previewDepositUnderlying(amountsMax[0]);
} else {
return _previewDepositAssets(assets_, amountsMax);
}
}
/// @inheritdoc IStrategy
function previewDepositAssetsWrite(
address[] memory assets_,
uint[] memory amountsMax
) external virtual returns (uint[] memory amountsConsumed, uint value) {
// nosemgrep
if (assets_.length == 1 && assets_[0] == _getStrategyBaseStorage()._underlying && assets_[0] != address(0)) {
if (amountsMax.length != 1) {
revert IControllable.IncorrectArrayLength();
}
value = amountsMax[0];
amountsConsumed = _previewDepositUnderlyingWrite(amountsMax[0]);
} else {
return _previewDepositAssetsWrite(assets_, amountsMax);
}
}
/// @inheritdoc IStrategy
function autoCompoundingByUnderlyingProtocol() public view virtual returns (bool) {
return false;
}
/// @inheritdoc IStrategy
function customPriceImpactTolerance() public view returns (uint) {
return _getStrategyBaseStorage().customPriceImpactTolerance;
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* Default implementations */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @dev Invest underlying asset. Asset must be already on strategy contract balance.
/// @return Cosumed amounts of invested assets
function _depositUnderlying(uint /*amount*/ ) internal virtual returns (uint[] memory /*amountsConsumed*/ ) {
revert(_getStrategyBaseStorage()._underlying == address(0) ? "no underlying" : "not implemented");
}
/// @dev Wothdraw underlying invested and send to receiver
function _withdrawUnderlying(uint, /*amount*/ address /*receiver*/ ) internal virtual {
revert(_getStrategyBaseStorage()._underlying == address(0) ? "no underlying" : "not implemented");
}
/// @dev Calculation of consumed amounts and liquidity/underlying value for provided amount of underlying
function _previewDepositUnderlying(uint /*amount*/ )
internal
view
virtual
returns (uint[] memory /*amountsConsumed*/ )
{}
function _previewDepositUnderlyingWrite(uint amount)
internal
view
virtual
returns (uint[] memory amountsConsumed)
{
return _previewDepositUnderlying(amount);
}
/// @dev Can be overrided by derived base strategies for custom logic
function _beforeDeposit() internal virtual {}
/// @dev Can be overrided by derived base strategies for custom logic
function _beforeWithdraw() internal virtual {}
/// @dev Can be overrided by derived base strategies for custom logic
function _beforeTransferAssets() internal virtual {}
/// @dev Can be overrided by derived base strategies for custom logic
function _beforeDoHardWork() internal virtual {
if (!IStrategy(this).isReadyForHardWork()) {
revert NotReadyForHardWork();
}
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* Must be implemented by derived contracts */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @inheritdoc IStrategy
function supportedVaultTypes() external view virtual returns (string[] memory types);
/// @dev Investing assets. Amounts must be on strategy contract balance.
/// @param amounts Amounts of strategy assets to invest
/// @param claimRevenue Claim revenue before investing
/// @return value Output of liquidity value or underlying token amount
function _depositAssets(uint[] memory amounts, bool claimRevenue) internal virtual returns (uint value);
/// @dev Withdraw assets from investing and send to user.
/// Here we give the user a choice of assets to withdraw if strategy support it.
/// This full form of _withdrawAssets can be implemented only in inherited base strategy contract.
/// @param assets_ Assets for withdrawal. Can contain not all strategy assets if it need.
/// @param value Part of strategy total value to withdraw
/// @param receiver User address
/// @return amountsOut Amounts of assets sent to user
function _withdrawAssets(
address[] memory assets_,
uint value,
address receiver
) internal virtual returns (uint[] memory amountsOut);
/// @dev Withdraw strategy assets from investing and send to user.
/// This light form of _withdrawAssets is suitable for implementation into final strategy contract.
/// @param value Part of strategy total value to withdraw
/// @param receiver User address
/// @return amountsOut Amounts of assets sent to user
function _withdrawAssets(uint value, address receiver) internal virtual returns (uint[] memory amountsOut);
/// @dev Claim all possible revenue to strategy contract balance and calculate claimed revenue after previous HardWork
/// @return __assets Strategy assets
/// @return __amounts Amounts of claimed revenue in form of strategy assets
/// @return __rewardAssets Farming reward assets
/// @return __rewardAmounts Amounts of claimed farming rewards
function _claimRevenue()
internal
virtual
returns (
address[] memory __assets,
uint[] memory __amounts,
address[] memory __rewardAssets,
uint[] memory __rewardAmounts
);
function _processRevenue(
address[] memory assets_,
uint[] memory amountsRemaining
) internal virtual returns (bool needCompound);
function _liquidateRewards(
address exchangeAsset,
address[] memory rewardAssets_,
uint[] memory rewardAmounts_
) internal virtual returns (uint earnedExchangeAsset);
/// @dev Reinvest strategy assets of strategy contract balance
function _compound() internal virtual;
/// @dev Strategy assets and amounts that strategy invests. Without assets on strategy contract balance
/// @return assets_ Strategy assets
/// @return amounts_ Amounts invested
function _assetsAmounts() internal view virtual returns (address[] memory assets_, uint[] memory amounts_);
/// @dev Calculation of consumed amounts and liquidity/underlying value for provided strategy assets and amounts.
/// @dev This full form of _previewDepositAssets can be implemented only in inherited base strategy contract
/// @param assets_ Strategy assets or part of them, if necessary
/// @param amountsMax Amounts of specified assets available for investing
/// @return amountsConsumed Consumed amounts of assets when investing
/// @return value Liquidity value or underlying token amount minted when investing
function _previewDepositAssets(
address[] memory assets_,
uint[] memory amountsMax
) internal view virtual returns (uint[] memory amountsConsumed, uint value);
/// @dev Write version of _previewDepositAssets
/// @param assets_ Strategy assets or part of them, if necessary
/// @param amountsMax Amounts of specified assets available for investing
/// @return amountsConsumed Consumed amounts of assets when investing
/// @return value Liquidity value or underlying token amount minted when investing
function _previewDepositAssetsWrite(
address[] memory assets_,
uint[] memory amountsMax
) internal virtual returns (uint[] memory amountsConsumed, uint value) {
return _previewDepositAssets(assets_, amountsMax);
}
/// @dev Calculation of consumed amounts and liquidity/underlying value for provided strategy assets and amounts.
/// Light form of _previewDepositAssets is suitable for implementation into final strategy contract.
/// @param amountsMax Amounts of specified assets available for investing
/// @return amountsConsumed Consumed amounts of assets when investing
/// @return value Liquidity value or underlying token amount minted when investing
function _previewDepositAssets(uint[] memory amountsMax)
internal
view
virtual
returns (uint[] memory amountsConsumed, uint value);
/// @dev Write version of _previewDepositAssets
/// @param amountsMax Amounts of specified assets available for investing
/// @return amountsConsumed Consumed amounts of assets when investing
/// @return value Liquidity value or underlying token amount minted when investing
function _previewDepositAssetsWrite(uint[] memory amountsMax)
internal
virtual
returns (uint[] memory amountsConsumed, uint value)
{
return _previewDepositAssets(amountsMax);
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* INTERNAL LOGIC */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
function _getStrategyBaseStorage() internal pure returns (StrategyBaseStorage storage $) {
//slither-disable-next-line assembly
assembly {
$.slot := STRATEGYBASE_STORAGE_LOCATION
}
}
function _requireVault() internal view {
if (msg.sender != _getStrategyBaseStorage().vault) {
revert IControllable.NotVault();
}
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;
library StrategyIdLib {
string internal constant DEV = "Dev Alpha DeepSpaceSwap Farm";
string internal constant QUICKSWAPV3_STATIC_FARM = "QuickSwapV3 Static Farm";
string internal constant GAMMA_QUICKSWAP_MERKL_FARM = "Gamma QuickSwap Merkl Farm";
string internal constant GAMMA_RETRO_MERKL_FARM = "Gamma Retro Merkl Farm";
string internal constant GAMMA_UNISWAPV3_MERKL_FARM = "Gamma UniswapV3 Merkl Farm";
string internal constant COMPOUND_FARM = "Compound Farm";
string internal constant DEFIEDGE_QUICKSWAP_MERKL_FARM = "DefiEdge QuickSwap Merkl Farm";
string internal constant STEER_QUICKSWAP_MERKL_FARM = "Steer QuickSwap Merkl Farm";
string internal constant ICHI_QUICKSWAP_MERKL_FARM = "Ichi QuickSwap Merkl Farm";
string internal constant ICHI_RETRO_MERKL_FARM = "Ichi Retro Merkl Farm";
string internal constant QUICKSWAP_STATIC_MERKL_FARM = "QuickSwap Static Merkl Farm";
string internal constant CURVE_CONVEX_FARM = "Curve Convex Farm";
string internal constant YEARN = "Yearn";
string internal constant TRIDENT_PEARL_FARM = "Trident Pearl Farm";
string internal constant BEETS_STABLE_FARM = "Beets Stable Farm";
string internal constant BEETS_WEIGHTED_FARM = "Beets Weighted Farm";
string internal constant EQUALIZER_FARM = "Equalizer Farm";
string internal constant ICHI_SWAPX_FARM = "Ichi SwapX Farm";
string internal constant SWAPX_FARM = "SwapX Farm";
string internal constant ALM_SHADOW_FARM = "ALM Shadow Farm";
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IALM} from "../../interfaces/IALM.sol";
import {ILPStrategy} from "../../interfaces/ILPStrategy.sol";
import {IStrategy} from "../../interfaces/IStrategy.sol";
import {ICAmmAdapter} from "../../interfaces/ICAmmAdapter.sol";
import {AmmAdapterIdLib} from "../../adapters/libs/AmmAdapterIdLib.sol";
import {IUniswapV3Pool} from "../../integrations/uniswapv3/IUniswapV3Pool.sol";
import {UniswapV3MathLib} from "./UniswapV3MathLib.sol";
library ALMLib {
uint public constant ALGO_FILL_UP = 0;
uint public constant PRECISION = 1e36;
/*function checkCompatibility(
IALM.ALMStrategyBaseStorage storage $,
ILPStrategy.LPStrategyBaseStorage storage _$_
) external view {
ICAmmAdapter adapter = ICAmmAdapter(address(_$_.ammAdapter));
if (keccak256(bytes(adapter.ammAdapterId())) != keccak256(bytes(AmmAdapterIdLib.UNISWAPV3))) {
revert("Not supported CL AMM adapter");
}
if ($.algoId != ALGO_FILL_UP) {
revert("Not supported ALM algo");
}
}*/
function getAssetsProportions(
IALM.ALMStrategyBaseStorage storage $,
ILPStrategy.LPStrategyBaseStorage storage _$_,
IStrategy.StrategyBaseStorage storage __$__
) external view returns (uint[] memory proportions) {
uint[] memory amounts;
ICAmmAdapter adapter = ICAmmAdapter(address(_$_.ammAdapter));
address pool = _$_.pool;
uint[] memory amountsMax = new uint[](2);
amountsMax[0] = 1e20;
amountsMax[1] = 1e20;
int24[] memory ticks = new int24[](2);
if (__$__.total != 0) {
IALM.Position memory position = $.positions[0];
ticks[0] = position.tickLower;
ticks[1] = position.tickUpper;
(, amounts) = adapter.getLiquidityForAmounts(pool, amountsMax, ticks);
} else {
int24 tick = getUniswapV3CurrentTick(pool);
(ticks[0], ticks[1]) = calcFillUpBaseTicks(tick, $.params[0], getUniswapV3TickSpacing(pool));
(, amounts) = adapter.getLiquidityForAmounts(pool, amountsMax, ticks);
}
uint price = getUniswapV3PoolPrice(_$_.pool);
uint amount0PricedInAmount1 = amounts[0] * price / PRECISION;
uint prop0 = 1e18 * amount0PricedInAmount1 / (amount0PricedInAmount1 + amounts[1]);
proportions = new uint[](2);
proportions[0] = prop0;
proportions[1] = 1e18 - prop0;
}
function needRebalance(
IALM.ALMStrategyBaseStorage storage $,
ILPStrategy.LPStrategyBaseStorage storage _$_
) external view returns (bool need) {
if ($.algoId == ALGO_FILL_UP) {
uint len = $.positions.length;
if (len == 0) {
return false;
}
int24 halfRange = $.params[0] / 2;
int24 halfTriggerRange = $.params[1] / 2;
int24 oldMedianTick = $.positions[0].tickLower + halfRange;
int24 currentTick = getUniswapV3CurrentTick(_$_.pool);
return (currentTick > oldMedianTick + halfTriggerRange) || (currentTick < oldMedianTick - halfTriggerRange);
}
}
function getAlgoNamyById(uint algoId) public pure returns (string memory) {
if (algoId == ALGO_FILL_UP) {
return "Fill-Up";
}
return "Unknown";
}
function getPresetNameByAlgoAndParams(uint algoId, int24[] memory params) public pure returns (string memory) {
if (algoId == ALGO_FILL_UP) {
if (params[0] >= 10000) {
return "Stretched";
}
if (params[0] >= 4000) {
return "Passive";
}
if (params[0] >= 2000) {
return "Wide";
}
if (params[0] >= 1000) {
return "Narrow";
}
if (params[0] >= 100) {
return "Aggressive";
}
return "Insane";
}
return "Unknown";
}
function preset(IALM.ALMStrategyBaseStorage storage $)
external
view
returns (uint algoId, string memory algoName, string memory presetName, int24[] memory params)
{
algoId = $.algoId;
algoName = getAlgoNamyById(algoId);
params = $.params;
presetName = getPresetNameByAlgoAndParams(algoId, params);
}
function assetsAmounts(
IALM.ALMStrategyBaseStorage storage $,
ILPStrategy.LPStrategyBaseStorage storage _$_,
IStrategy.StrategyBaseStorage storage __$__
) public view returns (address[] memory assets_, uint[] memory amounts_) {
ICAmmAdapter adapter = ICAmmAdapter(address(_$_.ammAdapter));
address _pool = _$_.pool;
assets_ = __$__._assets;
amounts_ = new uint[](2);
uint len = $.positions.length;
for (uint i; i < len; ++i) {
IALM.Position memory position = $.positions[i];
int24[] memory ticks = new int24[](2);
ticks[0] = position.tickLower;
ticks[1] = position.tickUpper;
uint[] memory positionAmounts = adapter.getAmountsForLiquidity(_pool, ticks, position.liquidity);
amounts_[0] += positionAmounts[0];
amounts_[1] += positionAmounts[1];
}
}
function previewDepositAssets(
uint[] memory amountsMax,
IALM.ALMStrategyBaseStorage storage $,
ILPStrategy.LPStrategyBaseStorage storage _$_,
IStrategy.StrategyBaseStorage storage __$__
) external view returns (uint[] memory amountsConsumed, uint value) {
if ($.algoId == ALGO_FILL_UP) {
ICAmmAdapter adapter = ICAmmAdapter(address(_$_.ammAdapter));
address pool = _$_.pool;
uint price = getUniswapV3PoolPrice(pool);
if (__$__.total == 0) {
int24 tick = getUniswapV3CurrentTick(pool);
int24[] memory ticks = new int24[](2);
(ticks[0], ticks[1]) = calcFillUpBaseTicks(tick, $.params[0], getUniswapV3TickSpacing(pool));
(, amountsConsumed) = adapter.getLiquidityForAmounts(pool, amountsMax, ticks);
value = amountsConsumed[1] + (amountsConsumed[0] * price / PRECISION);
} else {
int24[] memory ticks = new int24[](2);
IALM.Position memory position = $.positions[0];
ticks[0] = position.tickLower;
ticks[1] = position.tickUpper;
(, amountsConsumed) = adapter.getLiquidityForAmounts(pool, amountsMax, ticks);
value = amountsConsumed[1] + (amountsConsumed[0] * price / PRECISION);
(, uint[] memory totalAmounts) = IStrategy(address(this)).assetsAmounts();
uint totalAmount = totalAmounts[1] + totalAmounts[0] * price / PRECISION;
value = value * __$__.total / totalAmount;
}
}
}
function calcFillUpBaseTicks(
int24 tick,
int24 tickRange,
int24 tickSpacing
) public pure returns (int24 lowerTick, int24 upperTick) {
int24 halfTickRange = tickRange / 2;
if (tick < 0 && tick / tickSpacing * tickSpacing != tick) {
lowerTick = ((tick - halfTickRange) / tickSpacing - 1) * tickSpacing;
} else {
lowerTick = (tick - halfTickRange) / tickSpacing * tickSpacing;
}
upperTick = lowerTick + halfTickRange * 2;
}
function getUniswapV3PoolPrice(address pool) public view returns (uint price) {
// both ways are ok probably
(uint160 sqrtPrice,,,,,,) = IUniswapV3Pool(pool).slot0();
//(, int24 tick,,,,,) = IUniswapV3Pool(pool).slot0();
//uint160 sqrtPrice = UniswapV3MathLib.getSqrtRatioAtTick(tick);
price = UniswapV3MathLib.mulDiv(uint(sqrtPrice) * uint(sqrtPrice), PRECISION, 2 ** (96 * 2));
}
function getUniswapV3TickSpacing(address pool) public view returns (int24 tickSpacing) {
tickSpacing = IUniswapV3Pool(pool).tickSpacing();
}
function getUniswapV3CurrentTick(address pool) public view returns (int24 tick) {
//slither-disable-next-line unused-return
(, tick,,,,,) = IUniswapV3Pool(pool).slot0();
}
/// @notice Check if the price change overflows or not based on given twap and threshold in pool
/// @param pool UniswapV3Pool address
/// @param twapInterval Time intervals
/// @param priceThreshold Price Threshold
function checkPriceChange(address pool, uint32 twapInterval, uint priceThreshold) external view {
(uint160 sqrtPrice,,,,,,) = IUniswapV3Pool(pool).slot0();
uint price = UniswapV3MathLib.mulDiv(uint(sqrtPrice) * uint(sqrtPrice), PRECISION, 2 ** (96 * 2));
uint160 sqrtPriceBefore = _getUniswapV3SqrtTwapX96(pool, twapInterval);
uint priceBefore =
UniswapV3MathLib.mulDiv(uint(sqrtPriceBefore) * uint(sqrtPriceBefore), PRECISION, 2 ** (96 * 2));
if (price * 10_000 / priceBefore > priceThreshold || priceBefore * 10_000 / price > priceThreshold) {
revert IALM.PriceChangeProtection(price, priceBefore, priceThreshold, twapInterval);
}
}
/// @notice Get the sqrt price before the given interval
/// @param pool UniswapV3Pool address
/// @param twapInterval Time intervals
/// @return sqrtPriceX96 Sqrt price before interval
function _getUniswapV3SqrtTwapX96(address pool, uint32 twapInterval) internal view returns (uint160 sqrtPriceX96) {
if (twapInterval == 0) {
/// return the current price if _twapInterval == 0
(sqrtPriceX96,,,,,,) = IUniswapV3Pool(pool).slot0();
} else {
uint32[] memory secondsAgos = new uint32[](2);
secondsAgos[0] = twapInterval;
/// from (before)
secondsAgos[1] = 0;
/// to (now)
(int56[] memory tickCumulatives,) = IUniswapV3Pool(pool).observe(secondsAgos);
/// tick(imprecise as it's an integer) to price
sqrtPriceX96 = UniswapV3MathLib.getSqrtRatioAtTick(
int24((tickCumulatives[1] - tickCumulatives[0]) / int56(int32(twapInterval)))
);
}
}
function balance(address token) public view returns (uint) {
return IERC20(token).balanceOf(address(this));
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {ALMLib} from "./ALMLib.sol";
import {IALM} from "../../interfaces/IALM.sol";
import {ILPStrategy} from "../../interfaces/ILPStrategy.sol";
import {IStrategy} from "../../interfaces/IStrategy.sol";
import {INonfungiblePositionManager} from "../../integrations/ramsesv3/INonfungiblePositionManager.sol";
import {IFarmingStrategy} from "../../interfaces/IFarmingStrategy.sol";
import {IFactory} from "../../interfaces/IFactory.sol";
import {IPlatform} from "../../interfaces/IPlatform.sol";
import {IControllable} from "../../interfaces/IControllable.sol";
import {IGaugeV3} from "../../integrations/shadow/IGaugeV3.sol";
library ALMRamsesV3Lib {
using SafeERC20 for IERC20;
struct DepositAssetsVars {
address nft;
address pool;
address[] assets;
}
function depositAssets(
uint[] memory amounts,
IALM.ALMStrategyBaseStorage storage $,
ILPStrategy.LPStrategyBaseStorage storage _$_,
IStrategy.StrategyBaseStorage storage __$__
) external returns (uint value) {
if ($.algoId == ALMLib.ALGO_FILL_UP) {
DepositAssetsVars memory v;
v.nft = $.nft;
v.pool = _$_.pool;
v.assets = __$__._assets;
uint price = ALMLib.getUniswapV3PoolPrice(v.pool);
value = amounts[1] + (amounts[0] * price / ALMLib.PRECISION);
uint total = __$__.total;
int24 tickSpacing = ALMLib.getUniswapV3TickSpacing(v.pool);
if ($.priceChangeProtection) {
ALMLib.checkPriceChange(v.pool, $.twapInterval, $.priceThreshold);
}
if (total == 0) {
IALM.Position memory position;
(position.tickLower, position.tickUpper) =
ALMLib.calcFillUpBaseTicks(ALMLib.getUniswapV3CurrentTick(v.pool), $.params[0], tickSpacing);
(position.tokenId, position.liquidity,,) = INonfungiblePositionManager(v.nft).mint(
INonfungiblePositionManager.MintParams({
token0: v.assets[0],
token1: v.assets[1],
tickSpacing: tickSpacing,
tickLower: position.tickLower,
tickUpper: position.tickUpper,
amount0Desired: amounts[0],
amount1Desired: amounts[1],
amount0Min: 0,
amount1Min: 0,
recipient: address(this),
deadline: block.timestamp
})
);
$.positions.push(position);
__$__.total = value;
} else {
(, uint[] memory totalAmounts) = IStrategy(address(this)).assetsAmounts();
uint totalAmount = totalAmounts[1] + totalAmounts[0] * price / ALMLib.PRECISION - value;
value = value * total / totalAmount;
IALM.Position memory position = $.positions[0];
(uint128 addedLiquidity,,) = INonfungiblePositionManager(v.nft).increaseLiquidity(
INonfungiblePositionManager.IncreaseLiquidityParams({
tokenId: position.tokenId,
amount0Desired: ALMLib.balance(v.assets[0]),
amount1Desired: ALMLib.balance(v.assets[1]),
amount0Min: 0,
amount1Min: 0,
deadline: block.timestamp
})
);
$.positions[0].liquidity = position.liquidity + addedLiquidity;
__$__.total = total + value;
}
}
}
function withdrawAssets(
uint value,
address receiver,
IALM.ALMStrategyBaseStorage storage $,
IStrategy.StrategyBaseStorage storage __$__
) external returns (uint[] memory amountsOut) {
if ($.algoId == ALMLib.ALGO_FILL_UP) {
address nft = $.nft;
// burn liquidity
amountsOut = new uint[](2);
uint positionsLength = $.positions.length;
IALM.Position memory position = $.positions[0];
uint total = __$__.total;
uint128 liquidityToBurn = uint128(uint(position.liquidity) * value / total);
(amountsOut[0], amountsOut[1]) = INonfungiblePositionManager(nft).decreaseLiquidity(
INonfungiblePositionManager.DecreaseLiquidityParams({
tokenId: position.tokenId,
liquidity: liquidityToBurn,
amount0Min: 0,
amount1Min: 0,
deadline: block.timestamp
})
);
$.positions[0].liquidity = position.liquidity - liquidityToBurn;
INonfungiblePositionManager(nft).collect(
INonfungiblePositionManager.CollectParams({
tokenId: position.tokenId,
recipient: receiver,
amount0Max: uint128(amountsOut[0]),
amount1Max: uint128(amountsOut[1])
})
);
if (positionsLength == 2) {
position = $.positions[1];
liquidityToBurn = uint128(uint(position.liquidity) * value / total);
(uint fillupOut0, uint fillupOut1) = INonfungiblePositionManager(nft).decreaseLiquidity(
INonfungiblePositionManager.DecreaseLiquidityParams({
tokenId: position.tokenId,
liquidity: liquidityToBurn,
amount0Min: 0,
amount1Min: 0,
deadline: block.timestamp
})
);
$.positions[1].liquidity = position.liquidity - liquidityToBurn;
amountsOut[0] += fillupOut0;
amountsOut[1] += fillupOut1;
INonfungiblePositionManager(nft).collect(
INonfungiblePositionManager.CollectParams({
tokenId: position.tokenId,
recipient: receiver,
amount0Max: uint128(fillupOut0),
amount1Max: uint128(fillupOut1)
})
);
}
// send balance part
address[] memory assets = __$__._assets;
uint balance0ToSend = ALMLib.balance(assets[0]) * value / total;
uint balance1ToSend = ALMLib.balance(assets[1]) * value / total;
if (balance0ToSend != 0) {
IERC20(assets[0]).safeTransfer(receiver, balance0ToSend);
amountsOut[0] += balance0ToSend;
}
if (balance1ToSend != 0) {
IERC20(assets[1]).safeTransfer(receiver, balance1ToSend);
amountsOut[1] += balance1ToSend;
}
__$__.total = total - value;
}
}
function rebalance(
bool[] memory,
IALM.NewPosition[] memory mintNewPositions,
IALM.ALMStrategyBaseStorage storage $,
ILPStrategy.LPStrategyBaseStorage storage _$_,
IFarmingStrategy.FarmingStrategyBaseStorage storage _f$f_,
IStrategy.StrategyBaseStorage storage __$__
) external {
if ($.algoId == ALMLib.ALGO_FILL_UP) {
if (mintNewPositions.length != 1 && mintNewPositions.length != 2) {
revert IALM.IncorrectRebalanceArgs();
}
// collect farm rewards
// collectFees($, _$_);
collectFarmRewards($, _f$f_);
// burn old tokenIds
address nft = $.nft;
uint positionsLength = $.positions.length;
IALM.Position memory position;
if (positionsLength == 2) {
position = $.positions[1];
INonfungiblePositionManager(nft).decreaseLiquidity(
INonfungiblePositionManager.DecreaseLiquidityParams({
tokenId: position.tokenId,
liquidity: position.liquidity,
amount0Min: 0,
amount1Min: 0,
deadline: block.timestamp
})
);
INonfungiblePositionManager(nft).collect(
INonfungiblePositionManager.CollectParams({
tokenId: position.tokenId,
recipient: address(this),
amount0Max: type(uint128).max,
amount1Max: type(uint128).max
})
);
INonfungiblePositionManager(nft).burn(position.tokenId);
$.positions.pop();
}
position = $.positions[0];
INonfungiblePositionManager(nft).decreaseLiquidity(
INonfungiblePositionManager.DecreaseLiquidityParams({
tokenId: position.tokenId,
liquidity: position.liquidity,
amount0Min: 0,
amount1Min: 0,
deadline: block.timestamp
})
);
INonfungiblePositionManager(nft).collect(
INonfungiblePositionManager.CollectParams({
tokenId: position.tokenId,
recipient: address(this),
amount0Max: type(uint128).max,
amount1Max: type(uint128).max
})
);
INonfungiblePositionManager(nft).burn(position.tokenId);
$.positions.pop();
// mint new positions
{
address[] memory assets = __$__._assets;
int24 tickSpacing = ALMLib.getUniswapV3TickSpacing(_$_.pool);
position.tickLower = mintNewPositions[0].tickLower;
position.tickUpper = mintNewPositions[0].tickUpper;
(position.tokenId, position.liquidity,,) = INonfungiblePositionManager(nft).mint(
INonfungiblePositionManager.MintParams({
token0: assets[0],
token1: assets[1],
tickSpacing: tickSpacing,
tickLower: position.tickLower,
tickUpper: position.tickUpper,
amount0Desired: ALMLib.balance(assets[0]),
amount1Desired: ALMLib.balance(assets[1]),
amount0Min: mintNewPositions[0].minAmount0,
amount1Min: mintNewPositions[0].minAmount1,
recipient: address(this),
deadline: block.timestamp
})
);
$.positions.push(position);
if (mintNewPositions.length == 2) {
position.tickLower = mintNewPositions[1].tickLower;
position.tickUpper = mintNewPositions[1].tickUpper;
(position.tokenId, position.liquidity,,) = INonfungiblePositionManager(nft).mint(
INonfungiblePositionManager.MintParams({
token0: assets[0],
token1: assets[1],
tickSpacing: tickSpacing,
tickLower: position.tickLower,
tickUpper: position.tickUpper,
amount0Desired: ALMLib.balance(assets[0]),
amount1Desired: ALMLib.balance(assets[1]),
amount0Min: mintNewPositions[1].minAmount0,
amount1Min: mintNewPositions[1].minAmount1,
recipient: address(this),
deadline: block.timestamp
})
);
$.positions.push(position);
}
}
emit IALM.Rebalance($.positions);
}
}
/*function collectFees(IALM.ALMStrategyBaseStorage storage $, ILPStrategy.LPStrategyBaseStorage storage _$_) public {
if ($.algoId == ALMLib.ALGO_FILL_UP) {
address nft = $.nft;
// collect fees
uint positionsLength = $.positions.length;
IALM.Position memory position = $.positions[0];
{
uint[] memory fees = new uint[](2);
(uint feeAmount0, uint feeAmount1) = INonfungiblePositionManager(nft).collect(
INonfungiblePositionManager.CollectParams({
tokenId: position.tokenId,
recipient: address(this),
amount0Max: type(uint128).max,
amount1Max: type(uint128).max
})
);
fees[0] = feeAmount0;
fees[1] = feeAmount1;
console.log('fees', fees[0], fees[1]);
if (positionsLength == 2) {
position = $.positions[1];
(feeAmount0, feeAmount1) = INonfungiblePositionManager(nft).collect(
INonfungiblePositionManager.CollectParams({
tokenId: position.tokenId,
recipient: address(this),
amount0Max: type(uint128).max,
amount1Max: type(uint128).max
})
);
fees[0] += feeAmount0;
fees[1] += feeAmount1;
}
_$_._feesOnBalance[0] += fees[0];
_$_._feesOnBalance[1] += fees[1];
emit ILPStrategy.FeesClaimed(fees);
}
//////////
}
}*/
function collectFarmRewards(
IALM.ALMStrategyBaseStorage storage $,
IFarmingStrategy.FarmingStrategyBaseStorage storage _f$f_
) public {
IFactory.Farm memory farm =
IFactory(IPlatform(IControllable(address(this)).platform()).factory()).farm(_f$f_.farmId);
address gauge = farm.addresses[0];
uint len = $.positions.length;
uint[] memory tokenIds = new uint[](len);
for (uint i; i < len; ++i) {
tokenIds[i] = $.positions[i].tokenId;
}
address[] memory rewardAssets = _f$f_._rewardAssets;
len = rewardAssets.length;
uint[] memory rewardBalanceBefore = new uint[](len);
for (uint i; i < len; ++i) {
rewardBalanceBefore[i] = ALMLib.balance(rewardAssets[i]);
}
IGaugeV3(gauge).getReward(tokenIds, rewardAssets);
uint[] memory rewardsClaimed = new uint[](len);
for (uint i; i < len; ++i) {
rewardsClaimed[i] = ALMLib.balance(rewardAssets[i]) - rewardBalanceBefore[i];
_f$f_._rewardsOnBalance[i] += rewardsClaimed[i];
}
emit IFarmingStrategy.RewardsClaimed(rewardsClaimed);
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;
library FarmMechanicsLib {
// Staking to gauge/farm to earn rewards
string internal constant CLASSIC = "Classic";
// Merkl protocol rewards calculated off-chain and credited periodically
string internal constant MERKL = "Merkl";
// Automatic farming without staking with on-chain calculated rewards
string internal constant AUTO = "Auto";
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "./ConstantsLib.sol";
library CommonLib {
function filterAddresses(
address[] memory addresses,
address addressToRemove
) external pure returns (address[] memory filteredAddresses) {
uint len = addresses.length;
uint newLen;
// nosemgrep
for (uint i; i < len; ++i) {
if (addresses[i] != addressToRemove) {
++newLen;
}
}
filteredAddresses = new address[](newLen);
uint k;
// nosemgrep
for (uint i; i < len; ++i) {
if (addresses[i] != addressToRemove) {
filteredAddresses[k] = addresses[i];
++k;
}
}
}
function formatUsdAmount(uint amount) external pure returns (string memory formattedPrice) {
uint dollars = amount / 10 ** 18;
string memory priceStr;
if (dollars >= 1000) {
uint kDollars = dollars / 1000;
uint kDollarsFraction = (dollars - kDollars * 1000) / 10;
string memory delimiter = ".";
if (kDollarsFraction < 10) {
delimiter = ".0";
}
priceStr = string.concat(Strings.toString(kDollars), delimiter, Strings.toString(kDollarsFraction), "k");
} else if (dollars >= 100) {
priceStr = Strings.toString(dollars);
} else {
uint dollarsFraction = (amount - dollars * 10 ** 18) / 10 ** 14;
if (dollarsFraction > 0) {
string memory dollarsFractionDelimiter = ".";
if (dollarsFraction < 10) {
dollarsFractionDelimiter = ".000";
} else if (dollarsFraction < 100) {
dollarsFractionDelimiter = ".00";
} else if (dollarsFraction < 1000) {
dollarsFractionDelimiter = ".0";
}
priceStr = string.concat(
Strings.toString(dollars), dollarsFractionDelimiter, Strings.toString(dollarsFraction)
);
} else {
priceStr = Strings.toString(dollars);
}
}
formattedPrice = string.concat("$", priceStr);
}
function formatApr(uint apr) external pure returns (string memory formattedApr) {
uint aprInt = apr * 100 / ConstantsLib.DENOMINATOR;
uint aprFraction = (apr - aprInt * ConstantsLib.DENOMINATOR / 100) / 10;
string memory delimiter = ".";
if (aprFraction < 10) {
delimiter = ".0";
}
formattedApr = string.concat(Strings.toString(aprInt), delimiter, Strings.toString(aprFraction), "%");
}
function implodeSymbols(
address[] memory assets,
string memory delimiter
) external view returns (string memory outString) {
return implode(getSymbols(assets), delimiter);
}
function implode(string[] memory strings, string memory delimiter) public pure returns (string memory outString) {
uint len = strings.length;
if (len == 0) {
return "";
}
outString = strings[0];
// nosemgrep
for (uint i = 1; i < len; ++i) {
outString = string.concat(outString, delimiter, strings[i]);
}
return outString;
}
function getSymbols(address[] memory assets) public view returns (string[] memory symbols) {
uint len = assets.length;
symbols = new string[](len);
// nosemgrep
for (uint i; i < len; ++i) {
symbols[i] = IERC20Metadata(assets[i]).symbol();
}
}
function bytesToBytes32(bytes memory b) external pure returns (bytes32 out) {
// nosemgrep
for (uint i; i < b.length; ++i) {
out |= bytes32(b[i] & 0xFF) >> (i * 8);
}
// return out;
}
function bToHex(bytes memory buffer) external pure returns (string memory) {
// Fixed buffer size for hexadecimal convertion
bytes memory converted = new bytes(buffer.length * 2);
bytes memory _base = "0123456789abcdef";
uint baseLength = _base.length;
// nosemgrep
for (uint i; i < buffer.length; ++i) {
converted[i * 2] = _base[uint8(buffer[i]) / baseLength];
converted[i * 2 + 1] = _base[uint8(buffer[i]) % baseLength];
}
return string(abi.encodePacked(converted));
}
function shortId(string memory id) external pure returns (string memory) {
uint words = 1;
bytes memory idBytes = bytes(id);
uint idBytesLength = idBytes.length;
// nosemgrep
for (uint i; i < idBytesLength; ++i) {
if (keccak256(bytes(abi.encodePacked(idBytes[i]))) == keccak256(bytes(" "))) {
++words;
}
}
bytes memory _shortId = new bytes(words);
uint k = 1;
_shortId[0] = idBytes[0];
// nosemgrep
for (uint i = 1; i < idBytesLength; ++i) {
if (keccak256(bytes(abi.encodePacked(idBytes[i]))) == keccak256(bytes(" "))) {
if (keccak256(bytes(abi.encodePacked(idBytes[i + 1]))) == keccak256(bytes("0"))) {
_shortId[k] = idBytes[i + 3];
} else {
_shortId[k] = idBytes[i + 1];
}
++k;
}
}
return string(abi.encodePacked(_shortId));
}
function eq(string memory a, string memory b) external pure returns (bool) {
return keccak256(bytes(a)) == keccak256(bytes(b));
}
function u2s(uint num) external pure returns (string memory) {
return Strings.toString(num);
}
function i2s(int num) external pure returns (string memory) {
return Strings.toString(num > 0 ? uint(num) : uint(-num));
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.21;
library AmmAdapterIdLib {
string public constant UNISWAPV3 = "UniswapV3";
string public constant ALGEBRA = "Algebra";
string public constant KYBER = "KyberSwap";
string public constant CURVE = "Curve";
string public constant SOLIDLY = "Solidly";
string public constant BALANCER_COMPOSABLE_STABLE = "BalancerComposableStable";
string public constant BALANCER_WEIGHTED = "BalancerWeighted";
string public constant ALGEBRA_V4 = "AlgebraV4";
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;
/// @dev Base core interface implemented by most platform contracts.
/// Inherited contracts store an immutable Platform proxy address in the storage,
/// which provides authorization capabilities and infrastructure contract addresses.
/// @author Alien Deployer (https://github.com/a17)
/// @author JodsMigel (https://github.com/JodsMigel)
interface IControllable {
//region ----- Custom Errors -----
error IncorrectZeroArgument();
error IncorrectMsgSender();
error NotGovernance();
error NotMultisig();
error NotGovernanceAndNotMultisig();
error NotOperator();
error NotFactory();
error NotPlatform();
error NotVault();
error IncorrectArrayLength();
error AlreadyExist();
error NotExist();
error NotTheOwner();
error ETHTransferFailed();
error IncorrectInitParams();
//endregion -- Custom Errors -----
event ContractInitialized(address platform, uint ts, uint block);
/// @notice Stability Platform main contract address
function platform() external view returns (address);
/// @notice Version of contract implementation
/// @dev SemVer scheme MAJOR.MINOR.PATCH
//slither-disable-next-line naming-convention
function VERSION() external view returns (string memory);
/// @notice Block number when contract was initialized
function createdBlock() external view returns (uint);
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
/// @notice Creating vaults, upgrading vaults and strategies, vault list, farms and strategy logics management
/// @author Alien Deployer (https://github.com/a17)
/// @author Jude (https://github.com/iammrjude)
/// @author JodsMigel (https://github.com/JodsMigel)
/// @author HCrypto7 (https://github.com/hcrypto7)
interface IFactory {
//region ----- Custom Errors -----
error VaultImplementationIsNotAvailable();
error VaultNotAllowedToDeploy();
error StrategyImplementationIsNotAvailable();
error StrategyLogicNotAllowedToDeploy();
error YouDontHaveEnoughTokens(uint userBalance, uint requireBalance, address payToken);
error SuchVaultAlreadyDeployed(bytes32 key);
error NotActiveVault();
error UpgradeDenied(bytes32 _hash);
error AlreadyLastVersion(bytes32 _hash);
error NotStrategy();
error BoostDurationTooLow();
error BoostAmountTooLow();
error BoostAmountIsZero();
//endregion ----- Custom Errors -----
//region ----- Events -----
event VaultAndStrategy(
address indexed deployer,
string vaultType,
string strategyId,
address vault,
address strategy,
string name,
string symbol,
address[] assets,
bytes32 deploymentKey,
uint vaultManagerTokenId
);
event StrategyProxyUpgraded(address proxy, address oldImplementation, address newImplementation);
event VaultProxyUpgraded(address proxy, address oldImplementation, address newImplementation);
event VaultConfigChanged(
string type_, address implementation, bool deployAllowed, bool upgradeAllowed, bool newVaultType
);
event StrategyLogicConfigChanged(
string id, address implementation, bool deployAllowed, bool upgradeAllowed, bool newStrategy
);
event VaultStatus(address indexed vault, uint newStatus);
event NewFarm(Farm[] farms);
event UpdateFarm(uint id, Farm farm);
event SetStrategyAvailableInitParams(string id, address[] initAddresses, uint[] initNums, int24[] initTicks);
event AliasNameChanged(address indexed operator, address indexed tokenAddress, string newAliasName);
//endregion -- Events -----
//region ----- Data types -----
/// @custom:storage-location erc7201:stability.Factory
struct FactoryStorage {
/// @inheritdoc IFactory
mapping(bytes32 typeHash => VaultConfig) vaultConfig;
/// @inheritdoc IFactory
mapping(bytes32 idHash => StrategyLogicConfig) strategyLogicConfig;
/// @inheritdoc IFactory
mapping(bytes32 deploymentKey => address vaultProxy) deploymentKey;
/// @inheritdoc IFactory
mapping(address vault => uint status) vaultStatus;
/// @inheritdoc IFactory
mapping(address address_ => bool isStrategy_) isStrategy;
EnumerableSet.Bytes32Set vaultTypeHashes;
EnumerableSet.Bytes32Set strategyLogicIdHashes;
mapping(uint week => mapping(uint builderPermitTokenId => uint vaultsBuilt)) vaultsBuiltByPermitTokenId;
address[] deployedVaults;
Farm[] farms;
/// @inheritdoc IFactory
mapping(bytes32 idHash => StrategyAvailableInitParams) strategyAvailableInitParams;
mapping(address tokenAddress => string aliasName) aliasNames;
}
struct VaultConfig {
string vaultType;
address implementation;
bool deployAllowed;
bool upgradeAllowed;
uint buildingPrice;
}
struct StrategyLogicConfig {
string id;
address implementation;
bool deployAllowed;
bool upgradeAllowed;
bool farming;
uint tokenId;
}
struct Farm {
uint status;
address pool;
string strategyLogicId;
address[] rewardAssets;
address[] addresses;
uint[] nums;
int24[] ticks;
}
struct StrategyAvailableInitParams {
address[] initAddresses;
uint[] initNums;
int24[] initTicks;
}
//endregion -- Data types -----
//region ----- View functions -----
/// @notice All vaults deployed by the factory
/// @return Vault proxy addresses
function deployedVaults() external view returns (address[] memory);
/// @notice Total vaults deployed
function deployedVaultsLength() external view returns (uint);
/// @notice Get vault by VaultManager tokenId
/// @param id Vault array index. Same as tokenId of VaultManager NFT
/// @return Address of VaultProxy
function deployedVault(uint id) external view returns (address);
/// @notice All farms known by the factory in current network
function farms() external view returns (Farm[] memory);
/// @notice Total farms known by the factory in current network
function farmsLength() external view returns (uint);
/// @notice Farm data by farm index
/// @param id Index of farm
function farm(uint id) external view returns (Farm memory);
/// @notice Strategy logic settings
/// @param idHash keccak256 hash of strategy logic string ID
/// @return config Strategy logic settings
function strategyLogicConfig(bytes32 idHash) external view returns (StrategyLogicConfig memory config);
/// @notice All known strategies
/// @return Array of keccak256 hashes of strategy logic string ID
function strategyLogicIdHashes() external view returns (bytes32[] memory);
// todo remove, use new function without calculating vault symbol on the fly for not initialized vaults
// factory required that special functionally only internally, not for interface
function getStrategyData(
string memory vaultType,
address strategyAddress,
address bbAsset
)
external
view
returns (
string memory strategyId,
address[] memory assets,
string[] memory assetsSymbols,
string memory specificName,
string memory vaultSymbol
);
/// @dev Get best asset of assets to be strategy exchange asset
function getExchangeAssetIndex(address[] memory assets) external view returns (uint);
/// @notice Deployment key of created vault
/// @param deploymentKey_ Hash of concatenated unique vault and strategy initialization parameters
/// @return Address of deployed vault
function deploymentKey(bytes32 deploymentKey_) external view returns (address);
/// @notice Calculating deployment key based on unique vault and strategy initialization parameters
/// @param vaultType Vault type string
/// @param strategyId Strategy logic Id string
/// @param vaultInitAddresses Vault initialization addresses for deployVaultAndStrategy method
/// @param vaultInitNums Vault initialization uint numbers for deployVaultAndStrategy method
/// @param strategyInitAddresses Strategy initialization addresses for deployVaultAndStrategy method
/// @param strategyInitNums Strategy initialization uint numbers for deployVaultAndStrategy method
/// @param strategyInitTicks Strategy initialization int24 ticks for deployVaultAndStrategy method
function getDeploymentKey(
string memory vaultType,
string memory strategyId,
address[] memory vaultInitAddresses,
uint[] memory vaultInitNums,
address[] memory strategyInitAddresses,
uint[] memory strategyInitNums,
int24[] memory strategyInitTicks
) external view returns (bytes32);
/// @notice Available variants of new vault for creating.
/// DEPRECATED: use IFrontend.whatToBuild
/// The structure of the function's output values is complex,
/// but after parsing them, the front end has all the data to generate a list of vaults to create.
/// @return desc Descriptions of the strategy for making money
/// @return vaultType Vault type strings. Output values are matched by index with previous array.
/// @return strategyId Strategy logic ID strings. Output values are matched by index with previous array.
/// @return initIndexes Map of start and end indexes in next 5 arrays. Output values are matched by index with previous array.
/// [0] Start index in vaultInitAddresses
/// [1] End index in vaultInitAddresses
/// [2] Start index in vaultInitNums
/// [3] End index in vaultInitNums
/// [4] Start index in strategyInitAddresses
/// [5] End index in strategyInitAddresses
/// [6] Start index in strategyInitNums
/// [7] End index in strategyInitNums
/// [8] Start index in strategyInitTicks
/// [9] End index in strategyInitTicks
/// @return vaultInitAddresses Vault initialization addresses for deployVaultAndStrategy method for all building variants.
/// @return vaultInitNums Vault initialization uint numbers for deployVaultAndStrategy method for all building variants.
/// @return strategyInitAddresses Strategy initialization addresses for deployVaultAndStrategy method for all building variants.
/// @return strategyInitNums Strategy initialization uint numbers for deployVaultAndStrategy method for all building variants.
/// @return strategyInitTicks Strategy initialization int24 ticks for deployVaultAndStrategy method for all building variants.
function whatToBuild()
external
view
returns (
string[] memory desc,
string[] memory vaultType,
string[] memory strategyId,
uint[10][] memory initIndexes,
address[] memory vaultInitAddresses,
uint[] memory vaultInitNums,
address[] memory strategyInitAddresses,
uint[] memory strategyInitNums,
int24[] memory strategyInitTicks
);
/// @notice Governance and multisig can set a vault status other than Active - the default status.
/// HardWorker only works with active vaults.
/// @return status Constant from VaultStatusLib
function vaultStatus(address vault) external view returns (uint status);
/// @notice Check that strategy proxy deployed by the Factory
/// @param address_ Address of contract
/// @return This address is our strategy proxy
function isStrategy(address address_) external view returns (bool);
/// @notice How much vaults was built by builderPermitToken NFT tokenId in week
/// @param week Week index (timestamp / (86400 * 7))
/// @param builderPermitTokenId Token ID of buildingPermitToken NFT
/// @return vaultsBuilt Vaults built
function vaultsBuiltByPermitTokenId(
uint week,
uint builderPermitTokenId
) external view returns (uint vaultsBuilt);
/// @notice Data on all factory strategies.
/// The output values are matched by index in the arrays.
/// @return id Strategy logic ID strings
/// @return deployAllowed New vaults can be deployed
/// @return upgradeAllowed Strategy can be upgraded
/// @return farming It is farming strategy (earns farming/gauge rewards)
/// @return tokenId Token ID of StrategyLogic NFT
/// @return tokenURI StrategyLogic NFT tokenId metadata and on-chain image
/// @return extra Strategy color, background color and other extra data
function strategies()
external
view
returns (
string[] memory id,
bool[] memory deployAllowed,
bool[] memory upgradeAllowed,
bool[] memory farming,
uint[] memory tokenId,
string[] memory tokenURI,
bytes32[] memory extra
);
/// @notice Get config of vault type
/// @param typeHash Keccak256 hash of vault type string
/// @return vaultType Vault type string
/// @return implementation Vault implementation address
/// @return deployAllowed New vaults can be deployed
/// @return upgradeAllowed Vaults can be upgraded
/// @return buildingPrice Price of building new vault
function vaultConfig(bytes32 typeHash)
external
view
returns (
string memory vaultType,
address implementation,
bool deployAllowed,
bool upgradeAllowed,
uint buildingPrice
);
/// @notice Data on all factory vault types
/// The output values are matched by index in the arrays.
/// @return vaultType Vault type string
/// @return implementation Address of vault implemented logic
/// @return deployAllowed New vaults can be deployed
/// @return upgradeAllowed Vaults can be upgraded
/// @return buildingPrice Price of building new vault
/// @return extra Vault type color, background color and other extra data
function vaultTypes()
external
view
returns (
string[] memory vaultType,
address[] memory implementation,
bool[] memory deployAllowed,
bool[] memory upgradeAllowed,
uint[] memory buildingPrice,
bytes32[] memory extra
);
/// @notice Initialization strategy params store
function strategyAvailableInitParams(bytes32 idHash) external view returns (StrategyAvailableInitParams memory);
/// @notice Retrieves the alias name associated with a given address
/// @param tokenAddress_ The address to query for its alias name
/// @return The alias name associated with the provided address
function getAliasName(address tokenAddress_) external view returns (string memory);
//endregion -- View functions -----
//region ----- Write functions -----
/// @notice Main method of the Factory - new vault creation by user.
/// @param vaultType Vault type ID string
/// @param strategyId Strategy logic ID string
/// Different types of vaults and strategies have different lengths of input arrays.
/// @param vaultInitAddresses Addresses for vault initialization
/// @param vaultInitNums Numbers for vault initialization
/// @param strategyInitAddresses Addresses for strategy initialization
/// @param strategyInitNums Numbers for strategy initialization
/// @param strategyInitTicks Ticks for strategy initialization
/// @return vault Deployed VaultProxy address
/// @return strategy Deployed StrategyProxy address
function deployVaultAndStrategy(
string memory vaultType,
string memory strategyId,
address[] memory vaultInitAddresses,
uint[] memory vaultInitNums,
address[] memory strategyInitAddresses,
uint[] memory strategyInitNums,
int24[] memory strategyInitTicks
) external returns (address vault, address strategy);
/// @notice Upgrade vault proxy. Can be called by any address.
/// @param vault Address of vault proxy for upgrade
function upgradeVaultProxy(address vault) external;
/// @notice Upgrade strategy proxy. Can be called by any address.
/// @param strategy Address of strategy proxy for upgrade
function upgradeStrategyProxy(address strategy) external;
/// @notice Add farm to factory
/// @param farms_ Settings and data required to work with the farm.
function addFarms(Farm[] memory farms_) external;
/// @notice Update farm
/// @param id Farm index
/// @param farm_ Settings and data required to work with the farm.
function updateFarm(uint id, Farm memory farm_) external;
/// @notice Initial addition or change of vault type settings.
/// Operator can add new vault type. Governance or multisig can change existing vault type config.
/// @param vaultConfig_ Vault type settings
function setVaultConfig(VaultConfig memory vaultConfig_) external;
/// @notice Initial addition or change of strategy logic settings.
/// Operator can add new strategy logic. Governance or multisig can change existing logic config.
/// @param config Strategy logic settings
/// @param developer Strategy developer is receiver of minted StrategyLogic NFT on initial addition
function setStrategyLogicConfig(StrategyLogicConfig memory config, address developer) external;
/// @notice Governance and multisig can set a vault status other than Active - the default status.
/// @param vaults Addresses of vault proxy
/// @param statuses New vault statuses. Constant from VaultStatusLib
function setVaultStatus(address[] memory vaults, uint[] memory statuses) external;
/// @notice Initial addition or change of strategy available init params
/// @param id Strategy ID string
/// @param initParams Init params variations that will be parsed by strategy
function setStrategyAvailableInitParams(string memory id, StrategyAvailableInitParams memory initParams) external;
/// @notice Assigns a new alias name to a specific address
/// @dev This function may require certain permissions to be called successfully.
/// @param tokenAddress_ The address to assign an alias name to
/// @param aliasName_ The alias name to assign to the given address
function setAliasName(address tokenAddress_, string memory aliasName_) external;
//endregion -- Write functions -----
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
/// @dev Get price, swap, liquidity calculations. Used by strategies and swapper
/// @author Alien Deployer (https://github.com/a17)
/// @author JodsMigel (https://github.com/JodsMigel)
interface IAmmAdapter is IERC165 {
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* CUSTOM ERRORS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
error PriceIncreased();
error WrongCallbackAmount();
error NotSupportedByCAMM();
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* EVENTS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
event SwapInPool(
address pool,
address tokenIn,
address tokenOut,
address recipient,
uint priceImpactTolerance,
uint amountIn,
uint amountOut
);
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* DATA TYPES */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
struct SwapCallbackData {
address tokenIn;
uint amount;
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* VIEW FUNCTIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @notice String ID of the adapter
function ammAdapterId() external view returns (string memory);
/// @notice Tokens of a pool supported by the adapter
function poolTokens(address pool) external view returns (address[] memory);
/// @notice Computes the maximum amount of liquidity received for given amounts of pool assets and the current
/// pool price.
/// This function signature can be used only for non-concentrated AMMs.
/// @param pool Address of a pool supported by the adapter
/// @param amounts Amounts of pool assets
/// @return liquidity Liquidity out value
/// @return amountsConsumed Amounts of consumed assets when providing liquidity
function getLiquidityForAmounts(
address pool,
uint[] memory amounts
) external view returns (uint liquidity, uint[] memory amountsConsumed);
/// @notice Priced proportions of pool assets
/// @param pool Address of a pool supported by the adapter
/// @return Proportions with 18 decimals precision. Max is 1e18, min is 0.
function getProportions(address pool) external view returns (uint[] memory);
/// @notice Current price in pool without amount impact
/// @param pool Address of a pool supported by the adapter
/// @param tokenIn Token for sell
/// @param tokenOut Token for buy
/// @param amount Amount of tokenIn. For zero value provided amount 1.0 (10 ** decimals of tokenIn) will be used.
/// @return Amount of tokenOut with tokenOut decimals precision
function getPrice(address pool, address tokenIn, address tokenOut, uint amount) external view returns (uint);
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* WRITE FUNCTIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @notice Swap given tokenIn for tokenOut. Assume that tokenIn already sent to this contract.
/// @param pool Address of a pool supported by the adapter
/// @param tokenIn Token for sell
/// @param tokenOut Token for buy
/// @param recipient Recipient for tokenOut
/// @param priceImpactTolerance Price impact tolerance. Must include fees at least. Denominator is 100_000.
function swap(
address pool,
address tokenIn,
address tokenOut,
address recipient,
uint priceImpactTolerance
) external;
/// @dev Initializer for proxied adapter
function init(address platform) external;
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;
import "../interfaces/IAmmAdapter.sol";
/// @title Liquidity providing strategy
/// @author Alien Deployer (https://github.com/a17)
interface ILPStrategy {
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* EVENTS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
event FeesClaimed(uint[] fees);
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* ERRORS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
error ZeroAmmAdapter();
error IncorrectAssetsLength();
error IncorrectAssets();
error IncorrectAmountsLength();
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* DATA TYPES */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @custom:storage-location erc7201:stability.LPStrategyBase
struct LPStrategyBaseStorage {
/// @inheritdoc ILPStrategy
address pool;
/// @inheritdoc ILPStrategy
IAmmAdapter ammAdapter;
uint[] _feesOnBalance;
}
struct LPStrategyBaseInitParams {
string id;
address platform;
address vault;
address pool;
address underlying;
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* VIEW FUNCTIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @dev AMM adapter string ID for interacting with pool
function ammAdapterId() external view returns (string memory);
/// @dev AMM adapter address for interacting with pool
function ammAdapter() external view returns (IAmmAdapter);
/// @dev AMM
function pool() external view returns (address);
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;
/// @dev Mostly this interface need for front-end and tests for interacting with farming strategies
/// @author JodsMigel (https://github.com/JodsMigel)
interface IFarmingStrategy {
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* EVENTS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
event RewardsClaimed(uint[] amounts);
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* ERRORS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
error BadFarm();
error IncorrectStrategyId();
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* DATA TYPES */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @custom:storage-location erc7201:stability.FarmingStrategyBase
struct FarmingStrategyBaseStorage {
/// @inheritdoc IFarmingStrategy
uint farmId;
address[] _rewardAssets;
uint[] _rewardsOnBalance;
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* VIEW FUNCTIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @notice Index of the farm used by initialized strategy
function farmId() external view returns (uint);
/// @notice Strategy can earn money on farm now
/// Some strategies can continue work and earn pool fees after ending of farm rewards.
function canFarm() external view returns (bool);
/// @notice Mechanics of receiving farming rewards
function farmMechanics() external view returns (string memory);
/// @notice Farming reward assets for claim and liquidate
/// @return Addresses of farm reward ERC20 tokens
function farmingAssets() external view returns (address[] memory);
/// @notice Address of pool for staking asset/underlying
function stakingPool() external view returns (address);
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* WRITE FUNCTIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @notice Update strategy farming reward assets from Factory
/// Only operator can call this
function refreshFarmingAssets() external;
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;
import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
/// @dev Core interface of strategy logic
interface IStrategy is IERC165 {
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* EVENTS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
event HardWork(
uint apr, uint compoundApr, uint earned, uint tvl, uint duration, uint sharePrice, uint[] assetPrices
);
event ExtractFees(
uint vaultManagerReceiverFee,
uint strategyLogicReceiverFee,
uint ecosystemRevenueReceiverFee,
uint multisigReceiverFee
);
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* CUSTOM ERRORS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
error NotReadyForHardWork();
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* DATA TYPES */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @custom:storage-location erc7201:stability.StrategyBase
struct StrategyBaseStorage {
/// @inheritdoc IStrategy
address vault;
/// @inheritdoc IStrategy
uint total;
/// @inheritdoc IStrategy
uint lastHardWork;
/// @inheritdoc IStrategy
uint lastApr;
/// @inheritdoc IStrategy
uint lastAprCompound;
/// @inheritdoc IStrategy
address[] _assets;
/// @inheritdoc IStrategy
address _underlying;
string _id;
uint _exchangeAssetIndex;
uint customPriceImpactTolerance;
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* VIEW FUNCTIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @dev Strategy logic string ID
function strategyLogicId() external view returns (string memory);
/// @dev Extra data
/// @return 0-2 bytes - strategy color
/// 3-5 bytes - strategy background color
/// 6-31 bytes - free
function extra() external view returns (bytes32);
/// @dev Types of vault that supported by strategy implementation
/// @return types Vault type ID strings
function supportedVaultTypes() external view returns (string[] memory types);
/// @dev Linked vault address
function vault() external view returns (address);
/// @dev Final assets that strategy invests
function assets() external view returns (address[] memory);
/// @notice Final assets and amounts that strategy manages
function assetsAmounts() external view returns (address[] memory assets_, uint[] memory amounts_);
/// @notice Priced invested assets proportions
/// @return proportions Proportions of assets with 18 decimals. Min is 0, max is 1e18.
function getAssetsProportions() external view returns (uint[] memory proportions);
/// @notice Underlying token address
/// @dev Can be used for liquidity farming strategies where AMM has fungible liquidity token (Solidly forks, etc),
/// for concentrated liquidity tokenized vaults (Gamma, G-UNI etc) and for other needs.
/// @return Address of underlying token or zero address if no underlying in strategy
function underlying() external view returns (address);
/// @dev Balance of liquidity token or liquidity value
function total() external view returns (uint);
/// @dev Last HardWork time
/// @return Timestamp
function lastHardWork() external view returns (uint);
/// @dev Last APR of earned USD amount registered by HardWork
/// ONLY FOR OFF-CHAIN USE.
/// Not trusted asset price can be manipulated.
/// @return APR with 18 decimals. 1e18 - 100%.
function lastApr() external view returns (uint);
/// @dev Last APR of compounded assets registered by HardWork.
/// Can be used on-chain.
/// @return APR with 18 decimals. 1e18 - 100%.
function lastAprCompound() external view returns (uint);
/// @notice Calculation of consumed amounts and liquidity/underlying value for provided strategy assets and amounts.
/// @param assets_ Strategy assets or part of them, if necessary
/// @param amountsMax Amounts of specified assets available for investing
/// @return amountsConsumed Cosumed amounts of assets when investing
/// @return value Liquidity value or underlying token amount minted when investing
function previewDepositAssets(
address[] memory assets_,
uint[] memory amountsMax
) external view returns (uint[] memory amountsConsumed, uint value);
/// @notice Write version of previewDepositAssets
/// @param assets_ Strategy assets or part of them, if necessary
/// @param amountsMax Amounts of specified assets available for investing
/// @return amountsConsumed Cosumed amounts of assets when investing
/// @return value Liquidity value or underlying token amount minted when investing
function previewDepositAssetsWrite(
address[] memory assets_,
uint[] memory amountsMax
) external returns (uint[] memory amountsConsumed, uint value);
/// @notice All strategy revenue (pool fees, farm rewards etc) that not claimed by strategy yet
/// @return assets_ Revenue assets
/// @return amounts Amounts. Index of asset same as in previous array.
function getRevenue() external view returns (address[] memory assets_, uint[] memory amounts);
/// @notice Optional specific name of investing strategy, underyling type, setup variation etc
/// @return name Empty string or specific name
/// @return showInVaultSymbol Show specific in linked vault symbol
function getSpecificName() external view returns (string memory name, bool showInVaultSymbol);
/// @notice Variants pf strategy initializations with description of money making mechanic.
/// As example, if strategy need farm, then number of variations is number of available farms.
/// If CAMM strategy have set of available widths (tick ranges), then number of variations is number of available farms.
/// If both example conditions are met then total number or variations = total farms * total widths.
/// @param platform_ Need this param because method called when strategy implementation is not initialized
/// @return variants Descriptions of the strategy for making money
/// @return addresses Init strategy addresses. Indexes for each variants depends of copmpared arrays lengths.
/// @return nums Init strategy numbers. Indexes for each variants depends of copmpared arrays lengths.
/// @return ticks Init strategy ticks. Indexes for each variants depends of copmpared arrays lengths.
function initVariants(address platform_)
external
view
returns (string[] memory variants, address[] memory addresses, uint[] memory nums, int24[] memory ticks);
/// @notice How does the strategy make money?
/// @return Description in free form
function description() external view returns (string memory);
/// @notice Is HardWork on vault deposits can be enabled
function isHardWorkOnDepositAllowed() external view returns (bool);
/// @notice Is HardWork can be executed
function isReadyForHardWork() external view returns (bool);
/// @notice Strategy not need to process revenue on HardWorks
function autoCompoundingByUnderlyingProtocol() external view returns (bool);
/// @notice Custom price impact tolerance instead default need for specific cases where liquidity in pools is low
function customPriceImpactTolerance() external view returns (uint);
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* WRITE FUNCTIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @dev A single universal initializer for all strategy implementations.
/// @param addresses All addresses that strategy requires for initialization. Min array length is 2.
/// addresses[0]: platform (required)
/// addresses[1]: vault (required)
/// addresses[2]: initStrategyAddresses[0] (optional)
/// addresses[3]: initStrategyAddresses[1] (optional)
/// addresses[n]: initStrategyAddresses[n - 2] (optional)
/// @param nums All uint values that strategy requires for initialization. Min array length is 0.
/// @param ticks All int24 values that strategy requires for initialization. Min array length is 0.
function initialize(address[] memory addresses, uint[] memory nums, int24[] memory ticks) external;
/// @notice Invest strategy assets. Amounts of assets must be already on strategy contract balance.
/// Only vault can call this.
/// @param amounts Anounts of strategy assets
/// @return value Liquidity value or underlying token amount
function depositAssets(uint[] memory amounts) external returns (uint value);
/// @notice Invest underlying asset. Asset must be already on strategy contract balance.
/// Only vault can call this.
/// @param amount Amount of underlying asset to invest
/// @return amountsConsumed Cosumed amounts of invested assets
function depositUnderlying(uint amount) external returns (uint[] memory amountsConsumed);
/// @dev For specified amount of shares and assets_, withdraw strategy assets from farm/pool/staking and send to receiver if possible
/// Only vault can call this.
/// @param assets_ Here we give the user a choice of assets to withdraw if strategy support it
/// @param value Part of strategy total value to withdraw
/// @param receiver User address
/// @return amountsOut Amounts of assets sent to user
function withdrawAssets(
address[] memory assets_,
uint value,
address receiver
) external returns (uint[] memory amountsOut);
/// @notice Wothdraw underlying invested and send to receiver
/// Only vault can call this.
/// @param amount Ampunt of underlying asset to withdraw
/// @param receiver User of vault which withdraw underlying from the vault
function withdrawUnderlying(uint amount, address receiver) external;
/// @dev For specified amount of shares, transfer strategy assets from contract balance and send to receiver if possible
/// This method is called by vault w/o underlying on triggered fuse mode.
/// Only vault can call this.
/// @param amount Ampunt of liquidity value that user withdraw
/// @param totalAmount Total amount of strategy liquidity
/// @param receiver User of vault which withdraw assets
/// @return amountsOut Amounts of strategy assets sent to user
function transferAssets(
uint amount,
uint totalAmount,
address receiver
) external returns (uint[] memory amountsOut);
/// @notice Execute HardWork
/// During HardWork strategy claiming revenue and processing it.
/// Only vault can call this.
function doHardWork() external;
/// @notice Emergency stop investing by strategy, withdraw liquidity without rewards.
/// This action triggers FUSE mode.
/// Only governance or multisig can call this.
function emergencyStopInvesting() external;
/// @notice Custom price impact tolerance instead default need for specific cases where low liquidity in pools
/// @param priceImpactTolerance Tolerance percent with 100_000 DENOMINATOR. 4_000 == 4%
function setCustomPriceImpactTolerance(uint priceImpactTolerance) external;
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;
/// @notice Interface of the main contract and entry point to the platform.
/// @author Alien Deployer (https://github.com/a17)
/// @author Jude (https://github.com/iammrjude)
/// @author JodsMigel (https://github.com/JodsMigel)
interface IPlatform {
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* CUSTOM ERRORS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
error AlreadyAnnounced();
error SameVersion();
error NoNewVersion();
error UpgradeTimerIsNotOver(uint TimerTimestamp);
error IncorrectFee(uint minFee, uint maxFee);
error NotEnoughAllowedBBToken();
error TokenAlreadyExistsInSet(address token);
error AggregatorNotExists(address dexAggRouter);
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* EVENTS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
event PlatformVersion(string version);
event UpgradeAnnounce(
string oldVersion, string newVersion, address[] proxies, address[] newImplementations, uint timelock
);
event CancelUpgrade(string oldVersion, string newVersion);
event ProxyUpgraded(
address indexed proxy, address implementation, string oldContractVersion, string newContractVersion
);
event Addresses(
address multisig_,
address factory_,
address priceReader_,
address swapper_,
address buildingPermitToken_,
address vaultManager_,
address strategyLogic_,
address aprOracle_,
address hardWorker,
address rebalancer,
address zap,
address bridge
);
event OperatorAdded(address operator);
event OperatorRemoved(address operator);
event FeesChanged(uint fee, uint feeShareVaultManager, uint feeShareStrategyLogic, uint feeShareEcosystem);
event MinInitialBoostChanged(uint minInitialBoostPerDay, uint minInitialBoostDuration);
event NewAmmAdapter(string id, address proxy);
event EcosystemRevenueReceiver(address receiver);
event SetAllowedBBTokenVaults(address bbToken, uint vaultsToBuild, bool firstSet);
event RemoveAllowedBBToken(address bbToken);
event AddAllowedBoostRewardToken(address token);
event RemoveAllowedBoostRewardToken(address token);
event AddDefaultBoostRewardToken(address token);
event RemoveDefaultBoostRewardToken(address token);
event AddBoostTokens(address[] allowedBoostRewardToken, address[] defaultBoostRewardToken);
event AllowedBBTokenVaultUsed(address bbToken, uint vaultToUse);
event AddDexAggregator(address router);
event RemoveDexAggregator(address router);
event MinTvlForFreeHardWorkChanged(uint oldValue, uint newValue);
event CustomVaultFee(address vault, uint platformFee);
event Rebalancer(address rebalancer_);
event Bridge(address bridge_);
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* DATA TYPES */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
struct PlatformUpgrade {
string newVersion;
address[] proxies;
address[] newImplementations;
}
struct PlatformSettings {
string networkName;
bytes32 networkExtra;
uint fee;
uint feeShareVaultManager;
uint feeShareStrategyLogic;
uint feeShareEcosystem;
uint minInitialBoostPerDay;
uint minInitialBoostDuration;
}
struct AmmAdapter {
string id;
address proxy;
}
struct SetupAddresses {
address factory;
address priceReader;
address swapper;
address buildingPermitToken;
address buildingPayPerVaultToken;
address vaultManager;
address strategyLogic;
address aprOracle;
address targetExchangeAsset;
address hardWorker;
address zap;
address bridge;
address rebalancer;
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* VIEW FUNCTIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @notice Platform version in CalVer scheme: YY.MM.MINOR-tag. Updates on core contract upgrades.
function platformVersion() external view returns (string memory);
/// @notice Time delay for proxy upgrades of core contracts and changing important platform settings by multisig
//slither-disable-next-line naming-convention
function TIME_LOCK() external view returns (uint);
/// @notice DAO governance
function governance() external view returns (address);
/// @notice Core team multi signature wallet. Development and operations fund
function multisig() external view returns (address);
/// @notice This NFT allow user to build limited number of vaults per week
function buildingPermitToken() external view returns (address);
/// @notice This ERC20 token is used as payment token for vault building
function buildingPayPerVaultToken() external view returns (address);
/// @notice Receiver of ecosystem revenue
function ecosystemRevenueReceiver() external view returns (address);
/// @dev The best asset in a network for swaps between strategy assets and farms rewards assets
/// The target exchange asset is used for finding the best strategy's exchange asset.
/// Rhe fewer routes needed to swap to the target exchange asset, the better.
function targetExchangeAsset() external view returns (address);
/// @notice Platform factory assembling vaults. Stores settings, strategy logic, farms.
/// Provides the opportunity to upgrade vaults and strategies.
/// @return Address of Factory proxy
function factory() external view returns (address);
/// @notice The holders of these NFT receive a share of the vault revenue
/// @return Address of VaultManager proxy
function vaultManager() external view returns (address);
/// @notice The holders of these tokens receive a share of the revenue received in all vaults using this strategy logic.
function strategyLogic() external view returns (address);
/// @notice Combining oracle and DeX spot prices
/// @return Address of PriceReader proxy
function priceReader() external view returns (address);
/// @notice Providing underlying assets APRs on-chain
/// @return Address of AprOracle proxy
function aprOracle() external view returns (address);
/// @notice On-chain price quoter and swapper
/// @return Address of Swapper proxy
function swapper() external view returns (address);
/// @notice HardWork resolver and caller
/// @return Address of HardWorker proxy
function hardWorker() external view returns (address);
/// @notice Rebalance resolver
/// @return Address of Rebalancer proxy
function rebalancer() external view returns (address);
/// @notice ZAP feature
/// @return Address of Zap proxy
function zap() external view returns (address);
/// @notice Stability Bridge
/// @return Address of Bridge proxy
function bridge() external view returns (address);
/// @notice Name of current EVM network
function networkName() external view returns (string memory);
/// @notice Minimal initial boost rewards per day USD amount which needs to create rewarding vault
function minInitialBoostPerDay() external view returns (uint);
/// @notice Minimal boost rewards vesting duration for initial boost
function minInitialBoostDuration() external view returns (uint);
/// @notice This function provides the timestamp of the platform upgrade timelock.
/// @dev This function is an external view function, meaning it doesn't modify the state.
/// @return uint representing the timestamp of the platform upgrade timelock.
function platformUpgradeTimelock() external view returns (uint);
/// @dev Extra network data
/// @return 0-2 bytes - color
/// 3-5 bytes - background color
/// 6-31 bytes - free
function networkExtra() external view returns (bytes32);
/// @notice Pending platform upgrade data
function pendingPlatformUpgrade() external view returns (PlatformUpgrade memory);
/// @notice Get platform revenue fee settings
/// @return fee Revenue fee % (between MIN_FEE - MAX_FEE) with DENOMINATOR precision.
/// @return feeShareVaultManager Revenue fee share % of VaultManager tokenId owner
/// @return feeShareStrategyLogic Revenue fee share % of StrategyLogic tokenId owner
/// @return feeShareEcosystem Revenue fee share % of ecosystemFeeReceiver
function getFees()
external
view
returns (uint fee, uint feeShareVaultManager, uint feeShareStrategyLogic, uint feeShareEcosystem);
/// @notice Get custom vault platform fee
/// @return fee revenue fee % with DENOMINATOR precision
function getCustomVaultFee(address vault) external view returns (uint fee);
/// @notice Platform settings
function getPlatformSettings() external view returns (PlatformSettings memory);
/// @notice AMM adapters of the platform
function getAmmAdapters() external view returns (string[] memory id, address[] memory proxy);
/// @notice Get AMM adapter data by hash
/// @param ammAdapterIdHash Keccak256 hash of adapter ID string
/// @return ID string and proxy address of AMM adapter
function ammAdapter(bytes32 ammAdapterIdHash) external view returns (AmmAdapter memory);
/// @notice Allowed buy-back tokens for rewarding vaults
function allowedBBTokens() external view returns (address[] memory);
/// @notice Vaults building limit for buy-back token.
/// This limit decrements when a vault for BB-token is built.
/// @param token Allowed buy-back token
/// @return vaultsLimit Number of vaults that can be built for BB-token
function allowedBBTokenVaults(address token) external view returns (uint vaultsLimit);
/// @notice Vaults building limits for allowed buy-back tokens.
/// @return bbToken Allowed buy-back tokens
/// @return vaultsLimit Number of vaults that can be built for BB-tokens
function allowedBBTokenVaults() external view returns (address[] memory bbToken, uint[] memory vaultsLimit);
/// @notice Non-zero vaults building limits for allowed buy-back tokens.
/// @return bbToken Allowed buy-back tokens
/// @return vaultsLimit Number of vaults that can be built for BB-tokens
function allowedBBTokenVaultsFiltered()
external
view
returns (address[] memory bbToken, uint[] memory vaultsLimit);
/// @notice Check address for existance in operators list
/// @param operator Address
/// @return True if this address is Stability Operator
function isOperator(address operator) external view returns (bool);
/// @notice Tokens that can be used for boost rewards of rewarding vaults
/// @return Addresses of tokens
function allowedBoostRewardTokens() external view returns (address[] memory);
/// @notice Allowed boost reward tokens that used for unmanaged rewarding vaults creation
/// @return Addresses of tokens
function defaultBoostRewardTokens() external view returns (address[] memory);
/// @notice Allowed boost reward tokens that used for unmanaged rewarding vaults creation
/// @param addressToRemove This address will be removed from default boost reward tokens
/// @return Addresses of tokens
function defaultBoostRewardTokensFiltered(address addressToRemove) external view returns (address[] memory);
/// @notice Allowed DeX aggregators
/// @return Addresses of DeX aggregator rounters
function dexAggregators() external view returns (address[] memory);
/// @notice DeX aggregator router address is allowed to be used in the platform
/// @param dexAggRouter Address of DeX aggreagator router
/// @return Can be used
function isAllowedDexAggregatorRouter(address dexAggRouter) external view returns (bool);
/// @notice Show minimum TVL for compensate if vault has not enough ETH
/// @return Minimum TVL for compensate.
function minTvlForFreeHardWork() external view returns (uint);
/// @notice Front-end platform viewer
/// @return platformAddresses Platform core addresses
/// platformAddresses[0] factory
/// platformAddresses[1] vaultManager
/// platformAddresses[2] strategyLogic
/// platformAddresses[3] buildingPermitToken
/// platformAddresses[4] buildingPayPerVaultToken
/// platformAddresses[5] governance
/// platformAddresses[6] multisig
/// platformAddresses[7] zap
/// platformAddresses[8] bridge
/// @return bcAssets Blue chip token addresses
/// @return dexAggregators_ DeX aggregators allowed to be used entire the platform
/// @return vaultType Vault type ID strings
/// @return vaultExtra Vault color, background color and other extra data. Index of vault same as in previous array.
/// @return vaultBulldingPrice Price of creating new vault in buildingPayPerVaultToken. Index of vault same as in previous array.
/// @return strategyId Strategy logic ID strings
/// @return isFarmingStrategy True if strategy is farming strategy. Index of strategy same as in previous array.
/// @return strategyTokenURI StrategyLogic NFT tokenId metadata and on-chain image. Index of strategy same as in previous array.
/// @return strategyExtra Strategy color, background color and other extra data. Index of strategy same as in previous array.
function getData()
external
view
returns (
address[] memory platformAddresses,
address[] memory bcAssets,
address[] memory dexAggregators_,
string[] memory vaultType,
bytes32[] memory vaultExtra,
uint[] memory vaultBulldingPrice,
string[] memory strategyId,
bool[] memory isFarmingStrategy,
string[] memory strategyTokenURI,
bytes32[] memory strategyExtra
);
/// @notice Front-end balances, prices and vault list viewer
/// DEPRECATED: use IFrontend.getBalanceAssets and IFrontend.getBalanceVaults
/// @param yourAccount Address of account to query balances
/// @return token Tokens supported by the platform
/// @return tokenPrice USD price of token. Index of token same as in previous array.
/// @return tokenUserBalance User balance of token. Index of token same as in previous array.
/// @return vault Deployed vaults
/// @return vaultSharePrice Price 1.0 vault share. Index of vault same as in previous array.
/// @return vaultUserBalance User balance of vault. Index of vault same as in previous array.
/// @return nft Ecosystem NFTs
/// nft[0] BuildingPermitToken
/// nft[1] VaultManager
/// nft[2] StrategyLogic
/// @return nftUserBalance User balance of NFT. Index of NFT same as in previous array.
/// @return buildingPayPerVaultTokenBalance User balance of vault creation paying token
function getBalance(address yourAccount)
external
view
returns (
address[] memory token,
uint[] memory tokenPrice,
uint[] memory tokenUserBalance,
address[] memory vault,
uint[] memory vaultSharePrice,
uint[] memory vaultUserBalance,
address[] memory nft,
uint[] memory nftUserBalance,
uint buildingPayPerVaultTokenBalance
);
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* WRITE FUNCTIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @notice Add platform operator.
/// Only governance and multisig can add operator.
/// @param operator Address of new operator
function addOperator(address operator) external;
/// @notice Remove platform operator.
/// Only governance and multisig can remove operator.
/// @param operator Address of operator to remove
function removeOperator(address operator) external;
/// @notice Announce upgrade of platform proxies implementations
/// Only governance and multisig can announce platform upgrades.
/// @param newVersion New platform version. Version must be changed when upgrading.
/// @param proxies Addresses of core contract proxies
/// @param newImplementations New implementation for proxy. Index of proxy same as in previous array.
function announcePlatformUpgrade(
string memory newVersion,
address[] memory proxies,
address[] memory newImplementations
) external;
/// @notice Upgrade platform
/// Only operator (multisig is operator too) can ececute pending platform upgrade
function upgrade() external;
/// @notice Cancel pending platform upgrade
/// Only operator (multisig is operator too) can ececute pending platform upgrade
function cancelUpgrade() external;
/// @notice Register AMM adapter in platform
/// @param id AMM adapter ID string from AmmAdapterIdLib
/// @param proxy Address of AMM adapter proxy
function addAmmAdapter(string memory id, address proxy) external;
// todo Only governance and multisig can set allowed bb-token vaults building limit
/// @notice Set new vaults building limit for buy-back token
/// @param bbToken Address of allowed buy-back token
/// @param vaultsToBuild Number of vaults that can be built for BB-token
function setAllowedBBTokenVaults(address bbToken, uint vaultsToBuild) external;
// todo Only governance and multisig can add allowed boost reward token
/// @notice Add new allowed boost reward token
/// @param token Address of token
function addAllowedBoostRewardToken(address token) external;
// todo Only governance and multisig can remove allowed boost reward token
/// @notice Remove allowed boost reward token
/// @param token Address of allowed boost reward token
function removeAllowedBoostRewardToken(address token) external;
// todo Only governance and multisig can add default boost reward token
/// @notice Add default boost reward token
/// @param token Address of default boost reward token
function addDefaultBoostRewardToken(address token) external;
// todo Only governance and multisig can remove default boost reward token
/// @notice Remove default boost reward token
/// @param token Address of allowed boost reward token
function removeDefaultBoostRewardToken(address token) external;
// todo Only governance and multisig can add allowed boost reward token
// todo Only governance and multisig can add default boost reward token
/// @notice Add new allowed boost reward token
/// @notice Add default boost reward token
/// @param allowedBoostRewardToken Address of allowed boost reward token
/// @param defaultBoostRewardToken Address of default boost reward token
function addBoostTokens(
address[] memory allowedBoostRewardToken,
address[] memory defaultBoostRewardToken
) external;
/// @notice Decrease allowed BB-token vault building limit when vault is built
/// Only Factory can do it.
/// @param bbToken Address of allowed buy-back token
function useAllowedBBTokenVault(address bbToken) external;
/// @notice Allow DeX aggregator routers to be used in the platform
/// @param dexAggRouter Addresses of DeX aggreagator routers
function addDexAggregators(address[] memory dexAggRouter) external;
/// @notice Remove allowed DeX aggregator router from the platform
/// @param dexAggRouter Address of DeX aggreagator router
function removeDexAggregator(address dexAggRouter) external;
/// @notice Change initial boost rewards settings
/// @param minInitialBoostPerDay_ Minimal initial boost rewards per day USD amount which needs to create rewarding vault
/// @param minInitialBoostDuration_ Minimal boost rewards vesting duration for initial boost
function setInitialBoost(uint minInitialBoostPerDay_, uint minInitialBoostDuration_) external;
/// @notice Update new minimum TVL for compensate.
/// @param value New minimum TVL for compensate.
function setMinTvlForFreeHardWork(uint value) external;
/// @notice Set custom platform fee for vault
/// @param vault Vault address
/// @param platformFee Custom platform fee
function setCustomVaultFee(address vault, uint platformFee) external;
/// @notice Setup Rebalancer.
/// Only Goverannce or Multisig can do this when Rebalancer is not set.
/// @param rebalancer_ Proxy address of Bridge
function setupRebalancer(address rebalancer_) external;
/// @notice Setup Bridge.
/// Only Goverannce or Multisig can do this when Bridge is not set.
/// @param bridge_ Proxy address of Bridge
function setupBridge(address bridge_) external;
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;
interface IXShadow {
/**
* @dev exit instantly with a penalty
* @param amount amount of xShadows to exit
*/
function exit(uint amount) external returns(uint exitedAmount);
/// @notice address of the shadow token
function SHADOW() external view returns (address);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Permit.sol)
pragma solidity ^0.8.20;
/**
* @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
* https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
*
* Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
* presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
* need to send a transaction, and thus is not required to hold Ether at all.
*
* ==== Security Considerations
*
* There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
* expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
* considered as an intention to spend the allowance in any specific way. The second is that because permits have
* built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
* take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
* generally recommended is:
*
* ```solidity
* function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
* try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
* doThing(..., value);
* }
*
* function doThing(..., uint256 value) public {
* token.safeTransferFrom(msg.sender, address(this), value);
* ...
* }
* ```
*
* Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
* `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
* {SafeERC20-safeTransferFrom}).
*
* Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
* contracts should have entry points that don't rely on permit.
*/
interface IERC20Permit {
/**
* @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
* given ``owner``'s signed approval.
*
* IMPORTANT: The same issues {IERC20-approve} has related to transaction
* ordering also apply here.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `deadline` must be a timestamp in the future.
* - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
* over the EIP712-formatted function arguments.
* - the signature must use ``owner``'s current nonce (see {nonces}).
*
* For more information on the signature format, see the
* https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
* section].
*
* CAUTION: See Security Considerations above.
*/
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
/**
* @dev Returns the current nonce for `owner`. This value must be
* included whenever a signature is generated for {permit}.
*
* Every successful call to {permit} increases ``owner``'s nonce by one. This
* prevents a signature from being used multiple times.
*/
function nonces(address owner) external view returns (uint256);
/**
* @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
*/
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view returns (bytes32);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)
pragma solidity ^0.8.20;
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev The ETH balance of the account is not enough to perform the operation.
*/
error AddressInsufficientBalance(address account);
/**
* @dev There's no code at `target` (it is not a contract).
*/
error AddressEmptyCode(address target);
/**
* @dev A call to an address target failed. The target may have reverted.
*/
error FailedInnerCall();
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
if (address(this).balance < amount) {
revert AddressInsufficientBalance(address(this));
}
(bool success, ) = recipient.call{value: amount}("");
if (!success) {
revert FailedInnerCall();
}
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason or custom error, it is bubbled
* up by this function (like regular Solidity function calls). However, if
* the call reverted with no returned reason, this function reverts with a
* {FailedInnerCall} error.
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
if (address(this).balance < value) {
revert AddressInsufficientBalance(address(this));
}
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata);
}
/**
* @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
* was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an
* unsuccessful call.
*/
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata
) internal view returns (bytes memory) {
if (!success) {
_revert(returndata);
} else {
// only check if target is a contract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
if (returndata.length == 0 && target.code.length == 0) {
revert AddressEmptyCode(target);
}
return returndata;
}
}
/**
* @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
* revert reason or with a default {FailedInnerCall} error.
*/
function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
if (!success) {
_revert(returndata);
} else {
return returndata;
}
}
/**
* @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.
*/
function _revert(bytes memory returndata) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert FailedInnerCall();
}
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;
import "./StrategyBase.sol";
import "../libs/LPStrategyLib.sol";
import "../../interfaces/ILPStrategy.sol";
/// @dev Base liquidity providing strategy
/// Changelog:
/// 1.1.1: _swapForDepositProportion use try..catch
/// 1.1.0: use customPriceImpactTolerance
/// 1.0.4: _swapForDepositProportion support all amm adapters
/// @author Alien Deployer (https://github.com/a17)
/// @author JodsMigel (https://github.com/JodsMigel)
abstract contract LPStrategyBase is StrategyBase, ILPStrategy {
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* CONSTANTS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @dev Version of LPStrategyBase implementation
string public constant VERSION_LP_STRATEGY_BASE = "1.1.1";
// keccak256(abi.encode(uint256(keccak256("erc7201:stability.LPStrategyBase")) - 1)) & ~bytes32(uint256(0xff));
bytes32 private constant LPSTRATEGYBASE_STORAGE_LOCATION =
0xa6fdc931ca23c69f54119a0a2d6478619b5aa365084590a1fbc287668fbabe00;
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* INITIALIZATION */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
//slither-disable-next-line naming-convention
function __LPStrategyBase_init(LPStrategyBaseInitParams memory params) internal onlyInitializing {
LPStrategyBaseStorage storage $ = _getLPStrategyBaseStorage();
address[] memory _assets;
uint exchangeAssetIndex;
(_assets, exchangeAssetIndex) = LPStrategyLib.LPStrategyBase_init($, params.platform, params, ammAdapterId());
//slither-disable-next-line reentrancy-events
__StrategyBase_init(params.platform, params.id, params.vault, _assets, params.underlying, exchangeAssetIndex);
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* VIEW FUNCTIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @inheritdoc IERC165
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(ILPStrategy).interfaceId || super.supportsInterface(interfaceId);
}
/// @inheritdoc IStrategy
function supportedVaultTypes() external view virtual override returns (string[] memory types) {
types = new string[](3);
types[0] = VaultTypeLib.COMPOUNDING;
types[1] = VaultTypeLib.REWARDING;
types[2] = VaultTypeLib.REWARDING_MANAGED;
}
/// @inheritdoc ILPStrategy
function ammAdapterId() public view virtual returns (string memory);
/// @inheritdoc ILPStrategy
function pool() public view override returns (address) {
return _getLPStrategyBaseStorage().pool;
}
/// @inheritdoc ILPStrategy
function ammAdapter() public view returns (IAmmAdapter) {
return _getLPStrategyBaseStorage().ammAdapter;
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* INTERNAL LOGIC */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
//slither-disable-next-line dead-code
function _previewDepositAssets(uint[] memory amountsMax)
internal
view
virtual
override
returns (uint[] memory amountsConsumed, uint value)
{
LPStrategyBaseStorage storage $ = _getLPStrategyBaseStorage();
(value, amountsConsumed) = $.ammAdapter.getLiquidityForAmounts($.pool, amountsMax);
}
function _previewDepositAssets(
address[] memory assets_,
uint[] memory amountsMax
) internal view override returns (uint[] memory amountsConsumed, uint value) {
LPStrategyLib.checkPreviewDepositAssets(assets_, assets(), amountsMax);
return _previewDepositAssets(amountsMax);
}
function _withdrawAssets(
address[] memory assets_,
uint value,
address receiver
) internal virtual override returns (uint[] memory amountsOut) {
LPStrategyLib.checkAssets(assets_, assets());
return _withdrawAssets(value, receiver);
}
function _processRevenue(
address[] memory assets_,
uint[] memory amountsRemaining
) internal override returns (bool needCompound) {
LPStrategyBaseStorage storage $ = _getLPStrategyBaseStorage();
return LPStrategyLib.processRevenue(
platform(),
vault(),
$.ammAdapter,
_getStrategyBaseStorage()._exchangeAssetIndex,
$.pool,
assets_,
amountsRemaining
);
}
function _swapForDepositProportion(uint prop0Pool) internal returns (uint[] memory amountsToDeposit) {
LPStrategyBaseStorage storage $ = _getLPStrategyBaseStorage();
try LPStrategyLib.swapForDepositProportion(
platform(), $.ammAdapter, $.pool, assets(), prop0Pool, customPriceImpactTolerance()
) returns (uint[] memory _amountsToDeposit) {
return _amountsToDeposit;
} catch {
return new uint[](assets().length);
}
}
function _getLPStrategyBaseStorage() internal pure returns (LPStrategyBaseStorage storage $) {
//slither-disable-next-line assembly
assembly {
$.slot := LPSTRATEGYBASE_STORAGE_LOCATION
}
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;
library VaultTypeLib {
string internal constant COMPOUNDING = "Compounding";
string internal constant REWARDING = "Rewarding";
string internal constant REWARDING_MANAGED = "Rewarding Managed";
string internal constant SPLITTER_MANAGED = "Splitter Managed";
string internal constant SPLITTER_AUTO = "Splitter Automatic";
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;
interface IALM {
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* CUSTOM ERRORS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
error IncorrectRebalanceArgs();
error NotNeedRebalance();
error CantDoRebalance();
error NotALM();
error PriceChangeProtection(uint price, uint priceBefore, uint priceThreshold, uint32 twapInterval);
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* EVENTS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
event ALMParams(uint algoId, int24[] params);
event PriceChangeProtectionParams(bool enabled, uint32 twapInterval, uint priceThreshold);
event Rebalance(Position[] newPosition);
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* DATA TYPES */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @custom:storage-location erc7201:stability.ALMStrategyBase
struct ALMStrategyBaseStorage {
uint algoId;
int24[] params;
Position[] positions;
address nft;
bool priceChangeProtection;
uint32 twapInterval;
uint priceThreshold;
}
struct ALMStrategyBaseInitParams {
uint algoId;
int24[] params;
address nft;
}
struct Position {
uint tokenId;
int24 tickLower;
int24 tickUpper;
uint128 liquidity;
}
struct NewPosition {
int24 tickLower;
int24 tickUpper;
uint128 liquidity;
uint minAmount0;
uint minAmount1;
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* VIEW FUNCTIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @notice ALM preset
function preset()
external
view
returns (uint algoId, string memory algoName, string memory presetName, int24[] memory params);
/// @notice Show current ALM positions
function positions() external view returns (Position[] memory);
/// @notice Is a re-balance needed now
function needRebalance() external view returns (bool);
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* WRITE FUNCTIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @notice Re-balance positions
/// @param burnOldPositions Burn old position or keep. Burn all if length 0 passed than.
/// @param mintNewPositions New positions params
function rebalance(bool[] memory burnOldPositions, NewPosition[] memory mintNewPositions) external;
/// @notice Setup price change protection params
/// @param enabled Enable protection
/// @param twapInterval TWAP interval in seconds
/// @param priceThreshold Price threshold. Default is 10_000.
function setupPriceChangeProtection(bool enabled, uint32 twapInterval, uint priceThreshold) external;
/// @notice Change ALM re-balancing params
/// @param algoId ID of ALM algorithm
/// @param params Re-balancing params
function setupALMParams(uint algoId, int24[] memory params) external;
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.22;
import "./IAmmAdapter.sol";
/// @dev Adapter for interacting with Concentrated Automated Market Maker
/// based on liquidity pool of 2 tokens.
/// @author Alien Deployer (https://github.com/a17)
interface ICAmmAdapter is IAmmAdapter {
/// @notice Price in pool at specified tick
/// @param pool Address of a pool supported by the adapter
/// @param tokenIn Token for sell
/// @return Output amount of swap 1.0 tokenIn in pool without price impact
function getPriceAtTick(address pool, address tokenIn, int24 tick) external view returns (uint);
/// @notice Priced proportions of pool assets in specified range
/// @param pool Address of a pool supported by the adapter
/// @param ticks Tick boundaries. Lower and upper ticks for UniswapV3-like AMM position.
/// @return Proportions with 5 decimals precision. Max is 100_000, min is 0.
function getProportions(address pool, int24[] memory ticks) external view returns (uint[] memory);
/// @notice Computes the maximum amount of liquidity received for given amounts of pool assets and the current
/// pool prices and the prices at the tick boundaries
/// @param pool Address of a pool supported by the adapter
/// @param amounts Amounts of pool assets
/// @param ticks Tick boundaries. Lower and upper ticks for UniswapV3-like AMM position.
/// @return liquidity Liquidity out value
/// @return amountsConsumed Amounts of consumed assets of provided liquidity
function getLiquidityForAmounts(
address pool,
uint[] memory amounts,
int24[] memory ticks
) external view returns (uint liquidity, uint[] memory amountsConsumed);
/// @notice Computes pool assets amounts for a given amount of liquidity, the current
/// pool prices and the prices at the tick boundaries
/// @param pool Address of a pool supported by the adapter
/// @param ticks Tick boundaries. Lower and upper ticks for UniswapV3-like AMM position.
/// @param liquidity Liquidity value
/// @return amounts Amounts out of provided liquidity
function getAmountsForLiquidity(
address pool,
int24[] memory ticks,
uint128 liquidity
) external view returns (uint[] memory amounts);
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;
/// @dev HardWork resolver and caller. Primary executor is server script, reserve executor is Gelato Automate.
/// Hardwork is important task of any vault - claiming revenue and processing it by strategy, updating rewarding,
/// compounding, declaring income and losses, related things.
/// @author Alien Deployer (https://github.com/a17)
/// @author JodsMigel (https://github.com/JodsMigel)
interface IHardWorker {
//region ----- Custom Errors -----
error NotExistWithObject(address notExistObject);
error AlreadyExclude(address alreadyExcludedObject);
error NotServerOrGelato();
error NotEnoughETH();
//endregion ----- Custom Errors -----
event Call(uint hardworks, uint gasUsed, uint gasCost, bool server);
event DedicatedServerMsgSender(address indexed sender, bool allowed);
event DedicatedGelatoMsgSender(address oldSender, address newSender);
event Delays(uint delayServer, uint delayGelato);
event GelatoTask(bytes32 id);
event GelatoDeposit(uint amount);
event MaxHwPerCall(uint maxHwPerCall_);
event VaultExcludeStatusChanged(address vault, bool status);
function getDelays() external view returns (uint delayServer, uint delayGelato);
/// @notice Vaults that excluded from HardWork execution
function excludedVaults(address vault) external view returns (bool);
/// @notice Maximum vault HardWork calls per execution
function maxHwPerCall() external view returns (uint);
/// @notice Check dedicated server address allowance for execute vault HardWorks
function dedicatedServerMsgSender(address sender) external view returns (bool allowed);
/// @notice Dedicated Gelato OPS proxy for HardWorker contract address.
/// OPS proxy is deployed at HardWorker initialization.
/// @return Immutable Gelato dedicated msg.sender
function dedicatedGelatoMsgSender() external view returns (address);
/// @notice Checker method for calling from server script
/// @return canExec Hard Work can be executed
/// @return execPayload Vault addresses for HardWork
function checkerServer() external view returns (bool canExec, bytes memory execPayload);
/// @notice Checker method for calling from Gelato Automate
/// @return canExec Hard Work can be executed
/// @return execPayload Vault addresses for HardWork
function checkerGelato() external view returns (bool canExec, bytes memory execPayload);
/// @notice Gelato Automate task ID created by this contract
function gelatoTaskId() external view returns (bytes32);
/// @notice ETH balance of HardWork contract on Gelato
/// @return ETH amount with 18 decimals
function gelatoBalance() external view returns (uint);
/// @notice Return minimum required ETH balance of HardWork contract on Gelato
/// @return ETH amount with 18 decimals
function gelatoMinBalance() external view returns (uint);
/// @notice Setup allowance status for dedicated server address
function setDedicatedServerMsgSender(address sender, bool allowed) external;
/// @notice Setup delays between HardWorks in seconds
/// @param delayServer_ Delay for server script
/// @param delayGelato_ Delay for Gelato
function setDelays(uint delayServer_, uint delayGelato_) external;
/// @notice Set maximum vault HardWork calls per execution
/// Only operator cal call this
/// @param maxHwPerCall_ Max vault HardWorks per call(vaults) execution
//slither-disable-next-line similar-names
function setMaxHwPerCall(uint maxHwPerCall_) external;
/// @notice Changing vault excluding status
/// @param vaults_ Addresses of vaults
/// @param status New status
function changeVaultExcludeStatus(address[] memory vaults_, bool[] memory status) external;
/// @notice Call vault HardWorks
/// @param vaults Addresses of vault from checkerServer/checkerGelato output
function call(address[] memory vaults) external;
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;
import "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "../../core/libs/ConstantsLib.sol";
import "../../core/libs/VaultTypeLib.sol";
import "../../core/libs/CommonLib.sol";
import "../../interfaces/IPlatform.sol";
import "../../interfaces/IVault.sol";
import "../../interfaces/IVaultManager.sol";
import "../../interfaces/IStrategyLogic.sol";
import "../../interfaces/IFactory.sol";
import "../../interfaces/IPriceReader.sol";
import "../../interfaces/ISwapper.sol";
import "../../interfaces/ILPStrategy.sol";
import "../../interfaces/IFarmingStrategy.sol";
library StrategyLib {
using SafeERC20 for IERC20;
/// @dev Reward pools may have low liquidity and 1% fees
uint internal constant SWAP_REWARDS_PRICE_IMPACT_TOLERANCE = 7_000;
struct ExtractFeesVars {
IPlatform platform;
uint feePlatform;
uint amountPlatform;
uint feeShareVaultManager;
uint amountVaultManager;
uint feeShareStrategyLogic;
uint amountStrategyLogic;
uint feeShareEcosystem;
uint amountEcosystem;
}
function FarmingStrategyBase_init(
IFarmingStrategy.FarmingStrategyBaseStorage storage $,
string memory id,
address platform,
uint farmId
) external {
$.farmId = farmId;
IFactory.Farm memory farm = IFactory(IPlatform(platform).factory()).farm(farmId);
if (keccak256(bytes(farm.strategyLogicId)) != keccak256(bytes(id))) {
revert IFarmingStrategy.IncorrectStrategyId();
}
updateFarmingAssets($, platform);
$._rewardsOnBalance = new uint[](farm.rewardAssets.length);
}
function updateFarmingAssets(IFarmingStrategy.FarmingStrategyBaseStorage storage $, address platform) public {
IFactory.Farm memory farm = IFactory(IPlatform(platform).factory()).farm($.farmId);
address swapper = IPlatform(platform).swapper();
$._rewardAssets = farm.rewardAssets;
uint len = farm.rewardAssets.length;
// nosemgrep
for (uint i; i < len; ++i) {
IERC20(farm.rewardAssets[i]).forceApprove(swapper, type(uint).max);
}
}
function transferAssets(
IStrategy.StrategyBaseStorage storage $,
uint amount,
uint total_,
address receiver
) external returns (uint[] memory amountsOut) {
address[] memory assets = $._assets;
uint len = assets.length;
amountsOut = new uint[](len);
// nosemgrep
for (uint i; i < len; ++i) {
amountsOut[i] = balance(assets[i]) * amount / total_;
IERC20(assets[i]).transfer(receiver, amountsOut[i]);
}
}
function extractFees(
address platform,
address vault,
string memory _id,
address[] memory assets_,
uint[] memory amounts_
) external returns (uint[] memory amountsRemaining) {
ExtractFeesVars memory vars = ExtractFeesVars({
platform: IPlatform(platform),
feePlatform: 0,
amountPlatform: 0,
feeShareVaultManager: 0,
amountVaultManager: 0,
feeShareStrategyLogic: 0,
amountStrategyLogic: 0,
feeShareEcosystem: 0,
amountEcosystem: 0
});
(vars.feePlatform, vars.feeShareVaultManager, vars.feeShareStrategyLogic, vars.feeShareEcosystem) =
vars.platform.getFees();
try vars.platform.getCustomVaultFee(vault) returns (uint vaultCustomFee) {
if (vaultCustomFee != 0) {
vars.feePlatform = vaultCustomFee;
}
} catch {}
address vaultManagerReceiver =
IVaultManager(vars.platform.vaultManager()).getRevenueReceiver(IVault(vault).tokenId());
//slither-disable-next-line unused-return
uint strategyLogicTokenId = IFactory(vars.platform.factory()).strategyLogicConfig(keccak256(bytes(_id))).tokenId;
address strategyLogicReceiver =
IStrategyLogic(vars.platform.strategyLogic()).getRevenueReceiver(strategyLogicTokenId);
uint len = assets_.length;
amountsRemaining = new uint[](len);
// nosemgrep
for (uint i; i < len; ++i) {
// revenue fee amount of assets_[i]
vars.amountPlatform = amounts_[i] * vars.feePlatform / ConstantsLib.DENOMINATOR;
vars.amountPlatform = Math.min(vars.amountPlatform, balance(assets_[i]));
if (vars.amountPlatform > 0) {
// VaultManager amount
vars.amountVaultManager = vars.amountPlatform * vars.feeShareVaultManager / ConstantsLib.DENOMINATOR;
// StrategyLogic amount
vars.amountStrategyLogic = vars.amountPlatform * vars.feeShareStrategyLogic / ConstantsLib.DENOMINATOR;
// Ecosystem amount
vars.amountEcosystem = vars.amountPlatform * vars.feeShareEcosystem / ConstantsLib.DENOMINATOR;
// Multisig share and amount
uint multisigShare = ConstantsLib.DENOMINATOR - vars.feeShareVaultManager - vars.feeShareStrategyLogic
- vars.feeShareEcosystem;
uint multisigAmount = multisigShare > 0
? vars.amountPlatform - vars.amountVaultManager - vars.amountStrategyLogic - vars.amountEcosystem
: 0;
// send amounts
IERC20(assets_[i]).safeTransfer(vaultManagerReceiver, vars.amountVaultManager);
IERC20(assets_[i]).safeTransfer(strategyLogicReceiver, vars.amountStrategyLogic);
if (vars.amountEcosystem > 0) {
IERC20(assets_[i]).safeTransfer(vars.platform.ecosystemRevenueReceiver(), vars.amountEcosystem);
}
if (multisigAmount > 0) {
IERC20(assets_[i]).safeTransfer(vars.platform.multisig(), multisigAmount);
}
emit IStrategy.ExtractFees(
vars.amountVaultManager, vars.amountStrategyLogic, vars.amountEcosystem, multisigAmount
);
amountsRemaining[i] = amounts_[i] - vars.amountPlatform;
amountsRemaining[i] = Math.min(amountsRemaining[i], balance(assets_[i]));
}
}
}
function liquidateRewards(
address platform,
address exchangeAsset,
address[] memory rewardAssets_,
uint[] memory rewardAmounts_,
uint customPriceImpactTolerance
) external returns (uint earnedExchangeAsset) {
ISwapper swapper = ISwapper(IPlatform(platform).swapper());
uint len = rewardAssets_.length;
uint exchangeAssetBalanceBefore = balance(exchangeAsset);
// nosemgrep
for (uint i; i < len; ++i) {
if (rewardAmounts_[i] > swapper.threshold(rewardAssets_[i])) {
if (rewardAssets_[i] != exchangeAsset) {
swapper.swap(
rewardAssets_[i],
exchangeAsset,
Math.min(rewardAmounts_[i], balance(rewardAssets_[i])),
customPriceImpactTolerance != 0
? customPriceImpactTolerance
: SWAP_REWARDS_PRICE_IMPACT_TOLERANCE
);
} else {
exchangeAssetBalanceBefore = 0;
}
}
}
uint exchangeAssetBalanceAfter = balance(exchangeAsset);
earnedExchangeAsset = exchangeAssetBalanceAfter - exchangeAssetBalanceBefore;
}
function emitApr(
IStrategy.StrategyBaseStorage storage $,
address platform,
address[] memory assets,
uint[] memory amounts,
uint tvl,
uint totalBefore
) external {
uint duration = block.timestamp - $.lastHardWork;
IPriceReader priceReader = IPriceReader(IPlatform(platform).priceReader());
//slither-disable-next-line unused-return
(uint earned,, uint[] memory assetPrices,) = priceReader.getAssetsPrice(assets, amounts);
uint apr = computeApr(tvl, earned, duration);
uint aprCompound = totalBefore != 0 ? computeApr(totalBefore, $.total - totalBefore, duration) : apr;
uint sharePrice = tvl * 1e18 / IERC20($.vault).totalSupply();
emit IStrategy.HardWork(apr, aprCompound, earned, tvl, duration, sharePrice, assetPrices);
$.lastApr = apr;
$.lastAprCompound = aprCompound;
$.lastHardWork = block.timestamp;
}
function balance(address token) public view returns (uint) {
return IERC20(token).balanceOf(address(this));
}
/// @dev https://www.investopedia.com/terms/a/apr.asp
/// TVL and rewards should be in the same currency and with the same decimals
function computeApr(uint tvl, uint earned, uint duration) public pure returns (uint) {
if (tvl == 0 || duration == 0) {
return 0;
}
return earned * 1e18 * ConstantsLib.DENOMINATOR * uint(365) / tvl / (duration * 1e18 / 1 days);
}
function assetsAmountsWithBalances(
address[] memory assets_,
uint[] memory amounts_
) external view returns (address[] memory assets, uint[] memory amounts) {
assets = assets_;
amounts = amounts_;
uint len = assets_.length;
// nosemgrep
for (uint i; i < len; ++i) {
amounts[i] += balance(assets_[i]);
}
}
function assetsAreOnBalance(address[] memory assets) external view returns (bool isReady) {
uint rwLen = assets.length;
for (uint i; i < rwLen; ++i) {
if (IERC20(assets[i]).balanceOf(address(this)) > 0) {
isReady = true;
break;
}
}
}
// function getFarmsForStrategyId(address platform, string memory _id) external view returns (IFactory.Farm[] memory farms) {
// uint total;
// IFactory.Farm[] memory allFarms = IFactory(IPlatform(platform).factory()).farms();
// uint len = allFarms.length;
// for (uint i; i < len; ++i) {
// IFactory.Farm memory farm = allFarms[i];
// if (farm.status == 0 && CommonLib.eq(farm.strategyLogicId, _id)) {
// total++;
// }
// }
// farms = new IFactory.Farm[](total);
// uint k;
// for (uint i; i < len; ++i) {
// IFactory.Farm memory farm = allFarms[i];
// if (farm.status == 0 && CommonLib.eq(farm.strategyLogicId, _id)) {
// farms[k] = farm;
// k++;
// }
// }
// }
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;
/// @notice On-chain price quoter and swapper by predefined routes
/// @author Alien Deployer (https://github.com/a17)
/// @author Jude (https://github.com/iammrjude)
/// @author JodsMigel (https://github.com/JodsMigel)
/// @author 0xhokugava (https://github.com/0xhokugava)
interface ISwapper {
event Swap(address indexed tokenIn, address indexed tokenOut, uint amount);
event PoolAdded(PoolData poolData, bool assetAdded);
event PoolRemoved(address token);
event BlueChipAdded(PoolData poolData);
event ThresholdChanged(address[] tokenIn, uint[] thresholdAmount);
event BlueChipPoolRemoved(address tokenIn, address tokenOut);
//region ----- Custom Errors -----
error UnknownAMMAdapter();
error LessThenThreshold(uint minimumAmount);
error NoRouteFound();
error NoRoutesForAssets();
//endregion -- Custom Errors -----
struct PoolData {
address pool;
address ammAdapter;
address tokenIn;
address tokenOut;
}
struct AddPoolData {
address pool;
string ammAdapterId;
address tokenIn;
address tokenOut;
}
/// @notice All assets in pools added to Swapper
/// @return Addresses of assets
function assets() external view returns (address[] memory);
/// @notice All blue chip assets in blue chip pools added to Swapper
/// @return Addresses of blue chip assets
function bcAssets() external view returns (address[] memory);
/// @notice All assets in Swapper
/// @return Addresses of assets and blue chip assets
function allAssets() external view returns (address[] memory);
/// @notice Add pools with largest TVL
/// @param pools Largest pools with AMM adapter addresses
/// @param rewrite Rewrite pool for tokenIn
function addPools(PoolData[] memory pools, bool rewrite) external;
/// @notice Add pools with largest TVL
/// @param pools Largest pools with AMM adapter ID string
/// @param rewrite Rewrite pool for tokenIn
function addPools(AddPoolData[] memory pools, bool rewrite) external;
/// @notice Add largest pools with the most popular tokens on the current network
/// @param pools_ PoolData array with pool, tokens and AMM adapter address
/// @param rewrite Change exist pool records
function addBlueChipsPools(PoolData[] memory pools_, bool rewrite) external;
/// @notice Add largest pools with the most popular tokens on the current network
/// @param pools_ AddPoolData array with pool, tokens and AMM adapter string ID
/// @param rewrite Change exist pool records
function addBlueChipsPools(AddPoolData[] memory pools_, bool rewrite) external;
/// @notice Retrieves pool data for a specified token swap in Blue Chip Pools.
/// @dev This function provides information about the pool associated with the specified input and output tokens.
/// @param tokenIn The input token address.
/// @param tokenOut The output token address.
/// @return poolData The data structure containing information about the Blue Chip Pool.
/// @custom:opcodes view
function blueChipsPools(address tokenIn, address tokenOut) external view returns (PoolData memory poolData);
/// @notice Set swap threshold for token
/// @dev Prevents dust swap.
/// @param tokenIn Swap input token
/// @param thresholdAmount Minimum amount of token for executing swap
function setThresholds(address[] memory tokenIn, uint[] memory thresholdAmount) external;
/// @notice Swap threshold for token
/// @param token Swap input token
/// @return threshold_ Minimum amount of token for executing swap
function threshold(address token) external view returns (uint threshold_);
/// @notice Price of given tokenIn against tokenOut
/// @param tokenIn Swap input token
/// @param tokenOut Swap output token
/// @param amount Amount of tokenIn. If provide zero then amount is 1.0.
/// @return Amount of tokenOut with decimals of tokenOut
function getPrice(address tokenIn, address tokenOut, uint amount) external view returns (uint);
/// @notice Return price the first poolData.tokenIn against the last poolData.tokenOut in decimals of tokenOut.
/// @param route Array of pool address, swapper address tokenIn, tokenOut
/// @param amount Amount of tokenIn. If provide zero then amount is 1.0.
function getPriceForRoute(PoolData[] memory route, uint amount) external view returns (uint);
/// @notice Check possibility of swap tokenIn for tokenOut
/// @param tokenIn Swap input token
/// @param tokenOut Swap output token
/// @return Swap route exists
function isRouteExist(address tokenIn, address tokenOut) external view returns (bool);
/// @notice Build route for swap. No reverts inside.
/// @param tokenIn Swap input token
/// @param tokenOut Swap output token
/// @return route Array of pools for swap tokenIn to tokenOut. Zero length indicate an error.
/// @return errorMessage Possible reason why the route was not found. Empty for success routes.
function buildRoute(
address tokenIn,
address tokenOut
) external view returns (PoolData[] memory route, string memory errorMessage);
/// @notice Sell tokenIn for tokenOut
/// @dev Assume approve on this contract exist
/// @param tokenIn Swap input token
/// @param tokenOut Swap output token
/// @param amount Amount of tokenIn for swap.
/// @param priceImpactTolerance Price impact tolerance. Must include fees at least. Denominator is 100_000.
function swap(address tokenIn, address tokenOut, uint amount, uint priceImpactTolerance) external;
/// @notice Swap by predefined route
/// @param route Array of pool address, swapper address tokenIn, tokenOut.
/// TokenIn from first item will be swaped to tokenOut of last .
/// @param amount Amount of first item tokenIn.
/// @param priceImpactTolerance Price impact tolerance. Must include fees at least. Denominator is 100_000.
function swapWithRoute(PoolData[] memory route, uint amount, uint priceImpactTolerance) external;
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "../libs/SlotsLib.sol";
import "../../interfaces/IControllable.sol";
import "../../interfaces/IPlatform.sol";
/// @dev Base core contract.
/// It store an immutable platform proxy address in the storage and provides access control to inherited contracts.
/// @author Alien Deployer (https://github.com/a17)
/// @author 0xhokugava (https://github.com/0xhokugava)
abstract contract Controllable is Initializable, IControllable, ERC165 {
using SlotsLib for bytes32;
string public constant CONTROLLABLE_VERSION = "1.0.0";
bytes32 internal constant _PLATFORM_SLOT = bytes32(uint(keccak256("eip1967.controllable.platform")) - 1);
bytes32 internal constant _CREATED_BLOCK_SLOT = bytes32(uint(keccak256("eip1967.controllable.created_block")) - 1);
/// @dev Prevent implementation init
constructor() {
_disableInitializers();
}
/// @notice Initialize contract after setup it as proxy implementation
/// Save block.timestamp in the "created" variable
/// @dev Use it only once after first logic setup
/// @param platform_ Platform address
//slither-disable-next-line naming-convention
function __Controllable_init(address platform_) internal onlyInitializing {
if (platform_ == address(0) || IPlatform(platform_).multisig() == address(0)) {
revert IncorrectZeroArgument();
}
SlotsLib.set(_PLATFORM_SLOT, platform_); // syntax for forge coverage
_CREATED_BLOCK_SLOT.set(block.number);
emit ContractInitialized(platform_, block.timestamp, block.number);
}
modifier onlyGovernance() {
_requireGovernance();
_;
}
modifier onlyMultisig() {
_requireMultisig();
_;
}
modifier onlyGovernanceOrMultisig() {
_requireGovernanceOrMultisig();
_;
}
modifier onlyOperator() {
_requireOperator();
_;
}
modifier onlyFactory() {
_requireFactory();
_;
}
// ************* SETTERS/GETTERS *******************
/// @inheritdoc IControllable
function platform() public view override returns (address) {
return _PLATFORM_SLOT.getAddress();
}
/// @inheritdoc IControllable
function createdBlock() external view override returns (uint) {
return _CREATED_BLOCK_SLOT.getUint();
}
/// @inheritdoc IERC165
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IControllable).interfaceId || super.supportsInterface(interfaceId);
}
function _requireGovernance() internal view {
if (IPlatform(platform()).governance() != msg.sender) {
revert NotGovernance();
}
}
function _requireMultisig() internal view {
if (!IPlatform(platform()).isOperator(msg.sender)) {
revert NotMultisig();
}
}
function _requireGovernanceOrMultisig() internal view {
IPlatform _platform = IPlatform(platform());
// nosemgrep
if (_platform.governance() != msg.sender && _platform.multisig() != msg.sender) {
revert NotGovernanceAndNotMultisig();
}
}
function _requireOperator() internal view {
if (!IPlatform(platform()).isOperator(msg.sender)) {
revert NotOperator();
}
}
function _requireFactory() internal view {
if (IPlatform(platform()).factory() != msg.sender) {
revert NotFactory();
}
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;
import "./IStrategy.sol";
/// @notice Vault core interface.
/// Derived implementations can be effective for building tokenized vaults with single or multiple underlying liquidity mining position.
/// Fungible, static non-fungible and actively re-balancing liquidity is supported, as well as single token liquidity provided to lending protocols.
/// Vaults can be used for active concentrated liquidity management and market making.
/// @author Jude (https://github.com/iammrjude)
/// @author JodsMigel (https://github.com/JodsMigel)
interface IVault is IERC165 {
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* CUSTOM ERRORS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
error NotEnoughBalanceToPay();
error FuseTrigger();
error ExceedSlippage(uint mintToUser, uint minToMint);
error ExceedSlippageExactAsset(address asset, uint mintToUser, uint minToMint);
error ExceedMaxSupply(uint maxSupply);
error NotEnoughAmountToInitSupply(uint mintAmount, uint initialShares);
error WaitAFewBlocks();
error StrategyZeroDeposit();
error NotSupported();
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* EVENTS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
event DepositAssets(address indexed account, address[] assets, uint[] amounts, uint mintAmount);
event WithdrawAssets(
address indexed sender, address indexed owner, address[] assets, uint sharesAmount, uint[] amountsOut
);
event HardWorkGas(uint gasUsed, uint gasCost, bool compensated);
event DoHardWorkOnDepositChanged(bool oldValue, bool newValue);
event MaxSupply(uint maxShares);
event VaultName(string newName);
event VaultSymbol(string newSymbol);
event MintFees(
uint vaultManagerReceiverFee,
uint strategyLogicReceiverFee,
uint ecosystemRevenueReceiverFee,
uint multisigReceiverFee
);
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* DATA TYPES */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @custom:storage-location erc7201:stability.VaultBase
struct VaultBaseStorage {
/// @dev Prevents manipulations with deposit and withdraw in short time.
/// For simplification we are setup new withdraw request on each deposit/transfer.
mapping(address msgSender => uint blockNumber) withdrawRequests;
/// @inheritdoc IVault
IStrategy strategy;
/// @inheritdoc IVault
uint maxSupply;
/// @inheritdoc IVault
uint tokenId;
/// @inheritdoc IVault
bool doHardWorkOnDeposit;
/// @dev Immutable vault type ID
string _type;
/// @dev Changed ERC20 name
string changedName;
/// @dev Changed ERC20 symbol
string changedSymbol;
}
/// @title Vault Initialization Data
/// @notice Data structure containing parameters for initializing a new vault.
/// @dev This struct is commonly used as a parameter for the `initialize` function in vault contracts.
/// @param platform Platform address providing access control, infrastructure addresses, fee settings, and upgrade capability.
/// @param strategy Immutable strategy proxy used by the vault.
/// @param name ERC20 name for the vault token.
/// @param symbol ERC20 symbol for the vault token.
/// @param tokenId NFT ID associated with the VaultManager.
/// @param vaultInitAddresses Array of addresses used during vault initialization.
/// @param vaultInitNums Array of uint values corresponding to initialization parameters.
struct VaultInitializationData {
address platform;
address strategy;
string name;
string symbol;
uint tokenId;
address[] vaultInitAddresses;
uint[] vaultInitNums;
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* VIEW FUNCTIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @notice Immutable vault type ID
function vaultType() external view returns (string memory);
/// @return uniqueInitAddresses Return required unique init addresses
/// @return uniqueInitNums Return required unique init nums
function getUniqueInitParamLength() external view returns (uint uniqueInitAddresses, uint uniqueInitNums);
/// @notice Vault type extra data
/// @return Vault type color, background color and other extra data
function extra() external view returns (bytes32);
/// @notice Immutable strategy proxy used by the vault
/// @return Linked strategy
function strategy() external view returns (IStrategy);
/// @notice Max supply of shares in the vault.
/// Since the starting share price is $1, this ceiling can be considered as an approximate TVL limit.
/// @return Max total supply of vault
function maxSupply() external view returns (uint);
/// @dev VaultManager token ID. This tokenId earn feeVaultManager provided by Platform.
function tokenId() external view returns (uint);
/// @dev Trigger doHardwork on invest action. Enabled by default.
function doHardWorkOnDeposit() external view returns (bool);
/// @dev USD price of share with 18 decimals.
/// ONLY FOR OFF-CHAIN USE.
/// Not trusted vault share price can be manipulated.
/// @return price_ Price of 1e18 shares with 18 decimals precision
/// @return trusted True means oracle price, false means AMM spot price
function price() external view returns (uint price_, bool trusted);
/// @dev USD price of assets managed by strategy with 18 decimals
/// ONLY FOR OFF-CHAIN USE.
/// Not trusted TVL can be manipulated.
/// @return tvl_ Total USD value of final assets in vault
/// @return trusted True means TVL calculated based only on oracle prices, false means AMM spot price was used.
function tvl() external view returns (uint tvl_, bool trusted);
/// @dev Calculation of consumed amounts, shares amount and liquidity/underlying value for provided available amounts of strategy assets
/// @param assets_ Assets suitable for vault strategy. Can be strategy assets, underlying asset or specific set of assets depending on strategy logic.
/// @param amountsMax Available amounts of assets_ that user wants to invest in vault
/// @return amountsConsumed Amounts of strategy assets that can be deposited by providing amountsMax
/// @return sharesOut Amount of vault shares that will be minted
/// @return valueOut Liquidity value or underlying token amount that will be received by the strategy
function previewDepositAssets(
address[] memory assets_,
uint[] memory amountsMax
) external view returns (uint[] memory amountsConsumed, uint sharesOut, uint valueOut);
/// @notice All available data on the latest declared APR (annual percentage rate)
/// @return totalApr Total APR of investing money to vault. 18 decimals: 1e18 - +100% per year.
/// @return strategyApr Strategy investmnt APR declared on last HardWork.
/// @return assetsWithApr Assets with underlying APR
/// @return assetsAprs Underlying APR of asset
function getApr()
external
view
returns (uint totalApr, uint strategyApr, address[] memory assetsWithApr, uint[] memory assetsAprs);
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* WRITE FUNCTIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @notice Write version of previewDepositAssets
/// @param assets_ Assets suitable for vault strategy. Can be strategy assets, underlying asset or specific set of assets depending on strategy logic.
/// @param amountsMax Available amounts of assets_ that user wants to invest in vault
/// @return amountsConsumed Amounts of strategy assets that can be deposited by providing amountsMax
/// @return sharesOut Amount of vault shares that will be minted
/// @return valueOut Liquidity value or underlying token amount that will be received by the strategy
function previewDepositAssetsWrite(
address[] memory assets_,
uint[] memory amountsMax
) external returns (uint[] memory amountsConsumed, uint sharesOut, uint valueOut);
/// @dev Mint fee shares callback
/// @param revenueAssets Assets returned by _claimRevenue function that was earned during HardWork
/// @param revenueAmounts Assets amounts returned from _claimRevenue function that was earned during HardWork
/// Only strategy can call this
function hardWorkMintFeeCallback(address[] memory revenueAssets, uint[] memory revenueAmounts) external;
/// @dev Deposit final assets (pool assets) to the strategy and minting of vault shares.
/// If the strategy interacts with a pool or farms through an underlying token, then it will be minted.
/// Emits a {DepositAssets} event with consumed amounts.
/// @param assets_ Assets suitable for the strategy. Can be strategy assets, underlying asset or specific set of assets depending on strategy logic.
/// @param amountsMax Available amounts of assets_ that user wants to invest in vault
/// @param minSharesOut Slippage tolerance. Minimal shares amount which must be received by user.
/// @param receiver Receiver of deposit. If receiver is zero address, receiver is msg.sender.
function depositAssets(
address[] memory assets_,
uint[] memory amountsMax,
uint minSharesOut,
address receiver
) external;
/// @dev Burning shares of vault and obtaining strategy assets.
/// @param assets_ Assets suitable for the strategy. Can be strategy assets, underlying asset or specific set of assets depending on strategy logic.
/// @param amountShares Shares amount for burning
/// @param minAssetAmountsOut Slippage tolerance. Minimal amounts of strategy assets that user must receive.
/// @return Amount of assets for withdraw. It's related to assets_ one-by-one.
function withdrawAssets(
address[] memory assets_,
uint amountShares,
uint[] memory minAssetAmountsOut
) external returns (uint[] memory);
/// @dev Burning shares of vault and obtaining strategy assets.
/// @param assets_ Assets suitable for the strategy. Can be strategy assets, underlying asset or specific set of assets depending on strategy logic.
/// @param amountShares Shares amount for burning
/// @param minAssetAmountsOut Slippage tolerance. Minimal amounts of strategy assets that user must receive.
/// @param receiver Receiver of assets
/// @param owner Owner of vault shares
/// @return Amount of assets for withdraw. It's related to assets_ one-by-one.
function withdrawAssets(
address[] memory assets_,
uint amountShares,
uint[] memory minAssetAmountsOut,
address receiver,
address owner
) external returns (uint[] memory);
/// @dev Setting of vault capacity
/// @param maxShares If totalSupply() exceeds this value, deposits will not be possible
function setMaxSupply(uint maxShares) external;
/// @dev If activated will call doHardWork on strategy on some deposit actions
/// @param value HardWork on deposit is enabled
function setDoHardWorkOnDeposit(bool value) external;
/// @notice Initialization function for the vault.
/// @dev This function is usually called by the Factory during the creation of a new vault.
/// @param vaultInitializationData Data structure containing parameters for vault initialization.
function initialize(VaultInitializationData memory vaultInitializationData) external;
/// @dev Calling the strategy HardWork by operator with optional compensation for spent gas from the vault balance
function doHardWork() external;
/// @dev Changing ERC20 name of vault
function setName(string calldata newName) external;
/// @dev Changing ERC20 symbol of vault
function setSymbol(string calldata newSymbol) external;
}// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.23;
import "./pool/IUniswapV3PoolImmutables.sol";
import "./pool/IUniswapV3PoolState.sol";
import "./pool/IUniswapV3PoolDerivedState.sol";
import "./pool/IUniswapV3PoolActions.sol";
import "./pool/IUniswapV3PoolOwnerActions.sol";
import "./pool/IUniswapV3PoolEvents.sol";
/// @title The interface for a Uniswap V3 Pool
/// @notice A Uniswap pool facilitates swapping and automated market making between any two assets that strictly conform
/// to the ERC20 specification
/// @dev The pool interface is broken up into many smaller pieces
interface IUniswapV3Pool is
IUniswapV3PoolImmutables,
IUniswapV3PoolState,
IUniswapV3PoolDerivedState,
IUniswapV3PoolActions,
IUniswapV3PoolOwnerActions,
IUniswapV3PoolEvents
{}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;
library UniswapV3MathLib {
uint8 internal constant RESOLUTION = 96;
uint internal constant Q96 = 0x1000000000000000000000000;
uint internal constant TWO_96 = 2 ** 96;
uint160 internal constant MIN_SQRT_RATIO = 4295128739 + 1;
uint160 internal constant MAX_SQRT_RATIO = 1461446703485210103287273052203988822378723970342 - 1;
int24 internal constant MIN_TICK = -887272;
int24 internal constant MAX_TICK = -MIN_TICK;
struct ComputeFeesEarnedCommonParams {
int24 tick;
int24 lowerTick;
int24 upperTick;
uint128 liquidity;
}
function calcPriceOut(
address tokenIn,
address token0,
uint160 sqrtPriceX96,
uint tokenInDecimals,
uint tokenOutDecimals,
uint amount
) external pure returns (uint) {
uint divider = tokenOutDecimals < 18 ? _max(10 ** tokenOutDecimals / 10 ** tokenInDecimals, 1) : 1;
uint priceDigits = _countDigits(uint(sqrtPriceX96));
uint purePrice;
uint precision;
if (tokenIn == token0) {
precision = 10 ** ((priceDigits < 29 ? 29 - priceDigits : 0) + tokenInDecimals);
uint part = uint(sqrtPriceX96) * precision / TWO_96;
purePrice = part * part;
} else {
precision = 10 ** ((priceDigits > 29 ? priceDigits - 29 : 0) + tokenInDecimals);
uint part = TWO_96 * precision / uint(sqrtPriceX96);
purePrice = part * part;
}
uint price = purePrice / divider / precision / (precision > 1e18 ? (precision / 1e18) : 1);
if (amount != 0) {
return price * amount / (10 ** tokenInDecimals);
} else {
return price;
}
}
/// @dev Working only for Uniswap V3 native fee calculations. Not usable for Kyber's auto compounding fees and other specific implementations.
function computeFeesEarned(
ComputeFeesEarnedCommonParams memory params,
uint feeGrowthGlobal,
uint feeGrowthOutsideLower,
uint feeGrowthOutsideUpper,
uint feeGrowthInsideLast
) external pure returns (uint fee) {
unchecked {
// calculate fee growth below
uint feeGrowthBelow;
if (params.tick >= params.lowerTick) {
feeGrowthBelow = feeGrowthOutsideLower;
} else {
feeGrowthBelow = feeGrowthGlobal - feeGrowthOutsideLower;
}
// calculate fee growth above
uint feeGrowthAbove;
if (params.tick < params.upperTick) {
feeGrowthAbove = feeGrowthOutsideUpper;
} else {
feeGrowthAbove = feeGrowthGlobal - feeGrowthOutsideUpper;
}
uint feeGrowthInside = feeGrowthGlobal - feeGrowthBelow - feeGrowthAbove;
fee = mulDiv(params.liquidity, feeGrowthInside - feeGrowthInsideLast, 0x100000000000000000000000000000000);
}
}
function getTicksInSpacing(
int24 tick,
int24 tickSpacing
) internal pure returns (int24 lowerTick, int24 upperTick) {
// nosemgrep
if (tick < 0 && tick / tickSpacing * tickSpacing != tick) {
lowerTick = (tick / tickSpacing - 1) * tickSpacing;
} else {
lowerTick = tick / tickSpacing * tickSpacing;
}
upperTick = lowerTick + tickSpacing;
}
/// @notice Computes the maximum amount of liquidity received for a given amount of token0, token1, the current
/// pool prices and the prices at the tick boundaries
function getLiquidityForAmounts(
uint160 sqrtRatioX96,
int24 lowerTick,
int24 upperTick,
uint amount0,
uint amount1
) internal pure returns (uint128 liquidity) {
uint160 sqrtRatioAX96 = getSqrtRatioAtTick(lowerTick);
uint160 sqrtRatioBX96 = getSqrtRatioAtTick(upperTick);
if (sqrtRatioAX96 > sqrtRatioBX96) {
(sqrtRatioAX96, sqrtRatioBX96) = (sqrtRatioBX96, sqrtRatioAX96);
}
if (sqrtRatioX96 <= sqrtRatioAX96) {
liquidity = _getLiquidityForAmount0(sqrtRatioAX96, sqrtRatioBX96, amount0);
} else if (sqrtRatioX96 < sqrtRatioBX96) {
uint128 liquidity0 = _getLiquidityForAmount0(sqrtRatioX96, sqrtRatioBX96, amount0);
uint128 liquidity1 = _getLiquidityForAmount1(sqrtRatioAX96, sqrtRatioX96, amount1);
liquidity = liquidity0 < liquidity1 ? liquidity0 : liquidity1;
} else {
liquidity = _getLiquidityForAmount1(sqrtRatioAX96, sqrtRatioBX96, amount1);
}
}
/// @notice Computes the token0 and token1 value for a given amount of liquidity, the current
/// pool prices and the prices at the tick boundaries
function getAmountsForLiquidity(
uint160 sqrtRatioX96,
int24 lowerTick,
int24 upperTick,
uint128 liquidity
) internal pure returns (uint amount0, uint amount1) {
uint160 sqrtRatioAX96 = getSqrtRatioAtTick(lowerTick);
uint160 sqrtRatioBX96 = getSqrtRatioAtTick(upperTick);
if (sqrtRatioAX96 > sqrtRatioBX96) {
(sqrtRatioAX96, sqrtRatioBX96) = (sqrtRatioBX96, sqrtRatioAX96);
}
if (sqrtRatioX96 <= sqrtRatioAX96) {
amount0 = _getAmount0ForLiquidity(sqrtRatioAX96, sqrtRatioBX96, liquidity);
} else if (sqrtRatioX96 < sqrtRatioBX96) {
amount0 = _getAmount0ForLiquidity(sqrtRatioX96, sqrtRatioBX96, liquidity);
amount1 = _getAmount1ForLiquidity(sqrtRatioAX96, sqrtRatioX96, liquidity);
} else {
amount1 = _getAmount1ForLiquidity(sqrtRatioAX96, sqrtRatioBX96, liquidity);
}
}
/// @notice Computes the amount of liquidity received for a given amount of token0 and price range
/// @dev Calculates amount0 * (sqrt(upper) * sqrt(lower)) / (sqrt(upper) - sqrt(lower)).
/// @param sqrtRatioAX96 A sqrt price
/// @param sqrtRatioBX96 Another sqrt price
/// @param amount0 The amount0 being sent in
/// @return liquidity The amount of returned liquidity
function _getLiquidityForAmount0(
uint160 sqrtRatioAX96,
uint160 sqrtRatioBX96,
uint amount0
) internal pure returns (uint128 liquidity) {
if (sqrtRatioAX96 > sqrtRatioBX96) {
(sqrtRatioAX96, sqrtRatioBX96) = (sqrtRatioBX96, sqrtRatioAX96);
}
uint intermediate = mulDiv(sqrtRatioAX96, sqrtRatioBX96, Q96);
return _toUint128(mulDiv(amount0, intermediate, sqrtRatioBX96 - sqrtRatioAX96));
}
/// @notice Computes the amount of liquidity received for a given amount of token1 and price range
/// @dev Calculates amount1 / (sqrt(upper) - sqrt(lower)).
/// @param sqrtRatioAX96 A sqrt price
/// @param sqrtRatioBX96 Another sqrt price
/// @param amount1 The amount1 being sent in
/// @return liquidity The amount of returned liquidity
function _getLiquidityForAmount1(
uint160 sqrtRatioAX96,
uint160 sqrtRatioBX96,
uint amount1
) internal pure returns (uint128 liquidity) {
if (sqrtRatioAX96 > sqrtRatioBX96) {
(sqrtRatioAX96, sqrtRatioBX96) = (sqrtRatioBX96, sqrtRatioAX96);
}
return _toUint128(mulDiv(amount1, Q96, sqrtRatioBX96 - sqrtRatioAX96));
}
/// @notice Computes the amount of token0 for a given amount of liquidity and a price range
/// @param sqrtRatioAX96 A sqrt price
/// @param sqrtRatioBX96 Another sqrt price
/// @param liquidity The liquidity being valued
/// @return amount0 The amount0
function _getAmount0ForLiquidity(
uint160 sqrtRatioAX96,
uint160 sqrtRatioBX96,
uint128 liquidity
) internal pure returns (uint amount0) {
if (sqrtRatioAX96 > sqrtRatioBX96) {
(sqrtRatioAX96, sqrtRatioBX96) = (sqrtRatioBX96, sqrtRatioAX96);
}
return _mulDivRoundingUp(
1,
_mulDivRoundingUp(uint(liquidity) << RESOLUTION, sqrtRatioBX96 - sqrtRatioAX96, sqrtRatioBX96),
sqrtRatioAX96
);
}
/// @notice Computes the amount of token1 for a given amount of liquidity and a price range
/// @param sqrtRatioAX96 A sqrt price
/// @param sqrtRatioBX96 Another sqrt price
/// @param liquidity The liquidity being valued
/// @return amount1 The amount1
function _getAmount1ForLiquidity(
uint160 sqrtRatioAX96,
uint160 sqrtRatioBX96,
uint128 liquidity
) internal pure returns (uint amount1) {
if (sqrtRatioAX96 > sqrtRatioBX96) {
(sqrtRatioAX96, sqrtRatioBX96) = (sqrtRatioBX96, sqrtRatioAX96);
}
return _mulDivRoundingUp(liquidity, sqrtRatioBX96 - sqrtRatioAX96, Q96);
}
/// @notice Calculates floor(a×b÷denominator) with full precision. Throws if result overflows a uint or denominator == 0
/// @param a The multiplicand
/// @param b The multiplier
/// @param denominator The divisor
/// @return result The 256-bit result
/// @dev Credit to Remco Bloemen under MIT license https://xn--2-umb.com/21/muldiv
function mulDiv(uint a, uint b, uint denominator) public pure returns (uint result) {
unchecked {
// 512-bit multiply [prod1 prod0] = a * b
// Compute the product mod 2**256 and mod 2**256 - 1
// then 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
uint prod0;
// Least significant 256 bits of the product
uint prod1;
// Most significant 256 bits of the product
assembly {
let mm := mulmod(a, b, not(0))
prod0 := mul(a, b)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
// Handle non-overflow cases, 256 by 256 division
if (prod1 == 0) {
require(denominator > 0);
assembly {
result := div(prod0, denominator)
}
return result;
}
// 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]
// Compute remainder using mulmod
uint remainder;
assembly {
remainder := mulmod(a, b, denominator)
}
// Subtract 256 bit number from 512 bit number
assembly {
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
// Factor powers of two out of denominator
// Compute largest power of two divisor of denominator.
// Always >= 1.
// EDIT for 0.8 compatibility:
// see: https://ethereum.stackexchange.com/questions/96642/unary-operator-cannot-be-applied-to-type-uint
uint twos = denominator & (~denominator + 1);
// Divide denominator by power of two
assembly {
denominator := div(denominator, twos)
}
// Divide [prod1 prod0] by the factors of two
assembly {
prod0 := div(prod0, twos)
}
// Shift in bits from prod1 into prod0. For this we need
// to flip `twos` such that it is 2**256 / twos.
// If twos is zero, then it becomes one
assembly {
twos := add(div(sub(0, twos), twos), 1)
}
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
// correct for four bits. That is, denominator * inv = 1 mod 2**4
uint inv = (3 * denominator) ^ 2;
// Now use 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.
inv *= 2 - denominator * inv;
// inverse mod 2**8
inv *= 2 - denominator * inv;
// inverse mod 2**16
inv *= 2 - denominator * inv;
// inverse mod 2**32
inv *= 2 - denominator * inv;
// inverse mod 2**64
inv *= 2 - denominator * inv;
// inverse mod 2**128
inv *= 2 - denominator * inv;
// 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 precoditions 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 * inv;
return result;
}
}
/// @notice Calculates ceil(a×b÷denominator) with full precision. Throws if result overflows a uint or denominator == 0
/// @param a The multiplicand
/// @param b The multiplier
/// @param denominator The divisor
/// @return result The 256-bit result
function _mulDivRoundingUp(uint a, uint b, uint denominator) internal pure returns (uint result) {
result = mulDiv(a, b, denominator);
if (mulmod(a, b, denominator) > 0) {
require(result < type(uint).max);
// nosemgrep
result++;
}
}
function _countDigits(uint n) internal pure returns (uint) {
if (n == 0) {
return 0;
}
uint count = 0;
while (n != 0) {
n = n / 10;
++count;
}
return count;
}
function _max(uint a, uint b) internal pure returns (uint) {
return a > b ? a : b;
}
function _toUint128(uint x) private pure returns (uint128 y) {
require((y = uint128(x)) == x);
}
/// @notice Calculates sqrt(1.0001^tick) * 2^96
/// @dev Throws if |tick| > max tick
/// @param tick The input tick for the above formula
/// @return sqrtPriceX96 A Fixed point Q64.96 number representing the sqrt of the ratio of the two assets (token1/token0)
/// at the given tick
function getSqrtRatioAtTick(int24 tick) public pure returns (uint160 sqrtPriceX96) {
uint absTick = tick < 0 ? uint(-int(tick)) : uint(int(tick));
// EDIT: 0.8 compatibility
// nosemgrep
require(absTick <= uint(int(MAX_TICK)), "T");
uint ratio = absTick & 0x1 != 0 ? 0xfffcb933bd6fad37aa2d162d1a594001 : 0x100000000000000000000000000000000;
if (absTick & 0x2 != 0) {
ratio = (ratio * 0xfff97272373d413259a46990580e213a) >> 128;
}
if (absTick & 0x4 != 0) {
ratio = (ratio * 0xfff2e50f5f656932ef12357cf3c7fdcc) >> 128;
}
if (absTick & 0x8 != 0) {
ratio = (ratio * 0xffe5caca7e10e4e61c3624eaa0941cd0) >> 128;
}
if (absTick & 0x10 != 0) {
ratio = (ratio * 0xffcb9843d60f6159c9db58835c926644) >> 128;
}
if (absTick & 0x20 != 0) {
ratio = (ratio * 0xff973b41fa98c081472e6896dfb254c0) >> 128;
}
if (absTick & 0x40 != 0) {
ratio = (ratio * 0xff2ea16466c96a3843ec78b326b52861) >> 128;
}
if (absTick & 0x80 != 0) {
ratio = (ratio * 0xfe5dee046a99a2a811c461f1969c3053) >> 128;
}
if (absTick & 0x100 != 0) {
ratio = (ratio * 0xfcbe86c7900a88aedcffc83b479aa3a4) >> 128;
}
if (absTick & 0x200 != 0) {
ratio = (ratio * 0xf987a7253ac413176f2b074cf7815e54) >> 128;
}
if (absTick & 0x400 != 0) {
ratio = (ratio * 0xf3392b0822b70005940c7a398e4b70f3) >> 128;
}
if (absTick & 0x800 != 0) {
ratio = (ratio * 0xe7159475a2c29b7443b29c7fa6e889d9) >> 128;
}
if (absTick & 0x1000 != 0) {
ratio = (ratio * 0xd097f3bdfd2022b8845ad8f792aa5825) >> 128;
}
if (absTick & 0x2000 != 0) {
ratio = (ratio * 0xa9f746462d870fdf8a65dc1f90e061e5) >> 128;
}
if (absTick & 0x4000 != 0) {
ratio = (ratio * 0x70d869a156d2a1b890bb3df62baf32f7) >> 128;
}
if (absTick & 0x8000 != 0) {
ratio = (ratio * 0x31be135f97d08fd981231505542fcfa6) >> 128;
}
if (absTick & 0x10000 != 0) {
ratio = (ratio * 0x9aa508b5b7a84e1c677de54f3e99bc9) >> 128;
}
if (absTick & 0x20000 != 0) {
ratio = (ratio * 0x5d6af8dedb81196699c329225ee604) >> 128;
}
if (absTick & 0x40000 != 0) {
ratio = (ratio * 0x2216e584f5fa1ea926041bedfe98) >> 128;
}
if (absTick & 0x80000 != 0) {
ratio = (ratio * 0x48a170391f7dc42444e8fa2) >> 128;
}
if (tick > 0) ratio = type(uint).max / ratio;
// this divides by 1<<32 rounding up to go from a Q128.128 to a Q128.96.
// we then downcast because we know the result always fits within 160 bits due to our tick input constraint
// we round up in the division so getTickAtSqrtRatio of the output price is always consistent
sqrtPriceX96 = uint160((ratio >> 32) + (ratio % (1 << 32) == 0 ? 0 : 1));
}
}// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.23;
import {IPoolInitializer} from "./periphery/IPoolInitializer.sol";
import {IPeripheryPayments} from "./periphery/IPeripheryPayments.sol";
import {IPeripheryImmutableState} from "./periphery/IPeripheryImmutableState.sol";
import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import {IERC721Metadata} from "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol";
import {IERC721Enumerable} from "@openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol";
import {IPeripheryErrors} from "./periphery/IPeripheryErrors.sol";
/// @title Non-fungible token for positions
/// @notice Wraps Uniswap V3 positions in a non-fungible token interface which allows for them to be transferred
/// and authorized.
interface INonfungiblePositionManager is
IPeripheryErrors,
IPoolInitializer,
IPeripheryPayments,
IPeripheryImmutableState,
IERC721,
IERC721Metadata,
IERC721Enumerable
{
/// @notice Emitted when liquidity is increased for a position NFT
/// @dev Also emitted when a token is minted
/// @param tokenId The ID of the token for which liquidity was increased
/// @param liquidity The amount by which liquidity for the NFT position was increased
/// @param amount0 The amount of token0 that was paid for the increase in liquidity
/// @param amount1 The amount of token1 that was paid for the increase in liquidity
event IncreaseLiquidity(uint indexed tokenId, uint128 liquidity, uint amount0, uint amount1);
/// @notice Emitted when liquidity is decreased for a position NFT
/// @param tokenId The ID of the token for which liquidity was decreased
/// @param liquidity The amount by which liquidity for the NFT position was decreased
/// @param amount0 The amount of token0 that was accounted for the decrease in liquidity
/// @param amount1 The amount of token1 that was accounted for the decrease in liquidity
event DecreaseLiquidity(uint indexed tokenId, uint128 liquidity, uint amount0, uint amount1);
/// @notice Emitted when tokens are collected for a position NFT
/// @dev The amounts reported may not be exactly equivalent to the amounts transferred, due to rounding behavior
/// @param tokenId The ID of the token for which underlying tokens were collected
/// @param recipient The address of the account that received the collected tokens
/// @param amount0 The amount of token0 owed to the position that was collected
/// @param amount1 The amount of token1 owed to the position that was collected
event Collect(uint indexed tokenId, address recipient, uint amount0, uint amount1);
/// @notice Returns the position information associated with a given token ID.
/// @dev Throws if the token ID is not valid.
/// @param tokenId The ID of the token that represents the position
/// @return token0 The address of the token0 for a specific pool
/// @return token1 The address of the token1 for a specific pool
/// @return tickSpacing The tickSpacing the pool
/// @return tickLower The lower end of the tick range for the position
/// @return tickUpper The higher end of the tick range for the position
/// @return liquidity The liquidity of the position
/// @return feeGrowthInside0LastX128 The fee growth of token0 as of the last action on the individual position
/// @return feeGrowthInside1LastX128 The fee growth of token1 as of the last action on the individual position
/// @return tokensOwed0 The uncollected amount of token0 owed to the position as of the last computation
/// @return tokensOwed1 The uncollected amount of token1 owed to the position as of the last computation
function positions(uint tokenId)
external
view
returns (
address token0,
address token1,
int24 tickSpacing,
int24 tickLower,
int24 tickUpper,
uint128 liquidity,
uint feeGrowthInside0LastX128,
uint feeGrowthInside1LastX128,
uint128 tokensOwed0,
uint128 tokensOwed1
);
struct MintParams {
address token0;
address token1;
int24 tickSpacing;
int24 tickLower;
int24 tickUpper;
uint amount0Desired;
uint amount1Desired;
uint amount0Min;
uint amount1Min;
address recipient;
uint deadline;
}
/// @notice Creates a new position wrapped in a NFT
/// @dev Call this when the pool does exist and is initialized. Note that if the pool is created but not initialized
/// a method does not exist, i.e. the pool is assumed to be initialized.
/// @param params The params necessary to mint a position, encoded as `MintParams` in calldata
/// @return tokenId The ID of the token that represents the minted position
/// @return liquidity The amount of liquidity for this position
/// @return amount0 The amount of token0
/// @return amount1 The amount of token1
function mint(MintParams calldata params)
external
payable
returns (uint tokenId, uint128 liquidity, uint amount0, uint amount1);
struct IncreaseLiquidityParams {
uint tokenId;
uint amount0Desired;
uint amount1Desired;
uint amount0Min;
uint amount1Min;
uint deadline;
}
/// @notice Increases the amount of liquidity in a position, with tokens paid by the `msg.sender`
/// @param params tokenId The ID of the token for which liquidity is being increased,
/// amount0Desired The desired amount of token0 to be spent,
/// amount1Desired The desired amount of token1 to be spent,
/// amount0Min The minimum amount of token0 to spend, which serves as a slippage check,
/// amount1Min The minimum amount of token1 to spend, which serves as a slippage check,
/// deadline The time by which the transaction must be included to effect the change
/// @return liquidity The new liquidity amount as a result of the increase
/// @return amount0 The amount of token0 to acheive resulting liquidity
/// @return amount1 The amount of token1 to acheive resulting liquidity
function increaseLiquidity(IncreaseLiquidityParams calldata params)
external
payable
returns (uint128 liquidity, uint amount0, uint amount1);
struct DecreaseLiquidityParams {
uint tokenId;
uint128 liquidity;
uint amount0Min;
uint amount1Min;
uint deadline;
}
/// @notice Decreases the amount of liquidity in a position and accounts it to the position
/// @param params tokenId The ID of the token for which liquidity is being decreased,
/// amount The amount by which liquidity will be decreased,
/// amount0Min The minimum amount of token0 that should be accounted for the burned liquidity,
/// amount1Min The minimum amount of token1 that should be accounted for the burned liquidity,
/// deadline The time by which the transaction must be included to effect the change
/// @return amount0 The amount of token0 accounted to the position's tokens owed
/// @return amount1 The amount of token1 accounted to the position's tokens owed
function decreaseLiquidity(DecreaseLiquidityParams calldata params)
external
payable
returns (uint amount0, uint amount1);
struct CollectParams {
uint tokenId;
address recipient;
uint128 amount0Max;
uint128 amount1Max;
}
/// @notice Collects up to a maximum amount of fees owed to a specific position to the recipient
/// @param params tokenId The ID of the NFT for which tokens are being collected,
/// recipient The account that should receive the tokens,
/// amount0Max The maximum amount of token0 to collect,
/// amount1Max The maximum amount of token1 to collect
/// @return amount0 The amount of fees collected in token0
/// @return amount1 The amount of fees collected in token1
function collect(CollectParams calldata params) external payable returns (uint amount0, uint amount1);
/// @notice Burns a token ID, which deletes it from the NFT contract. The token must have 0 liquidity and all tokens
/// must be collected first.
/// @param tokenId The ID of the token that is being burned
function burn(uint tokenId) external payable;
/// @notice Claims gauge rewards from liquidity incentives for a specific tokenId
/// @param tokenId The ID of the token to claim rewards from
/// @param tokens an array of reward tokens to claim
function getReward(uint tokenId, address[] calldata tokens) external;
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;
interface IGaugeV3 {
/// @notice Returns an array of reward token addresses.
/// @return An array of reward token addresses.
function getRewardTokens() external view returns (address[] memory);
/// @notice Returns the amount of rewards earned for an NFP.
/// @param token The address of the token for which to retrieve the earned rewards.
/// @param tokenId The identifier of the specific NFP for which to retrieve the earned rewards.
/// @return reward The amount of rewards earned for the specified NFP and tokens.
function earned(address token, uint tokenId) external view returns (uint reward);
/// @notice retrieves rewards based on an NFP id and an array of tokens
function getReward(uint tokenId, address[] memory tokens) external;
/// @notice retrieves rewards based on an array of NFP ids and an array of tokens
function getReward(uint[] calldata tokenIds, address[] memory tokens) external;
function pool() external view returns (address);
function nfpManager() external view returns (address);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Metadata.sol)
pragma solidity ^0.8.20;
import {IERC20} from "../IERC20.sol";
/**
* @dev Interface for the optional metadata functions from the ERC20 standard.
*/
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Strings.sol)
pragma solidity ^0.8.20;
import {Math} from "./math/Math.sol";
import {SignedMath} from "./math/SignedMath.sol";
/**
* @dev String operations.
*/
library Strings {
bytes16 private constant HEX_DIGITS = "0123456789abcdef";
uint8 private constant ADDRESS_LENGTH = 20;
/**
* @dev The `value` string doesn't fit in the specified `length`.
*/
error StringsInsufficientHexLength(uint256 value, uint256 length);
/**
* @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), HEX_DIGITS))
}
value /= 10;
if (value == 0) break;
}
return buffer;
}
}
/**
* @dev Converts a `int256` to its ASCII `string` decimal representation.
*/
function toStringSigned(int256 value) internal pure returns (string memory) {
return string.concat(value < 0 ? "-" : "", toString(SignedMath.abs(value)));
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
unchecked {
return toHexString(value, Math.log256(value) + 1);
}
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
uint256 localValue = value;
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] = HEX_DIGITS[localValue & 0xf];
localValue >>= 4;
}
if (localValue != 0) {
revert StringsInsufficientHexLength(value, length);
}
return string(buffer);
}
/**
* @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal
* representation.
*/
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH);
}
/**
* @dev Returns true if the two strings are equal.
*/
function equal(string memory a, string memory b) internal pure returns (bool) {
return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b));
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;
library ConstantsLib {
uint internal constant DENOMINATOR = 100_000;
address internal constant DEAD_ADDRESS = 0xdEad000000000000000000000000000000000000;
}// 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;
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "../../core/libs/CommonLib.sol";
import "../../core/libs/VaultTypeLib.sol";
import "../../core/libs/ConstantsLib.sol";
import "../../interfaces/ILPStrategy.sol";
import "../../interfaces/IPlatform.sol";
import "../../interfaces/IFactory.sol";
import "../../interfaces/ISwapper.sol";
import "../../interfaces/IRVault.sol";
library LPStrategyLib {
using SafeERC20 for IERC20;
uint internal constant SWAP_ASSETS_PRICE_IMPACT_TOLERANCE = 4_000;
struct ProcessRevenueVars {
string vaultYpe;
uint compoundRatio;
address bbToken;
uint bbAmountBefore;
}
struct SwapForDepositProportionVars {
ISwapper swapper;
uint price;
uint balance0;
uint balance1;
uint asset1decimals;
uint threshold0;
uint threshold1;
}
function LPStrategyBase_init(
ILPStrategy.LPStrategyBaseStorage storage $,
address platform,
ILPStrategy.LPStrategyBaseInitParams memory params,
string memory ammAdapterId
) external returns (address[] memory _assets, uint exchangeAssetIndex) {
IPlatform.AmmAdapter memory ammAdapterData = IPlatform(platform).ammAdapter(keccak256(bytes(ammAdapterId)));
if (ammAdapterData.proxy == address(0)) {
revert ILPStrategy.ZeroAmmAdapter();
}
IAmmAdapter ammAdapter = IAmmAdapter(ammAdapterData.proxy);
_assets = ammAdapter.poolTokens(params.pool);
uint len = _assets.length;
exchangeAssetIndex = IFactory(IPlatform(platform).factory()).getExchangeAssetIndex(_assets);
address swapper = IPlatform(params.platform).swapper();
// nosemgrep
for (uint i; i < len; ++i) {
IERC20(_assets[i]).forceApprove(swapper, type(uint).max);
}
$._feesOnBalance = new uint[](_assets.length);
$.pool = params.pool;
$.ammAdapter = ammAdapter;
}
function checkPreviewDepositAssets(
address[] memory assets_,
address[] memory _assets,
uint[] memory amountsMax
) external pure {
if (_assets.length != amountsMax.length) {
revert ILPStrategy.IncorrectAmountsLength();
}
checkAssets(assets_, _assets);
}
function checkAssets(address[] memory assets_, address[] memory _assets) public pure {
uint len = assets_.length;
if (len != _assets.length) {
revert ILPStrategy.IncorrectAssetsLength();
}
// nosemgrep
for (uint i; i < len; ++i) {
if (assets_[i] != _assets[i]) {
revert ILPStrategy.IncorrectAssets();
}
}
}
/// @dev For now this support only pools of 2 tokens
function processRevenue(
address platform,
address vault,
IAmmAdapter ammAdapter,
uint exchangeAssetIndex,
address pool,
address[] memory assets_,
uint[] memory amountsRemaining
) external returns (bool needCompound) {
needCompound = true;
ProcessRevenueVars memory vars;
vars.vaultYpe = IVault(vault).vaultType();
if (
CommonLib.eq(vars.vaultYpe, VaultTypeLib.REWARDING)
|| CommonLib.eq(vars.vaultYpe, VaultTypeLib.REWARDING_MANAGED)
) {
IRVault rVault = IRVault(vault);
vars.compoundRatio = rVault.compoundRatio();
vars.bbToken = rVault.bbToken();
vars.bbAmountBefore = _balance(vars.bbToken);
{
uint otherAssetIndex = exchangeAssetIndex == 0 ? 1 : 0;
uint exchangeAssetBBAmount = (ConstantsLib.DENOMINATOR - vars.compoundRatio)
* amountsRemaining[exchangeAssetIndex] / ConstantsLib.DENOMINATOR;
uint otherAssetBBAmount = (ConstantsLib.DENOMINATOR - vars.compoundRatio)
* amountsRemaining[otherAssetIndex] / ConstantsLib.DENOMINATOR;
// try to make less swaps
if (otherAssetBBAmount > 0) {
if (exchangeAssetBBAmount > 0) {
uint otherAssetBBAmountPrice =
ammAdapter.getPrice(pool, assets_[otherAssetIndex], address(0), otherAssetBBAmount);
uint exchangeAssetAmountRemaining = amountsRemaining[exchangeAssetIndex] - exchangeAssetBBAmount;
if (otherAssetBBAmountPrice <= exchangeAssetAmountRemaining) {
otherAssetBBAmount = 0;
exchangeAssetBBAmount += otherAssetBBAmountPrice;
}
}
}
ISwapper swapper = ISwapper(IPlatform(platform).swapper());
if (exchangeAssetBBAmount > 0) {
if (assets_[exchangeAssetIndex] != vars.bbToken) {
if (exchangeAssetBBAmount > swapper.threshold(assets_[exchangeAssetIndex])) {
swapper.swap(
assets_[exchangeAssetIndex],
vars.bbToken,
exchangeAssetBBAmount,
SWAP_ASSETS_PRICE_IMPACT_TOLERANCE
);
}
} else {
vars.bbAmountBefore -= exchangeAssetBBAmount;
}
}
if (otherAssetBBAmount > 0) {
if (assets_[otherAssetIndex] != vars.bbToken) {
if (otherAssetBBAmount > swapper.threshold(assets_[otherAssetIndex])) {
swapper.swap(
assets_[otherAssetIndex],
vars.bbToken,
otherAssetBBAmount,
SWAP_ASSETS_PRICE_IMPACT_TOLERANCE
);
}
} else {
vars.bbAmountBefore -= otherAssetBBAmount;
}
}
}
uint bbAmount = _balance(vars.bbToken) - vars.bbAmountBefore;
if (bbAmount > 0) {
_approveIfNeeded(vars.bbToken, bbAmount, vault);
rVault.notifyTargetRewardAmount(0, bbAmount);
}
if (vars.compoundRatio == 0) {
needCompound = false;
}
}
}
/// @dev For now this support only pools of 2 tokens
function swapForDepositProportion(
address platform,
IAmmAdapter ammAdapter,
address _pool,
address[] memory assets,
uint prop0Pool,
uint customPriceImpactTolerance
) external returns (uint[] memory amountsToDeposit) {
amountsToDeposit = new uint[](2);
SwapForDepositProportionVars memory vars;
vars.swapper = ISwapper(IPlatform(platform).swapper());
vars.asset1decimals = IERC20Metadata(assets[1]).decimals();
vars.price = ammAdapter.getPrice(_pool, assets[1], assets[0], 10 ** vars.asset1decimals);
vars.balance0 = _balance(assets[0]);
vars.balance1 = _balance(assets[1]);
vars.threshold0 = vars.swapper.threshold(assets[0]);
vars.threshold1 = vars.swapper.threshold(assets[1]);
if (vars.balance0 > vars.threshold0 || vars.balance1 > vars.threshold1) {
uint balance1PricedInAsset0 = vars.balance1 * vars.price / 10 ** vars.asset1decimals;
// here is change LPStrategyBase 1.0.3
// removed such code: `if (!(vars.balance1 > 0 && balance1PricedInAsset0 == 0)) {`
// because in setup where one of asset if reward asset this condition not work
uint prop0Balances =
vars.balance1 > 0 ? vars.balance0 * 1e18 / (balance1PricedInAsset0 + vars.balance0) : 1e18;
if (prop0Balances > prop0Pool) {
// extra assets[0]
uint correctAsset0Balance = (vars.balance0 + balance1PricedInAsset0) * prop0Pool / 1e18;
uint toSwapAsset0 = vars.balance0 - correctAsset0Balance;
// this is correct too, but difficult to understand..
// uint correctAsset0Balance = vars.balance1 * 1e18 / (1e18 - prop0Pool) * prop0Pool / 1e18
// * vars.price / 10 ** vars.asset1decimals;
// uint extraBalance = vars.balance0 - correctAsset0Balance;
// uint toSwapAsset0 = extraBalance - extraBalance * prop0Pool / 1e18;
// swap assets[0] to assets[1]
if (toSwapAsset0 > vars.threshold0) {
vars.swapper.swap(
assets[0],
assets[1],
toSwapAsset0,
customPriceImpactTolerance != 0
? customPriceImpactTolerance
: SWAP_ASSETS_PRICE_IMPACT_TOLERANCE
);
}
} else if (prop0Pool > 0) {
// extra assets[1]
uint correctAsset1Balance = vars.balance0 * 1e18 / prop0Pool * (1e18 - prop0Pool) / 1e18
* 10 ** vars.asset1decimals / vars.price;
uint extraBalance = vars.balance1 - correctAsset1Balance;
uint toSwapAsset1 = extraBalance * prop0Pool / 1e18;
// swap assets[1] to assets[0]
if (toSwapAsset1 > vars.threshold1) {
vars.swapper.swap(
assets[1],
assets[0],
toSwapAsset1,
customPriceImpactTolerance != 0
? customPriceImpactTolerance
: SWAP_ASSETS_PRICE_IMPACT_TOLERANCE
);
}
}
amountsToDeposit[0] = _balance(assets[0]);
amountsToDeposit[1] = _balance(assets[1]);
}
}
function _balance(address token) internal view returns (uint) {
return IERC20(token).balanceOf(address(this));
}
/// @notice Make infinite approve of {token} to {spender} if the approved amount is less than {amount}
/// @dev Should NOT be used for third-party pools
function _approveIfNeeded(address token, uint amount, address spender) internal {
if (IERC20(token).allowance(address(this), spender) < amount) {
// infinite approve, 2*255 is more gas efficient then type(uint).max
IERC20(token).forceApprove(spender, 2 ** 255);
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/ERC20.sol)
pragma solidity ^0.8.20;
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IERC20Metadata} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import {ContextUpgradeable} from "../../utils/ContextUpgradeable.sol";
import {IERC20Errors} from "@openzeppelin/contracts/interfaces/draft-IERC6093.sol";
import {Initializable} from "../../proxy/utils/Initializable.sol";
/**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
*
* TIP: For a detailed writeup see our guide
* https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* The default value of {decimals} is 18. To change this, you should override
* this function so it returns a different value.
*
* We have followed general OpenZeppelin Contracts guidelines: functions revert
* instead returning `false` on failure. This behavior is nonetheless
* conventional and does not conflict with the expectations of ERC20
* applications.
*
* Additionally, an {Approval} event is emitted on calls to {transferFrom}.
* This allows applications to reconstruct the allowance for all accounts just
* by listening to said events. Other implementations of the EIP may not emit
* these events, as it isn't required by the specification.
*/
abstract contract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20, IERC20Metadata, IERC20Errors {
/// @custom:storage-location erc7201:openzeppelin.storage.ERC20
struct ERC20Storage {
mapping(address account => uint256) _balances;
mapping(address account => mapping(address spender => uint256)) _allowances;
uint256 _totalSupply;
string _name;
string _symbol;
}
// keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.ERC20")) - 1)) & ~bytes32(uint256(0xff))
bytes32 private constant ERC20StorageLocation = 0x52c63247e1f47db19d5ce0460030c497f067ca4cebf71ba98eeadabe20bace00;
function _getERC20Storage() private pure returns (ERC20Storage storage $) {
assembly {
$.slot := ERC20StorageLocation
}
}
/**
* @dev Sets the values for {name} and {symbol}.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
function __ERC20_init(string memory name_, string memory symbol_) internal onlyInitializing {
__ERC20_init_unchained(name_, symbol_);
}
function __ERC20_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing {
ERC20Storage storage $ = _getERC20Storage();
$._name = name_;
$._symbol = symbol_;
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual returns (string memory) {
ERC20Storage storage $ = _getERC20Storage();
return $._name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual returns (string memory) {
ERC20Storage storage $ = _getERC20Storage();
return $._symbol;
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5.05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the default value returned by this function, unless
* it's overridden.
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual returns (uint8) {
return 18;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual returns (uint256) {
ERC20Storage storage $ = _getERC20Storage();
return $._totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual returns (uint256) {
ERC20Storage storage $ = _getERC20Storage();
return $._balances[account];
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - the caller must have a balance of at least `value`.
*/
function transfer(address to, uint256 value) public virtual returns (bool) {
address owner = _msgSender();
_transfer(owner, to, value);
return true;
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual returns (uint256) {
ERC20Storage storage $ = _getERC20Storage();
return $._allowances[owner][spender];
}
/**
* @dev See {IERC20-approve}.
*
* NOTE: If `value` is the maximum `uint256`, the allowance is not updated on
* `transferFrom`. This is semantically equivalent to an infinite approval.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 value) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, value);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* NOTE: Does not update the allowance if the current allowance
* is the maximum `uint256`.
*
* Requirements:
*
* - `from` and `to` cannot be the zero address.
* - `from` must have a balance of at least `value`.
* - the caller must have allowance for ``from``'s tokens of at least
* `value`.
*/
function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, value);
_transfer(from, to, value);
return true;
}
/**
* @dev Moves a `value` amount of tokens from `from` to `to`.
*
* This internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* NOTE: This function is not virtual, {_update} should be overridden instead.
*/
function _transfer(address from, address to, uint256 value) internal {
if (from == address(0)) {
revert ERC20InvalidSender(address(0));
}
if (to == address(0)) {
revert ERC20InvalidReceiver(address(0));
}
_update(from, to, value);
}
/**
* @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`
* (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding
* this function.
*
* Emits a {Transfer} event.
*/
function _update(address from, address to, uint256 value) internal virtual {
ERC20Storage storage $ = _getERC20Storage();
if (from == address(0)) {
// Overflow check required: The rest of the code assumes that totalSupply never overflows
$._totalSupply += value;
} else {
uint256 fromBalance = $._balances[from];
if (fromBalance < value) {
revert ERC20InsufficientBalance(from, fromBalance, value);
}
unchecked {
// Overflow not possible: value <= fromBalance <= totalSupply.
$._balances[from] = fromBalance - value;
}
}
if (to == address(0)) {
unchecked {
// Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.
$._totalSupply -= value;
}
} else {
unchecked {
// Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.
$._balances[to] += value;
}
}
emit Transfer(from, to, value);
}
/**
* @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).
* Relies on the `_update` mechanism
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* NOTE: This function is not virtual, {_update} should be overridden instead.
*/
function _mint(address account, uint256 value) internal {
if (account == address(0)) {
revert ERC20InvalidReceiver(address(0));
}
_update(address(0), account, value);
}
/**
* @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.
* Relies on the `_update` mechanism.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* NOTE: This function is not virtual, {_update} should be overridden instead
*/
function _burn(address account, uint256 value) internal {
if (account == address(0)) {
revert ERC20InvalidSender(address(0));
}
_update(account, address(0), value);
}
/**
* @dev Sets `value` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*
* Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
*/
function _approve(address owner, address spender, uint256 value) internal {
_approve(owner, spender, value, true);
}
/**
* @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.
*
* By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by
* `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any
* `Approval` event during `transferFrom` operations.
*
* Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to
* true using the following override:
* ```
* function _approve(address owner, address spender, uint256 value, bool) internal virtual override {
* super._approve(owner, spender, value, true);
* }
* ```
*
* Requirements are the same as {_approve}.
*/
function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {
ERC20Storage storage $ = _getERC20Storage();
if (owner == address(0)) {
revert ERC20InvalidApprover(address(0));
}
if (spender == address(0)) {
revert ERC20InvalidSpender(address(0));
}
$._allowances[owner][spender] = value;
if (emitEvent) {
emit Approval(owner, spender, value);
}
}
/**
* @dev Updates `owner` s allowance for `spender` based on spent `value`.
*
* Does not update the allowance value in case of infinite allowance.
* Revert if not enough allowance is available.
*
* Does not emit an {Approval} event.
*/
function _spendAllowance(address owner, address spender, uint256 value) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
if (currentAllowance < value) {
revert ERC20InsufficientAllowance(spender, currentAllowance, value);
}
unchecked {
_approve(owner, spender, currentAllowance - value, false);
}
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/Math.sol)
pragma solidity ^0.8.20;
/**
* @dev Standard math utilities missing in the Solidity language.
*/
library Math {
/**
* @dev Muldiv operation overflow.
*/
error MathOverflowedMulDiv();
enum Rounding {
Floor, // Toward negative infinity
Ceil, // Toward positive infinity
Trunc, // Toward zero
Expand // Away from zero
}
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
/**
* @dev Returns the subtraction of two unsigned integers, with an overflow flag.
*/
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
/**
* @dev Returns the multiplication of two unsigned integers, with an overflow flag.
*/
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
/**
* @dev Returns the division of two unsigned integers, with a division by zero flag.
*/
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
/**
* @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
*/
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
/**
* @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 towards infinity instead
* of rounding towards zero.
*/
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
if (b == 0) {
// Guarantee the same behavior as in a regular Solidity division.
return a / b;
}
// (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 = x * y; // Least significant 256 bits of the product
uint256 prod1; // Most significant 256 bits of the product
assembly {
let mm := mulmod(x, y, not(0))
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
// Handle non-overflow cases, 256 by 256 division.
if (prod1 == 0) {
// Solidity will revert if denominator == 0, unlike the div opcode on its own.
// The surrounding unchecked block does not change this fact.
// See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
return prod0 / denominator;
}
// Make sure the result is less than 2^256. Also prevents denominator == 0.
if (denominator <= prod1) {
revert MathOverflowedMulDiv();
}
///////////////////////////////////////////////
// 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.
uint256 twos = denominator & (0 - denominator);
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 (unsignedRoundsUp(rounding) && 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
* towards zero.
*
* 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 + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);
}
}
/**
* @dev Return the log in base 2 of a positive value rounded towards zero.
* 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 + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0);
}
}
/**
* @dev Return the log in base 10 of a positive value rounded towards zero.
* Returns 0 if given 0.
*/
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10 ** 64) {
value /= 10 ** 64;
result += 64;
}
if (value >= 10 ** 32) {
value /= 10 ** 32;
result += 32;
}
if (value >= 10 ** 16) {
value /= 10 ** 16;
result += 16;
}
if (value >= 10 ** 8) {
value /= 10 ** 8;
result += 8;
}
if (value >= 10 ** 4) {
value /= 10 ** 4;
result += 4;
}
if (value >= 10 ** 2) {
value /= 10 ** 2;
result += 2;
}
if (value >= 10 ** 1) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 10, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0);
}
}
/**
* @dev Return the log in base 256 of a positive value rounded towards zero.
* Returns 0 if given 0.
*
* Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
*/
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 256, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0);
}
}
/**
* @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
*/
function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
return uint8(rounding) % 2 == 1;
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol";
/// @notice The vaults are assembled at the factory by users through UI.
/// Deployment rights of a vault are tokenized in VaultManager NFT.
/// The holders of these tokens receive a share of the vault revenue and can manage vault if possible.
/// @dev Rewards transfers to token owner or revenue receiver address managed by token owner.
/// @author Alien Deployer (https://github.com/a17)
/// @author Jude (https://github.com/iammrjude)
/// @author JodsMigel (https://github.com/JodsMigel)
interface IVaultManager is IERC721Metadata {
//region ----- Events -----
event ChangeVaultParams(uint tokenId, address[] addresses, uint[] nums);
event SetRevenueReceiver(uint tokenId, address receiver);
//endregion -- Events -----
struct VaultData {
// vault
uint tokenId;
address vault;
string vaultType;
string name;
string symbol;
string[] assetsSymbols;
string[] rewardAssetsSymbols;
uint sharePrice;
uint tvl;
uint totalApr;
bytes32 vaultExtra;
// strategy
uint strategyTokenId;
string strategyId;
string strategySpecific;
uint strategyApr;
bytes32 strategyExtra;
}
//region ----- View functions -----
/// @notice Vault address managed by token
/// @param tokenId ID of NFT. Starts from 0 and increments on mints.
/// @return vault Address of vault proxy
function tokenVault(uint tokenId) external view returns (address vault);
/// @notice Receiver of token owner's platform revenue share
/// @param tokenId ID of NFT
/// @return receiver Address of vault manager fees receiver
function getRevenueReceiver(uint tokenId) external view returns (address receiver);
/// @notice All vaults data.
/// DEPRECATED: use IFrontend.vaults
/// The output values are matched by index in the arrays.
/// @param vaultAddress Vault addresses
/// @param name Vault name
/// @param symbol Vault symbol
/// @param vaultType Vault type ID string
/// @param strategyId Strategy logic ID string
/// @param sharePrice Current vault share price in USD. 18 decimals
/// @param tvl Current vault TVL in USD. 18 decimals
/// @param totalApr Last total vault APR. Denominator is 100_00.
/// @param strategyApr Last strategy APR. Denominator is 100_00.
/// @param strategySpecific Strategy specific name
function vaults()
external
view
returns (
address[] memory vaultAddress,
string[] memory name,
string[] memory symbol,
string[] memory vaultType,
string[] memory strategyId,
uint[] memory sharePrice,
uint[] memory tvl,
uint[] memory totalApr,
uint[] memory strategyApr,
string[] memory strategySpecific
);
/// @notice All deployed vault addresses
/// @return vaultAddress Addresses of vault proxy
function vaultAddresses() external view returns (address[] memory vaultAddress);
/// @notice Vault extended info getter
/// @param vault Address of vault proxy
/// @return strategy
/// @return strategyAssets
/// @return underlying
/// @return assetsWithApr Assets with underlying APRs that can be provided by AprOracle
/// @return assetsAprs APRs of assets with APR. Matched by index wuth previous param.
/// @return lastHardWork Last HardWork time
function vaultInfo(address vault)
external
view
returns (
address strategy,
address[] memory strategyAssets,
address underlying,
address[] memory assetsWithApr,
uint[] memory assetsAprs,
uint lastHardWork
);
//endregion -- View functions -----
//region ----- Write functions -----
/// @notice Changing managed vault init parameters by Vault Manager (owner of VaultManager NFT)
/// @param tokenId ID of VaultManager NFT
/// @param addresses Vault init addresses. Must contain also not changeable init addresses
/// @param nums Vault init numbers. Must contant also not changeable init numbers
function changeVaultParams(uint tokenId, address[] memory addresses, uint[] memory nums) external;
/// @notice Minting of new token on deploying vault by Factory
/// Only Factory can call this.
/// @param to User which creates vault
/// @param vault Address of vault proxy
/// @return tokenId Minted token ID
function mint(address to, address vault) external returns (uint tokenId);
/// @notice Owner of token can change revenue reciever of platform fee share
/// @param tokenId Owned token ID
/// @param receiver New revenue receiver address
function setRevenueReceiver(uint tokenId, address receiver) external;
//endregion -- Write functions -----
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;
import "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol";
/// @dev Interface of developed strategy logic NFT
/// @author Alien Deployer (https://github.com/a17)
/// @author Jude (https://github.com/iammrjude)
/// @author JodsMigel (https://github.com/JodsMigel)
interface IStrategyLogic is IERC721Metadata {
//region ----- Events -----
event SetRevenueReceiver(uint tokenId, address receiver);
//endregion -- Events -----
struct StrategyData {
uint strategyTokenId;
string strategyId;
bytes32 strategyExtra;
}
/// @notice Minting of new developed strategy by the factory
/// @dev Parameters from StrategyDeveloperLib, StrategyIdLib.
/// Only factory can call it.
/// @param to Strategy developer address
/// @param strategyLogicId Strategy logic ID string
/// @return tokenId Minted token ID
function mint(address to, string memory strategyLogicId) external returns (uint tokenId);
/// @notice Owner of token can change address for receiving strategy logic revenue share
/// Only owner of token can call it.
/// @param tokenId Owned token ID
/// @param receiver Address for receiving revenue
function setRevenueReceiver(uint tokenId, address receiver) external;
/// @notice Token ID to strategy logic ID map
/// @param tokenId Owned token ID
/// @return strategyLogicId Strategy logic ID string
function tokenStrategyLogic(uint tokenId) external view returns (string memory strategyLogicId);
/// @notice Current revenue reciever for token
/// @param tokenId Token ID
/// @return receiver Address for receiving revenue
function getRevenueReceiver(uint tokenId) external view returns (address receiver);
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;
/// @dev Combining oracle and DeX spot prices
/// @author Alien Deployer (https://github.com/a17)
/// @author Jude (https://github.com/iammrjude)
/// @author JodsMigel (https://github.com/JodsMigel)
interface IPriceReader {
//region ----- Events -----
event AdapterAdded(address adapter);
event AdapterRemoved(address adapter);
//endregion -- Events -----
/// @notice Price of asset
/// @dev Price of 1.0 amount of asset in USD
/// @param asset Address of asset
/// @return price USD price with 18 decimals
/// @return trusted Price from oracle
function getPrice(address asset) external view returns (uint price, bool trusted);
/// @notice Get USD price of specified assets and amounts
/// @param assets_ Addresses of assets
/// @param amounts_ Amount of asset. Index of asset same as in previous parameter.
/// @return total Total USD value with 18 decimals
/// @return assetAmountPrice USD price of asset amount. Index of assetAmountPrice same as in assets_ parameters.
/// @return assetPrice USD price of asset. Index of assetAmountPrice same as in assets_ parameters.
/// @return trusted True if only oracle prices was used for calculation.
function getAssetsPrice(
address[] memory assets_,
uint[] memory amounts_
) external view returns (uint total, uint[] memory assetAmountPrice, uint[] memory assetPrice, bool trusted);
/// @notice Add oracle adapter to PriceReader
/// Only operator (multisig is operator too) can add adapter
/// @param adapter_ Address of price oracle proxy
function addAdapter(address adapter_) external;
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (proxy/utils/Initializable.sol)
pragma solidity ^0.8.20;
/**
* @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
* behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
* external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
* function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
*
* The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
* reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
* case an upgrade adds a module that needs to be initialized.
*
* For example:
*
* [.hljs-theme-light.nopadding]
* ```solidity
* contract MyToken is ERC20Upgradeable {
* function initialize() initializer public {
* __ERC20_init("MyToken", "MTK");
* }
* }
*
* contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
* function initializeV2() reinitializer(2) public {
* __ERC20Permit_init("MyToken");
* }
* }
* ```
*
* TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
* possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
*
* CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
* that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
*
* [CAUTION]
* ====
* Avoid leaving a contract uninitialized.
*
* An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
* contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
* the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
*
* [.hljs-theme-light.nopadding]
* ```
* /// @custom:oz-upgrades-unsafe-allow constructor
* constructor() {
* _disableInitializers();
* }
* ```
* ====
*/
abstract contract Initializable {
/**
* @dev Storage of the initializable contract.
*
* It's implemented on a custom ERC-7201 namespace to reduce the risk of storage collisions
* when using with upgradeable contracts.
*
* @custom:storage-location erc7201:openzeppelin.storage.Initializable
*/
struct InitializableStorage {
/**
* @dev Indicates that the contract has been initialized.
*/
uint64 _initialized;
/**
* @dev Indicates that the contract is in the process of being initialized.
*/
bool _initializing;
}
// keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Initializable")) - 1)) & ~bytes32(uint256(0xff))
bytes32 private constant INITIALIZABLE_STORAGE = 0xf0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a00;
/**
* @dev The contract is already initialized.
*/
error InvalidInitialization();
/**
* @dev The contract is not initializing.
*/
error NotInitializing();
/**
* @dev Triggered when the contract has been initialized or reinitialized.
*/
event Initialized(uint64 version);
/**
* @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
* `onlyInitializing` functions can be used to initialize parent contracts.
*
* Similar to `reinitializer(1)`, except that in the context of a constructor an `initializer` may be invoked any
* number of times. This behavior in the constructor can be useful during testing and is not expected to be used in
* production.
*
* Emits an {Initialized} event.
*/
modifier initializer() {
// solhint-disable-next-line var-name-mixedcase
InitializableStorage storage $ = _getInitializableStorage();
// Cache values to avoid duplicated sloads
bool isTopLevelCall = !$._initializing;
uint64 initialized = $._initialized;
// Allowed calls:
// - initialSetup: the contract is not in the initializing state and no previous version was
// initialized
// - construction: the contract is initialized at version 1 (no reininitialization) and the
// current contract is just being deployed
bool initialSetup = initialized == 0 && isTopLevelCall;
bool construction = initialized == 1 && address(this).code.length == 0;
if (!initialSetup && !construction) {
revert InvalidInitialization();
}
$._initialized = 1;
if (isTopLevelCall) {
$._initializing = true;
}
_;
if (isTopLevelCall) {
$._initializing = false;
emit Initialized(1);
}
}
/**
* @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
* contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
* used to initialize parent contracts.
*
* A reinitializer may be used after the original initialization step. This is essential to configure modules that
* are added through upgrades and that require initialization.
*
* When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`
* cannot be nested. If one is invoked in the context of another, execution will revert.
*
* Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
* a contract, executing them in the right order is up to the developer or operator.
*
* WARNING: Setting the version to 2**64 - 1 will prevent any future reinitialization.
*
* Emits an {Initialized} event.
*/
modifier reinitializer(uint64 version) {
// solhint-disable-next-line var-name-mixedcase
InitializableStorage storage $ = _getInitializableStorage();
if ($._initializing || $._initialized >= version) {
revert InvalidInitialization();
}
$._initialized = version;
$._initializing = true;
_;
$._initializing = false;
emit Initialized(version);
}
/**
* @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
* {initializer} and {reinitializer} modifiers, directly or indirectly.
*/
modifier onlyInitializing() {
_checkInitializing();
_;
}
/**
* @dev Reverts if the contract is not in an initializing state. See {onlyInitializing}.
*/
function _checkInitializing() internal view virtual {
if (!_isInitializing()) {
revert NotInitializing();
}
}
/**
* @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
* Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
* to any version. It is recommended to use this to lock implementation contracts that are designed to be called
* through proxies.
*
* Emits an {Initialized} event the first time it is successfully executed.
*/
function _disableInitializers() internal virtual {
// solhint-disable-next-line var-name-mixedcase
InitializableStorage storage $ = _getInitializableStorage();
if ($._initializing) {
revert InvalidInitialization();
}
if ($._initialized != type(uint64).max) {
$._initialized = type(uint64).max;
emit Initialized(type(uint64).max);
}
}
/**
* @dev Returns the highest version that has been initialized. See {reinitializer}.
*/
function _getInitializedVersion() internal view returns (uint64) {
return _getInitializableStorage()._initialized;
}
/**
* @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.
*/
function _isInitializing() internal view returns (bool) {
return _getInitializableStorage()._initializing;
}
/**
* @dev Returns a pointer to the storage namespace.
*/
// solhint-disable-next-line var-name-mixedcase
function _getInitializableStorage() private pure returns (InitializableStorage storage $) {
assembly {
$.slot := INITIALIZABLE_STORAGE
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/ERC165.sol)
pragma solidity ^0.8.20;
import {IERC165} from "./IERC165.sol";
/**
* @dev Implementation of the {IERC165} interface.
*
* Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
* for the additional interface id that will be supported. For example:
*
* ```solidity
* function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
* return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
* }
* ```
*/
abstract contract ERC165 is IERC165 {
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;
/// @title Minimal library for setting / getting slot variables (used in upgradable proxy contracts)
library SlotsLib {
/// @dev Gets a slot as an address
function getAddress(bytes32 slot) internal view returns (address result) {
assembly {
result := sload(slot)
}
}
/// @dev Gets a slot as uint256
function getUint(bytes32 slot) internal view returns (uint result) {
assembly {
result := sload(slot)
}
}
/// @dev Sets a slot with address
/// @notice Check address for 0 at the setter
function set(bytes32 slot, address value) internal {
assembly {
sstore(slot, value)
}
}
/// @dev Sets a slot with uint
function set(bytes32 slot, uint value) internal {
assembly {
sstore(slot, value)
}
}
}// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.23;
/// @title Pool state that never changes
/// @notice These parameters are fixed for a pool forever, i.e., the methods will always return the same values
interface IUniswapV3PoolImmutables {
/// @notice The contract that deployed the pool, which must adhere to the IUniswapV3Factory interface
/// @return The contract address
function factory() external view returns (address);
/// @notice The first of the two tokens of the pool, sorted by address
/// @return The token contract address
function token0() external view returns (address);
/// @notice The second of the two tokens of the pool, sorted by address
/// @return The token contract address
function token1() external view returns (address);
/// @notice The pool's fee in hundredths of a bip, i.e. 1e-6
/// @return The fee
function fee() external view returns (uint24);
/// @notice The pool tick spacing
/// @dev Ticks can only be used at multiples of this value, minimum of 1 and always positive
/// e.g.: a tickSpacing of 3 means ticks can be initialized every 3rd tick, i.e., ..., -6, -3, 0, 3, 6, ...
/// This value is an int24 to avoid casting even though it is always positive.
/// @return The tick spacing
function tickSpacing() external view returns (int24);
/// @notice The maximum amount of position liquidity that can use any tick in the range
/// @dev This parameter is enforced per tick to prevent liquidity from overflowing a uint128 at any point, and
/// also prevents out-of-range liquidity from being used to prevent adding in-range liquidity to a pool
/// @return The max amount of liquidity per tick
function maxLiquidityPerTick() external view returns (uint128);
}// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.23;
/// @title Pool state that can change
/// @notice These methods compose the pool's state, and can change with any frequency including multiple times
/// per transaction
interface IUniswapV3PoolState {
/// @notice The 0th storage slot in the pool stores many values, and is exposed as a single method to save gas
/// when accessed externally.
/// @return sqrtPriceX96 The current price of the pool as a sqrt(token1/token0) Q64.96 value
/// tick The current tick of the pool, i.e. according to the last tick transition that was run.
/// This value may not always be equal to SqrtTickMath.getTickAtSqrtRatio(sqrtPriceX96) if the price is on a tick
/// boundary.
/// observationIndex The index of the last oracle observation that was written,
/// observationCardinality The current maximum number of observations stored in the pool,
/// observationCardinalityNext The next maximum number of observations, to be updated when the observation.
/// feeProtocol The protocol fee for both tokens of the pool.
/// Encoded as two 4 bit values, where the protocol fee of token1 is shifted 4 bits and the protocol fee of token0
/// is the lower 4 bits. Used as the denominator of a fraction of the swap fee, e.g. 4 means 1/4th of the swap fee.
/// unlocked Whether the pool is currently locked to reentrancy
function slot0()
external
view
returns (
uint160 sqrtPriceX96,
int24 tick,
uint16 observationIndex,
uint16 observationCardinality,
uint16 observationCardinalityNext,
uint8 feeProtocol,
bool unlocked
);
/// @notice The fee growth as a Q128.128 fees of token0 collected per unit of liquidity for the entire life of the pool
/// @dev This value can overflow the uint256
function feeGrowthGlobal0X128() external view returns (uint);
/// @notice The fee growth as a Q128.128 fees of token1 collected per unit of liquidity for the entire life of the pool
/// @dev This value can overflow the uint256
function feeGrowthGlobal1X128() external view returns (uint);
/// @notice The amounts of token0 and token1 that are owed to the protocol
/// @dev Protocol fees will never exceed uint128 max in either token
function protocolFees() external view returns (uint128 token0, uint128 token1);
/// @notice The currently in range liquidity available to the pool
/// @dev This value has no relationship to the total liquidity across all ticks
function liquidity() external view returns (uint128);
/// @notice Look up information about a specific tick in the pool
/// @param tick The tick to look up
/// @return liquidityGross the total amount of position liquidity that uses the pool either as tick lower or
/// tick upper,
/// liquidityNet how much liquidity changes when the pool price crosses the tick,
/// feeGrowthOutside0X128 the fee growth on the other side of the tick from the current tick in token0,
/// feeGrowthOutside1X128 the fee growth on the other side of the tick from the current tick in token1,
/// tickCumulativeOutside the cumulative tick value on the other side of the tick from the current tick
/// secondsPerLiquidityOutsideX128 the seconds spent per liquidity on the other side of the tick from the current tick,
/// secondsOutside the seconds spent on the other side of the tick from the current tick,
/// initialized Set to true if the tick is initialized, i.e. liquidityGross is greater than 0, otherwise equal to false.
/// Outside values can only be used if the tick is initialized, i.e. if liquidityGross is greater than 0.
/// In addition, these values are only relative and must be used only in comparison to previous snapshots for
/// a specific position.
function ticks(int24 tick)
external
view
returns (
uint128 liquidityGross,
int128 liquidityNet,
uint feeGrowthOutside0X128,
uint feeGrowthOutside1X128,
int56 tickCumulativeOutside,
uint160 secondsPerLiquidityOutsideX128,
uint32 secondsOutside,
bool initialized
);
/// @notice Returns 256 packed tick initialized boolean values. See TickBitmap for more information
function tickBitmap(int16 wordPosition) external view returns (uint);
/// @notice Returns the information about a position by the position's key
/// @param key The position's key is a hash of a preimage composed by the owner, tickLower and tickUpper
/// @return _liquidity The amount of liquidity in the position,
/// Returns feeGrowthInside0LastX128 fee growth of token0 inside the tick range as of the last mint/burn/poke,
/// Returns feeGrowthInside1LastX128 fee growth of token1 inside the tick range as of the last mint/burn/poke,
/// Returns tokensOwed0 the computed amount of token0 owed to the position as of the last mint/burn/poke,
/// Returns tokensOwed1 the computed amount of token1 owed to the position as of the last mint/burn/poke
function positions(bytes32 key)
external
view
returns (
uint128 _liquidity,
uint feeGrowthInside0LastX128,
uint feeGrowthInside1LastX128,
uint128 tokensOwed0,
uint128 tokensOwed1
);
/// @notice Returns data about a specific observation index
/// @param index The element of the observations array to fetch
/// @dev You most likely want to use #observe() instead of this method to get an observation as of some amount of time
/// ago, rather than at a specific index in the array.
/// @return blockTimestamp The timestamp of the observation,
/// Returns tickCumulative the tick multiplied by seconds elapsed for the life of the pool as of the observation timestamp,
/// Returns secondsPerLiquidityCumulativeX128 the seconds per in range liquidity for the life of the pool as of the observation timestamp,
/// Returns initialized whether the observation has been initialized and the values are safe to use
function observations(uint index)
external
view
returns (
uint32 blockTimestamp,
int56 tickCumulative,
uint160 secondsPerLiquidityCumulativeX128,
bool initialized
);
}// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.23;
/// @title Pool state that is not stored
/// @notice Contains view functions to provide information about the pool that is computed rather than stored on the
/// blockchain. The functions here may have variable gas costs.
interface IUniswapV3PoolDerivedState {
/// @notice Returns the cumulative tick and liquidity as of each timestamp `secondsAgo` from the current block timestamp
/// @dev To get a time weighted average tick or liquidity-in-range, you must call this with two values, one representing
/// the beginning of the period and another for the end of the period. E.g., to get the last hour time-weighted average tick,
/// you must call it with secondsAgos = [3600, 0].
/// @dev The time weighted average tick represents the geometric time weighted average price of the pool, in
/// log base sqrt(1.0001) of token1 / token0. The TickMath library can be used to go from a tick value to a ratio.
/// @param secondsAgos From how long ago each cumulative tick and liquidity value should be returned
/// @return tickCumulatives Cumulative tick values as of each `secondsAgos` from the current block timestamp
/// @return secondsPerLiquidityCumulativeX128s Cumulative seconds per liquidity-in-range value as of each `secondsAgos` from the current block
/// timestamp
function observe(uint32[] calldata secondsAgos)
external
view
returns (int56[] memory tickCumulatives, uint160[] memory secondsPerLiquidityCumulativeX128s);
/// @notice Returns a snapshot of the tick cumulative, seconds per liquidity and seconds inside a tick range
/// @dev Snapshots must only be compared to other snapshots, taken over a period for which a position existed.
/// I.e., snapshots cannot be compared if a position is not held for the entire period between when the first
/// snapshot is taken and the second snapshot is taken.
/// @param tickLower The lower tick of the range
/// @param tickUpper The upper tick of the range
/// @return tickCumulativeInside The snapshot of the tick accumulator for the range
/// @return secondsPerLiquidityInsideX128 The snapshot of seconds per liquidity for the range
/// @return secondsInside The snapshot of seconds per liquidity for the range
function snapshotCumulativesInside(
int24 tickLower,
int24 tickUpper
) external view returns (int56 tickCumulativeInside, uint160 secondsPerLiquidityInsideX128, uint32 secondsInside);
}// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.23;
/// @title Permissionless pool actions
/// @notice Contains pool methods that can be called by anyone
interface IUniswapV3PoolActions {
/// @notice Sets the initial price for the pool
/// @dev Price is represented as a sqrt(amountToken1/amountToken0) Q64.96 value
/// @param sqrtPriceX96 the initial sqrt price of the pool as a Q64.96
function initialize(uint160 sqrtPriceX96) external;
/// @notice Adds liquidity for the given recipient/tickLower/tickUpper position
/// @dev The caller of this method receives a callback in the form of IUniswapV3MintCallback#uniswapV3MintCallback
/// in which they must pay any token0 or token1 owed for the liquidity. The amount of token0/token1 due depends
/// on tickLower, tickUpper, the amount of liquidity, and the current price.
/// @param recipient The address for which the liquidity will be created
/// @param tickLower The lower tick of the position in which to add liquidity
/// @param tickUpper The upper tick of the position in which to add liquidity
/// @param amount The amount of liquidity to mint
/// @param data Any data that should be passed through to the callback
/// @return amount0 The amount of token0 that was paid to mint the given amount of liquidity. Matches the value in the callback
/// @return amount1 The amount of token1 that was paid to mint the given amount of liquidity. Matches the value in the callback
function mint(
address recipient,
int24 tickLower,
int24 tickUpper,
uint128 amount,
bytes calldata data
) external returns (uint amount0, uint amount1);
/// @notice Collects tokens owed to a position
/// @dev Does not recompute fees earned, which must be done either via mint or burn of any amount of liquidity.
/// Collect must be called by the position owner. To withdraw only token0 or only token1, amount0Requested or
/// amount1Requested may be set to zero. To withdraw all tokens owed, caller may pass any value greater than the
/// actual tokens owed, e.g. type(uint128).max. Tokens owed may be from accumulated swap fees or burned liquidity.
/// @param recipient The address which should receive the fees collected
/// @param tickLower The lower tick of the position for which to collect fees
/// @param tickUpper The upper tick of the position for which to collect fees
/// @param amount0Requested How much token0 should be withdrawn from the fees owed
/// @param amount1Requested How much token1 should be withdrawn from the fees owed
/// @return amount0 The amount of fees collected in token0
/// @return amount1 The amount of fees collected in token1
function collect(
address recipient,
int24 tickLower,
int24 tickUpper,
uint128 amount0Requested,
uint128 amount1Requested
) external returns (uint128 amount0, uint128 amount1);
/// @notice Burn liquidity from the sender and account tokens owed for the liquidity to the position
/// @dev Can be used to trigger a recalculation of fees owed to a position by calling with an amount of 0
/// @dev Fees must be collected separately via a call to #collect
/// @param tickLower The lower tick of the position for which to burn liquidity
/// @param tickUpper The upper tick of the position for which to burn liquidity
/// @param amount How much liquidity to burn
/// @return amount0 The amount of token0 sent to the recipient
/// @return amount1 The amount of token1 sent to the recipient
function burn(int24 tickLower, int24 tickUpper, uint128 amount) external returns (uint amount0, uint amount1);
/// @notice Swap token0 for token1, or token1 for token0
/// @dev The caller of this method receives a callback in the form of IUniswapV3SwapCallback#uniswapV3SwapCallback
/// @param recipient The address to receive the output of the swap
/// @param zeroForOne The direction of the swap, true for token0 to token1, false for token1 to token0
/// @param amountSpecified The amount of the swap, which implicitly configures the swap as exact input (positive), or exact output (negative)
/// @param sqrtPriceLimitX96 The Q64.96 sqrt price limit. If zero for one, the price cannot be less than this
/// value after the swap. If one for zero, the price cannot be greater than this value after the swap
/// @param data Any data to be passed through to the callback
/// @return amount0 The delta of the balance of token0 of the pool, exact when negative, minimum when positive
/// @return amount1 The delta of the balance of token1 of the pool, exact when negative, minimum when positive
function swap(
address recipient,
bool zeroForOne,
int amountSpecified,
uint160 sqrtPriceLimitX96,
bytes calldata data
) external returns (int amount0, int amount1);
/// @notice Receive token0 and/or token1 and pay it back, plus a fee, in the callback
/// @dev The caller of this method receives a callback in the form of IUniswapV3FlashCallback#uniswapV3FlashCallback
/// @dev Can be used to donate underlying tokens pro-rata to currently in-range liquidity providers by calling
/// with 0 amount{0,1} and sending the donation amount(s) from the callback
/// @param recipient The address which will receive the token0 and token1 amounts
/// @param amount0 The amount of token0 to send
/// @param amount1 The amount of token1 to send
/// @param data Any data to be passed through to the callback
function flash(address recipient, uint amount0, uint amount1, bytes calldata data) external;
/// @notice Increase the maximum number of price and liquidity observations that this pool will store
/// @dev This method is no-op if the pool already has an observationCardinalityNext greater than or equal to
/// the input observationCardinalityNext.
/// @param observationCardinalityNext The desired minimum number of observations for the pool to store
function increaseObservationCardinalityNext(uint16 observationCardinalityNext) external;
}// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.23;
/// @title Permissioned pool actions
/// @notice Contains pool methods that may only be called by the factory owner
interface IUniswapV3PoolOwnerActions {
/// @notice Set the denominator of the protocol's % share of the fees
/// @param feeProtocol0 new protocol fee for token0 of the pool
/// @param feeProtocol1 new protocol fee for token1 of the pool
function setFeeProtocol(uint8 feeProtocol0, uint8 feeProtocol1) external;
/// @notice Collect the protocol fee accrued to the pool
/// @param recipient The address to which collected protocol fees should be sent
/// @param amount0Requested The maximum amount of token0 to send, can be 0 to collect fees in only token1
/// @param amount1Requested The maximum amount of token1 to send, can be 0 to collect fees in only token0
/// @return amount0 The protocol fee collected in token0
/// @return amount1 The protocol fee collected in token1
function collectProtocol(
address recipient,
uint128 amount0Requested,
uint128 amount1Requested
) external returns (uint128 amount0, uint128 amount1);
}// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.23;
/// @title Events emitted by a pool
/// @notice Contains all events emitted by the pool
interface IUniswapV3PoolEvents {
/// @notice Emitted exactly once by a pool when #initialize is first called on the pool
/// @dev Mint/Burn/Swap cannot be emitted by the pool before Initialize
/// @param sqrtPriceX96 The initial sqrt price of the pool, as a Q64.96
/// @param tick The initial tick of the pool, i.e. log base 1.0001 of the starting price of the pool
event Initialize(uint160 sqrtPriceX96, int24 tick);
/// @notice Emitted when liquidity is minted for a given position
/// @param sender The address that minted the liquidity
/// @param owner The owner of the position and recipient of any minted liquidity
/// @param tickLower The lower tick of the position
/// @param tickUpper The upper tick of the position
/// @param amount The amount of liquidity minted to the position range
/// @param amount0 How much token0 was required for the minted liquidity
/// @param amount1 How much token1 was required for the minted liquidity
event Mint(
address sender,
address indexed owner,
int24 indexed tickLower,
int24 indexed tickUpper,
uint128 amount,
uint amount0,
uint amount1
);
/// @notice Emitted when fees are collected by the owner of a position
/// @dev Collect events may be emitted with zero amount0 and amount1 when the caller chooses not to collect fees
/// @param owner The owner of the position for which fees are collected
/// @param tickLower The lower tick of the position
/// @param tickUpper The upper tick of the position
/// @param amount0 The amount of token0 fees collected
/// @param amount1 The amount of token1 fees collected
event Collect(
address indexed owner,
address recipient,
int24 indexed tickLower,
int24 indexed tickUpper,
uint128 amount0,
uint128 amount1
);
/// @notice Emitted when a position's liquidity is removed
/// @dev Does not withdraw any fees earned by the liquidity position, which must be withdrawn via #collect
/// @param owner The owner of the position for which liquidity is removed
/// @param tickLower The lower tick of the position
/// @param tickUpper The upper tick of the position
/// @param amount The amount of liquidity to remove
/// @param amount0 The amount of token0 withdrawn
/// @param amount1 The amount of token1 withdrawn
event Burn(
address indexed owner,
int24 indexed tickLower,
int24 indexed tickUpper,
uint128 amount,
uint amount0,
uint amount1
);
/// @notice Emitted by the pool for any swaps between token0 and token1
/// @param sender The address that initiated the swap call, and that received the callback
/// @param recipient The address that received the output of the swap
/// @param amount0 The delta of the token0 balance of the pool
/// @param amount1 The delta of the token1 balance of the pool
/// @param sqrtPriceX96 The sqrt(price) of the pool after the swap, as a Q64.96
/// @param liquidity The liquidity of the pool after the swap
/// @param tick The log base 1.0001 of price of the pool after the swap
event Swap(
address indexed sender,
address indexed recipient,
int amount0,
int amount1,
uint160 sqrtPriceX96,
uint128 liquidity,
int24 tick
);
/// @notice Emitted by the pool for any flashes of token0/token1
/// @param sender The address that initiated the swap call, and that received the callback
/// @param recipient The address that received the tokens from flash
/// @param amount0 The amount of token0 that was flashed
/// @param amount1 The amount of token1 that was flashed
/// @param paid0 The amount of token0 paid for the flash, which can exceed the amount0 plus the fee
/// @param paid1 The amount of token1 paid for the flash, which can exceed the amount1 plus the fee
event Flash(address indexed sender, address indexed recipient, uint amount0, uint amount1, uint paid0, uint paid1);
/// @notice Emitted by the pool for increases to the number of observations that can be stored
/// @dev observationCardinalityNext is not the observation cardinality until an observation is written at the index
/// just before a mint/swap/burn.
/// @param observationCardinalityNextOld The previous value of the next observation cardinality
/// @param observationCardinalityNextNew The updated value of the next observation cardinality
event IncreaseObservationCardinalityNext(
uint16 observationCardinalityNextOld, uint16 observationCardinalityNextNew
);
/// @notice Emitted when the protocol fee is changed by the pool
/// @param feeProtocol0Old The previous value of the token0 protocol fee
/// @param feeProtocol1Old The previous value of the token1 protocol fee
/// @param feeProtocol0New The updated value of the token0 protocol fee
/// @param feeProtocol1New The updated value of the token1 protocol fee
event SetFeeProtocol(uint8 feeProtocol0Old, uint8 feeProtocol1Old, uint8 feeProtocol0New, uint8 feeProtocol1New);
/// @notice Emitted when the collected protocol fees are withdrawn by the factory owner
/// @param sender The address that collects the protocol fees
/// @param recipient The address that receives the collected protocol fees
/// @param amount0 The amount of token0 protocol fees that is withdrawn
/// @param amount0 The amount of token1 protocol fees that is withdrawn
event CollectProtocol(address indexed sender, address indexed recipient, uint128 amount0, uint128 amount1);
}// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.23;
/// @title Creates and initializes V3 Pools
/// @notice Provides a method for creating and initializing a pool, if necessary, for bundling with other methods that
/// require the pool to exist.
interface IPoolInitializer {
/// @notice Creates a new pool if it does not exist, then initializes if not initialized
/// @dev This method can be bundled with others via IMulticall for the first action (e.g. mint) performed against a pool
/// @param token0 The contract address of token0 of the pool
/// @param token1 The contract address of token1 of the pool
/// @param tickSpacing The tickSpacing of the v3 pool for the specified token pair
/// @param sqrtPriceX96 The initial square root price of the pool as a Q64.96 value
/// @return pool Returns the pool address based on the pair of tokens and fee, will return the newly created pool address if necessary
function createAndInitializePoolIfNecessary(
address token0,
address token1,
int24 tickSpacing,
uint160 sqrtPriceX96
) external payable returns (address pool);
}// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.23;
/// @title Periphery Payments
/// @notice Functions to ease deposits and withdrawals of ETH
interface IPeripheryPayments {
/// @notice Unwraps the contract's WETH9 balance and sends it to recipient as ETH.
/// @dev The amountMinimum parameter prevents malicious contracts from stealing WETH9 from users.
/// @param amountMinimum The minimum amount of WETH9 to unwrap
/// @param recipient The address receiving ETH
function unwrapWETH9(uint amountMinimum, address recipient) external payable;
/// @notice Refunds any ETH balance held by this contract to the `msg.sender`
/// @dev Useful for bundling with mint or increase liquidity that uses ether, or exact output swaps
/// that use ether for the input amount
function refundETH() external payable;
/// @notice Transfers the full amount of a token held by this contract to recipient
/// @dev The amountMinimum parameter prevents malicious contracts from stealing the token from users
/// @param token The contract address of the token which will be transferred to `recipient`
/// @param amountMinimum The minimum amount of token required for a transfer
/// @param recipient The destination address of the token
function sweepToken(address token, uint amountMinimum, address recipient) external payable;
}// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.23;
/// @title Immutable state
/// @notice Functions that return immutable state of the router
interface IPeripheryImmutableState {
/// @return Returns the address of the Uniswap V3 deployer
function deployer() external view returns (address);
/// @return Returns the address of WETH9
function WETH9() external view returns (address);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/IERC721.sol)
pragma solidity ^0.8.20;
import {IERC165} from "../../utils/introspection/IERC165.sol";
/**
* @dev Required interface of an ERC721 compliant contract.
*/
interface IERC721 is IERC165 {
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
*/
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/**
* @dev Returns the number of tokens in ``owner``'s account.
*/
function balanceOf(address owner) external view returns (uint256 balance);
/**
* @dev Returns the owner of the `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function ownerOf(uint256 tokenId) external view returns (address owner);
/**
* @dev Safely transfers `tokenId` token from `from` to `to`.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon
* a safe transfer.
*
* Emits a {Transfer} event.
*/
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must have been allowed to move this token by either {approve} or
* {setApprovalForAll}.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon
* a safe transfer.
*
* Emits a {Transfer} event.
*/
function safeTransferFrom(address from, address to, uint256 tokenId) external;
/**
* @dev Transfers `tokenId` token from `from` to `to`.
*
* WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
* or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
* understand this adds an external call which potentially creates a reentrancy vulnerability.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
*
* Emits a {Transfer} event.
*/
function transferFrom(address from, address to, uint256 tokenId) external;
/**
* @dev Gives permission to `to` to transfer `tokenId` token to another account.
* The approval is cleared when the token is transferred.
*
* Only a single account can be approved at a time, so approving the zero address clears previous approvals.
*
* Requirements:
*
* - The caller must own the token or be an approved operator.
* - `tokenId` must exist.
*
* Emits an {Approval} event.
*/
function approve(address to, uint256 tokenId) external;
/**
* @dev Approve or remove `operator` as an operator for the caller.
* Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
*
* Requirements:
*
* - The `operator` cannot be the address zero.
*
* Emits an {ApprovalForAll} event.
*/
function setApprovalForAll(address operator, bool approved) external;
/**
* @dev Returns the account approved for `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function getApproved(uint256 tokenId) external view returns (address operator);
/**
* @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
*
* See {setApprovalForAll}
*/
function isApprovedForAll(address owner, address operator) external view returns (bool);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/extensions/IERC721Metadata.sol)
pragma solidity ^0.8.20;
import {IERC721} from "../IERC721.sol";
/**
* @title ERC-721 Non-Fungible Token Standard, optional metadata extension
* @dev See https://eips.ethereum.org/EIPS/eip-721
*/
interface IERC721Metadata is IERC721 {
/**
* @dev Returns the token collection name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the token collection symbol.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 tokenId) external view returns (string memory);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/extensions/IERC721Enumerable.sol)
pragma solidity ^0.8.20;
import {IERC721} from "../IERC721.sol";
/**
* @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
* @dev See https://eips.ethereum.org/EIPS/eip-721
*/
interface IERC721Enumerable is IERC721 {
/**
* @dev Returns the total amount of tokens stored by the contract.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns a token ID owned by `owner` at a given `index` of its token list.
* Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
*/
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);
/**
* @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
* Use along with {totalSupply} to enumerate all tokens.
*/
function tokenByIndex(uint256 index) external view returns (uint256);
}// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.23;
/// @title Errors emitted by the NonFungiblePositionManager
/// @notice Contains all events emitted by the NfpManager
interface IPeripheryErrors {
error InvalidTokenId(uint tokenId);
error CheckSlippage();
error NotCleared();
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SignedMath.sol)
pragma solidity ^0.8.20;
/**
* @dev Standard signed math utilities missing in the Solidity language.
*/
library SignedMath {
/**
* @dev Returns the largest of two signed numbers.
*/
function max(int256 a, int256 b) internal pure returns (int256) {
return a > b ? a : b;
}
/**
* @dev Returns the smallest of two signed numbers.
*/
function min(int256 a, int256 b) internal pure returns (int256) {
return a < b ? a : b;
}
/**
* @dev Returns the average of two signed numbers without overflow.
* The result is rounded towards zero.
*/
function average(int256 a, int256 b) internal pure returns (int256) {
// Formula from the book "Hacker's Delight"
int256 x = (a & b) + ((a ^ b) >> 1);
return x + (int256(uint256(x) >> 255) & (a ^ b));
}
/**
* @dev Returns the absolute unsigned value of a signed value.
*/
function abs(int256 n) internal pure returns (uint256) {
unchecked {
// must be unchecked in order to support `n = type(int256).min`
return uint256(n >= 0 ? n : -n);
}
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;
import "./IVault.sol";
/// @notice Interface of Rewarding Vault
/// @author Alien Deployer (https://github.com/a17)
/// @author JodsMigel (https://github.com/JodsMigel)
/// @author 0xhokugava (https://github.com/0xhokugava)
interface IRVault is IVault {
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* CUSTOM ERRORS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
error NotAllowed();
error Overflow(uint maxAmount);
error RTNotFound();
error NoBBToken();
error NotAllowedBBToken();
error IncorrectNums();
error ZeroToken();
error ZeroVestingDuration();
error TooHighCompoundRation();
error RewardIsTooSmall();
// error RewardIsTooBig();
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* EVENTS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
event RewardAdded(address rewardToken, uint reward);
event RewardPaid(address indexed user, address rewardToken, uint reward);
event SetRewardsRedirect(address owner, address receiver);
event AddedRewardToken(address indexed token, uint indexed tokenIndex);
event CompoundRatio(uint compoundRatio_);
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* DATA TYPES */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @custom:storage-location erc7201:stability.RVaultBase
struct RVaultBaseStorage {
/// @inheritdoc IRVault
mapping(uint tokenIndex => address rewardToken) rewardToken;
/// @inheritdoc IRVault
mapping(uint tokenIndex => uint durationSeconds) duration;
/// @inheritdoc IRVault
mapping(address owner => address receiver) rewardsRedirect;
/// @dev Timestamp value when current period of rewards will be ended
mapping(uint tokenIndex => uint finishTimestamp) periodFinishForToken;
/// @dev Reward rate in normal circumstances is distributed rewards divided on duration
mapping(uint tokenIndex => uint rewardRate) rewardRateForToken;
/// @dev Last rewards snapshot time. Updated on each share movements
mapping(uint tokenIndex => uint lastUpdateTimestamp) lastUpdateTimeForToken;
/// @dev Rewards snapshot calculated from rewardPerToken(rt). Updated on each share movements
mapping(uint tokenIndex => uint rewardPerTokenStored) rewardPerTokenStoredForToken;
/// @dev User personal reward rate snapshot. Updated on each share movements
mapping(uint tokenIndex => mapping(address user => uint rewardPerTokenPaid)) userRewardPerTokenPaidForToken;
/// @dev User personal earned reward snapshot. Updated on each share movements
mapping(uint tokenIndex => mapping(address user => uint earned)) rewardsForToken;
/// @inheritdoc IRVault
uint rewardTokensTotal;
/// @inheritdoc IRVault
uint compoundRatio;
}
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* VIEW FUNCTIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @notice All vault rewarding tokens
/// @return Reward token addresses
function rewardTokens() external view returns (address[] memory);
/// @return Total of bbToken + boost reward tokens
function rewardTokensTotal() external view returns (uint);
/// @notice Immutable reward buy-back token with tokenIndex 0
function bbToken() external view returns (address);
/// @dev A mapping of reward tokens that able to be distributed to this contract.
/// Token with index 0 always is bbToken.
function rewardToken(uint tokenIndex) external view returns (address rewardToken_);
/// @notice Re-investing ratio
/// @dev Changeable ratio of revenue part for re-investing. Other part goes to rewarding by bbToken.
/// @return Ratio of re-investing part of revenue. Denominator is 100_000.
function compoundRatio() external view returns (uint);
/// @notice Vesting period for distribution reward
/// @param tokenIndex Index of rewarding token
/// @return durationSeconds Duration for distributing of notified reward
function duration(uint tokenIndex) external view returns (uint durationSeconds);
/// @notice Return earned rewards for specific token and account
/// Accurate value returns only after updateRewards call
/// ((balanceOf(account)
/// * (rewardPerToken - userRewardPerTokenPaidForToken)) / 10**18) + rewardsForToken
function earned(uint rewardTokenIndex, address account) external view returns (uint);
/// @notice Return reward per token ratio by reward token address
/// rewardPerTokenStoredForToken + (
/// (lastTimeRewardApplicable - lastUpdateTimeForToken)
/// * rewardRateForToken * 10**18 / totalSupply)
/// @param rewardTokenIndex Index of reward token
/// @return Return reward per token ratio by reward token address
function rewardPerToken(uint rewardTokenIndex) external view returns (uint);
/// @dev Receiver of rewards can be set by multisig when owner cant claim rewards himself
/// @param owner Token owner address
/// @return receiver Return reward's receiver
function rewardsRedirect(address owner) external view returns (address receiver);
/*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
/* WRITE FUNCTIONS */
/*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
/// @notice Filling vault with rewards
/// @dev Update rewardRateForToken
/// If period ended: reward / duration
/// else add leftover to the reward amount and refresh the period
/// (reward + ((periodFinishForToken - block.timestamp) * rewardRateForToken)) / duration
/// @param tokenIndex Index of rewarding token
/// @param amount Amount for rewarding
function notifyTargetRewardAmount(uint tokenIndex, uint amount) external;
/// @notice Update and Claim all rewards for caller
function getAllRewards() external;
/// @notice Update and Claim rewards for specific token
/// @param rt Index of reward token
function getReward(uint rt) external;
/// @dev All rewards for given owner could be claimed for receiver address.
/// @param owner Token owner address
/// @param receiver New reward's receiver
function setRewardsRedirect(address owner, address receiver) external;
/// @notice Update and Claim all rewards for given owner address. Send them to predefined receiver.
/// @param owner Token owner address
function getAllRewardsAndRedirect(address owner) external;
/// @notice Update and Claim all rewards for the given owner.
/// Sender should have allowance for push rewards for the owner.
/// @param owner Token owner address
function getAllRewardsFor(address owner) external;
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Context.sol)
pragma solidity ^0.8.20;
import {Initializable} from "../proxy/utils/Initializable.sol";
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal onlyInitializing {
}
function __Context_init_unchained() internal onlyInitializing {
}
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol)
pragma solidity ^0.8.20;
/**
* @dev Standard ERC20 Errors
* Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC20 tokens.
*/
interface IERC20Errors {
/**
* @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
* @param sender Address whose tokens are being transferred.
* @param balance Current balance for the interacting account.
* @param needed Minimum amount required to perform a transfer.
*/
error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);
/**
* @dev Indicates a failure with the token `sender`. Used in transfers.
* @param sender Address whose tokens are being transferred.
*/
error ERC20InvalidSender(address sender);
/**
* @dev Indicates a failure with the token `receiver`. Used in transfers.
* @param receiver Address to which tokens are being transferred.
*/
error ERC20InvalidReceiver(address receiver);
/**
* @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
* @param spender Address that may be allowed to operate on tokens without being their owner.
* @param allowance Amount of tokens a `spender` is allowed to operate with.
* @param needed Minimum amount required to perform a transfer.
*/
error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);
/**
* @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
* @param approver Address initiating an approval operation.
*/
error ERC20InvalidApprover(address approver);
/**
* @dev Indicates a failure with the `spender` to be approved. Used in approvals.
* @param spender Address that may be allowed to operate on tokens without being their owner.
*/
error ERC20InvalidSpender(address spender);
}
/**
* @dev Standard ERC721 Errors
* Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC721 tokens.
*/
interface IERC721Errors {
/**
* @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in EIP-20.
* Used in balance queries.
* @param owner Address of the current owner of a token.
*/
error ERC721InvalidOwner(address owner);
/**
* @dev Indicates a `tokenId` whose `owner` is the zero address.
* @param tokenId Identifier number of a token.
*/
error ERC721NonexistentToken(uint256 tokenId);
/**
* @dev Indicates an error related to the ownership over a particular token. Used in transfers.
* @param sender Address whose tokens are being transferred.
* @param tokenId Identifier number of a token.
* @param owner Address of the current owner of a token.
*/
error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);
/**
* @dev Indicates a failure with the token `sender`. Used in transfers.
* @param sender Address whose tokens are being transferred.
*/
error ERC721InvalidSender(address sender);
/**
* @dev Indicates a failure with the token `receiver`. Used in transfers.
* @param receiver Address to which tokens are being transferred.
*/
error ERC721InvalidReceiver(address receiver);
/**
* @dev Indicates a failure with the `operator`’s approval. Used in transfers.
* @param operator Address that may be allowed to operate on tokens without being their owner.
* @param tokenId Identifier number of a token.
*/
error ERC721InsufficientApproval(address operator, uint256 tokenId);
/**
* @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
* @param approver Address initiating an approval operation.
*/
error ERC721InvalidApprover(address approver);
/**
* @dev Indicates a failure with the `operator` to be approved. Used in approvals.
* @param operator Address that may be allowed to operate on tokens without being their owner.
*/
error ERC721InvalidOperator(address operator);
}
/**
* @dev Standard ERC1155 Errors
* Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC1155 tokens.
*/
interface IERC1155Errors {
/**
* @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
* @param sender Address whose tokens are being transferred.
* @param balance Current balance for the interacting account.
* @param needed Minimum amount required to perform a transfer.
* @param tokenId Identifier number of a token.
*/
error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);
/**
* @dev Indicates a failure with the token `sender`. Used in transfers.
* @param sender Address whose tokens are being transferred.
*/
error ERC1155InvalidSender(address sender);
/**
* @dev Indicates a failure with the token `receiver`. Used in transfers.
* @param receiver Address to which tokens are being transferred.
*/
error ERC1155InvalidReceiver(address receiver);
/**
* @dev Indicates a failure with the `operator`’s approval. Used in transfers.
* @param operator Address that may be allowed to operate on tokens without being their owner.
* @param owner Address of the current owner of a token.
*/
error ERC1155MissingApprovalForAll(address operator, address owner);
/**
* @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
* @param approver Address initiating an approval operation.
*/
error ERC1155InvalidApprover(address approver);
/**
* @dev Indicates a failure with the `operator` to be approved. Used in approvals.
* @param operator Address that may be allowed to operate on tokens without being their owner.
*/
error ERC1155InvalidOperator(address operator);
/**
* @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
* Used in batch transfers.
* @param idsLength Length of the array of token identifiers
* @param valuesLength Length of the array of token amounts
*/
error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}{
"remappings": [
"@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
"@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/",
"@solady/=lib/solady/src/",
"ds-test/=lib/forge-std/lib/ds-test/src/",
"erc4626-tests/=lib/openzeppelin-contracts-upgradeable/lib/erc4626-tests/",
"forge-std/=lib/forge-std/src/",
"openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/",
"openzeppelin/=lib/openzeppelin-contracts-upgradeable/contracts/",
"solady/=lib/solady/",
"openzeppelin-contracts/=lib/openzeppelin-contracts/"
],
"optimizer": {
"enabled": true,
"runs": 200
},
"metadata": {
"useLiteralContent": false,
"bytecodeHash": "ipfs",
"appendCBOR": true
},
"outputSelection": {
"*": {
"*": [
"evm.bytecode",
"evm.deployedBytecode",
"devdoc",
"userdoc",
"metadata",
"abi"
]
}
},
"evmVersion": "shanghai",
"viaIR": false,
"libraries": {
"src/core/libs/CommonLib.sol": {
"CommonLib": "0x4f76ADd676c04ecA837130CeB58Bc173de8799dE"
},
"src/strategies/libs/ALMLib.sol": {
"ALMLib": "0x6286AF61EF7D0C5667B9D99B60191E3E01035Aaf"
},
"src/strategies/libs/ALMRamsesV3Lib.sol": {
"ALMRamsesV3Lib": "0x3885f90E22c2B304Cd2Fe04A5B71738A5350E9BB"
},
"src/strategies/libs/LPStrategyLib.sol": {
"LPStrategyLib": "0xD06d560102FC1B9C794BefACC64BBcd2Cacac4e2"
},
"src/strategies/libs/StrategyLib.sol": {
"StrategyLib": "0xD3a656e047489c4584ACc6547528E54A9c14D784"
},
"src/strategies/libs/UniswapV3MathLib.sol": {
"UniswapV3MathLib": "0xbbc63ee4a06bf1F2432ccC4d70103e3D465fcA39"
}
}
}Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"AddressEmptyCode","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"AddressInsufficientBalance","type":"error"},{"inputs":[],"name":"AlreadyExist","type":"error"},{"inputs":[],"name":"BadFarm","type":"error"},{"inputs":[],"name":"CantDoRebalance","type":"error"},{"inputs":[],"name":"ETHTransferFailed","type":"error"},{"inputs":[],"name":"FailedInnerCall","type":"error"},{"inputs":[],"name":"IncorrectAmountsLength","type":"error"},{"inputs":[],"name":"IncorrectArrayLength","type":"error"},{"inputs":[],"name":"IncorrectAssets","type":"error"},{"inputs":[],"name":"IncorrectAssetsLength","type":"error"},{"inputs":[],"name":"IncorrectInitParams","type":"error"},{"inputs":[],"name":"IncorrectMsgSender","type":"error"},{"inputs":[],"name":"IncorrectRebalanceArgs","type":"error"},{"inputs":[],"name":"IncorrectStrategyId","type":"error"},{"inputs":[],"name":"IncorrectZeroArgument","type":"error"},{"inputs":[],"name":"InvalidInitialization","type":"error"},{"inputs":[],"name":"NotALM","type":"error"},{"inputs":[],"name":"NotExist","type":"error"},{"inputs":[],"name":"NotFactory","type":"error"},{"inputs":[],"name":"NotGovernance","type":"error"},{"inputs":[],"name":"NotGovernanceAndNotMultisig","type":"error"},{"inputs":[],"name":"NotInitializing","type":"error"},{"inputs":[],"name":"NotMultisig","type":"error"},{"inputs":[],"name":"NotNeedRebalance","type":"error"},{"inputs":[],"name":"NotOperator","type":"error"},{"inputs":[],"name":"NotPlatform","type":"error"},{"inputs":[],"name":"NotReadyForHardWork","type":"error"},{"inputs":[],"name":"NotTheOwner","type":"error"},{"inputs":[],"name":"NotVault","type":"error"},{"inputs":[{"internalType":"uint256","name":"price","type":"uint256"},{"internalType":"uint256","name":"priceBefore","type":"uint256"},{"internalType":"uint256","name":"priceThreshold","type":"uint256"},{"internalType":"uint32","name":"twapInterval","type":"uint32"}],"name":"PriceChangeProtection","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"inputs":[],"name":"ZeroAmmAdapter","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"algoId","type":"uint256"},{"indexed":false,"internalType":"int24[]","name":"params","type":"int24[]"}],"name":"ALMParams","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"platform","type":"address"},{"indexed":false,"internalType":"uint256","name":"ts","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"block","type":"uint256"}],"name":"ContractInitialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"vaultManagerReceiverFee","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"strategyLogicReceiverFee","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"ecosystemRevenueReceiverFee","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"multisigReceiverFee","type":"uint256"}],"name":"ExtractFees","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256[]","name":"fees","type":"uint256[]"}],"name":"FeesClaimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"apr","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"compoundApr","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"earned","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"tvl","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"duration","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"sharePrice","type":"uint256"},{"indexed":false,"internalType":"uint256[]","name":"assetPrices","type":"uint256[]"}],"name":"HardWork","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint64","name":"version","type":"uint64"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"enabled","type":"bool"},{"indexed":false,"internalType":"uint32","name":"twapInterval","type":"uint32"},{"indexed":false,"internalType":"uint256","name":"priceThreshold","type":"uint256"}],"name":"PriceChangeProtectionParams","type":"event"},{"anonymous":false,"inputs":[{"components":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"int24","name":"tickLower","type":"int24"},{"internalType":"int24","name":"tickUpper","type":"int24"},{"internalType":"uint128","name":"liquidity","type":"uint128"}],"indexed":false,"internalType":"struct IALM.Position[]","name":"newPosition","type":"tuple[]"}],"name":"Rebalance","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"name":"RewardsClaimed","type":"event"},{"inputs":[],"name":"CONTROLLABLE_VERSION","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"VERSION","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"VERSION_ALM_STRATEGY_BASE","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"VERSION_FARMING_STRATEGY_BASE","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"VERSION_LP_STRATEGY_BASE","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"VERSION_STRATEGY_BASE","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ammAdapter","outputs":[{"internalType":"contract IAmmAdapter","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ammAdapterId","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"assets","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"assetsAmounts","outputs":[{"internalType":"address[]","name":"assets_","type":"address[]"},{"internalType":"uint256[]","name":"amounts_","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"autoCompoundingByUnderlyingProtocol","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"canFarm","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"createdBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"customPriceImpactTolerance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"name":"depositAssets","outputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"depositUnderlying","outputs":[{"internalType":"uint256[]","name":"amountsConsumed","type":"uint256[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"description","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"doHardWork","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"emergencyStopInvesting","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"extra","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"farmId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"farmMechanics","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"farmingAssets","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getAssetsProportions","outputs":[{"internalType":"uint256[]","name":"proportions","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getRevenue","outputs":[{"internalType":"address[]","name":"__assets","type":"address[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"getSpecificName","outputs":[{"internalType":"string","name":"","type":"string"},{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"platform_","type":"address"}],"name":"initVariants","outputs":[{"internalType":"string[]","name":"variants","type":"string[]"},{"internalType":"address[]","name":"addresses","type":"address[]"},{"internalType":"uint256[]","name":"nums","type":"uint256[]"},{"internalType":"int24[]","name":"ticks","type":"int24[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"addresses","type":"address[]"},{"internalType":"uint256[]","name":"nums","type":"uint256[]"},{"internalType":"int24[]","name":"ticks","type":"int24[]"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"isHardWorkOnDepositAllowed","outputs":[{"internalType":"bool","name":"allowed","type":"bool"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"isReadyForHardWork","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastApr","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastAprCompound","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastHardWork","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"needRebalance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"platform","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pool","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"positions","outputs":[{"components":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"int24","name":"tickLower","type":"int24"},{"internalType":"int24","name":"tickUpper","type":"int24"},{"internalType":"uint128","name":"liquidity","type":"uint128"}],"internalType":"struct IALM.Position[]","name":"","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"preset","outputs":[{"internalType":"uint256","name":"algoId","type":"uint256"},{"internalType":"string","name":"algoName","type":"string"},{"internalType":"string","name":"presetName","type":"string"},{"internalType":"int24[]","name":"params","type":"int24[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"assets_","type":"address[]"},{"internalType":"uint256[]","name":"amountsMax","type":"uint256[]"}],"name":"previewDepositAssets","outputs":[{"internalType":"uint256[]","name":"amountsConsumed","type":"uint256[]"},{"internalType":"uint256","name":"value","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"assets_","type":"address[]"},{"internalType":"uint256[]","name":"amountsMax","type":"uint256[]"}],"name":"previewDepositAssetsWrite","outputs":[{"internalType":"uint256[]","name":"amountsConsumed","type":"uint256[]"},{"internalType":"uint256","name":"value","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool[]","name":"burnOldPositions","type":"bool[]"},{"components":[{"internalType":"int24","name":"tickLower","type":"int24"},{"internalType":"int24","name":"tickUpper","type":"int24"},{"internalType":"uint128","name":"liquidity","type":"uint128"},{"internalType":"uint256","name":"minAmount0","type":"uint256"},{"internalType":"uint256","name":"minAmount1","type":"uint256"}],"internalType":"struct IALM.NewPosition[]","name":"mintNewPositions","type":"tuple[]"}],"name":"rebalance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"refreshFarmingAssets","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"priceImpactTolerance","type":"uint256"}],"name":"setCustomPriceImpactTolerance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"algoId","type":"uint256"},{"internalType":"int24[]","name":"params","type":"int24[]"}],"name":"setupALMParams","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"enabled","type":"bool"},{"internalType":"uint32","name":"twapInterval","type":"uint32"},{"internalType":"uint256","name":"priceThreshold","type":"uint256"}],"name":"setupPriceChangeProtection","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stakingPool","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"strategyLogicId","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"supportedVaultTypes","outputs":[{"internalType":"string[]","name":"types","type":"string[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"total","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"total_","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"}],"name":"transferAssets","outputs":[{"internalType":"uint256[]","name":"amountsOut","type":"uint256[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"underlying","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"vault","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"assets_","type":"address[]"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"}],"name":"withdrawAssets","outputs":[{"internalType":"uint256[]","name":"amountsOut","type":"uint256[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"}],"name":"withdrawUnderlying","outputs":[],"stateMutability":"nonpayable","type":"function"}]Contract Creation Code
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
Deployed Bytecode
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
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 30 Chains
| Chain | Token | Portfolio % | Price | Amount | Value |
|---|
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.