// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)pragmasolidity ^0.8.20;/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/interfaceIERC20{
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/eventTransfer(addressindexedfrom, addressindexed 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.
*/eventApproval(addressindexed owner, addressindexed spender, uint256 value);
/**
* @dev Returns the value of tokens in existence.
*/functiontotalSupply() externalviewreturns (uint256);
/**
* @dev Returns the value of tokens owned by `account`.
*/functionbalanceOf(address account) externalviewreturns (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.
*/functiontransfer(address to, uint256 value) externalreturns (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.
*/functionallowance(address owner, address spender) externalviewreturns (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.
*/functionapprove(address spender, uint256 value) externalreturns (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.
*/functiontransferFrom(addressfrom, address to, uint256 value) externalreturns (bool);
}
Contract Source Code
File 7 of 35: IERC20Metadata.sol
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Metadata.sol)pragmasolidity ^0.8.20;import {IERC20} from"../IERC20.sol";
/**
* @dev Interface for the optional metadata functions from the ERC20 standard.
*/interfaceIERC20MetadataisIERC20{
/**
* @dev Returns the name of the token.
*/functionname() externalviewreturns (stringmemory);
/**
* @dev Returns the symbol of the token.
*/functionsymbol() externalviewreturns (stringmemory);
/**
* @dev Returns the decimals places of the token.
*/functiondecimals() externalviewreturns (uint8);
}
Contract Source Code
File 8 of 35: IPGauge.sol
// SPDX-License-Identifier: GPL-3.0-or-laterpragmasolidity ^0.8.0;interfaceIPGauge{
functiontotalActiveSupply() externalviewreturns (uint256);
functionactiveBalance(address user) externalviewreturns (uint256);
// only available for newer factories. please check the verified contractseventRedeemRewards(addressindexed user, uint256[] rewardsOut);
}
// SPDX-License-Identifier: MITpragmasolidity ^0.8.21;interfaceIRedstonePriceFeed{
/**
* @notice Returns details of the latest successful update round
* @dev It uses few helpful functions to abstract logic of getting
* latest round id and value
* @return roundId The number of the latest round
* @return answer The latest reported value
* @return startedAt Block timestamp when the latest successful round started
* @return updatedAt Block timestamp of the latest successful round
* @return answeredInRound The number of the latest round
*/functionlatestRoundData()
externalviewreturns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);
}
Contract Source Code
File 15 of 35: IReserveFeed.sol
// SPDX-License-Identifier: UNLICENSEDpragmasolidity 0.8.21;/**
* @title IReserveFeed interface
* @notice Interface for the reserve feeds for Ion Protocol.
*
*/interfaceIReserveFeed{
/**
* @dev updates the total reserve of the validator backed asset
* @param ilkIndex the ilk index of the asset
* @param reserve the total ETH reserve of the asset in wei
*/functionupdateExchangeRate(uint8 ilkIndex, uint256 reserve) external;
/**
* @dev returns the total reserve of the validator backed asset
* @param ilkIndex the ilk index of the asset
* @return the total ETH reserve of the asset in wei
*/functiongetExchangeRate(uint8 ilkIndex) externalviewreturns (uint256);
}
// SPDX-License-Identifier: GPL-3.0-or-later/*
* MIT License
* ===========
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
*/pragmasolidity ^0.8.0;import"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
interfaceIStandardizedYieldisIERC20Metadata{
/// @dev Emitted when any base tokens is deposited to mint shareseventDeposit(addressindexed caller,
addressindexed receiver,
addressindexed tokenIn,
uint256 amountDeposited,
uint256 amountSyOut
);
/// @dev Emitted when any shares are redeemed for base tokenseventRedeem(addressindexed caller,
addressindexed receiver,
addressindexed tokenOut,
uint256 amountSyToRedeem,
uint256 amountTokenOut
);
/// @dev check `assetInfo()` for more informationenumAssetType {
TOKEN,
LIQUIDITY
}
/// @dev Emitted when (`user`) claims their rewardseventClaimRewards(addressindexed user, address[] rewardTokens, uint256[] rewardAmounts);
/**
* @notice mints an amount of shares by depositing a base token.
* @param receiver shares recipient address
* @param tokenIn address of the base tokens to mint shares
* @param amountTokenToDeposit amount of base tokens to be transferred from (`msg.sender`)
* @param minSharesOut reverts if amount of shares minted is lower than this
* @return amountSharesOut amount of shares minted
* @dev Emits a {Deposit} event
*
* Requirements:
* - (`tokenIn`) must be a valid base token.
*/functiondeposit(address receiver,
address tokenIn,
uint256 amountTokenToDeposit,
uint256 minSharesOut
) externalpayablereturns (uint256 amountSharesOut);
/**
* @notice redeems an amount of base tokens by burning some shares
* @param receiver recipient address
* @param amountSharesToRedeem amount of shares to be burned
* @param tokenOut address of the base token to be redeemed
* @param minTokenOut reverts if amount of base token redeemed is lower than this
* @param burnFromInternalBalance if true, burns from balance of `address(this)`, otherwise burns from `msg.sender`
* @return amountTokenOut amount of base tokens redeemed
* @dev Emits a {Redeem} event
*
* Requirements:
* - (`tokenOut`) must be a valid base token.
*/functionredeem(address receiver,
uint256 amountSharesToRedeem,
address tokenOut,
uint256 minTokenOut,
bool burnFromInternalBalance
) externalreturns (uint256 amountTokenOut);
/**
* @notice exchangeRate * syBalance / 1e18 must return the asset balance of the account
* @notice vice-versa, if a user uses some amount of tokens equivalent to X asset, the amount of sy
he can mint must be X * exchangeRate / 1e18
* @dev SYUtils's assetToSy & syToAsset should be used instead of raw multiplication
& division
*/functionexchangeRate() externalviewreturns (uint256 res);
/**
* @notice claims reward for (`user`)
* @param user the user receiving their rewards
* @return rewardAmounts an array of reward amounts in the same order as `getRewardTokens`
* @dev
* Emits a `ClaimRewards` event
* See {getRewardTokens} for list of reward tokens
*/functionclaimRewards(address user) externalreturns (uint256[] memory rewardAmounts);
/**
* @notice get the amount of unclaimed rewards for (`user`)
* @param user the user to check for
* @return rewardAmounts an array of reward amounts in the same order as `getRewardTokens`
*/functionaccruedRewards(address user) externalviewreturns (uint256[] memory rewardAmounts);
functionrewardIndexesCurrent() externalreturns (uint256[] memory indexes);
functionrewardIndexesStored() externalviewreturns (uint256[] memory indexes);
/**
* @notice returns the list of reward token addresses
*/functiongetRewardTokens() externalviewreturns (address[] memory);
/**
* @notice returns the address of the underlying yield token
*/functionyieldToken() externalviewreturns (address);
/**
* @notice returns all tokens that can mint this SY
*/functiongetTokensIn() externalviewreturns (address[] memory res);
/**
* @notice returns all tokens that can be redeemed by this SY
*/functiongetTokensOut() externalviewreturns (address[] memory res);
functionisValidTokenIn(address token) externalviewreturns (bool);
functionisValidTokenOut(address token) externalviewreturns (bool);
functionpreviewDeposit(address tokenIn,
uint256 amountTokenToDeposit
) externalviewreturns (uint256 amountSharesOut);
functionpreviewRedeem(address tokenOut,
uint256 amountSharesToRedeem
) externalviewreturns (uint256 amountTokenOut);
/**
* @notice This function contains information to interpret what the asset is
* @return assetType the type of the asset (0 for ERC20 tokens, 1 for AMM liquidity tokens,
2 for bridged yield bearing tokens like wstETH, rETH on Arbi whose the underlying asset doesn't exist on the chain)
* @return assetAddress the address of the asset
* @return assetDecimals the decimals of the asset
*/functionassetInfo() externalviewreturns (AssetType assetType, address assetAddress, uint8 assetDecimals);
}
Contract Source Code
File 18 of 35: IUniswapV3Pool.sol
// SPDX-License-Identifier: GPL-2.0-or-laterpragmasolidity >=0.5.0;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 piecesinterfaceIUniswapV3PoolisIUniswapV3PoolImmutables,
IUniswapV3PoolState,
IUniswapV3PoolDerivedState,
IUniswapV3PoolActions,
IUniswapV3PoolOwnerActions,
IUniswapV3PoolEvents{
}
Contract Source Code
File 19 of 35: IUniswapV3PoolActions.sol
// SPDX-License-Identifier: GPL-2.0-or-laterpragmasolidity >=0.5.0;/// @title Permissionless pool actions/// @notice Contains pool methods that can be called by anyoneinterfaceIUniswapV3PoolActions{
/// @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.96functioninitialize(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 callbackfunctionmint(address recipient,
int24 tickLower,
int24 tickUpper,
uint128 amount,
bytescalldata data
) externalreturns (uint256 amount0, uint256 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 token1functioncollect(address recipient,
int24 tickLower,
int24 tickUpper,
uint128 amount0Requested,
uint128 amount1Requested
) externalreturns (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 recipientfunctionburn(int24 tickLower,
int24 tickUpper,
uint128 amount
) externalreturns (uint256 amount0, uint256 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 positivefunctionswap(address recipient,
bool zeroForOne,
int256 amountSpecified,
uint160 sqrtPriceLimitX96,
bytescalldata data
) externalreturns (int256 amount0, int256 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 callbackfunctionflash(address recipient,
uint256 amount0,
uint256 amount1,
bytescalldata 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 storefunctionincreaseObservationCardinalityNext(uint16 observationCardinalityNext) external;
}
Contract Source Code
File 20 of 35: IUniswapV3PoolDerivedState.sol
// SPDX-License-Identifier: GPL-2.0-or-laterpragmasolidity >=0.5.0;/// @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.interfaceIUniswapV3PoolDerivedState{
/// @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/// timestampfunctionobserve(uint32[] calldata secondsAgos)
externalviewreturns (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 rangefunctionsnapshotCumulativesInside(int24 tickLower, int24 tickUpper)
externalviewreturns (int56 tickCumulativeInside,
uint160 secondsPerLiquidityInsideX128,
uint32 secondsInside
);
}
Contract Source Code
File 21 of 35: IUniswapV3PoolEvents.sol
// SPDX-License-Identifier: GPL-2.0-or-laterpragmasolidity >=0.5.0;/// @title Events emitted by a pool/// @notice Contains all events emitted by the poolinterfaceIUniswapV3PoolEvents{
/// @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 pooleventInitialize(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 liquidityeventMint(address sender,
addressindexed owner,
int24indexed tickLower,
int24indexed tickUpper,
uint128 amount,
uint256 amount0,
uint256 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 collectedeventCollect(addressindexed owner,
address recipient,
int24indexed tickLower,
int24indexed 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 withdrawneventBurn(addressindexed owner,
int24indexed tickLower,
int24indexed tickUpper,
uint128 amount,
uint256 amount0,
uint256 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 swapeventSwap(addressindexed sender,
addressindexed recipient,
int256 amount0,
int256 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 feeeventFlash(addressindexed sender,
addressindexed recipient,
uint256 amount0,
uint256 amount1,
uint256 paid0,
uint256 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 cardinalityeventIncreaseObservationCardinalityNext(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 feeeventSetFeeProtocol(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 withdrawneventCollectProtocol(addressindexed sender, addressindexed recipient, uint128 amount0, uint128 amount1);
}
Contract Source Code
File 22 of 35: IUniswapV3PoolImmutables.sol
// SPDX-License-Identifier: GPL-2.0-or-laterpragmasolidity >=0.5.0;/// @title Pool state that never changes/// @notice These parameters are fixed for a pool forever, i.e., the methods will always return the same valuesinterfaceIUniswapV3PoolImmutables{
/// @notice The contract that deployed the pool, which must adhere to the IUniswapV3Factory interface/// @return The contract addressfunctionfactory() externalviewreturns (address);
/// @notice The first of the two tokens of the pool, sorted by address/// @return The token contract addressfunctiontoken0() externalviewreturns (address);
/// @notice The second of the two tokens of the pool, sorted by address/// @return The token contract addressfunctiontoken1() externalviewreturns (address);
/// @notice The pool's fee in hundredths of a bip, i.e. 1e-6/// @return The feefunctionfee() externalviewreturns (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 spacingfunctiontickSpacing() externalviewreturns (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 tickfunctionmaxLiquidityPerTick() externalviewreturns (uint128);
}
Contract Source Code
File 23 of 35: IUniswapV3PoolOwnerActions.sol
// SPDX-License-Identifier: GPL-2.0-or-laterpragmasolidity >=0.5.0;/// @title Permissioned pool actions/// @notice Contains pool methods that may only be called by the factory ownerinterfaceIUniswapV3PoolOwnerActions{
/// @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 poolfunctionsetFeeProtocol(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 token1functioncollectProtocol(address recipient,
uint128 amount0Requested,
uint128 amount1Requested
) externalreturns (uint128 amount0, uint128 amount1);
}
Contract Source Code
File 24 of 35: IUniswapV3PoolState.sol
// SPDX-License-Identifier: GPL-2.0-or-laterpragmasolidity >=0.5.0;/// @title Pool state that can change/// @notice These methods compose the pool's state, and can change with any frequency including multiple times/// per transactioninterfaceIUniswapV3PoolState{
/// @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 reentrancyfunctionslot0()
externalviewreturns (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 uint256functionfeeGrowthGlobal0X128() externalviewreturns (uint256);
/// @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 uint256functionfeeGrowthGlobal1X128() externalviewreturns (uint256);
/// @notice The amounts of token0 and token1 that are owed to the protocol/// @dev Protocol fees will never exceed uint128 max in either tokenfunctionprotocolFees() externalviewreturns (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 ticksfunctionliquidity() externalviewreturns (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.functionticks(int24 tick)
externalviewreturns (uint128 liquidityGross,
int128 liquidityNet,
uint256 feeGrowthOutside0X128,
uint256 feeGrowthOutside1X128,
int56 tickCumulativeOutside,
uint160 secondsPerLiquidityOutsideX128,
uint32 secondsOutside,
bool initialized
);
/// @notice Returns 256 packed tick initialized boolean values. See TickBitmap for more informationfunctiontickBitmap(int16 wordPosition) externalviewreturns (uint256);
/// @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/pokefunctionpositions(bytes32 key)
externalviewreturns (uint128 _liquidity,
uint256 feeGrowthInside0LastX128,
uint256 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 usefunctionobservations(uint256 index)
externalviewreturns (uint32 blockTimestamp,
int56 tickCumulative,
uint160 secondsPerLiquidityCumulativeX128,
bool initialized
);
}
Contract Source Code
File 25 of 35: IWETH9.sol
// SPDX-License-Identifier: MITpragmasolidity ^0.8.21;import { IERC20 } from"@openzeppelin/contracts/token/ERC20/IERC20.sol";
/**
* @dev WETH9 interface
*/interfaceIWETH9isIERC20{
/**
* @dev Deposit ether to get wrapped ether
*/functiondeposit() externalpayable;
/**
* @dev Withdraw wrapped ether to get ether
* @param amount Amount of wrapped ether to withdraw
*/functionwithdraw(uint256 amount) external;
}
Contract Source Code
File 26 of 35: LogExpMath.sol
// SPDX-License-Identifier: GPL-3.0-or-later// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated// documentation files (the “Software”), to deal in the Software without restriction, including without limitation the// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to// permit persons to whom the Software is furnished to do so, subject to the following conditions:// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the// Software.// THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE// WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.pragmasolidity ^0.8.0;/* solhint-disable *//**
* @dev Exponentiation and logarithm functions for 18 decimal fixed point numbers (both base and exponent/argument).
*
* Exponentiation and logarithm with arbitrary bases (x^y and log_x(y)) are implemented by conversion to natural
* exponentiation and logarithm (where the base is Euler's number).
*
* @author Fernando Martinelli - @fernandomartinelli
* @author Sergio Yuhjtman - @sergioyuhjtman
* @author Daniel Fernandez - @dmf7z
*/libraryLogExpMath{
// All fixed point multiplications and divisions are inlined. This means we need to divide by ONE when multiplying// two numbers, and multiply by ONE when dividing them.// All arguments and return values are 18 decimal fixed point numbers.int256constant ONE_18 =1e18;
// Internally, intermediate values are computed with higher precision as 20 decimal fixed point numbers, and in the// case of ln36, 36 decimals.int256constant ONE_20 =1e20;
int256constant ONE_36 =1e36;
// The domain of natural exponentiation is bound by the word size and number of decimals used.//// Because internally the result will be stored using 20 decimals, the largest possible result is// (2^255 - 1) / 10^20, which makes the largest exponent ln((2^255 - 1) / 10^20) = 130.700829182905140221.// The smallest possible result is 10^(-18), which makes largest negative argument// ln(10^(-18)) = -41.446531673892822312.// We use 130.0 and -41.0 to have some safety margin.int256constant MAX_NATURAL_EXPONENT =130e18;
int256constant MIN_NATURAL_EXPONENT =-41e18;
// Bounds for ln_36's argument. Both ln(0.9) and ln(1.1) can be represented with 36 decimal places in a fixed point// 256 bit integer.int256constant LN_36_LOWER_BOUND = ONE_18 -1e17;
int256constant LN_36_UPPER_BOUND = ONE_18 +1e17;
uint256constant MILD_EXPONENT_BOUND =2**254/uint256(ONE_20);
// 18 decimal constantsint256constant x0 =128000000000000000000; // 2ˆ7int256constant a0 =38877084059945950922200000000000000000000000000000000000; // eˆ(x0) (no decimals)int256constant x1 =64000000000000000000; // 2ˆ6int256constant a1 =6235149080811616882910000000; // eˆ(x1) (no decimals)// 20 decimal constantsint256constant x2 =3200000000000000000000; // 2ˆ5int256constant a2 =7896296018268069516100000000000000; // eˆ(x2)int256constant x3 =1600000000000000000000; // 2ˆ4int256constant a3 =888611052050787263676000000; // eˆ(x3)int256constant x4 =800000000000000000000; // 2ˆ3int256constant a4 =298095798704172827474000; // eˆ(x4)int256constant x5 =400000000000000000000; // 2ˆ2int256constant a5 =5459815003314423907810; // eˆ(x5)int256constant x6 =200000000000000000000; // 2ˆ1int256constant a6 =738905609893065022723; // eˆ(x6)int256constant x7 =100000000000000000000; // 2ˆ0int256constant a7 =271828182845904523536; // eˆ(x7)int256constant x8 =50000000000000000000; // 2ˆ-1int256constant a8 =164872127070012814685; // eˆ(x8)int256constant x9 =25000000000000000000; // 2ˆ-2int256constant a9 =128402541668774148407; // eˆ(x9)int256constant x10 =12500000000000000000; // 2ˆ-3int256constant a10 =113314845306682631683; // eˆ(x10)int256constant x11 =6250000000000000000; // 2ˆ-4int256constant a11 =106449445891785942956; // eˆ(x11)/**
* @dev Natural exponentiation (e^x) with signed 18 decimal fixed point exponent.
*
* Reverts if `x` is smaller than MIN_NATURAL_EXPONENT, or larger than `MAX_NATURAL_EXPONENT`.
*/functionexp(int256 x) internalpurereturns (int256) {
unchecked {
require(x >= MIN_NATURAL_EXPONENT && x <= MAX_NATURAL_EXPONENT, "Invalid exponent");
if (x <0) {
// We only handle positive exponents: e^(-x) is computed as 1 / e^x. We can safely make x positive since it// fits in the signed 256 bit range (as it is larger than MIN_NATURAL_EXPONENT).// Fixed point division requires multiplying by ONE_18.return ((ONE_18 * ONE_18) / exp(-x));
}
// First, we use the fact that e^(x+y) = e^x * e^y to decompose x into a sum of powers of two, which we call x_n,// where x_n == 2^(7 - n), and e^x_n = a_n has been precomputed. We choose the first x_n, x0, to equal 2^7// because all larger powers are larger than MAX_NATURAL_EXPONENT, and therefore not present in the// decomposition.// At the end of this process we will have the product of all e^x_n = a_n that apply, and the remainder of this// decomposition, which will be lower than the smallest x_n.// exp(x) = k_0 * a_0 * k_1 * a_1 * ... + k_n * a_n * exp(remainder), where each k_n equals either 0 or 1.// We mutate x by subtracting x_n, making it the remainder of the decomposition.// The first two a_n (e^(2^7) and e^(2^6)) are too large if stored as 18 decimal numbers, and could cause// intermediate overflows. Instead we store them as plain integers, with 0 decimals.// Additionally, x0 + x1 is larger than MAX_NATURAL_EXPONENT, which means they will not both be present in the// decomposition.// For each x_n, we test if that term is present in the decomposition (if x is larger than it), and if so deduct// it and compute the accumulated product.int256 firstAN;
if (x >= x0) {
x -= x0;
firstAN = a0;
} elseif (x >= x1) {
x -= x1;
firstAN = a1;
} else {
firstAN =1; // One with no decimal places
}
// We now transform x into a 20 decimal fixed point number, to have enhanced precision when computing the// smaller terms.
x *=100;
// `product` is the accumulated product of all a_n (except a0 and a1), which starts at 20 decimal fixed point// one. Recall that fixed point multiplication requires dividing by ONE_20.int256 product = ONE_20;
if (x >= x2) {
x -= x2;
product = (product * a2) / ONE_20;
}
if (x >= x3) {
x -= x3;
product = (product * a3) / ONE_20;
}
if (x >= x4) {
x -= x4;
product = (product * a4) / ONE_20;
}
if (x >= x5) {
x -= x5;
product = (product * a5) / ONE_20;
}
if (x >= x6) {
x -= x6;
product = (product * a6) / ONE_20;
}
if (x >= x7) {
x -= x7;
product = (product * a7) / ONE_20;
}
if (x >= x8) {
x -= x8;
product = (product * a8) / ONE_20;
}
if (x >= x9) {
x -= x9;
product = (product * a9) / ONE_20;
}
// x10 and x11 are unnecessary here since we have high enough precision already.// Now we need to compute e^x, where x is small (in particular, it is smaller than x9). We use the Taylor series// expansion for e^x: 1 + x + (x^2 / 2!) + (x^3 / 3!) + ... + (x^n / n!).int256 seriesSum = ONE_20; // The initial one in the sum, with 20 decimal places.int256 term; // Each term in the sum, where the nth term is (x^n / n!).// The first term is simply x.
term = x;
seriesSum += term;
// Each term (x^n / n!) equals the previous one times x, divided by n. Since x is a fixed point number,// multiplying by it requires dividing by ONE_20, but dividing by the non-fixed point n values does not.
term = ((term * x) / ONE_20) /2;
seriesSum += term;
term = ((term * x) / ONE_20) /3;
seriesSum += term;
term = ((term * x) / ONE_20) /4;
seriesSum += term;
term = ((term * x) / ONE_20) /5;
seriesSum += term;
term = ((term * x) / ONE_20) /6;
seriesSum += term;
term = ((term * x) / ONE_20) /7;
seriesSum += term;
term = ((term * x) / ONE_20) /8;
seriesSum += term;
term = ((term * x) / ONE_20) /9;
seriesSum += term;
term = ((term * x) / ONE_20) /10;
seriesSum += term;
term = ((term * x) / ONE_20) /11;
seriesSum += term;
term = ((term * x) / ONE_20) /12;
seriesSum += term;
// 12 Taylor terms are sufficient for 18 decimal precision.// We now have the first a_n (with no decimals), and the product of all other a_n present, and the Taylor// approximation of the exponentiation of the remainder (both with 20 decimals). All that remains is to multiply// all three (one 20 decimal fixed point multiplication, dividing by ONE_20, and one integer multiplication),// and then drop two digits to return an 18 decimal value.return (((product * seriesSum) / ONE_20) * firstAN) /100;
}
}
/**
* @dev Natural logarithm (ln(a)) with signed 18 decimal fixed point argument.
*/functionln(int256 a) internalpurereturns (int256) {
unchecked {
// The real natural logarithm is not defined for negative numbers or zero.require(a >0, "out of bounds");
if (LN_36_LOWER_BOUND < a && a < LN_36_UPPER_BOUND) {
return _ln_36(a) / ONE_18;
} else {
return _ln(a);
}
}
}
/**
* @dev Exponentiation (x^y) with unsigned 18 decimal fixed point base and exponent.
*
* Reverts if ln(x) * y is smaller than `MIN_NATURAL_EXPONENT`, or larger than `MAX_NATURAL_EXPONENT`.
*/functionpow(uint256 x, uint256 y) internalpurereturns (uint256) {
unchecked {
if (y ==0) {
// We solve the 0^0 indetermination by making it equal one.returnuint256(ONE_18);
}
if (x ==0) {
return0;
}
// Instead of computing x^y directly, we instead rely on the properties of logarithms and exponentiation to// arrive at that r`esult. In particular, exp(ln(x)) = x, and ln(x^y) = y * ln(x). This means// x^y = exp(y * ln(x)).// The ln function takes a signed value, so we need to make sure x fits in the signed 256 bit range.require(x <2**255, "x out of bounds");
int256 x_int256 =int256(x);
// We will compute y * ln(x) in a single step. Depending on the value of x, we can either use ln or ln_36. In// both cases, we leave the division by ONE_18 (due to fixed point multiplication) to the end.// This prevents y * ln(x) from overflowing, and at the same time guarantees y fits in the signed 256 bit range.require(y < MILD_EXPONENT_BOUND, "y out of bounds");
int256 y_int256 =int256(y);
int256 logx_times_y;
if (LN_36_LOWER_BOUND < x_int256 && x_int256 < LN_36_UPPER_BOUND) {
int256 ln_36_x = _ln_36(x_int256);
// ln_36_x has 36 decimal places, so multiplying by y_int256 isn't as straightforward, since we can't just// bring y_int256 to 36 decimal places, as it might overflow. Instead, we perform two 18 decimal// multiplications and add the results: one with the first 18 decimals of ln_36_x, and one with the// (downscaled) last 18 decimals.
logx_times_y = ((ln_36_x / ONE_18) * y_int256 + ((ln_36_x % ONE_18) * y_int256) / ONE_18);
} else {
logx_times_y = _ln(x_int256) * y_int256;
}
logx_times_y /= ONE_18;
// Finally, we compute exp(y * ln(x)) to arrive at x^yrequire(
MIN_NATURAL_EXPONENT <= logx_times_y && logx_times_y <= MAX_NATURAL_EXPONENT,
"product out of bounds"
);
returnuint256(exp(logx_times_y));
}
}
/**
* @dev Internal natural logarithm (ln(a)) with signed 18 decimal fixed point argument.
*/function_ln(int256 a) privatepurereturns (int256) {
unchecked {
if (a < ONE_18) {
// Since ln(a^k) = k * ln(a), we can compute ln(a) as ln(a) = ln((1/a)^(-1)) = - ln((1/a)). If a is less// than one, 1/a will be greater than one, and this if statement will not be entered in the recursive call.// Fixed point division requires multiplying by ONE_18.return (-_ln((ONE_18 * ONE_18) / a));
}
// First, we use the fact that ln^(a * b) = ln(a) + ln(b) to decompose ln(a) into a sum of powers of two, which// we call x_n, where x_n == 2^(7 - n), which are the natural logarithm of precomputed quantities a_n (that is,// ln(a_n) = x_n). We choose the first x_n, x0, to equal 2^7 because the exponential of all larger powers cannot// be represented as 18 fixed point decimal numbers in 256 bits, and are therefore larger than a.// At the end of this process we will have the sum of all x_n = ln(a_n) that apply, and the remainder of this// decomposition, which will be lower than the smallest a_n.// ln(a) = k_0 * x_0 + k_1 * x_1 + ... + k_n * x_n + ln(remainder), where each k_n equals either 0 or 1.// We mutate a by subtracting a_n, making it the remainder of the decomposition.// For reasons related to how `exp` works, the first two a_n (e^(2^7) and e^(2^6)) are not stored as fixed point// numbers with 18 decimals, but instead as plain integers with 0 decimals, so we need to multiply them by// ONE_18 to convert them to fixed point.// For each a_n, we test if that term is present in the decomposition (if a is larger than it), and if so divide// by it and compute the accumulated sum.int256 sum =0;
if (a >= a0 * ONE_18) {
a /= a0; // Integer, not fixed point division
sum += x0;
}
if (a >= a1 * ONE_18) {
a /= a1; // Integer, not fixed point division
sum += x1;
}
// All other a_n and x_n are stored as 20 digit fixed point numbers, so we convert the sum and a to this format.
sum *=100;
a *=100;
// Because further a_n are 20 digit fixed point numbers, we multiply by ONE_20 when dividing by them.if (a >= a2) {
a = (a * ONE_20) / a2;
sum += x2;
}
if (a >= a3) {
a = (a * ONE_20) / a3;
sum += x3;
}
if (a >= a4) {
a = (a * ONE_20) / a4;
sum += x4;
}
if (a >= a5) {
a = (a * ONE_20) / a5;
sum += x5;
}
if (a >= a6) {
a = (a * ONE_20) / a6;
sum += x6;
}
if (a >= a7) {
a = (a * ONE_20) / a7;
sum += x7;
}
if (a >= a8) {
a = (a * ONE_20) / a8;
sum += x8;
}
if (a >= a9) {
a = (a * ONE_20) / a9;
sum += x9;
}
if (a >= a10) {
a = (a * ONE_20) / a10;
sum += x10;
}
if (a >= a11) {
a = (a * ONE_20) / a11;
sum += x11;
}
// a is now a small number (smaller than a_11, which roughly equals 1.06). This means we can use a Taylor series// that converges rapidly for values of `a` close to one - the same one used in ln_36.// Let z = (a - 1) / (a + 1).// ln(a) = 2 * (z + z^3 / 3 + z^5 / 5 + z^7 / 7 + ... + z^(2 * n + 1) / (2 * n + 1))// Recall that 20 digit fixed point division requires multiplying by ONE_20, and multiplication requires// division by ONE_20.int256 z = ((a - ONE_20) * ONE_20) / (a + ONE_20);
int256 z_squared = (z * z) / ONE_20;
// num is the numerator of the series: the z^(2 * n + 1) termint256 num = z;
// seriesSum holds the accumulated sum of each term in the series, starting with the initial zint256 seriesSum = num;
// In each step, the numerator is multiplied by z^2
num = (num * z_squared) / ONE_20;
seriesSum += num /3;
num = (num * z_squared) / ONE_20;
seriesSum += num /5;
num = (num * z_squared) / ONE_20;
seriesSum += num /7;
num = (num * z_squared) / ONE_20;
seriesSum += num /9;
num = (num * z_squared) / ONE_20;
seriesSum += num /11;
// 6 Taylor terms are sufficient for 36 decimal precision.// Finally, we multiply by 2 (non fixed point) to compute ln(remainder)
seriesSum *=2;
// We now have the sum of all x_n present, and the Taylor approximation of the logarithm of the remainder (both// with 20 decimals). All that remains is to sum these two, and then drop two digits to return a 18 decimal// value.return (sum + seriesSum) /100;
}
}
/**
* @dev Intrnal high precision (36 decimal places) natural logarithm (ln(x)) with signed 18 decimal fixed point argument,
* for x close to one.
*
* Should only be used if x is between LN_36_LOWER_BOUND and LN_36_UPPER_BOUND.
*/function_ln_36(int256 x) privatepurereturns (int256) {
unchecked {
// Since ln(1) = 0, a value of x close to one will yield a very small result, which makes using 36 digits// worthwhile.// First, we transform x to a 36 digit fixed point value.
x *= ONE_18;
// We will use the following Taylor expansion, which converges very rapidly. Let z = (x - 1) / (x + 1).// ln(x) = 2 * (z + z^3 / 3 + z^5 / 5 + z^7 / 7 + ... + z^(2 * n + 1) / (2 * n + 1))// Recall that 36 digit fixed point division requires multiplying by ONE_36, and multiplication requires// division by ONE_36.int256 z = ((x - ONE_36) * ONE_36) / (x + ONE_36);
int256 z_squared = (z * z) / ONE_36;
// num is the numerator of the series: the z^(2 * n + 1) termint256 num = z;
// seriesSum holds the accumulated sum of each term in the series, starting with the initial zint256 seriesSum = num;
// In each step, the numerator is multiplied by z^2
num = (num * z_squared) / ONE_36;
seriesSum += num /3;
num = (num * z_squared) / ONE_36;
seriesSum += num /5;
num = (num * z_squared) / ONE_36;
seriesSum += num /7;
num = (num * z_squared) / ONE_36;
seriesSum += num /9;
num = (num * z_squared) / ONE_36;
seriesSum += num /11;
num = (num * z_squared) / ONE_36;
seriesSum += num /13;
num = (num * z_squared) / ONE_36;
seriesSum += num /15;
// 8 Taylor terms are sufficient for 36 decimal precision.// All that remains is multiplying by 2 (non fixed point).return seriesSum *2;
}
}
}
// SPDX-License-Identifier: MIT// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/Math.sol)pragmasolidity ^0.8.20;/**
* @dev Standard math utilities missing in the Solidity language.
*/libraryMath{
/**
* @dev Muldiv operation overflow.
*/errorMathOverflowedMulDiv();
enumRounding {
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.
*/functiontryAdd(uint256 a, uint256 b) internalpurereturns (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.
*/functiontrySub(uint256 a, uint256 b) internalpurereturns (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.
*/functiontryMul(uint256 a, uint256 b) internalpurereturns (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/522if (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.
*/functiontryDiv(uint256 a, uint256 b) internalpurereturns (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.
*/functiontryMod(uint256 a, uint256 b) internalpurereturns (bool, uint256) {
unchecked {
if (b ==0) return (false, 0);
return (true, a % b);
}
}
/**
* @dev Returns the largest of two numbers.
*/functionmax(uint256 a, uint256 b) internalpurereturns (uint256) {
return a > b ? a : b;
}
/**
* @dev Returns the smallest of two numbers.
*/functionmin(uint256 a, uint256 b) internalpurereturns (uint256) {
return a < b ? a : b;
}
/**
* @dev Returns the average of two numbers. The result is rounded towards
* zero.
*/functionaverage(uint256 a, uint256 b) internalpurereturns (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.
*/functionceilDiv(uint256 a, uint256 b) internalpurereturns (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.
*/functionmulDiv(uint256 x, uint256 y, uint256 denominator) internalpurereturns (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 productuint256 prod1; // Most significant 256 bits of the productassembly {
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.
*/functionmulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internalpurereturns (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).
*/functionsqrt(uint256 a) internalpurereturns (uint256) {
if (a ==0) {
return0;
}
// 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.
*/functionsqrt(uint256 a, Rounding rounding) internalpurereturns (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.
*/functionlog2(uint256 value) internalpurereturns (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.
*/functionlog2(uint256 value, Rounding rounding) internalpurereturns (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.
*/functionlog10(uint256 value) internalpurereturns (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.
*/functionlog10(uint256 value, Rounding rounding) internalpurereturns (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.
*/functionlog256(uint256 value) internalpurereturns (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.
*/functionlog256(uint256 value, Rounding rounding) internalpurereturns (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.
*/functionunsignedRoundsUp(Rounding rounding) internalpurereturns (bool) {
returnuint8(rounding) %2==1;
}
}
// SPDX-License-Identifier: GPL-3.0-or-later// This program is free software: you can redistribute it and/or modify// it under the terms of the GNU General Public License as published by// the Free Software Foundation, either version 3 of the License, or// (at your option) any later version.// This program is distributed in the hope that it will be useful,// but WITHOUT ANY WARRANTY; without even the implied warranty of// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the// GNU General Public License for more details.// You should have received a copy of the GNU General Public License// along with this program. If not, see <http://www.gnu.org/licenses/>.pragmasolidity ^0.8.0;/* solhint-disable private-vars-leading-underscore, reason-string */libraryPMath{
uint256internalconstant ONE =1e18; // 18 decimal placesint256internalconstant IONE =1e18; // 18 decimal placesfunctionsubMax0(uint256 a, uint256 b) internalpurereturns (uint256) {
unchecked {
return (a >= b ? a - b : 0);
}
}
functionsubNoNeg(int256 a, int256 b) internalpurereturns (int256) {
require(a >= b, "negative");
return a - b; // no unchecked since if b is very negative, a - b might overflow
}
functionmulDown(uint256 a, uint256 b) internalpurereturns (uint256) {
uint256 product = a * b;
unchecked {
return product / ONE;
}
}
functionmulDown(int256 a, int256 b) internalpurereturns (int256) {
int256 product = a * b;
unchecked {
return product / IONE;
}
}
functiondivDown(uint256 a, uint256 b) internalpurereturns (uint256) {
uint256 aInflated = a * ONE;
unchecked {
return aInflated / b;
}
}
functiondivDown(int256 a, int256 b) internalpurereturns (int256) {
int256 aInflated = a * IONE;
unchecked {
return aInflated / b;
}
}
functionrawDivUp(uint256 a, uint256 b) internalpurereturns (uint256) {
return (a + b -1) / b;
}
// @author Uniswapfunctionsqrt(uint256 y) internalpurereturns (uint256 z) {
if (y >3) {
z = y;
uint256 x = y /2+1;
while (x < z) {
z = x;
x = (y / x + x) /2;
}
} elseif (y !=0) {
z =1;
}
}
functionsquare(uint256 x) internalpurereturns (uint256) {
return x * x;
}
functionsquareDown(uint256 x) internalpurereturns (uint256) {
return mulDown(x, x);
}
functionabs(int256 x) internalpurereturns (uint256) {
returnuint256(x >0 ? x : -x);
}
functionneg(int256 x) internalpurereturns (int256) {
return x * (-1);
}
functionneg(uint256 x) internalpurereturns (int256) {
return Int(x) * (-1);
}
functionmax(uint256 x, uint256 y) internalpurereturns (uint256) {
return (x > y ? x : y);
}
functionmax(int256 x, int256 y) internalpurereturns (int256) {
return (x > y ? x : y);
}
functionmin(uint256 x, uint256 y) internalpurereturns (uint256) {
return (x < y ? x : y);
}
functionmin(int256 x, int256 y) internalpurereturns (int256) {
return (x < y ? x : y);
}
/*///////////////////////////////////////////////////////////////
SIGNED CASTS
//////////////////////////////////////////////////////////////*/functionInt(uint256 x) internalpurereturns (int256) {
require(x <=uint256(type(int256).max));
returnint256(x);
}
functionInt128(int256 x) internalpurereturns (int128) {
require(type(int128).min<= x && x <=type(int128).max);
returnint128(x);
}
functionInt128(uint256 x) internalpurereturns (int128) {
return Int128(Int(x));
}
/*///////////////////////////////////////////////////////////////
UNSIGNED CASTS
//////////////////////////////////////////////////////////////*/functionUint(int256 x) internalpurereturns (uint256) {
require(x >=0);
returnuint256(x);
}
functionUint32(uint256 x) internalpurereturns (uint32) {
require(x <=type(uint32).max);
returnuint32(x);
}
functionUint64(uint256 x) internalpurereturns (uint64) {
require(x <=type(uint64).max);
returnuint64(x);
}
functionUint112(uint256 x) internalpurereturns (uint112) {
require(x <=type(uint112).max);
returnuint112(x);
}
functionUint96(uint256 x) internalpurereturns (uint96) {
require(x <=type(uint96).max);
returnuint96(x);
}
functionUint128(uint256 x) internalpurereturns (uint128) {
require(x <=type(uint128).max);
returnuint128(x);
}
functionUint192(uint256 x) internalpurereturns (uint192) {
require(x <=type(uint192).max);
returnuint192(x);
}
functionisAApproxB(uint256 a, uint256 b, uint256 eps) internalpurereturns (bool) {
return mulDown(b, ONE - eps) <= a && a <= mulDown(b, ONE + eps);
}
functionisAGreaterApproxB(uint256 a, uint256 b, uint256 eps) internalpurereturns (bool) {
return a >= b && a <= mulDown(b, ONE + eps);
}
functionisASmallerApproxB(uint256 a, uint256 b, uint256 eps) internalpurereturns (bool) {
return a <= b && a >= mulDown(b, ONE - eps);
}
}
// SPDX-License-Identifier: MITpragmasolidity 0.8.21;import { IReserveFeed } from"../../interfaces/IReserveFeed.sol";
import { WadRayMath, RAY } from"../../libraries/math/WadRayMath.sol";
import { Math } from"@openzeppelin/contracts/utils/math/Math.sol";
// should equal to the number of feeds available in the contractuint8constant FEED_COUNT =3;
uint256constant UPDATE_COOLDOWN =58minutes;
/**
* @notice Reserve oracles are used to determine the LST provider exchange rate
* and is utilizated by Ion's liquidation module. Liquidations will only be
* triggered against this exchange rate and will be completely market-price
* agnostic. Importantly, this means that liquidations will only be triggered
* through lack of debt repayment or slashing events.
*
* @dev In order to protect against potential provider bugs or incorrect one-off
* values (malicious or accidental), the reserve oracle does not use live data.
* Instead it will query the exchange every intermittent period and persist the
* value and this value can only move up or down by a maximum percentage per query.
*
* If additional data sources are available, they can be involved as `FEED`s. If
* other `FEED`s are provided to the reserve oracle, a mean of all the `FEED`s
* is compared to the protocol exchange rate and the minimum of the two is used
* as the new exchange rate. This final value is subject to the bounding rules.
*
* @custom:security-contact security@molecularlabs.io
*/abstractcontractReserveOracle{
usingWadRayMathforuint256;
uint8publicimmutable ILK_INDEX;
uint8publicimmutable QUORUM; // the number of feeds to aggregateuint256publicimmutable MAX_CHANGE; // maximum change allowed in percentage [ray] i.e. 3e25 [ray] would be 3%
IReserveFeed publicimmutable FEED0; // different reserve oracle feeds excluding the protocol exchange rate
IReserveFeed publicimmutable FEED1;
IReserveFeed publicimmutable FEED2;
uint256public currentExchangeRate; // [wad] the bounded queried last timeuint256public lastUpdated; // [wad] the bounded queried last time// --- Events ---eventUpdateExchangeRate(uint256 exchangeRate);
// --- Errors ---errorInvalidQuorum(uint8 invalidQuorum);
errorInvalidFeedLength(uint256 invalidLength);
errorInvalidMaxChange(uint256 invalidMaxChange);
errorInvalidMinMax(uint256 invalidMin, uint256 invalidMax);
errorInvalidInitialization(uint256 invalidExchangeRate);
errorUpdateCooldown(uint256 lastUpdated);
/**
* @notice Creates a new `ReserveOracle` instance.
* @param _ilkIndex of the associated collateral.
* @param _feeds Alternative data sources to be used for the reserve oracle.
* @param _quorum The number of feeds to aggregate.
* @param _maxChange Maximum percent change between exchange rate updates. [RAY]
*/constructor(uint8 _ilkIndex, address[] memory _feeds, uint8 _quorum, uint256 _maxChange) {
if (_feeds.length!= FEED_COUNT) revert InvalidFeedLength(_feeds.length);
if (_quorum > FEED_COUNT) revert InvalidQuorum(_quorum);
if (_maxChange ==0|| _maxChange > RAY) revert InvalidMaxChange(_maxChange);
ILK_INDEX = _ilkIndex;
QUORUM = _quorum;
MAX_CHANGE = _maxChange;
FEED0 = IReserveFeed(_feeds[0]);
FEED1 = IReserveFeed(_feeds[1]);
FEED2 = IReserveFeed(_feeds[2]);
}
// --- Override ---/**
* @notice Returns the protocol exchange rate.
* @dev Must be implemented in the child contract with LST-specific logic.
* @return The protocol exchange rate.
*/function_getProtocolExchangeRate() internalviewvirtualreturns (uint256);
/**
* @notice Returns the protocol exchange rate.
* @return The protocol exchange rate.
*/functiongetProtocolExchangeRate() externalviewreturns (uint256) {
return _getProtocolExchangeRate();
}
/**
* @notice Queries values from whitelisted data feeds and calculates the
* mean. This does not include the protocol exchange rate.
* @param _ILK_INDEX of the associated collateral.
*/function_aggregate(uint8 _ILK_INDEX) internalviewreturns (uint256 val) {
if (QUORUM ==0) {
returntype(uint256).max;
} elseif (QUORUM ==1) {
val = FEED0.getExchangeRate(_ILK_INDEX);
} elseif (QUORUM ==2) {
uint256 feed0ExchangeRate = FEED0.getExchangeRate(_ILK_INDEX);
uint256 feed1ExchangeRate = FEED1.getExchangeRate(_ILK_INDEX);
val = ((feed0ExchangeRate + feed1ExchangeRate) /uint256(QUORUM));
} elseif (QUORUM ==3) {
uint256 feed0ExchangeRate = FEED0.getExchangeRate(_ILK_INDEX);
uint256 feed1ExchangeRate = FEED1.getExchangeRate(_ILK_INDEX);
uint256 feed2ExchangeRate = FEED2.getExchangeRate(_ILK_INDEX);
val = ((feed0ExchangeRate + feed1ExchangeRate + feed2ExchangeRate) /uint256(QUORUM));
}
}
/**
* @notice Bounds the value between the min and the max.
* @param value The value to be bounded.
* @param min The minimum bound.
* @param max The maximum bound.
*/function_bound(uint256 value, uint256 min, uint256 max) internalpurereturns (uint256) {
if (min > max) revert InvalidMinMax(min, max);
return Math.max(min, Math.min(max, value));
}
/**
* @notice Initializes the `currentExchangeRate` state variable.
* @dev Called once during construction.
*/function_initializeExchangeRate() internal{
currentExchangeRate = Math.min(_getProtocolExchangeRate(), _aggregate(ILK_INDEX));
if (currentExchangeRate ==0) {
revert InvalidInitialization(currentExchangeRate);
}
emit UpdateExchangeRate(currentExchangeRate);
}
/**
* @notice Updates the `currentExchangeRate` state variable.
* @dev Takes the minimum between the aggregated values and the protocol exchange rate,
* then bounds it up to the maximum change and writes the bounded value to the state.
* NOTE: keepers should call this update to reflect recent values
*/functionupdateExchangeRate() external{
if (block.timestamp- lastUpdated < UPDATE_COOLDOWN) revert UpdateCooldown(lastUpdated);
uint256 _currentExchangeRate = currentExchangeRate;
uint256 minimum = Math.min(_getProtocolExchangeRate(), _aggregate(ILK_INDEX));
uint256 diff = _currentExchangeRate.rayMulDown(MAX_CHANGE);
uint256 bounded = _bound(minimum, _currentExchangeRate - diff, _currentExchangeRate + diff);
currentExchangeRate = bounded;
lastUpdated =block.timestamp;
emit UpdateExchangeRate(bounded);
}
}
// SPDX-License-Identifier: UNLICENSEDpragmasolidity ^0.8.0;import { Math } from"@openzeppelin/contracts/utils/math/Math.sol";
uint256constant WAD =1e18;
uint256constant RAY =1e27;
uint256constant RAD =1e45;
/**
* @title WadRayMath
*
* @notice This library provides mul/div[up/down] functionality for WAD, RAY and
* RAD with phantom overflow protection as well as scale[up/down] functionality
* for WAD, RAY and RAD.
*
* @custom:security-contact security@molecularlabs.io
*/libraryWadRayMath{
usingMathforuint256;
errorNotScalingUp(uint256from, uint256 to);
errorNotScalingDown(uint256from, uint256 to);
/**
* @notice Multiplies two WAD numbers and returns the result as a WAD
* rounding the result down.
* @param a Multiplicand.
* @param b Multiplier.
*/functionwadMulDown(uint256 a, uint256 b) internalpurereturns (uint256) {
return a.mulDiv(b, WAD);
}
/**
* @notice Multiplies two WAD numbers and returns the result as a WAD
* rounding the result up.
* @param a Multiplicand.
* @param b Multiplier.
*/functionwadMulUp(uint256 a, uint256 b) internalpurereturns (uint256) {
return a.mulDiv(b, WAD, Math.Rounding.Ceil);
}
/**
* @notice Divides two WAD numbers and returns the result as a WAD rounding
* the result down.
* @param a Dividend.
* @param b Divisor.
*/functionwadDivDown(uint256 a, uint256 b) internalpurereturns (uint256) {
return a.mulDiv(WAD, b);
}
/**
* @notice Divides two WAD numbers and returns the result as a WAD rounding
* the result up.
* @param a Dividend.
* @param b Divisor.
*/functionwadDivUp(uint256 a, uint256 b) internalpurereturns (uint256) {
return a.mulDiv(WAD, b, Math.Rounding.Ceil);
}
/**
* @notice Multiplies two RAY numbers and returns the result as a RAY
* rounding the result down.
* @param a Multiplicand
* @param b Multiplier
*/functionrayMulDown(uint256 a, uint256 b) internalpurereturns (uint256) {
return a.mulDiv(b, RAY);
}
/**
* @notice Multiplies two RAY numbers and returns the result as a RAY
* rounding the result up.
* @param a Multiplicand
* @param b Multiplier
*/functionrayMulUp(uint256 a, uint256 b) internalpurereturns (uint256) {
return a.mulDiv(b, RAY, Math.Rounding.Ceil);
}
/**
* @notice Divides two RAY numbers and returns the result as a RAY
* rounding the result down.
* @param a Dividend
* @param b Divisor
*/functionrayDivDown(uint256 a, uint256 b) internalpurereturns (uint256) {
return a.mulDiv(RAY, b);
}
/**
* @notice Divides two RAY numbers and returns the result as a RAY
* rounding the result up.
* @param a Dividend
* @param b Divisor
*/functionrayDivUp(uint256 a, uint256 b) internalpurereturns (uint256) {
return a.mulDiv(RAY, b, Math.Rounding.Ceil);
}
/**
* @notice Multiplies two RAD numbers and returns the result as a RAD
* rounding the result down.
* @param a Multiplicand
* @param b Multiplier
*/functionradMulDown(uint256 a, uint256 b) internalpurereturns (uint256) {
return a.mulDiv(b, RAD);
}
/**
* @notice Multiplies two RAD numbers and returns the result as a RAD
* rounding the result up.
* @param a Multiplicand
* @param b Multiplier
*/functionradMulUp(uint256 a, uint256 b) internalpurereturns (uint256) {
return a.mulDiv(b, RAD, Math.Rounding.Ceil);
}
/**
* @notice Divides two RAD numbers and returns the result as a RAD rounding
* the result down.
* @param a Dividend
* @param b Divisor
*/functionradDivDown(uint256 a, uint256 b) internalpurereturns (uint256) {
return a.mulDiv(RAD, b);
}
/**
* @notice Divides two RAD numbers and returns the result as a RAD rounding
* the result up.
* @param a Dividend
* @param b Divisor
*/functionradDivUp(uint256 a, uint256 b) internalpurereturns (uint256) {
return a.mulDiv(RAD, b, Math.Rounding.Ceil);
}
// --- Scalers ---/**
* @notice Scales a value up from WAD. NOTE: The `scale` value must be
* less than 18.
* @param value to scale up.
* @param scale of the returned value.
*/functionscaleUpToWad(uint256 value, uint256 scale) internalpurereturns (uint256) {
return scaleUp(value, scale, 18);
}
/**
* @notice Scales a value up from RAY. NOTE: The `scale` value must be
* less than 27.
* @param value to scale up.
* @param scale of the returned value.
*/functionscaleUpToRay(uint256 value, uint256 scale) internalpurereturns (uint256) {
return scaleUp(value, scale, 27);
}
/**
* @notice Scales a value up from RAD. NOTE: The `scale` value must be
* less than 45.
* @param value to scale up.
* @param scale of the returned value.
*/functionscaleUpToRad(uint256 value, uint256 scale) internalpurereturns (uint256) {
return scaleUp(value, scale, 45);
}
/**
* @notice Scales a value down to WAD. NOTE: The `scale` value must be
* greater than 18.
* @param value to scale down.
* @param scale of the returned value.
*/functionscaleDownToWad(uint256 value, uint256 scale) internalpurereturns (uint256) {
return scaleDown(value, scale, 18);
}
/**
* @notice Scales a value down to RAY. NOTE: The `scale` value must be
* greater than 27.
* @param value to scale down.
* @param scale of the returned value.
*/functionscaleDownToRay(uint256 value, uint256 scale) internalpurereturns (uint256) {
return scaleDown(value, scale, 27);
}
/**
* @notice Scales a value down to RAD. NOTE: The `scale` value must be
* greater than 45.
* @param value to scale down.
* @param scale of the returned value.
*/functionscaleDownToRad(uint256 value, uint256 scale) internalpurereturns (uint256) {
return scaleDown(value, scale, 45);
}
/**
* @notice Scales a value up from one fixed-point precision to another.
* @param value to scale up.
* @param from Precision to scale from.
* @param to Precision to scale to.
*/functionscaleUp(uint256 value, uint256from, uint256 to) internalpurereturns (uint256) {
if (from>= to) revert NotScalingUp(from, to);
return value * (10** (to -from));
}
/**
* @notice Scales a value down from one fixed-point precision to another.
* @param value to scale down.
* @param from Precision to scale from.
* @param to Precision to scale to.
*/functionscaleDown(uint256 value, uint256from, uint256 to) internalpurereturns (uint256) {
if (from<= to) revert NotScalingDown(from, to);
return value / (10** (from- to));
}
}
