Contract Name:
InterestRateModelV2Factory
Contract Source Code:
// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.28;
import {Clones} from "openzeppelin5/proxy/Clones.sol";
import {InterestRateModelV2} from "./InterestRateModelV2.sol";
import {IInterestRateModel} from "../interfaces/IInterestRateModel.sol";
import {IInterestRateModelV2} from "../interfaces/IInterestRateModelV2.sol";
import {IInterestRateModelV2Factory} from "../interfaces/IInterestRateModelV2Factory.sol";
import {InterestRateModelV2Config} from "./InterestRateModelV2Config.sol";
/// @title InterestRateModelV2Factory
/// @dev It creates InterestRateModelV2Config.
contract InterestRateModelV2Factory is IInterestRateModelV2Factory {
/// @dev DP is 18 decimal points used for integer calculations
uint256 public constant DP = 1e18;
/// @dev IRM contract implementation address to clone
address public immutable IRM;
/// Config hash is determine by initial configuration, the logic is the same, so config is the only difference
/// that's why we can use it as ID, at the same time we can detect duplicated and save gas by reusing same config
/// multiple times
mapping(bytes32 configHash => IInterestRateModelV2) public irmByConfigHash;
constructor() {
IRM = address(new InterestRateModelV2());
}
/// @inheritdoc IInterestRateModelV2Factory
function create(IInterestRateModelV2.Config calldata _config)
external
virtual
returns (bytes32 configHash, IInterestRateModelV2 irm)
{
configHash = hashConfig(_config);
irm = irmByConfigHash[configHash];
if (address(irm) != address(0)) {
return (configHash, irm);
}
verifyConfig(_config);
address configContract = address(new InterestRateModelV2Config(_config));
irm = IInterestRateModelV2(Clones.clone(IRM));
IInterestRateModel(address(irm)).initialize(configContract);
irmByConfigHash[configHash] = irm;
emit NewInterestRateModelV2(configHash, irm);
}
/// @inheritdoc IInterestRateModelV2Factory
// solhint-disable-next-line code-complexity
function verifyConfig(IInterestRateModelV2.Config calldata _config) public view virtual {
int256 dp = int256(DP);
require(_config.uopt > 0 && _config.uopt < dp, IInterestRateModelV2.InvalidUopt());
require(_config.ucrit > _config.uopt && _config.ucrit < dp, IInterestRateModelV2.InvalidUcrit());
require(_config.ulow > 0 && _config.ulow < _config.uopt, IInterestRateModelV2.InvalidUlow());
require(_config.ki >= 0, IInterestRateModelV2.InvalidKi());
require(_config.kcrit >= 0, IInterestRateModelV2.InvalidKcrit());
require(_config.klow >= 0, IInterestRateModelV2.InvalidKlow());
require(_config.klin >= 0, IInterestRateModelV2.InvalidKlin());
require(_config.beta >= 0, IInterestRateModelV2.InvalidBeta());
require(_config.ri >= 0, IInterestRateModelV2.InvalidRi());
require(_config.Tcrit >= 0, IInterestRateModelV2.InvalidTcrit());
// overflow check
InterestRateModelV2(IRM).configOverflowCheck(_config);
}
/// @inheritdoc IInterestRateModelV2Factory
function hashConfig(IInterestRateModelV2.Config calldata _config)
public
pure
virtual
returns (bytes32 configId)
{
configId = keccak256(abi.encode(_config));
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (proxy/Clones.sol)
pragma solidity ^0.8.20;
import {Errors} from "../utils/Errors.sol";
/**
* @dev https://eips.ethereum.org/EIPS/eip-1167[ERC-1167] is a standard for
* deploying minimal proxy contracts, also known as "clones".
*
* > To simply and cheaply clone contract functionality in an immutable way, this standard specifies
* > a minimal bytecode implementation that delegates all calls to a known, fixed address.
*
* The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`
* (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the
* deterministic method.
*/
library Clones {
/**
* @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.
*
* This function uses the create opcode, which should never revert.
*/
function clone(address implementation) internal returns (address instance) {
return clone(implementation, 0);
}
/**
* @dev Same as {xref-Clones-clone-address-}[clone], but with a `value` parameter to send native currency
* to the new contract.
*
* NOTE: Using a non-zero value at creation will require the contract using this function (e.g. a factory)
* to always have enough balance for new deployments. Consider exposing this function under a payable method.
*/
function clone(address implementation, uint256 value) internal returns (address instance) {
if (address(this).balance < value) {
revert Errors.InsufficientBalance(address(this).balance, value);
}
/// @solidity memory-safe-assembly
assembly {
// Stores the bytecode after address
mstore(0x20, 0x5af43d82803e903d91602b57fd5bf3)
// implementation address
mstore(0x11, implementation)
// Packs the first 3 bytes of the `implementation` address with the bytecode before the address.
mstore(0x00, or(shr(0x88, implementation), 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000))
instance := create(value, 0x09, 0x37)
}
if (instance == address(0)) {
revert Errors.FailedDeployment();
}
}
/**
* @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.
*
* This function uses the create2 opcode and a `salt` to deterministically deploy
* the clone. Using the same `implementation` and `salt` multiple time will revert, since
* the clones cannot be deployed twice at the same address.
*/
function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {
return cloneDeterministic(implementation, salt, 0);
}
/**
* @dev Same as {xref-Clones-cloneDeterministic-address-bytes32-}[cloneDeterministic], but with
* a `value` parameter to send native currency to the new contract.
*
* NOTE: Using a non-zero value at creation will require the contract using this function (e.g. a factory)
* to always have enough balance for new deployments. Consider exposing this function under a payable method.
*/
function cloneDeterministic(
address implementation,
bytes32 salt,
uint256 value
) internal returns (address instance) {
if (address(this).balance < value) {
revert Errors.InsufficientBalance(address(this).balance, value);
}
/// @solidity memory-safe-assembly
assembly {
// Stores the bytecode after address
mstore(0x20, 0x5af43d82803e903d91602b57fd5bf3)
// implementation address
mstore(0x11, implementation)
// Packs the first 3 bytes of the `implementation` address with the bytecode before the address.
mstore(0x00, or(shr(0x88, implementation), 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000))
instance := create2(value, 0x09, 0x37, salt)
}
if (instance == address(0)) {
revert Errors.FailedDeployment();
}
}
/**
* @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.
*/
function predictDeterministicAddress(
address implementation,
bytes32 salt,
address deployer
) internal pure returns (address predicted) {
/// @solidity memory-safe-assembly
assembly {
let ptr := mload(0x40)
mstore(add(ptr, 0x38), deployer)
mstore(add(ptr, 0x24), 0x5af43d82803e903d91602b57fd5bf3ff)
mstore(add(ptr, 0x14), implementation)
mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73)
mstore(add(ptr, 0x58), salt)
mstore(add(ptr, 0x78), keccak256(add(ptr, 0x0c), 0x37))
predicted := keccak256(add(ptr, 0x43), 0x55)
}
}
/**
* @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.
*/
function predictDeterministicAddress(
address implementation,
bytes32 salt
) internal view returns (address predicted) {
return predictDeterministicAddress(implementation, salt, address(this));
}
}
// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.28;
import {SafeCast} from "openzeppelin5/utils/math/SafeCast.sol";
import {PRBMathSD59x18} from "../lib/PRBMathSD59x18.sol";
import {SiloMathLib} from "../lib/SiloMathLib.sol";
import {ISilo} from "../interfaces/ISilo.sol";
import {IInterestRateModel} from "../interfaces/IInterestRateModel.sol";
import {IInterestRateModelV2} from "../interfaces/IInterestRateModelV2.sol";
import {IInterestRateModelV2Config} from "../interfaces/IInterestRateModelV2Config.sol";
// solhint-disable func-name-mixedcase
/// @title InterestRateModelV2
/// @notice This model is for one silo/asset set. So one silo need to have as many IRMs as many assets it holds.
/// @dev Model stores some Silo specific data. If model is replaced, it needs to set proper config after redeployment
/// for seamless service. Please refer to separate litepaper about model for design details.
/// Difference between original `InterestRateModel` is that we made methods to be `virtual` and :
/// if (_config.ki < 0) revert InvalidKi(); --- was ... <= 0
// if (_config.kcrit < 0) revert InvalidKcrit(); --- was ... <= 0
/// @custom:security-contact [email protected]
contract InterestRateModelV2 is IInterestRateModel, IInterestRateModelV2 {
using PRBMathSD59x18 for int256;
using SafeCast for int256;
using SafeCast for uint256;
struct LocalVarsRCur {
int256 T;
int256 u;
int256 DP;
int256 rp;
int256 rlin;
int256 ri;
bool overflow;
}
struct LocalVarsRComp {
int256 T;
int256 slopei;
int256 rp;
int256 slope;
int256 r0;
int256 rlin;
int256 r1;
int256 x;
int256 rlin1;
int256 u;
}
/// @dev DP is 18 decimal points used for integer calculations
uint256 internal constant _DP = 1e18;
/// @dev maximum value of compound interest the model will return
uint256 public constant RCOMP_MAX = (2**16) * 1e18;
/// @dev maximum value of X for which, RCOMP_MAX should be returned. If x > X_MAX => exp(x) > RCOMP_MAX.
/// X_MAX = ln(RCOMP_MAX + 1)
int256 public constant X_MAX = 11090370147631773313;
/// @dev maximum allowed amount for accruedInterest, totalDeposits and totalBorrowedAmount
/// after adding compounded interest. If rcomp cause this values to overflow, rcomp is reduced.
/// 196 bits max allowed for an asset amounts because the multiplication product with
/// decimal points (10^18) should not cause an overflow. 196 < log2(2^256 / 10^18) => ~196.2
/// there is another case, for which we need to limit asset amount, we multiply it by rcomp
/// 2^196 > (max(uitn256) / RCOMP_MAX), so as a limit we need to use: `max(uitn256) / RCOMP_MAX`
uint256 public constant ASSET_DATA_OVERFLOW_LIMIT = type(uint256).max / RCOMP_MAX;
/// @dev Each Silo setup is stored separately in mapping. We will write to this mapping based on the msg.sender.
/// Silo => IInterestRateModelV2.Setup
mapping (address silo => Setup) public getSetup;
/// @dev Config for the model
IInterestRateModelV2Config public irmConfig;
/// @notice Emitted on config init
/// @param config config struct for asset in Silo
event Initialized(address indexed config);
/// @inheritdoc IInterestRateModel
function initialize(address _irmConfig) external virtual {
require(_irmConfig != address(0), AddressZero());
require(address(irmConfig) == address(0), AlreadyInitialized());
irmConfig = IInterestRateModelV2Config(_irmConfig);
emit Initialized(_irmConfig);
}
/// @inheritdoc IInterestRateModel
function getCompoundInterestRateAndUpdate(
uint256 _collateralAssets,
uint256 _debtAssets,
uint256 _interestRateTimestamp
)
external
virtual
override
returns (uint256 rcomp)
{
// assume that caller is Silo
address silo = msg.sender;
Setup storage currentSetup = getSetup[silo];
int256 ri;
int256 Tcrit;
(rcomp, ri, Tcrit) = calculateCompoundInterestRate(
getConfig(silo),
_collateralAssets,
_debtAssets,
_interestRateTimestamp,
block.timestamp
);
currentSetup.initialized = true;
currentSetup.ri = ri > type(int112).max
? type(int112).max
: ri < type(int112).min ? type(int112).min : int112(ri);
currentSetup.Tcrit = Tcrit > type(int112).max
? type(int112).max
: Tcrit < type(int112).min ? type(int112).min : int112(Tcrit);
}
/// @inheritdoc IInterestRateModel
function decimals() external view virtual returns (uint256) {
return 18;
}
/// @inheritdoc IInterestRateModel
function getCompoundInterestRate(address _silo, uint256 _blockTimestamp)
external
view
virtual
override
returns (uint256 rcomp)
{
ISilo.UtilizationData memory data = ISilo(_silo).utilizationData();
(rcomp,,) = calculateCompoundInterestRate(
getConfig(_silo),
data.collateralAssets,
data.debtAssets,
data.interestRateTimestamp,
_blockTimestamp
);
}
/// @inheritdoc IInterestRateModelV2
function overflowDetected(address _silo, uint256 _blockTimestamp)
external
view
virtual
override
returns (bool overflow)
{
ISilo.UtilizationData memory data = ISilo(_silo).utilizationData();
(,,,overflow) = calculateCompoundInterestRateWithOverflowDetection(
getConfig(_silo),
data.collateralAssets,
data.debtAssets,
data.interestRateTimestamp,
_blockTimestamp
);
}
/// @inheritdoc IInterestRateModel
function getCurrentInterestRate(address _silo, uint256 _blockTimestamp)
external
view
virtual
override
returns (uint256 rcur)
{
ISilo.UtilizationData memory data = ISilo(_silo).utilizationData();
rcur = calculateCurrentInterestRate(
getConfig(_silo),
data.collateralAssets,
data.debtAssets,
data.interestRateTimestamp,
_blockTimestamp
);
}
function getConfig(address _silo) public view virtual returns (Config memory fullConfig) {
Setup memory siloSetup = getSetup[_silo];
fullConfig = irmConfig.getConfig();
// if initialized, read ri and Tcrit from storage. Otherwise use config values.
if (siloSetup.initialized) {
fullConfig.ri = siloSetup.ri;
fullConfig.Tcrit = siloSetup.Tcrit;
}
}
/// @inheritdoc IInterestRateModelV2
function calculateCurrentInterestRate(
Config memory _c,
uint256 _totalDeposits,
uint256 _totalBorrowAmount,
uint256 _interestRateTimestamp,
uint256 _blockTimestamp
) public pure virtual returns (uint256 rcur) {
require(_interestRateTimestamp <= _blockTimestamp, InvalidTimestamps());
LocalVarsRCur memory _l = LocalVarsRCur(0,0,0,0,0,0,false); // struct for local vars to avoid "Stack too deep"
(,,,_l.overflow) = calculateCompoundInterestRateWithOverflowDetection(
_c,
_totalDeposits,
_totalBorrowAmount,
_interestRateTimestamp,
_blockTimestamp
);
if (_l.overflow) {
return 0;
}
// There can't be an underflow in the subtraction because of the previous check
unchecked {
// T := t1 - t0 # length of time period in seconds
_l.T = (_blockTimestamp - _interestRateTimestamp).toInt256();
}
_l.u = SiloMathLib.calculateUtilization(_DP, _totalDeposits, _totalBorrowAmount).toInt256();
_l.DP = int256(_DP);
if (_l.u > _c.ucrit) {
// rp := kcrit *(1 + Tcrit + beta *T)*( u0 - ucrit )
_l.rp = _c.kcrit * (_l.DP + _c.Tcrit + _c.beta * _l.T) / _l.DP * (_l.u - _c.ucrit) / _l.DP;
} else {
// rp := min (0, klow * (u0 - ulow ))
_l.rp = _min(0, _c.klow * (_l.u - _c.ulow) / _l.DP);
}
// rlin := klin * u0 # lower bound between t0 and t1
_l.rlin = _c.klin * _l.u / _l.DP;
// ri := max(ri , rlin )
_l.ri = _max(_c.ri, _l.rlin);
// ri := max(ri + ki * (u0 - uopt ) * T, rlin )
_l.ri = _max(_l.ri + _c.ki * (_l.u - _c.uopt) * _l.T / _l.DP, _l.rlin);
// rcur := max (ri + rp , rlin ) # current per second interest rate
rcur = (_max(_l.ri + _l.rp, _l.rlin)).toUint256();
rcur *= 365 days;
return _currentInterestRateCAP(rcur);
}
/// @inheritdoc IInterestRateModelV2
function calculateCompoundInterestRate(
Config memory _c,
uint256 _totalDeposits,
uint256 _totalBorrowAmount,
uint256 _interestRateTimestamp,
uint256 _blockTimestamp
) public pure virtual override returns (
uint256 rcomp,
int256 ri,
int256 Tcrit
) {
(rcomp, ri, Tcrit,) = calculateCompoundInterestRateWithOverflowDetection(
_c,
_totalDeposits,
_totalBorrowAmount,
_interestRateTimestamp,
_blockTimestamp
);
}
/// @inheritdoc IInterestRateModelV2
function calculateCompoundInterestRateWithOverflowDetection( // solhint-disable-line function-max-lines
Config memory _c,
uint256 _totalDeposits,
uint256 _totalBorrowAmount,
uint256 _interestRateTimestamp,
uint256 _blockTimestamp
) public pure virtual returns (
uint256 rcomp,
int256 ri,
int256 Tcrit,
bool overflow
) {
ri = _c.ri;
Tcrit = _c.Tcrit;
// struct for local vars to avoid "Stack too deep"
LocalVarsRComp memory _l = LocalVarsRComp(0,0,0,0,0,0,0,0,0,0);
require(_interestRateTimestamp <= _blockTimestamp, InvalidTimestamps());
// There can't be an underflow in the subtraction because of the previous check
unchecked {
// length of time period in seconds
_l.T = (_blockTimestamp - _interestRateTimestamp).toInt256();
}
int256 decimalPoints = int256(_DP);
_l.u = SiloMathLib.calculateUtilization(_DP, _totalDeposits, _totalBorrowAmount).toInt256();
// slopei := ki * (u0 - uopt )
_l.slopei = _c.ki * (_l.u - _c.uopt) / decimalPoints;
if (_l.u > _c.ucrit) {
// rp := kcrit * (1 + Tcrit) * (u0 - ucrit )
_l.rp = _c.kcrit * (decimalPoints + Tcrit) / decimalPoints * (_l.u - _c.ucrit) / decimalPoints;
// slope := slopei + kcrit * beta * (u0 - ucrit )
_l.slope = _l.slopei + _c.kcrit * _c.beta / decimalPoints * (_l.u - _c.ucrit) / decimalPoints;
// Tcrit := Tcrit + beta * T
Tcrit = Tcrit + _c.beta * _l.T;
} else {
// rp := min (0, klow * (u0 - ulow ))
_l.rp = _min(0, _c.klow * (_l.u - _c.ulow) / decimalPoints);
// slope := slopei
_l.slope = _l.slopei;
// Tcrit := max (0, Tcrit - beta * T)
Tcrit = _max(0, Tcrit - _c.beta * _l.T);
}
// rlin := klin * u0 # lower bound between t0 and t1
_l.rlin = _c.klin * _l.u / decimalPoints;
// ri := max(ri , rlin )
ri = _max(ri , _l.rlin);
// r0 := ri + rp # interest rate at t0 ignoring lower bound
_l.r0 = ri + _l.rp;
// r1 := r0 + slope *T # what interest rate would be at t1 ignoring lower bound
_l.r1 = _l.r0 + _l.slope * _l.T;
// Calculating the compound interest
if (_l.r0 >= _l.rlin && _l.r1 >= _l.rlin) {
// lower bound isn’t activated
// rcomp := exp (( r0 + r1) * T / 2) - 1
_l.x = (_l.r0 + _l.r1) * _l.T / 2;
} else if (_l.r0 < _l.rlin && _l.r1 < _l.rlin) {
// lower bound is active during the whole time
// rcomp := exp( rlin * T) - 1
_l.x = _l.rlin * _l.T;
} else if (_l.r0 >= _l.rlin && _l.r1 < _l.rlin) {
// lower bound is active after some time
// rcomp := exp( rlin *T - (r0 - rlin )^2/ slope /2) - 1
_l.x = _l.rlin * _l.T - (_l.r0 - _l.rlin)**2 / _l.slope / 2;
} else {
// lower bound is active before some time
// rcomp := exp( rlin *T + (r1 - rlin )^2/ slope /2) - 1
_l.x = _l.rlin * _l.T + (_l.r1 - _l.rlin)**2 / _l.slope / 2;
}
// ri := max(ri + slopei * T, rlin )
ri = _max(ri + _l.slopei * _l.T, _l.rlin);
// Checking for the overflow below. In case of the overflow, ri and Tcrit will be set back to zeros. Rcomp is
// calculated to not make an overflow in totalBorrowedAmount, totalDeposits.
(rcomp, overflow) = _calculateRComp(_totalDeposits, _totalBorrowAmount, _l.x);
// if we got a limit for rcomp, we reset Tcrit and Ri model parameters to zeros
// Resetting parameters will make IR drop from 10k%/year to 100% per year and it will start growing again.
// If we don’t reset, we will have to wait ~2 weeks to make IR drop (low utilization ratio required).
// So zeroing parameters is a only hope for a market to get well again, otherwise it will be almost impossible.
bool capApplied;
(rcomp, capApplied) = _compoundInterestRateCAP(rcomp, _l.T.toUint256());
if (overflow || capApplied) {
ri = 0;
Tcrit = 0;
}
}
/// @dev this method is to detect possible overflow in math for provided config in next 50 years
function configOverflowCheck(IInterestRateModelV2.Config calldata _config) external pure virtual {
int256 YEAR = 365 days;
int256 MAX_TIME = 50 * 365 days;
int256 DP = int256(_DP);
int256 rcur_max;
{
int256 Tcrit_max = _config.Tcrit + _config.beta * MAX_TIME;
int256 rp_max = _config.kcrit * (DP + Tcrit_max) / DP * (DP - _config.ucrit) / DP;
int256 rp_min = -_config.klow * _config.ulow / DP;
int256 rlin_max = _config.klin * DP / DP;
int256 ri_max = _max(_config.ri, rlin_max) +_config.ki * (DP - _config.uopt) * MAX_TIME / DP;
int256 ri_min = -_config.ki * _config.uopt * MAX_TIME / DP;
rcur_max = ri_max + rp_max;
int256 rcur_min = ri_min + rp_min;
int256 rcur_ann_max = rcur_max * YEAR;
}
{
int256 slopei_max = _config.ki * (DP - _config.uopt) / DP;
int256 slopei_min = - _config.ki * _config.uopt / DP;
int256 slope_max = slopei_max + _config.kcrit * _config.beta / DP * (DP - _config.ucrit) / DP;
int256 slope_min = slopei_min;
int256 x_max = rcur_max * 2 * MAX_TIME / 2 + (_max(slope_max, -slope_min) * MAX_TIME)**2 / 2;
}
}
/// @dev checks for the overflow in rcomp calculations, accruedInterest, totalDeposits and totalBorrowedAmount.
/// In case of the overflow, rcomp is reduced to make totalDeposits and totalBorrowedAmount <= 2**196.
function _calculateRComp(
uint256 _totalDeposits,
uint256 _totalBorrowAmount,
int256 _x
) internal pure virtual returns (uint256 rcomp, bool overflow) {
int256 rcompSigned;
if (_x >= X_MAX) {
rcomp = RCOMP_MAX;
// overflow, but not return now. It counts as an overflow to reset model parameters,
// but later on we can get overflow worse.
overflow = true;
} else {
rcompSigned = _x.exp() - int256(_DP);
rcomp = rcompSigned > 0 ? rcompSigned.toUint256() : 0;
}
unchecked {
// maxAmount = max(_totalDeposits, _totalBorrowAmount) to see
// if any of this variables overflow in result.
uint256 maxAmount = _totalDeposits > _totalBorrowAmount ? _totalDeposits : _totalBorrowAmount;
if (maxAmount >= ASSET_DATA_OVERFLOW_LIMIT) {
return (0, true);
}
uint256 rcompMulTBA = rcomp * _totalBorrowAmount;
if (rcompMulTBA == 0) {
return (rcomp, overflow);
}
if (
rcompMulTBA / rcomp != _totalBorrowAmount ||
rcompMulTBA / _DP > ASSET_DATA_OVERFLOW_LIMIT - maxAmount
) {
rcomp = (ASSET_DATA_OVERFLOW_LIMIT - maxAmount) * _DP / _totalBorrowAmount;
return (rcomp, true);
}
}
}
/// @dev Returns the largest of two numbers
function _max(int256 a, int256 b) internal pure virtual returns (int256) {
return a > b ? a : b;
}
/// @dev Returns the smallest of two numbers
function _min(int256 a, int256 b) internal pure virtual returns (int256) {
return a < b ? a : b;
}
/// @dev in order to keep methods pure and bee able to deploy easily new caps,
/// that method with hardcoded CAP was created
/// @notice limit for compounding interest rcomp := RCOMP_CAP * _l.T.
/// The limit is simple. Let’s threat our interest rate model as the black box. And for past _l.T time we got
/// a value for rcomp. We need to provide the top limit this value to take into account the limit for current
/// interest. Let’s imagine, if we had maximum allowed interest for _l.T. `RCOMP_CAP * _l.T` will be the value of
/// rcomp in this case, which will serve as the limit.
/// If we got this limit, we should make Tcrit and Ri equal to zero, otherwise there is a low probability of the
/// market going back below the limit.
function _compoundInterestRateCAP(uint256 _rcomp, uint256 _t)
internal
pure
virtual
returns (uint256 updatedRcomp, bool capApplied)
{
// uint256 cap = 10**20 / (365 * 24 * 3600); // this is per-second rate because _l.T is in seconds.
uint256 cap = 3170979198376 * _t;
return _rcomp > cap ? (cap, true) : (_rcomp, false);
}
/// @notice limit for rcur - RCUR_CAP (FE/integrations, does not affect our protocol).
/// This is the limit for current interest rate, we picked 10k% of interest per year. Interest rate model is working
/// as expected before that threshold and simply sets the maximum value in case of limit.
/// 10k% is a really significant threshold, which will mean the death of market in most of cases.
/// Before 10k% interest rate can be good for certain market conditions.
/// We don’t read the current interest rate in our protocol, because we care only about the interest we compounded
/// over the past time since the last update. It is used in UI and other protocols integrations,
/// for example investing strategies.
function _currentInterestRateCAP(uint256 _rcur) internal pure virtual returns (uint256) {
uint256 cap = 1e20; // 10**20; this is 10,000% APR in the 18-decimals format.
return _rcur > cap ? cap : _rcur;
}
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.5.0;
interface IInterestRateModel {
event InterestRateModelError();
/// @dev Sets config address for all Silos that will use this model
/// @param _irmConfig address of IRM config contract
function initialize(address _irmConfig) external;
/// @dev get compound interest rate and update model storage for current block.timestamp
/// @param _collateralAssets total silo collateral assets
/// @param _debtAssets total silo debt assets
/// @param _interestRateTimestamp last IRM timestamp
/// @return rcomp compounded interest rate from last update until now (1e18 == 100%)
function getCompoundInterestRateAndUpdate(
uint256 _collateralAssets,
uint256 _debtAssets,
uint256 _interestRateTimestamp
)
external
returns (uint256 rcomp);
/// @dev get compound interest rate
/// @param _silo address of Silo for which interest rate should be calculated
/// @param _blockTimestamp current block timestamp
/// @return rcomp compounded interest rate from last update until now (1e18 == 100%)
function getCompoundInterestRate(address _silo, uint256 _blockTimestamp)
external
view
returns (uint256 rcomp);
/// @dev get current annual interest rate
/// @param _silo address of Silo for which interest rate should be calculated
/// @param _blockTimestamp current block timestamp
/// @return rcur current annual interest rate (1e18 == 100%)
function getCurrentInterestRate(address _silo, uint256 _blockTimestamp)
external
view
returns (uint256 rcur);
/// @dev returns decimal points used by model
function decimals() external view returns (uint256);
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.5.0;
import {IInterestRateModelV2Config} from "./IInterestRateModelV2Config.sol";
interface IInterestRateModelV2 {
struct Config {
// uopt ∈ (0, 1) – optimal utilization;
int256 uopt;
// ucrit ∈ (uopt, 1) – threshold of large utilization;
int256 ucrit;
// ulow ∈ (0, uopt) – threshold of low utilization
int256 ulow;
// ki > 0 – integrator gain
int256 ki;
// kcrit > 0 – proportional gain for large utilization
int256 kcrit;
// klow ≥ 0 – proportional gain for low utilization
int256 klow;
// klin ≥ 0 – coefficient of the lower linear bound
int256 klin;
// beta ≥ 0 - a scaling factor
int256 beta;
// ri ≥ 0 – initial value of the integrator
int112 ri;
// Tcrit ≥ 0 - initial value of the time during which the utilization exceeds the critical value
int112 Tcrit;
}
struct Setup {
// ri ≥ 0 – the integrator
int112 ri;
// Tcrit ≥ 0 - the time during which the utilization exceeds the critical value
int112 Tcrit;
// flag that informs if setup is initialized
bool initialized;
}
/* solhint-enable */
error AddressZero();
error DeployConfigFirst();
error AlreadyInitialized();
error InvalidBeta();
error InvalidKcrit();
error InvalidKi();
error InvalidKlin();
error InvalidKlow();
error InvalidTcrit();
error InvalidTimestamps();
error InvalidUcrit();
error InvalidUlow();
error InvalidUopt();
error InvalidRi();
/// @dev Get config for given asset in a Silo.
/// @param _silo Silo address for which config should be set
/// @return Config struct for asset in Silo
function getConfig(address _silo) external view returns (Config memory);
/// @notice get the flag to detect rcomp restriction (zero current interest) due to overflow
/// overflow boolean flag to detect rcomp restriction
function overflowDetected(address _silo, uint256 _blockTimestamp)
external
view
returns (bool overflow);
/// @dev pure function that calculates current annual interest rate
/// @param _c configuration object, IInterestRateModel.Config
/// @param _totalBorrowAmount current total borrows for asset
/// @param _totalDeposits current total deposits for asset
/// @param _interestRateTimestamp timestamp of last interest rate update
/// @param _blockTimestamp current block timestamp
/// @return rcur current annual interest rate (1e18 == 100%)
function calculateCurrentInterestRate(
Config calldata _c,
uint256 _totalDeposits,
uint256 _totalBorrowAmount,
uint256 _interestRateTimestamp,
uint256 _blockTimestamp
) external pure returns (uint256 rcur);
/// @dev pure function that calculates interest rate based on raw input data
/// @param _c configuration object, IInterestRateModel.Config
/// @param _totalBorrowAmount current total borrows for asset
/// @param _totalDeposits current total deposits for asset
/// @param _interestRateTimestamp timestamp of last interest rate update
/// @param _blockTimestamp current block timestamp
/// @return rcomp compounded interest rate from last update until now (1e18 == 100%)
/// @return ri current integral part of the rate
/// @return Tcrit time during which the utilization exceeds the critical value
/// @return overflow boolean flag to detect rcomp restriction
function calculateCompoundInterestRateWithOverflowDetection(
Config memory _c,
uint256 _totalDeposits,
uint256 _totalBorrowAmount,
uint256 _interestRateTimestamp,
uint256 _blockTimestamp
)
external
pure
returns (
uint256 rcomp,
int256 ri,
int256 Tcrit,
bool overflow
);
/// @dev pure function that calculates interest rate based on raw input data
/// @param _c configuration object, IInterestRateModel.Config
/// @param _totalBorrowAmount current total borrows for asset
/// @param _totalDeposits current total deposits for asset
/// @param _interestRateTimestamp timestamp of last interest rate update
/// @param _blockTimestamp current block timestamp
/// @return rcomp compounded interest rate from last update until now (1e18 == 100%)
/// @return ri current integral part of the rate
/// @return Tcrit time during which the utilization exceeds the critical value
function calculateCompoundInterestRate(
Config memory _c,
uint256 _totalDeposits,
uint256 _totalBorrowAmount,
uint256 _interestRateTimestamp,
uint256 _blockTimestamp
) external pure returns (uint256 rcomp, int256 ri, int256 Tcrit);
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.5.0;
import {IInterestRateModelV2} from "./IInterestRateModelV2.sol";
interface IInterestRateModelV2Factory {
/// @dev config hash and IRM should be easily accessible directly from oracle contract
event NewInterestRateModelV2(bytes32 indexed configHash, IInterestRateModelV2 indexed irm);
/// @dev verifies config and creates IRM config contract
/// @notice it can be used in separate tx eg config can be prepared before it will be used for Silo creation
/// @param _config IRM configuration
/// @return configHash the hashed config used as a key for IRM contract
/// @return irm deployed (or existing one, depends on the config) contract address
function create(IInterestRateModelV2.Config calldata _config)
external
returns (bytes32 configHash, IInterestRateModelV2 irm);
/// @dev DP is 18 decimal points used for integer calculations
// solhint-disable-next-line func-name-mixedcase
function DP() external view returns (uint256);
/// @dev verifies if config has correct values for a model, throws on invalid `_config`
/// @param _config config that will ve verified
function verifyConfig(IInterestRateModelV2.Config calldata _config) external view;
/// @dev hashes IRM config
/// @param _config IRM config
/// @return configId hash of `_config`
function hashConfig(IInterestRateModelV2.Config calldata _config) external pure returns (bytes32 configId);
}
// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.28;
import {IInterestRateModelV2Config} from "../interfaces/IInterestRateModelV2Config.sol";
import {IInterestRateModelV2} from "../interfaces/IInterestRateModelV2.sol";
/// @title InterestRateModelV2Config
/// @notice Please never deploy config manually, always use factory, because factory does necessary checks.
contract InterestRateModelV2Config is IInterestRateModelV2Config {
// uopt ∈ (0, 1) – optimal utilization;
int256 internal immutable _UOPT;
// ucrit ∈ (uopt, 1) – threshold of large utilization;
int256 internal immutable _UCRIT;
// ulow ∈ (0, uopt) – threshold of low utilization
int256 internal immutable _ULOW;
// ki > 0 – integrator gain
int256 internal immutable _KI;
// kcrit > 0 – proportional gain for large utilization
int256 internal immutable _KCRIT;
// klow ≥ 0 – proportional gain for low utilization
int256 internal immutable _KLOW;
// klin ≥ 0 – coefficient of the lower linear bound
int256 internal immutable _KLIN;
// beta ≥ 0 - a scaling factor
int256 internal immutable _BETA;
// initial value for ri, ri ≥ 0 – initial value of the integrator
int112 internal immutable _RI;
// initial value for Tcrit, Tcrit ≥ 0 - the time during which the utilization exceeds the critical value
int112 internal immutable _TCRIT;
constructor(IInterestRateModelV2.Config memory _config) {
_UOPT = _config.uopt;
_UCRIT = _config.ucrit;
_ULOW = _config.ulow;
_KI = _config.ki;
_KCRIT = _config.kcrit;
_KLOW = _config.klow;
_KLIN = _config.klin;
_BETA = _config.beta;
_RI = _config.ri;
_TCRIT = _config.Tcrit;
}
/// @inheritdoc IInterestRateModelV2Config
function getConfig() external view virtual returns (IInterestRateModelV2.Config memory config) {
config.uopt = _UOPT;
config.ucrit = _UCRIT;
config.ulow = _ULOW;
config.ki = _KI;
config.kcrit = _KCRIT;
config.klow = _KLOW;
config.klin = _KLIN;
config.beta = _BETA;
config.ri = _RI;
config.Tcrit = _TCRIT;
}
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
/**
* @dev Collection of common custom errors used in multiple contracts
*
* IMPORTANT: Backwards compatibility is not guaranteed in future versions of the library.
* It is recommended to avoid relying on the error API for critical functionality.
*/
library Errors {
/**
* @dev The ETH balance of the account is not enough to perform the operation.
*/
error InsufficientBalance(uint256 balance, uint256 needed);
/**
* @dev A call to an address target failed. The target may have reverted.
*/
error FailedCall();
/**
* @dev The deployment failed.
*/
error FailedDeployment();
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SafeCast.sol)
// This file was procedurally generated from scripts/generate/templates/SafeCast.js.
pragma solidity ^0.8.20;
/**
* @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow
* checks.
*
* Downcasting from uint256/int256 in Solidity does not revert on overflow. This can
* easily result in undesired exploitation or bugs, since developers usually
* assume that overflows raise errors. `SafeCast` restores this intuition by
* reverting the transaction when such an operation overflows.
*
* Using this library instead of the unchecked operations eliminates an entire
* class of bugs, so it's recommended to use it always.
*/
library SafeCast {
/**
* @dev Value doesn't fit in an uint of `bits` size.
*/
error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);
/**
* @dev An int value doesn't fit in an uint of `bits` size.
*/
error SafeCastOverflowedIntToUint(int256 value);
/**
* @dev Value doesn't fit in an int of `bits` size.
*/
error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);
/**
* @dev An uint value doesn't fit in an int of `bits` size.
*/
error SafeCastOverflowedUintToInt(uint256 value);
/**
* @dev Returns the downcasted uint248 from uint256, reverting on
* overflow (when the input is greater than largest uint248).
*
* Counterpart to Solidity's `uint248` operator.
*
* Requirements:
*
* - input must fit into 248 bits
*/
function toUint248(uint256 value) internal pure returns (uint248) {
if (value > type(uint248).max) {
revert SafeCastOverflowedUintDowncast(248, value);
}
return uint248(value);
}
/**
* @dev Returns the downcasted uint240 from uint256, reverting on
* overflow (when the input is greater than largest uint240).
*
* Counterpart to Solidity's `uint240` operator.
*
* Requirements:
*
* - input must fit into 240 bits
*/
function toUint240(uint256 value) internal pure returns (uint240) {
if (value > type(uint240).max) {
revert SafeCastOverflowedUintDowncast(240, value);
}
return uint240(value);
}
/**
* @dev Returns the downcasted uint232 from uint256, reverting on
* overflow (when the input is greater than largest uint232).
*
* Counterpart to Solidity's `uint232` operator.
*
* Requirements:
*
* - input must fit into 232 bits
*/
function toUint232(uint256 value) internal pure returns (uint232) {
if (value > type(uint232).max) {
revert SafeCastOverflowedUintDowncast(232, value);
}
return uint232(value);
}
/**
* @dev Returns the downcasted uint224 from uint256, reverting on
* overflow (when the input is greater than largest uint224).
*
* Counterpart to Solidity's `uint224` operator.
*
* Requirements:
*
* - input must fit into 224 bits
*/
function toUint224(uint256 value) internal pure returns (uint224) {
if (value > type(uint224).max) {
revert SafeCastOverflowedUintDowncast(224, value);
}
return uint224(value);
}
/**
* @dev Returns the downcasted uint216 from uint256, reverting on
* overflow (when the input is greater than largest uint216).
*
* Counterpart to Solidity's `uint216` operator.
*
* Requirements:
*
* - input must fit into 216 bits
*/
function toUint216(uint256 value) internal pure returns (uint216) {
if (value > type(uint216).max) {
revert SafeCastOverflowedUintDowncast(216, value);
}
return uint216(value);
}
/**
* @dev Returns the downcasted uint208 from uint256, reverting on
* overflow (when the input is greater than largest uint208).
*
* Counterpart to Solidity's `uint208` operator.
*
* Requirements:
*
* - input must fit into 208 bits
*/
function toUint208(uint256 value) internal pure returns (uint208) {
if (value > type(uint208).max) {
revert SafeCastOverflowedUintDowncast(208, value);
}
return uint208(value);
}
/**
* @dev Returns the downcasted uint200 from uint256, reverting on
* overflow (when the input is greater than largest uint200).
*
* Counterpart to Solidity's `uint200` operator.
*
* Requirements:
*
* - input must fit into 200 bits
*/
function toUint200(uint256 value) internal pure returns (uint200) {
if (value > type(uint200).max) {
revert SafeCastOverflowedUintDowncast(200, value);
}
return uint200(value);
}
/**
* @dev Returns the downcasted uint192 from uint256, reverting on
* overflow (when the input is greater than largest uint192).
*
* Counterpart to Solidity's `uint192` operator.
*
* Requirements:
*
* - input must fit into 192 bits
*/
function toUint192(uint256 value) internal pure returns (uint192) {
if (value > type(uint192).max) {
revert SafeCastOverflowedUintDowncast(192, value);
}
return uint192(value);
}
/**
* @dev Returns the downcasted uint184 from uint256, reverting on
* overflow (when the input is greater than largest uint184).
*
* Counterpart to Solidity's `uint184` operator.
*
* Requirements:
*
* - input must fit into 184 bits
*/
function toUint184(uint256 value) internal pure returns (uint184) {
if (value > type(uint184).max) {
revert SafeCastOverflowedUintDowncast(184, value);
}
return uint184(value);
}
/**
* @dev Returns the downcasted uint176 from uint256, reverting on
* overflow (when the input is greater than largest uint176).
*
* Counterpart to Solidity's `uint176` operator.
*
* Requirements:
*
* - input must fit into 176 bits
*/
function toUint176(uint256 value) internal pure returns (uint176) {
if (value > type(uint176).max) {
revert SafeCastOverflowedUintDowncast(176, value);
}
return uint176(value);
}
/**
* @dev Returns the downcasted uint168 from uint256, reverting on
* overflow (when the input is greater than largest uint168).
*
* Counterpart to Solidity's `uint168` operator.
*
* Requirements:
*
* - input must fit into 168 bits
*/
function toUint168(uint256 value) internal pure returns (uint168) {
if (value > type(uint168).max) {
revert SafeCastOverflowedUintDowncast(168, value);
}
return uint168(value);
}
/**
* @dev Returns the downcasted uint160 from uint256, reverting on
* overflow (when the input is greater than largest uint160).
*
* Counterpart to Solidity's `uint160` operator.
*
* Requirements:
*
* - input must fit into 160 bits
*/
function toUint160(uint256 value) internal pure returns (uint160) {
if (value > type(uint160).max) {
revert SafeCastOverflowedUintDowncast(160, value);
}
return uint160(value);
}
/**
* @dev Returns the downcasted uint152 from uint256, reverting on
* overflow (when the input is greater than largest uint152).
*
* Counterpart to Solidity's `uint152` operator.
*
* Requirements:
*
* - input must fit into 152 bits
*/
function toUint152(uint256 value) internal pure returns (uint152) {
if (value > type(uint152).max) {
revert SafeCastOverflowedUintDowncast(152, value);
}
return uint152(value);
}
/**
* @dev Returns the downcasted uint144 from uint256, reverting on
* overflow (when the input is greater than largest uint144).
*
* Counterpart to Solidity's `uint144` operator.
*
* Requirements:
*
* - input must fit into 144 bits
*/
function toUint144(uint256 value) internal pure returns (uint144) {
if (value > type(uint144).max) {
revert SafeCastOverflowedUintDowncast(144, value);
}
return uint144(value);
}
/**
* @dev Returns the downcasted uint136 from uint256, reverting on
* overflow (when the input is greater than largest uint136).
*
* Counterpart to Solidity's `uint136` operator.
*
* Requirements:
*
* - input must fit into 136 bits
*/
function toUint136(uint256 value) internal pure returns (uint136) {
if (value > type(uint136).max) {
revert SafeCastOverflowedUintDowncast(136, value);
}
return uint136(value);
}
/**
* @dev Returns the downcasted uint128 from uint256, reverting on
* overflow (when the input is greater than largest uint128).
*
* Counterpart to Solidity's `uint128` operator.
*
* Requirements:
*
* - input must fit into 128 bits
*/
function toUint128(uint256 value) internal pure returns (uint128) {
if (value > type(uint128).max) {
revert SafeCastOverflowedUintDowncast(128, value);
}
return uint128(value);
}
/**
* @dev Returns the downcasted uint120 from uint256, reverting on
* overflow (when the input is greater than largest uint120).
*
* Counterpart to Solidity's `uint120` operator.
*
* Requirements:
*
* - input must fit into 120 bits
*/
function toUint120(uint256 value) internal pure returns (uint120) {
if (value > type(uint120).max) {
revert SafeCastOverflowedUintDowncast(120, value);
}
return uint120(value);
}
/**
* @dev Returns the downcasted uint112 from uint256, reverting on
* overflow (when the input is greater than largest uint112).
*
* Counterpart to Solidity's `uint112` operator.
*
* Requirements:
*
* - input must fit into 112 bits
*/
function toUint112(uint256 value) internal pure returns (uint112) {
if (value > type(uint112).max) {
revert SafeCastOverflowedUintDowncast(112, value);
}
return uint112(value);
}
/**
* @dev Returns the downcasted uint104 from uint256, reverting on
* overflow (when the input is greater than largest uint104).
*
* Counterpart to Solidity's `uint104` operator.
*
* Requirements:
*
* - input must fit into 104 bits
*/
function toUint104(uint256 value) internal pure returns (uint104) {
if (value > type(uint104).max) {
revert SafeCastOverflowedUintDowncast(104, value);
}
return uint104(value);
}
/**
* @dev Returns the downcasted uint96 from uint256, reverting on
* overflow (when the input is greater than largest uint96).
*
* Counterpart to Solidity's `uint96` operator.
*
* Requirements:
*
* - input must fit into 96 bits
*/
function toUint96(uint256 value) internal pure returns (uint96) {
if (value > type(uint96).max) {
revert SafeCastOverflowedUintDowncast(96, value);
}
return uint96(value);
}
/**
* @dev Returns the downcasted uint88 from uint256, reverting on
* overflow (when the input is greater than largest uint88).
*
* Counterpart to Solidity's `uint88` operator.
*
* Requirements:
*
* - input must fit into 88 bits
*/
function toUint88(uint256 value) internal pure returns (uint88) {
if (value > type(uint88).max) {
revert SafeCastOverflowedUintDowncast(88, value);
}
return uint88(value);
}
/**
* @dev Returns the downcasted uint80 from uint256, reverting on
* overflow (when the input is greater than largest uint80).
*
* Counterpart to Solidity's `uint80` operator.
*
* Requirements:
*
* - input must fit into 80 bits
*/
function toUint80(uint256 value) internal pure returns (uint80) {
if (value > type(uint80).max) {
revert SafeCastOverflowedUintDowncast(80, value);
}
return uint80(value);
}
/**
* @dev Returns the downcasted uint72 from uint256, reverting on
* overflow (when the input is greater than largest uint72).
*
* Counterpart to Solidity's `uint72` operator.
*
* Requirements:
*
* - input must fit into 72 bits
*/
function toUint72(uint256 value) internal pure returns (uint72) {
if (value > type(uint72).max) {
revert SafeCastOverflowedUintDowncast(72, value);
}
return uint72(value);
}
/**
* @dev Returns the downcasted uint64 from uint256, reverting on
* overflow (when the input is greater than largest uint64).
*
* Counterpart to Solidity's `uint64` operator.
*
* Requirements:
*
* - input must fit into 64 bits
*/
function toUint64(uint256 value) internal pure returns (uint64) {
if (value > type(uint64).max) {
revert SafeCastOverflowedUintDowncast(64, value);
}
return uint64(value);
}
/**
* @dev Returns the downcasted uint56 from uint256, reverting on
* overflow (when the input is greater than largest uint56).
*
* Counterpart to Solidity's `uint56` operator.
*
* Requirements:
*
* - input must fit into 56 bits
*/
function toUint56(uint256 value) internal pure returns (uint56) {
if (value > type(uint56).max) {
revert SafeCastOverflowedUintDowncast(56, value);
}
return uint56(value);
}
/**
* @dev Returns the downcasted uint48 from uint256, reverting on
* overflow (when the input is greater than largest uint48).
*
* Counterpart to Solidity's `uint48` operator.
*
* Requirements:
*
* - input must fit into 48 bits
*/
function toUint48(uint256 value) internal pure returns (uint48) {
if (value > type(uint48).max) {
revert SafeCastOverflowedUintDowncast(48, value);
}
return uint48(value);
}
/**
* @dev Returns the downcasted uint40 from uint256, reverting on
* overflow (when the input is greater than largest uint40).
*
* Counterpart to Solidity's `uint40` operator.
*
* Requirements:
*
* - input must fit into 40 bits
*/
function toUint40(uint256 value) internal pure returns (uint40) {
if (value > type(uint40).max) {
revert SafeCastOverflowedUintDowncast(40, value);
}
return uint40(value);
}
/**
* @dev Returns the downcasted uint32 from uint256, reverting on
* overflow (when the input is greater than largest uint32).
*
* Counterpart to Solidity's `uint32` operator.
*
* Requirements:
*
* - input must fit into 32 bits
*/
function toUint32(uint256 value) internal pure returns (uint32) {
if (value > type(uint32).max) {
revert SafeCastOverflowedUintDowncast(32, value);
}
return uint32(value);
}
/**
* @dev Returns the downcasted uint24 from uint256, reverting on
* overflow (when the input is greater than largest uint24).
*
* Counterpart to Solidity's `uint24` operator.
*
* Requirements:
*
* - input must fit into 24 bits
*/
function toUint24(uint256 value) internal pure returns (uint24) {
if (value > type(uint24).max) {
revert SafeCastOverflowedUintDowncast(24, value);
}
return uint24(value);
}
/**
* @dev Returns the downcasted uint16 from uint256, reverting on
* overflow (when the input is greater than largest uint16).
*
* Counterpart to Solidity's `uint16` operator.
*
* Requirements:
*
* - input must fit into 16 bits
*/
function toUint16(uint256 value) internal pure returns (uint16) {
if (value > type(uint16).max) {
revert SafeCastOverflowedUintDowncast(16, value);
}
return uint16(value);
}
/**
* @dev Returns the downcasted uint8 from uint256, reverting on
* overflow (when the input is greater than largest uint8).
*
* Counterpart to Solidity's `uint8` operator.
*
* Requirements:
*
* - input must fit into 8 bits
*/
function toUint8(uint256 value) internal pure returns (uint8) {
if (value > type(uint8).max) {
revert SafeCastOverflowedUintDowncast(8, value);
}
return uint8(value);
}
/**
* @dev Converts a signed int256 into an unsigned uint256.
*
* Requirements:
*
* - input must be greater than or equal to 0.
*/
function toUint256(int256 value) internal pure returns (uint256) {
if (value < 0) {
revert SafeCastOverflowedIntToUint(value);
}
return uint256(value);
}
/**
* @dev Returns the downcasted int248 from int256, reverting on
* overflow (when the input is less than smallest int248 or
* greater than largest int248).
*
* Counterpart to Solidity's `int248` operator.
*
* Requirements:
*
* - input must fit into 248 bits
*/
function toInt248(int256 value) internal pure returns (int248 downcasted) {
downcasted = int248(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(248, value);
}
}
/**
* @dev Returns the downcasted int240 from int256, reverting on
* overflow (when the input is less than smallest int240 or
* greater than largest int240).
*
* Counterpart to Solidity's `int240` operator.
*
* Requirements:
*
* - input must fit into 240 bits
*/
function toInt240(int256 value) internal pure returns (int240 downcasted) {
downcasted = int240(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(240, value);
}
}
/**
* @dev Returns the downcasted int232 from int256, reverting on
* overflow (when the input is less than smallest int232 or
* greater than largest int232).
*
* Counterpart to Solidity's `int232` operator.
*
* Requirements:
*
* - input must fit into 232 bits
*/
function toInt232(int256 value) internal pure returns (int232 downcasted) {
downcasted = int232(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(232, value);
}
}
/**
* @dev Returns the downcasted int224 from int256, reverting on
* overflow (when the input is less than smallest int224 or
* greater than largest int224).
*
* Counterpart to Solidity's `int224` operator.
*
* Requirements:
*
* - input must fit into 224 bits
*/
function toInt224(int256 value) internal pure returns (int224 downcasted) {
downcasted = int224(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(224, value);
}
}
/**
* @dev Returns the downcasted int216 from int256, reverting on
* overflow (when the input is less than smallest int216 or
* greater than largest int216).
*
* Counterpart to Solidity's `int216` operator.
*
* Requirements:
*
* - input must fit into 216 bits
*/
function toInt216(int256 value) internal pure returns (int216 downcasted) {
downcasted = int216(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(216, value);
}
}
/**
* @dev Returns the downcasted int208 from int256, reverting on
* overflow (when the input is less than smallest int208 or
* greater than largest int208).
*
* Counterpart to Solidity's `int208` operator.
*
* Requirements:
*
* - input must fit into 208 bits
*/
function toInt208(int256 value) internal pure returns (int208 downcasted) {
downcasted = int208(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(208, value);
}
}
/**
* @dev Returns the downcasted int200 from int256, reverting on
* overflow (when the input is less than smallest int200 or
* greater than largest int200).
*
* Counterpart to Solidity's `int200` operator.
*
* Requirements:
*
* - input must fit into 200 bits
*/
function toInt200(int256 value) internal pure returns (int200 downcasted) {
downcasted = int200(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(200, value);
}
}
/**
* @dev Returns the downcasted int192 from int256, reverting on
* overflow (when the input is less than smallest int192 or
* greater than largest int192).
*
* Counterpart to Solidity's `int192` operator.
*
* Requirements:
*
* - input must fit into 192 bits
*/
function toInt192(int256 value) internal pure returns (int192 downcasted) {
downcasted = int192(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(192, value);
}
}
/**
* @dev Returns the downcasted int184 from int256, reverting on
* overflow (when the input is less than smallest int184 or
* greater than largest int184).
*
* Counterpart to Solidity's `int184` operator.
*
* Requirements:
*
* - input must fit into 184 bits
*/
function toInt184(int256 value) internal pure returns (int184 downcasted) {
downcasted = int184(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(184, value);
}
}
/**
* @dev Returns the downcasted int176 from int256, reverting on
* overflow (when the input is less than smallest int176 or
* greater than largest int176).
*
* Counterpart to Solidity's `int176` operator.
*
* Requirements:
*
* - input must fit into 176 bits
*/
function toInt176(int256 value) internal pure returns (int176 downcasted) {
downcasted = int176(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(176, value);
}
}
/**
* @dev Returns the downcasted int168 from int256, reverting on
* overflow (when the input is less than smallest int168 or
* greater than largest int168).
*
* Counterpart to Solidity's `int168` operator.
*
* Requirements:
*
* - input must fit into 168 bits
*/
function toInt168(int256 value) internal pure returns (int168 downcasted) {
downcasted = int168(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(168, value);
}
}
/**
* @dev Returns the downcasted int160 from int256, reverting on
* overflow (when the input is less than smallest int160 or
* greater than largest int160).
*
* Counterpart to Solidity's `int160` operator.
*
* Requirements:
*
* - input must fit into 160 bits
*/
function toInt160(int256 value) internal pure returns (int160 downcasted) {
downcasted = int160(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(160, value);
}
}
/**
* @dev Returns the downcasted int152 from int256, reverting on
* overflow (when the input is less than smallest int152 or
* greater than largest int152).
*
* Counterpart to Solidity's `int152` operator.
*
* Requirements:
*
* - input must fit into 152 bits
*/
function toInt152(int256 value) internal pure returns (int152 downcasted) {
downcasted = int152(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(152, value);
}
}
/**
* @dev Returns the downcasted int144 from int256, reverting on
* overflow (when the input is less than smallest int144 or
* greater than largest int144).
*
* Counterpart to Solidity's `int144` operator.
*
* Requirements:
*
* - input must fit into 144 bits
*/
function toInt144(int256 value) internal pure returns (int144 downcasted) {
downcasted = int144(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(144, value);
}
}
/**
* @dev Returns the downcasted int136 from int256, reverting on
* overflow (when the input is less than smallest int136 or
* greater than largest int136).
*
* Counterpart to Solidity's `int136` operator.
*
* Requirements:
*
* - input must fit into 136 bits
*/
function toInt136(int256 value) internal pure returns (int136 downcasted) {
downcasted = int136(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(136, value);
}
}
/**
* @dev Returns the downcasted int128 from int256, reverting on
* overflow (when the input is less than smallest int128 or
* greater than largest int128).
*
* Counterpart to Solidity's `int128` operator.
*
* Requirements:
*
* - input must fit into 128 bits
*/
function toInt128(int256 value) internal pure returns (int128 downcasted) {
downcasted = int128(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(128, value);
}
}
/**
* @dev Returns the downcasted int120 from int256, reverting on
* overflow (when the input is less than smallest int120 or
* greater than largest int120).
*
* Counterpart to Solidity's `int120` operator.
*
* Requirements:
*
* - input must fit into 120 bits
*/
function toInt120(int256 value) internal pure returns (int120 downcasted) {
downcasted = int120(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(120, value);
}
}
/**
* @dev Returns the downcasted int112 from int256, reverting on
* overflow (when the input is less than smallest int112 or
* greater than largest int112).
*
* Counterpart to Solidity's `int112` operator.
*
* Requirements:
*
* - input must fit into 112 bits
*/
function toInt112(int256 value) internal pure returns (int112 downcasted) {
downcasted = int112(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(112, value);
}
}
/**
* @dev Returns the downcasted int104 from int256, reverting on
* overflow (when the input is less than smallest int104 or
* greater than largest int104).
*
* Counterpart to Solidity's `int104` operator.
*
* Requirements:
*
* - input must fit into 104 bits
*/
function toInt104(int256 value) internal pure returns (int104 downcasted) {
downcasted = int104(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(104, value);
}
}
/**
* @dev Returns the downcasted int96 from int256, reverting on
* overflow (when the input is less than smallest int96 or
* greater than largest int96).
*
* Counterpart to Solidity's `int96` operator.
*
* Requirements:
*
* - input must fit into 96 bits
*/
function toInt96(int256 value) internal pure returns (int96 downcasted) {
downcasted = int96(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(96, value);
}
}
/**
* @dev Returns the downcasted int88 from int256, reverting on
* overflow (when the input is less than smallest int88 or
* greater than largest int88).
*
* Counterpart to Solidity's `int88` operator.
*
* Requirements:
*
* - input must fit into 88 bits
*/
function toInt88(int256 value) internal pure returns (int88 downcasted) {
downcasted = int88(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(88, value);
}
}
/**
* @dev Returns the downcasted int80 from int256, reverting on
* overflow (when the input is less than smallest int80 or
* greater than largest int80).
*
* Counterpart to Solidity's `int80` operator.
*
* Requirements:
*
* - input must fit into 80 bits
*/
function toInt80(int256 value) internal pure returns (int80 downcasted) {
downcasted = int80(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(80, value);
}
}
/**
* @dev Returns the downcasted int72 from int256, reverting on
* overflow (when the input is less than smallest int72 or
* greater than largest int72).
*
* Counterpart to Solidity's `int72` operator.
*
* Requirements:
*
* - input must fit into 72 bits
*/
function toInt72(int256 value) internal pure returns (int72 downcasted) {
downcasted = int72(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(72, value);
}
}
/**
* @dev Returns the downcasted int64 from int256, reverting on
* overflow (when the input is less than smallest int64 or
* greater than largest int64).
*
* Counterpart to Solidity's `int64` operator.
*
* Requirements:
*
* - input must fit into 64 bits
*/
function toInt64(int256 value) internal pure returns (int64 downcasted) {
downcasted = int64(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(64, value);
}
}
/**
* @dev Returns the downcasted int56 from int256, reverting on
* overflow (when the input is less than smallest int56 or
* greater than largest int56).
*
* Counterpart to Solidity's `int56` operator.
*
* Requirements:
*
* - input must fit into 56 bits
*/
function toInt56(int256 value) internal pure returns (int56 downcasted) {
downcasted = int56(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(56, value);
}
}
/**
* @dev Returns the downcasted int48 from int256, reverting on
* overflow (when the input is less than smallest int48 or
* greater than largest int48).
*
* Counterpart to Solidity's `int48` operator.
*
* Requirements:
*
* - input must fit into 48 bits
*/
function toInt48(int256 value) internal pure returns (int48 downcasted) {
downcasted = int48(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(48, value);
}
}
/**
* @dev Returns the downcasted int40 from int256, reverting on
* overflow (when the input is less than smallest int40 or
* greater than largest int40).
*
* Counterpart to Solidity's `int40` operator.
*
* Requirements:
*
* - input must fit into 40 bits
*/
function toInt40(int256 value) internal pure returns (int40 downcasted) {
downcasted = int40(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(40, value);
}
}
/**
* @dev Returns the downcasted int32 from int256, reverting on
* overflow (when the input is less than smallest int32 or
* greater than largest int32).
*
* Counterpart to Solidity's `int32` operator.
*
* Requirements:
*
* - input must fit into 32 bits
*/
function toInt32(int256 value) internal pure returns (int32 downcasted) {
downcasted = int32(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(32, value);
}
}
/**
* @dev Returns the downcasted int24 from int256, reverting on
* overflow (when the input is less than smallest int24 or
* greater than largest int24).
*
* Counterpart to Solidity's `int24` operator.
*
* Requirements:
*
* - input must fit into 24 bits
*/
function toInt24(int256 value) internal pure returns (int24 downcasted) {
downcasted = int24(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(24, value);
}
}
/**
* @dev Returns the downcasted int16 from int256, reverting on
* overflow (when the input is less than smallest int16 or
* greater than largest int16).
*
* Counterpart to Solidity's `int16` operator.
*
* Requirements:
*
* - input must fit into 16 bits
*/
function toInt16(int256 value) internal pure returns (int16 downcasted) {
downcasted = int16(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(16, value);
}
}
/**
* @dev Returns the downcasted int8 from int256, reverting on
* overflow (when the input is less than smallest int8 or
* greater than largest int8).
*
* Counterpart to Solidity's `int8` operator.
*
* Requirements:
*
* - input must fit into 8 bits
*/
function toInt8(int256 value) internal pure returns (int8 downcasted) {
downcasted = int8(value);
if (downcasted != value) {
revert SafeCastOverflowedIntDowncast(8, value);
}
}
/**
* @dev Converts an unsigned uint256 into a signed int256.
*
* Requirements:
*
* - input must be less than or equal to maxInt256.
*/
function toInt256(uint256 value) internal pure returns (int256) {
// Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive
if (value > uint256(type(int256).max)) {
revert SafeCastOverflowedUintToInt(value);
}
return int256(value);
}
/**
* @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.
*/
function toUint(bool b) internal pure returns (uint256 u) {
/// @solidity memory-safe-assembly
assembly {
u := iszero(iszero(b))
}
}
}
// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.28;
import {PRBMathCommon} from "./PRBMathCommon.sol";
/* solhint-disable */
/// @title PRBMathSD59x18
/// @author Paul Razvan Berg
/// @notice Smart contract library for advanced fixed-point math. It works with int256 numbers considered to have 18
/// trailing decimals. We call this number representation signed 59.18-decimal fixed-point, since the numbers can have
/// a sign and there can be up to 59 digits in the integer part and up to 18 decimals in the fractional part. The numbers
/// are bound by the minimum and the maximum values permitted by the Solidity type int256.
library PRBMathSD59x18 {
/// @dev log2(e) as a signed 59.18-decimal fixed-point number.
int256 internal constant _LOG2_E = 1442695040888963407;
/// @dev Half the SCALE number.
int256 internal constant _HALF_SCALE = 5e17;
/// @dev The maximum value a signed 59.18-decimal fixed-point number can have.
int256 internal constant _MAX_SD59x18 = 57896044618658097711785492504343953926634992332820282019728792003956564819967;
/// @dev How many trailing decimals can be represented.
int256 internal constant _SCALE = 1e18;
/// INTERNAL FUNCTIONS ///
/// @notice Calculates the natural exponent of x.
///
/// @dev Based on the insight that e^x = 2^(x * log2(e)).
///
/// Requirements:
/// - All from "log2".
/// - x must be less than 88722839111672999628.
///
/// @param x The exponent as a signed 59.18-decimal fixed-point number.
/// @return result The result as a signed 59.18-decimal fixed-point number.
function exp(int256 x) internal pure returns (int256 result) {
// Without this check, the value passed to "exp2" would be less than -59794705707972522261.
if (x < -41446531673892822322) {
return 0;
}
// Without this check, the value passed to "exp2" would be greater than 128e18.
require(x < 88722839111672999628);
// Do the fixed-point multiplication inline to save gas.
unchecked {
int256 doubleScaleProduct = x * _LOG2_E;
result = exp2((doubleScaleProduct + _HALF_SCALE) / _SCALE);
}
}
/// @notice Calculates the binary exponent of x using the binary fraction method.
///
/// @dev See https://ethereum.stackexchange.com/q/79903/24693.
///
/// Requirements:
/// - x must be 128e18 or less.
/// - The result must fit within MAX_SD59x18.
///
/// Caveats:
/// - For any x less than -59794705707972522261, the result is zero.
///
/// @param x The exponent as a signed 59.18-decimal fixed-point number.
/// @return result The result as a signed 59.18-decimal fixed-point number.
function exp2(int256 x) internal pure returns (int256 result) {
// This works because 2^-x = 1/2^x.
if (x < 0) {
// 2**59.794705707972522262 is the maximum number whose inverse does not equal zero.
if (x < -59794705707972522261) {
return 0;
}
// Do the fixed-point inversion inline to save gas. The numerator is SCALE * SCALE.
unchecked { result = 1e36 / exp2(-x); }
return result;
} else {
// 2**128 doesn't fit within the 128.128-bit fixed-point representation.
require(x < 128e18);
unchecked {
// Convert x to the 128.128-bit fixed-point format.
uint256 x128x128 = (uint256(x) << 128) / uint256(_SCALE);
// Safe to convert the result to int256 directly because the maximum input allowed is 128e18.
result = int256(PRBMathCommon.exp2(x128x128));
}
}
}
}
/* solhint-enable */
// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.28;
import {Math} from "openzeppelin5/utils/math/Math.sol";
import {Rounding} from "../lib/Rounding.sol";
import {ISilo} from "../interfaces/ISilo.sol";
library SiloMathLib {
using Math for uint256;
uint256 internal constant _PRECISION_DECIMALS = 1e18;
uint256 internal constant _DECIMALS_OFFSET = 3;
/// @dev this is constant version of openzeppelin5/contracts/token/ERC20/extensions/ERC4626._decimalsOffset
uint256 internal constant _DECIMALS_OFFSET_POW = 10 ** _DECIMALS_OFFSET;
/// @notice Returns available liquidity to be borrowed
/// @dev Accrued interest is entirely added to `debtAssets` but only part of it is added to `collateralAssets`. The
/// difference is DAO's and deployer's cut. That means DAO's and deployer's cut is not considered a borrowable
/// liquidity.
function liquidity(uint256 _collateralAssets, uint256 _debtAssets) internal pure returns (uint256 liquidAssets) {
unchecked {
// we checked the underflow
liquidAssets = _debtAssets > _collateralAssets ? 0 : _collateralAssets - _debtAssets;
}
}
/// @notice Calculate collateral assets with accrued interest and associated fees
/// @param _collateralAssets The total amount of collateral assets
/// @param _debtAssets The total amount of debt assets
/// @param _rcomp Compound interest rate for debt
/// @param _daoFee The fee (in 18 decimals points) to be taken for the DAO
/// @param _deployerFee The fee (in 18 decimals points) to be taken for the deployer
/// @return collateralAssetsWithInterest The total collateral assets including the accrued interest
/// @return debtAssetsWithInterest The debt assets with accrued interest
/// @return daoAndDeployerRevenue Total fees amount to be split between DAO and deployer
/// @return accruedInterest The total accrued interest
function getCollateralAmountsWithInterest(
uint256 _collateralAssets,
uint256 _debtAssets,
uint256 _rcomp,
uint256 _daoFee,
uint256 _deployerFee
)
internal
pure
returns (
uint256 collateralAssetsWithInterest,
uint256 debtAssetsWithInterest,
uint256 daoAndDeployerRevenue,
uint256 accruedInterest
)
{
(debtAssetsWithInterest, accruedInterest) = getDebtAmountsWithInterest(_debtAssets, _rcomp);
uint256 fees;
// _daoFee and _deployerFee are expected to be less than 1e18, so we will not overflow
unchecked { fees = _daoFee + _deployerFee; }
daoAndDeployerRevenue = mulDivOverflow(accruedInterest, fees, _PRECISION_DECIMALS);
// we will not underflow because daoAndDeployerRevenue is chunk of accruedInterest
uint256 collateralInterest = accruedInterest - daoAndDeployerRevenue;
// save to uncheck because variable can not be more than max
uint256 cap = type(uint256).max - _collateralAssets;
if (cap < collateralInterest) {
// avoid overflow on interest
collateralInterest = cap;
}
// safe to uncheck because of cap
unchecked { collateralAssetsWithInterest = _collateralAssets + collateralInterest; }
}
/// @notice Calculate the debt assets with accrued interest, it should never revert with over/under flow
/// @param _totalDebtAssets The total amount of debt assets before accrued interest
/// @param _rcomp Compound interest rate for the debt in 18 decimal precision
/// @return debtAssetsWithInterest The debt assets including the accrued interest
/// @return accruedInterest The total amount of interest accrued on the debt assets
function getDebtAmountsWithInterest(uint256 _totalDebtAssets, uint256 _rcomp)
internal
pure
returns (uint256 debtAssetsWithInterest, uint256 accruedInterest)
{
if (_totalDebtAssets == 0 || _rcomp == 0) {
return (_totalDebtAssets, 0);
}
accruedInterest = mulDivOverflow(_totalDebtAssets, _rcomp, _PRECISION_DECIMALS);
unchecked {
// We intentionally allow overflow here, to prevent transaction revert due to interest calculation.
debtAssetsWithInterest = _totalDebtAssets + accruedInterest;
// If overflow occurs, we skip accruing interest.
if (debtAssetsWithInterest < _totalDebtAssets) {
debtAssetsWithInterest = _totalDebtAssets;
accruedInterest = 0;
}
}
}
/// @notice Calculates fraction between borrowed and deposited amount of tokens denominated in percentage
/// @dev It assumes `_dp` = 100%.
/// @param _dp decimal points used by model
/// @param _collateralAssets current total deposits for assets
/// @param _debtAssets current total borrows for assets
/// @return utilization value, capped to 100%
/// Limiting utilization ratio by 100% max will allows us to perform better interest rate computations
/// and should not affect any other part of protocol. It is possible to go over 100% only when bad debt.
function calculateUtilization(uint256 _dp, uint256 _collateralAssets, uint256 _debtAssets)
internal
pure
returns (uint256 utilization)
{
if (_collateralAssets == 0 || _debtAssets == 0 || _dp == 0) return 0;
/*
how to prevent overflow on: _debtAssets.mulDiv(_dp, _collateralAssets, Rounding.ACCRUED_INTEREST):
1. max > _debtAssets * _dp / _collateralAssets
2. max / _dp > _debtAssets / _collateralAssets
*/
if (type(uint256).max / _dp > _debtAssets / _collateralAssets) {
utilization = _debtAssets.mulDiv(_dp, _collateralAssets, Rounding.ACCRUED_INTEREST);
// cap at 100%
if (utilization > _dp) utilization = _dp;
} else {
// we have overflow
utilization = _dp;
}
}
function convertToAssetsOrToShares(
uint256 _assets,
uint256 _shares,
uint256 _totalAssets,
uint256 _totalShares,
Math.Rounding _roundingToAssets,
Math.Rounding _roundingToShares,
ISilo.AssetType _assetType
) internal pure returns (uint256 assets, uint256 shares) {
if (_assets == 0) {
require(_shares != 0, ISilo.InputZeroShares());
shares = _shares;
assets = convertToAssets(_shares, _totalAssets, _totalShares, _roundingToAssets, _assetType);
require(assets != 0, ISilo.ReturnZeroAssets());
} else if (_shares == 0) {
shares = convertToShares(_assets, _totalAssets, _totalShares, _roundingToShares, _assetType);
assets = _assets;
require(shares != 0, ISilo.ReturnZeroShares());
} else {
revert ISilo.InputCanBeAssetsOrShares();
}
}
/// @dev Math for collateral is exact copy of
/// openzeppelin5/contracts/token/ERC20/extensions/ERC4626._convertToShares
function convertToShares(
uint256 _assets,
uint256 _totalAssets,
uint256 _totalShares,
Math.Rounding _rounding,
ISilo.AssetType _assetType
) internal pure returns (uint256 shares) {
(uint256 totalShares, uint256 totalAssets) = _commonConvertTo(_totalAssets, _totalShares, _assetType);
// initially, in case of debt, if silo is empty we return shares==assets
// for collateral, this will never be the case, because we are adding `+1` and offset in `_commonConvertTo`
if (totalShares == 0) return _assets;
shares = _assets.mulDiv(totalShares, totalAssets, _rounding);
}
/// @dev Math for collateral is exact copy of
/// openzeppelin5/contracts/token/ERC20/extensions/ERC4626._convertToAssets
function convertToAssets(
uint256 _shares,
uint256 _totalAssets,
uint256 _totalShares,
Math.Rounding _rounding,
ISilo.AssetType _assetType
) internal pure returns (uint256 assets) {
(uint256 totalShares, uint256 totalAssets) = _commonConvertTo(_totalAssets, _totalShares, _assetType);
// initially, in case of debt, if silo is empty we return shares==assets
// for collateral, this will never be the case, because of `+1` in line above
if (totalShares == 0) return _shares;
assets = _shares.mulDiv(totalAssets, totalShares, _rounding);
}
/// @param _collateralMaxLtv maxLTV in 18 decimals that is set for debt asset
/// @param _sumOfBorrowerCollateralValue borrower total collateral value (including protected)
/// @param _borrowerDebtValue total value of borrower debt
/// @return maxBorrowValue max borrow value yet available for borrower
function calculateMaxBorrowValue(
uint256 _collateralMaxLtv,
uint256 _sumOfBorrowerCollateralValue,
uint256 _borrowerDebtValue
) internal pure returns (uint256 maxBorrowValue) {
if (_sumOfBorrowerCollateralValue == 0) {
return 0;
}
uint256 maxDebtValue = _sumOfBorrowerCollateralValue.mulDiv(
_collateralMaxLtv, _PRECISION_DECIMALS, Rounding.MAX_BORROW_VALUE
);
unchecked {
// we will not underflow because we checking `maxDebtValue > _borrowerDebtValue`
maxBorrowValue = maxDebtValue > _borrowerDebtValue ? maxDebtValue - _borrowerDebtValue : 0;
}
}
/// @notice Calculate the maximum assets a borrower can withdraw without breaching the liquidation threshold
/// @param _sumOfCollateralsValue The combined value of collateral and protected assets of the borrower
/// @param _debtValue The total debt value of the borrower
/// @param _lt The liquidation threshold in 18 decimal points
/// @param _borrowerCollateralAssets The borrower's collateral assets before the withdrawal
/// @param _borrowerProtectedAssets The borrower's protected assets before the withdrawal
/// @return maxAssets The maximum assets the borrower can safely withdraw
function calculateMaxAssetsToWithdraw(
uint256 _sumOfCollateralsValue,
uint256 _debtValue,
uint256 _lt,
uint256 _borrowerCollateralAssets,
uint256 _borrowerProtectedAssets
) internal pure returns (uint256 maxAssets) {
if (_sumOfCollateralsValue == 0) return 0;
if (_debtValue == 0) return _sumOfCollateralsValue;
if (_lt == 0) return 0;
// using Rounding.LT (up) to have highest collateralValue that we have to leave for user to stay solvent
uint256 minimumCollateralValue = _debtValue.mulDiv(_PRECISION_DECIMALS, _lt, Rounding.LTV);
// if we over LT, we can not withdraw
if (_sumOfCollateralsValue <= minimumCollateralValue) {
return 0;
}
uint256 spareCollateralValue;
// safe because we checked `if (_sumOfCollateralsValue <= minimumCollateralValue)`
unchecked { spareCollateralValue = _sumOfCollateralsValue - minimumCollateralValue; }
maxAssets = (_borrowerProtectedAssets + _borrowerCollateralAssets)
.mulDiv(spareCollateralValue, _sumOfCollateralsValue, Rounding.MAX_WITHDRAW_TO_ASSETS);
}
/// @notice Determines the maximum number of assets and corresponding shares a borrower can safely withdraw
/// @param _maxAssets The calculated limit on how many assets can be withdrawn without breaching the liquidation
/// threshold
/// @param _borrowerCollateralAssets Amount of collateral assets currently held by the borrower
/// @param _borrowerProtectedAssets Amount of protected assets currently held by the borrower
/// @param _collateralType Specifies whether the asset is of type Collateral or Protected
/// @param _totalAssets The entire quantity of assets available in the system for withdrawal
/// @param _assetTypeShareTokenTotalSupply Total supply of share tokens for the specified asset type
/// @param _liquidity Current liquidity in the system for the asset type
/// @return assets Maximum assets the borrower can withdraw
/// @return shares Corresponding number of shares for the derived `assets` amount
function maxWithdrawToAssetsAndShares(
uint256 _maxAssets,
uint256 _borrowerCollateralAssets,
uint256 _borrowerProtectedAssets,
ISilo.CollateralType _collateralType,
uint256 _totalAssets,
uint256 _assetTypeShareTokenTotalSupply,
uint256 _liquidity
) internal pure returns (uint256 assets, uint256 shares) {
if (_maxAssets == 0) return (0, 0);
if (_assetTypeShareTokenTotalSupply == 0) return (0, 0);
if (_collateralType == ISilo.CollateralType.Collateral) {
assets = _maxAssets > _borrowerCollateralAssets ? _borrowerCollateralAssets : _maxAssets;
if (assets > _liquidity) {
assets = _liquidity;
}
} else {
assets = _maxAssets > _borrowerProtectedAssets ? _borrowerProtectedAssets : _maxAssets;
}
shares = SiloMathLib.convertToShares(
assets,
_totalAssets,
_assetTypeShareTokenTotalSupply,
Rounding.MAX_WITHDRAW_TO_SHARES,
ISilo.AssetType(uint256(_collateralType))
);
}
/// @dev executed `_a * _b / _c`, reverts on _c == 0
/// @return mulDivResult on overflow returns 0
function mulDivOverflow(uint256 _a, uint256 _b, uint256 _c)
internal
pure
returns (uint256 mulDivResult)
{
if (_a == 0) return (0);
unchecked {
// we have to uncheck to detect overflow
mulDivResult = _a * _b;
if (mulDivResult / _a != _b) return 0;
mulDivResult /= _c;
}
}
/// @dev Debt calculations should not lower the result. Debt is a liability so protocol should not take any for
/// itself. It should return actual result and round it up.
function _commonConvertTo(
uint256 _totalAssets,
uint256 _totalShares,
ISilo.AssetType _assetType
) private pure returns (uint256 totalShares, uint256 totalAssets) {
if (_totalShares == 0) {
// silo is empty and we have dust to redistribute: this can only happen when everyone exits silo
// this case can happen only for collateral, because for collateral we rounding in favorite of protocol
// by resetting totalAssets, the dust that we have will go to first depositor and we starts from clean state
_totalAssets = 0;
}
(totalShares, totalAssets) = _assetType == ISilo.AssetType.Debt
? (_totalShares, _totalAssets)
: (_totalShares + _DECIMALS_OFFSET_POW, _totalAssets + 1);
}
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.5.0;
import {IERC4626, IERC20, IERC20Metadata} from "openzeppelin5/interfaces/IERC4626.sol";
import {IERC3156FlashLender} from "./IERC3156FlashLender.sol";
import {ISiloConfig} from "./ISiloConfig.sol";
import {ISiloFactory} from "./ISiloFactory.sol";
import {IHookReceiver} from "./IHookReceiver.sol";
// solhint-disable ordering
interface ISilo is IERC20, IERC4626, IERC3156FlashLender {
/// @dev Interest accrual happens on each deposit/withdraw/borrow/repay. View methods work on storage that might be
/// outdate. Some calculations require accrued interest to return current state of Silo. This struct is used
/// to make a decision inside functions if interest should be accrued in memory to work on updated values.
enum AccrueInterestInMemory {
No,
Yes
}
/// @dev Silo has two separate oracles for solvency and maxLtv calculations. MaxLtv oracle is optional. Solvency
/// oracle can also be optional if asset is used as denominator in Silo config. For example, in ETH/USDC Silo
/// one could setup only solvency oracle for ETH that returns price in USDC. Then USDC does not need an oracle
/// because it's used as denominator for ETH and it's "price" can be assume as 1.
enum OracleType {
Solvency,
MaxLtv
}
/// @dev There are 3 types of accounting in the system: for non-borrowable collateral deposit called "protected",
/// for borrowable collateral deposit called "collateral" and for borrowed tokens called "debt". System does
/// identical calculations for each type of accounting but it uses different data. To avoid code duplication
/// this enum is used to decide which data should be read.
enum AssetType {
Protected, // default
Collateral,
Debt
}
/// @dev There are 2 types of accounting in the system: for non-borrowable collateral deposit called "protected" and
/// for borrowable collateral deposit called "collateral". System does
/// identical calculations for each type of accounting but it uses different data. To avoid code duplication
/// this enum is used to decide which data should be read.
enum CollateralType {
Protected, // default
Collateral
}
/// @dev Types of calls that can be made by the hook receiver on behalf of Silo via `callOnBehalfOfSilo` fn
enum CallType {
Call, // default
Delegatecall
}
/// @param _assets Amount of assets the user wishes to withdraw. Use 0 if shares are provided.
/// @param _shares Shares the user wishes to burn in exchange for the withdrawal. Use 0 if assets are provided.
/// @param _receiver Address receiving the withdrawn assets
/// @param _owner Address of the owner of the shares being burned
/// @param _spender Address executing the withdrawal; may be different than `_owner` if an allowance was set
/// @param _collateralType Type of the asset being withdrawn (Collateral or Protected)
struct WithdrawArgs {
uint256 assets;
uint256 shares;
address receiver;
address owner;
address spender;
ISilo.CollateralType collateralType;
}
/// @param assets Number of assets the borrower intends to borrow. Use 0 if shares are provided.
/// @param shares Number of shares corresponding to the assets that the borrower intends to borrow. Use 0 if
/// assets are provided.
/// @param receiver Address that will receive the borrowed assets
/// @param borrower The user who is borrowing the assets
struct BorrowArgs {
uint256 assets;
uint256 shares;
address receiver;
address borrower;
}
/// @param shares Amount of shares the user wishes to transit.
/// @param owner owner of the shares after transition.
/// @param transitionFrom type of collateral that will be transitioned.
struct TransitionCollateralArgs {
uint256 shares;
address owner;
ISilo.CollateralType transitionFrom;
}
struct UtilizationData {
/// @dev COLLATERAL: Amount of asset token that has been deposited to Silo plus interest earned by depositors.
/// It also includes token amount that has been borrowed.
uint256 collateralAssets;
/// @dev DEBT: Amount of asset token that has been borrowed plus accrued interest.
uint256 debtAssets;
/// @dev timestamp of the last interest accrual
uint64 interestRateTimestamp;
}
struct SiloStorage {
/// @param daoAndDeployerRevenue Current amount of assets (fees) accrued by DAO and Deployer
/// but not yet withdrawn
uint192 daoAndDeployerRevenue;
/// @dev timestamp of the last interest accrual
uint64 interestRateTimestamp;
/// @dev silo is just for one asset,
/// but this one asset can be of three types: mapping key is uint256(AssetType), so we store `assets` by type.
/// Assets based on type:
/// - PROTECTED COLLATERAL: Amount of asset token that has been deposited to Silo that can be ONLY used
/// as collateral. These deposits do NOT earn interest and CANNOT be borrowed.
/// - COLLATERAL: Amount of asset token that has been deposited to Silo plus interest earned by depositors.
/// It also includes token amount that has been borrowed.
/// - DEBT: Amount of asset token that has been borrowed plus accrued interest.
/// `totalAssets` can have outdated value (without interest), if you doing view call (of off-chain call)
/// please use getters eg `getCollateralAssets()` to fetch value that includes interest.
mapping(AssetType assetType => uint256 assets) totalAssets;
}
/// @notice Emitted on protected deposit
/// @param sender wallet address that deposited asset
/// @param owner wallet address that received shares in Silo
/// @param assets amount of asset that was deposited
/// @param shares amount of shares that was minted
event DepositProtected(address indexed sender, address indexed owner, uint256 assets, uint256 shares);
/// @notice Emitted on protected withdraw
/// @param sender wallet address that sent transaction
/// @param receiver wallet address that received asset
/// @param owner wallet address that owned asset
/// @param assets amount of asset that was withdrew
/// @param shares amount of shares that was burn
event WithdrawProtected(
address indexed sender, address indexed receiver, address indexed owner, uint256 assets, uint256 shares
);
/// @notice Emitted on borrow
/// @param sender wallet address that sent transaction
/// @param receiver wallet address that received asset
/// @param owner wallet address that owes assets
/// @param assets amount of asset that was borrowed
/// @param shares amount of shares that was minted
event Borrow(
address indexed sender, address indexed receiver, address indexed owner, uint256 assets, uint256 shares
);
/// @notice Emitted on repayment
/// @param sender wallet address that repaid asset
/// @param owner wallet address that owed asset
/// @param assets amount of asset that was repaid
/// @param shares amount of shares that was burn
event Repay(address indexed sender, address indexed owner, uint256 assets, uint256 shares);
/// @notice emitted only when collateral has been switched to other one
event CollateralTypeChanged(address indexed borrower);
event HooksUpdated(uint24 hooksBefore, uint24 hooksAfter);
event AccruedInterest(uint256 hooksBefore);
event FlashLoan(uint256 amount);
event WithdrawnFeed(uint256 daoFees, uint256 deployerFees);
error Unsupported();
error NothingToWithdraw();
error NotEnoughLiquidity();
error NotSolvent();
error BorrowNotPossible();
error EarnedZero();
error FlashloanFailed();
error AboveMaxLtv();
error SiloInitialized();
error OnlyHookReceiver();
error NoLiquidity();
error InputCanBeAssetsOrShares();
error CollateralSiloAlreadySet();
error RepayTooHigh();
error ZeroAmount();
error InputZeroShares();
error ReturnZeroAssets();
error ReturnZeroShares();
/// @return siloFactory The associated factory of the silo
function factory() external view returns (ISiloFactory siloFactory);
/// @notice Method for HookReceiver only to call on behalf of Silo
/// @param _target address of the contract to call
/// @param _value amount of ETH to send
/// @param _callType type of the call (Call or Delegatecall)
/// @param _input calldata for the call
function callOnBehalfOfSilo(address _target, uint256 _value, CallType _callType, bytes calldata _input)
external
payable
returns (bool success, bytes memory result);
/// @notice Initialize Silo
/// @param _siloConfig address of ISiloConfig with full config for this Silo
function initialize(ISiloConfig _siloConfig) external;
/// @notice Update hooks configuration for Silo
/// @dev This function must be called after the hooks configuration is changed in the hook receiver
function updateHooks() external;
/// @notice Fetches the silo configuration contract
/// @return siloConfig Address of the configuration contract associated with the silo
function config() external view returns (ISiloConfig siloConfig);
/// @notice Fetches the utilization data of the silo used by IRM
function utilizationData() external view returns (UtilizationData memory utilizationData);
/// @notice Fetches the real (available to borrow) liquidity in the silo, it does include interest
/// @return liquidity The amount of liquidity
function getLiquidity() external view returns (uint256 liquidity);
/// @notice Determines if a borrower is solvent
/// @param _borrower Address of the borrower to check for solvency
/// @return True if the borrower is solvent, otherwise false
function isSolvent(address _borrower) external view returns (bool);
/// @notice Retrieves the raw total amount of assets based on provided type (direct storage access)
function getTotalAssetsStorage(AssetType _assetType) external view returns (uint256);
/// @notice Direct storage access to silo storage
/// @dev See struct `SiloStorage` for more details
function getSiloStorage()
external
view
returns (
uint192 daoAndDeployerRevenue,
uint64 interestRateTimestamp,
uint256 protectedAssets,
uint256 collateralAssets,
uint256 debtAssets
);
/// @notice Retrieves the total amount of collateral (borrowable) assets with interest
/// @return totalCollateralAssets The total amount of assets of type 'Collateral'
function getCollateralAssets() external view returns (uint256 totalCollateralAssets);
/// @notice Retrieves the total amount of debt assets with interest
/// @return totalDebtAssets The total amount of assets of type 'Debt'
function getDebtAssets() external view returns (uint256 totalDebtAssets);
/// @notice Retrieves the total amounts of collateral and protected (non-borrowable) assets
/// @return totalCollateralAssets The total amount of assets of type 'Collateral'
/// @return totalProtectedAssets The total amount of protected (non-borrowable) assets
function getCollateralAndProtectedTotalsStorage()
external
view
returns (uint256 totalCollateralAssets, uint256 totalProtectedAssets);
/// @notice Retrieves the total amounts of collateral and debt assets
/// @return totalCollateralAssets The total amount of assets of type 'Collateral'
/// @return totalDebtAssets The total amount of debt assets of type 'Debt'
function getCollateralAndDebtTotalsStorage()
external
view
returns (uint256 totalCollateralAssets, uint256 totalDebtAssets);
/// @notice Implements IERC4626.convertToShares for each asset type
function convertToShares(uint256 _assets, AssetType _assetType) external view returns (uint256 shares);
/// @notice Implements IERC4626.convertToAssets for each asset type
function convertToAssets(uint256 _shares, AssetType _assetType) external view returns (uint256 assets);
/// @notice Implements IERC4626.previewDeposit for protected (non-borrowable) collateral and collateral
/// @dev Reverts for debt asset type
function previewDeposit(uint256 _assets, CollateralType _collateralType) external view returns (uint256 shares);
/// @notice Implements IERC4626.deposit for protected (non-borrowable) collateral and collateral
/// @dev Reverts for debt asset type
function deposit(uint256 _assets, address _receiver, CollateralType _collateralType)
external
returns (uint256 shares);
/// @notice Implements IERC4626.previewMint for protected (non-borrowable) collateral and collateral
/// @dev Reverts for debt asset type
function previewMint(uint256 _shares, CollateralType _collateralType) external view returns (uint256 assets);
/// @notice Implements IERC4626.mint for protected (non-borrowable) collateral and collateral
/// @dev Reverts for debt asset type
function mint(uint256 _shares, address _receiver, CollateralType _collateralType) external returns (uint256 assets);
/// @notice Implements IERC4626.maxWithdraw for protected (non-borrowable) collateral and collateral
/// @dev Reverts for debt asset type
function maxWithdraw(address _owner, CollateralType _collateralType) external view returns (uint256 maxAssets);
/// @notice Implements IERC4626.previewWithdraw for protected (non-borrowable) collateral and collateral
/// @dev Reverts for debt asset type
function previewWithdraw(uint256 _assets, CollateralType _collateralType) external view returns (uint256 shares);
/// @notice Implements IERC4626.withdraw for protected (non-borrowable) collateral and collateral
/// @dev Reverts for debt asset type
function withdraw(uint256 _assets, address _receiver, address _owner, CollateralType _collateralType)
external
returns (uint256 shares);
/// @notice Implements IERC4626.maxRedeem for protected (non-borrowable) collateral and collateral
/// @dev Reverts for debt asset type
function maxRedeem(address _owner, CollateralType _collateralType) external view returns (uint256 maxShares);
/// @notice Implements IERC4626.previewRedeem for protected (non-borrowable) collateral and collateral
/// @dev Reverts for debt asset type
function previewRedeem(uint256 _shares, CollateralType _collateralType) external view returns (uint256 assets);
/// @notice Implements IERC4626.redeem for protected (non-borrowable) collateral and collateral
/// @dev Reverts for debt asset type
function redeem(uint256 _shares, address _receiver, address _owner, CollateralType _collateralType)
external
returns (uint256 assets);
/// @notice Calculates the maximum amount of assets that can be borrowed by the given address
/// @param _borrower Address of the potential borrower
/// @return maxAssets Maximum amount of assets that the borrower can borrow, this value is underestimated
/// That means, in some cases when you borrow maxAssets, you will be able to borrow again eg. up to 2wei
/// Reason for underestimation is to return value that will not cause borrow revert
function maxBorrow(address _borrower) external view returns (uint256 maxAssets);
/// @notice Previews the amount of shares equivalent to the given asset amount for borrowing
/// @param _assets Amount of assets to preview the equivalent shares for
/// @return shares Amount of shares equivalent to the provided asset amount
function previewBorrow(uint256 _assets) external view returns (uint256 shares);
/// @notice Allows an address to borrow a specified amount of assets
/// @param _assets Amount of assets to borrow
/// @param _receiver Address receiving the borrowed assets
/// @param _borrower Address responsible for the borrowed assets
/// @return shares Amount of shares equivalent to the borrowed assets
function borrow(uint256 _assets, address _receiver, address _borrower)
external returns (uint256 shares);
/// @notice Calculates the maximum amount of shares that can be borrowed by the given address
/// @param _borrower Address of the potential borrower
/// @return maxShares Maximum number of shares that the borrower can borrow
function maxBorrowShares(address _borrower) external view returns (uint256 maxShares);
/// @notice Previews the amount of assets equivalent to the given share amount for borrowing
/// @param _shares Amount of shares to preview the equivalent assets for
/// @return assets Amount of assets equivalent to the provided share amount
function previewBorrowShares(uint256 _shares) external view returns (uint256 assets);
/// @notice Calculates the maximum amount of assets that can be borrowed by the given address
/// @param _borrower Address of the potential borrower
/// @return maxAssets Maximum amount of assets that the borrower can borrow, this value is underestimated
/// That means, in some cases when you borrow maxAssets, you will be able to borrow again eg. up to 2wei
/// Reason for underestimation is to return value that will not cause borrow revert
function maxBorrowSameAsset(address _borrower) external view returns (uint256 maxAssets);
/// @notice Allows an address to borrow a specified amount of assets that will be back up with deposit made with the
/// same asset
/// @param _assets Amount of assets to borrow
/// @param _receiver Address receiving the borrowed assets
/// @param _borrower Address responsible for the borrowed assets
/// @return shares Amount of shares equivalent to the borrowed assets
function borrowSameAsset(uint256 _assets, address _receiver, address _borrower)
external returns (uint256 shares);
/// @notice Allows a user to borrow assets based on the provided share amount
/// @param _shares Amount of shares to borrow against
/// @param _receiver Address to receive the borrowed assets
/// @param _borrower Address responsible for the borrowed assets
/// @return assets Amount of assets borrowed
function borrowShares(uint256 _shares, address _receiver, address _borrower)
external
returns (uint256 assets);
/// @notice Calculates the maximum amount an address can repay based on their debt shares
/// @param _borrower Address of the borrower
/// @return assets Maximum amount of assets the borrower can repay
function maxRepay(address _borrower) external view returns (uint256 assets);
/// @notice Provides an estimation of the number of shares equivalent to a given asset amount for repayment
/// @param _assets Amount of assets to be repaid
/// @return shares Estimated number of shares equivalent to the provided asset amount
function previewRepay(uint256 _assets) external view returns (uint256 shares);
/// @notice Repays a given asset amount and returns the equivalent number of shares
/// @param _assets Amount of assets to be repaid
/// @param _borrower Address of the borrower whose debt is being repaid
/// @return shares The equivalent number of shares for the provided asset amount
function repay(uint256 _assets, address _borrower) external returns (uint256 shares);
/// @notice Calculates the maximum number of shares that can be repaid for a given borrower
/// @param _borrower Address of the borrower
/// @return shares The maximum number of shares that can be repaid for the borrower
function maxRepayShares(address _borrower) external view returns (uint256 shares);
/// @notice Provides a preview of the equivalent assets for a given number of shares to repay
/// @param _shares Number of shares to preview repayment for
/// @return assets Equivalent assets for the provided shares
function previewRepayShares(uint256 _shares) external view returns (uint256 assets);
/// @notice Allows a user to repay a loan using shares instead of assets
/// @param _shares The number of shares the borrower wants to repay with
/// @param _borrower The address of the borrower for whom to repay the loan
/// @return assets The equivalent assets amount for the provided shares
function repayShares(uint256 _shares, address _borrower) external returns (uint256 assets);
/// @notice Transitions assets between borrowable (collateral) and non-borrowable (protected) states
/// @dev This function allows assets to move between collateral and protected (non-borrowable) states without
/// leaving the protocol
/// @param _shares Amount of shares to be transitioned
/// @param _owner Owner of the assets being transitioned
/// @param _transitionFrom Specifies if the transition is from collateral or protected assets
/// @return assets Amount of assets transitioned
function transitionCollateral(uint256 _shares, address _owner, CollateralType _transitionFrom)
external
returns (uint256 assets);
/// @notice Switches the collateral silo to this silo
/// @dev Revert if the collateral silo is already set
function switchCollateralToThisSilo() external;
/// @notice Accrues interest for the asset and returns the accrued interest amount
/// @return accruedInterest The total interest accrued during this operation
function accrueInterest() external returns (uint256 accruedInterest);
/// @notice only for SiloConfig
function accrueInterestForConfig(
address _interestRateModel,
uint256 _daoFee,
uint256 _deployerFee
) external;
/// @notice Withdraws earned fees and distributes them to the DAO and deployer fee receivers
function withdrawFees() external;
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.5.0;
import {IInterestRateModelV2} from "./IInterestRateModelV2.sol";
interface IInterestRateModelV2Config {
/// @return config returns immutable IRM configuration that is present in contract
function getConfig() external view returns (IInterestRateModelV2.Config memory config);
}
// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.28;
/* solhint-disable */
/// @dev Common mathematical functions used in both PRBMathSD59x18 and PRBMathUD60x18. Note that this shared library
/// does not always assume the signed 59.18-decimal fixed-point or the unsigned 60.18-decimal fixed-point
// representation. When it does not, it is annotated in the function's NatSpec documentation.
/// @author Paul Razvan Berg
library PRBMathCommon {
/// @dev How many trailing decimals can be represented.
uint256 internal constant _SCALE = 1e18;
/// @notice Calculates the binary exponent of x using the binary fraction method.
/// @dev Uses 128.128-bit fixed-point numbers - it is the most efficient way.
/// @param x The exponent as an unsigned 128.128-bit fixed-point number.
/// @return result The result as an unsigned 60x18 decimal fixed-point number.
function exp2(uint256 x) internal pure returns (uint256 result) {
unchecked {
// Start from 0.5 in the 128.128-bit fixed-point format. We need to use uint256 because the intermediary
// may get very close to 2^256, which doesn't fit in int256.
result = 0x80000000000000000000000000000000;
// Multiply the result by root(2, 2^-i) when the bit at debt i is 1. None of the intermediary results overflows
// because the initial result is 2^127 and all magic factors are less than 2^129.
if (x & 0x80000000000000000000000000000000 > 0) result = (result * 0x16A09E667F3BCC908B2FB1366EA957D3E) >> 128;
if (x & 0x40000000000000000000000000000000 > 0) result = (result * 0x1306FE0A31B7152DE8D5A46305C85EDED) >> 128;
if (x & 0x20000000000000000000000000000000 > 0) result = (result * 0x1172B83C7D517ADCDF7C8C50EB14A7920) >> 128;
if (x & 0x10000000000000000000000000000000 > 0) result = (result * 0x10B5586CF9890F6298B92B71842A98364) >> 128;
if (x & 0x8000000000000000000000000000000 > 0) result = (result * 0x1059B0D31585743AE7C548EB68CA417FE) >> 128;
if (x & 0x4000000000000000000000000000000 > 0) result = (result * 0x102C9A3E778060EE6F7CACA4F7A29BDE9) >> 128;
if (x & 0x2000000000000000000000000000000 > 0) result = (result * 0x10163DA9FB33356D84A66AE336DCDFA40) >> 128;
if (x & 0x1000000000000000000000000000000 > 0) result = (result * 0x100B1AFA5ABCBED6129AB13EC11DC9544) >> 128;
if (x & 0x800000000000000000000000000000 > 0) result = (result * 0x10058C86DA1C09EA1FF19D294CF2F679C) >> 128;
if (x & 0x400000000000000000000000000000 > 0) result = (result * 0x1002C605E2E8CEC506D21BFC89A23A011) >> 128;
if (x & 0x200000000000000000000000000000 > 0) result = (result * 0x100162F3904051FA128BCA9C55C31E5E0) >> 128;
if (x & 0x100000000000000000000000000000 > 0) result = (result * 0x1000B175EFFDC76BA38E31671CA939726) >> 128;
if (x & 0x80000000000000000000000000000 > 0) result = (result * 0x100058BA01FB9F96D6CACD4B180917C3E) >> 128;
if (x & 0x40000000000000000000000000000 > 0) result = (result * 0x10002C5CC37DA9491D0985C348C68E7B4) >> 128;
if (x & 0x20000000000000000000000000000 > 0) result = (result * 0x1000162E525EE054754457D5995292027) >> 128;
if (x & 0x10000000000000000000000000000 > 0) result = (result * 0x10000B17255775C040618BF4A4ADE83FD) >> 128;
if (x & 0x8000000000000000000000000000 > 0) result = (result * 0x1000058B91B5BC9AE2EED81E9B7D4CFAC) >> 128;
if (x & 0x4000000000000000000000000000 > 0) result = (result * 0x100002C5C89D5EC6CA4D7C8ACC017B7CA) >> 128;
if (x & 0x2000000000000000000000000000 > 0) result = (result * 0x10000162E43F4F831060E02D839A9D16D) >> 128;
if (x & 0x1000000000000000000000000000 > 0) result = (result * 0x100000B1721BCFC99D9F890EA06911763) >> 128;
if (x & 0x800000000000000000000000000 > 0) result = (result * 0x10000058B90CF1E6D97F9CA14DBCC1629) >> 128;
if (x & 0x400000000000000000000000000 > 0) result = (result * 0x1000002C5C863B73F016468F6BAC5CA2C) >> 128;
if (x & 0x200000000000000000000000000 > 0) result = (result * 0x100000162E430E5A18F6119E3C02282A6) >> 128;
if (x & 0x100000000000000000000000000 > 0) result = (result * 0x1000000B1721835514B86E6D96EFD1BFF) >> 128;
if (x & 0x80000000000000000000000000 > 0) result = (result * 0x100000058B90C0B48C6BE5DF846C5B2F0) >> 128;
if (x & 0x40000000000000000000000000 > 0) result = (result * 0x10000002C5C8601CC6B9E94213C72737B) >> 128;
if (x & 0x20000000000000000000000000 > 0) result = (result * 0x1000000162E42FFF037DF38AA2B219F07) >> 128;
if (x & 0x10000000000000000000000000 > 0) result = (result * 0x10000000B17217FBA9C739AA5819F44FA) >> 128;
if (x & 0x8000000000000000000000000 > 0) result = (result * 0x1000000058B90BFCDEE5ACD3C1CEDC824) >> 128;
if (x & 0x4000000000000000000000000 > 0) result = (result * 0x100000002C5C85FE31F35A6A30DA1BE51) >> 128;
if (x & 0x2000000000000000000000000 > 0) result = (result * 0x10000000162E42FF0999CE3541B9FFFD0) >> 128;
if (x & 0x1000000000000000000000000 > 0) result = (result * 0x100000000B17217F80F4EF5AADDA45554) >> 128;
if (x & 0x800000000000000000000000 > 0) result = (result * 0x10000000058B90BFBF8479BD5A81B51AE) >> 128;
if (x & 0x400000000000000000000000 > 0) result = (result * 0x1000000002C5C85FDF84BD62AE30A74CD) >> 128;
if (x & 0x200000000000000000000000 > 0) result = (result * 0x100000000162E42FEFB2FED257559BDAA) >> 128;
if (x & 0x100000000000000000000000 > 0) result = (result * 0x1000000000B17217F7D5A7716BBA4A9AF) >> 128;
if (x & 0x80000000000000000000000 > 0) result = (result * 0x100000000058B90BFBE9DDBAC5E109CCF) >> 128;
if (x & 0x40000000000000000000000 > 0) result = (result * 0x10000000002C5C85FDF4B15DE6F17EB0E) >> 128;
if (x & 0x20000000000000000000000 > 0) result = (result * 0x1000000000162E42FEFA494F1478FDE05) >> 128;
if (x & 0x10000000000000000000000 > 0) result = (result * 0x10000000000B17217F7D20CF927C8E94D) >> 128;
if (x & 0x8000000000000000000000 > 0) result = (result * 0x1000000000058B90BFBE8F71CB4E4B33E) >> 128;
if (x & 0x4000000000000000000000 > 0) result = (result * 0x100000000002C5C85FDF477B662B26946) >> 128;
if (x & 0x2000000000000000000000 > 0) result = (result * 0x10000000000162E42FEFA3AE53369388D) >> 128;
if (x & 0x1000000000000000000000 > 0) result = (result * 0x100000000000B17217F7D1D351A389D41) >> 128;
if (x & 0x800000000000000000000 > 0) result = (result * 0x10000000000058B90BFBE8E8B2D3D4EDF) >> 128;
if (x & 0x400000000000000000000 > 0) result = (result * 0x1000000000002C5C85FDF4741BEA6E77F) >> 128;
if (x & 0x200000000000000000000 > 0) result = (result * 0x100000000000162E42FEFA39FE95583C3) >> 128;
if (x & 0x100000000000000000000 > 0) result = (result * 0x1000000000000B17217F7D1CFB72B45E3) >> 128;
if (x & 0x80000000000000000000 > 0) result = (result * 0x100000000000058B90BFBE8E7CC35C3F2) >> 128;
if (x & 0x40000000000000000000 > 0) result = (result * 0x10000000000002C5C85FDF473E242EA39) >> 128;
if (x & 0x20000000000000000000 > 0) result = (result * 0x1000000000000162E42FEFA39F02B772C) >> 128;
if (x & 0x10000000000000000000 > 0) result = (result * 0x10000000000000B17217F7D1CF7D83C1A) >> 128;
if (x & 0x8000000000000000000 > 0) result = (result * 0x1000000000000058B90BFBE8E7BDCBE2E) >> 128;
if (x & 0x4000000000000000000 > 0) result = (result * 0x100000000000002C5C85FDF473DEA871F) >> 128;
if (x & 0x2000000000000000000 > 0) result = (result * 0x10000000000000162E42FEFA39EF44D92) >> 128;
if (x & 0x1000000000000000000 > 0) result = (result * 0x100000000000000B17217F7D1CF79E949) >> 128;
if (x & 0x800000000000000000 > 0) result = (result * 0x10000000000000058B90BFBE8E7BCE545) >> 128;
if (x & 0x400000000000000000 > 0) result = (result * 0x1000000000000002C5C85FDF473DE6ECA) >> 128;
if (x & 0x200000000000000000 > 0) result = (result * 0x100000000000000162E42FEFA39EF366F) >> 128;
if (x & 0x100000000000000000 > 0) result = (result * 0x1000000000000000B17217F7D1CF79AFA) >> 128;
if (x & 0x80000000000000000 > 0) result = (result * 0x100000000000000058B90BFBE8E7BCD6E) >> 128;
if (x & 0x40000000000000000 > 0) result = (result * 0x10000000000000002C5C85FDF473DE6B3) >> 128;
if (x & 0x20000000000000000 > 0) result = (result * 0x1000000000000000162E42FEFA39EF359) >> 128;
if (x & 0x10000000000000000 > 0) result = (result * 0x10000000000000000B17217F7D1CF79AC) >> 128;
// Multiply the result by the integer part 2^n + 1. We have to shift by one bit extra because we have already divided
// by two when we set the result equal to 0.5 above.
result = result << ((x >> 128) + 1);
// Convert the result to the signed 60.18-decimal fixed-point format.
result = PRBMathCommon.mulDiv(result, 1e18, 2**128);
}
}
/// @notice Calculates floor(x*y÷denominator) with full precision.
///
/// @dev Credit to Remco Bloemen under MIT license https://xn--2-umb.com/21/muldiv.
///
/// Requirements:
/// - The denominator cannot be zero.
/// - The result must fit within uint256.
///
/// Caveats:
/// - This function does not work with fixed-point numbers.
///
/// @param x The multiplicand as an uint256.
/// @param y The multiplier as an uint256.
/// @param denominator The divisor as an uint256.
/// @return result The result as an uint256.
function mulDiv(
uint256 x,
uint256 y,
uint256 denominator
) internal pure returns (uint256 result) {
// 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2**256 and mod 2**256 - 1, then use
// use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
// variables such that product = prod1 * 2**256 + prod0.
uint256 prod0; // Least significant 256 bits of the product
uint256 prod1; // Most significant 256 bits of the product
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
// Handle non-overflow cases, 256 by 256 division
if (prod1 == 0) {
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].
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.
unchecked {
// Does not overflow because the denominator cannot be zero at this stage in the function.
uint256 lpotdod = denominator & (~denominator + 1);
assembly {
// Divide denominator by lpotdod.
denominator := div(denominator, lpotdod)
// Divide [prod1 prod0] by lpotdod.
prod0 := div(prod0, lpotdod)
// Flip lpotdod such that it is 2**256 / lpotdod. If lpotdod is zero, then it becomes one.
lpotdod := add(div(sub(0, lpotdod), lpotdod), 1)
}
// Shift in bits from prod1 into prod0.
prod0 |= prod1 * lpotdod;
// 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;
// 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.
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;
}
}
}
/* solhint-enable */
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/Math.sol)
pragma solidity ^0.8.20;
import {Panic} from "../Panic.sol";
import {SafeCast} from "./SafeCast.sol";
/**
* @dev Standard math utilities missing in the Solidity language.
*/
library Math {
enum Rounding {
Floor, // Toward negative infinity
Ceil, // Toward positive infinity
Trunc, // Toward zero
Expand // Away from zero
}
/**
* @dev Returns the addition of two unsigned integers, with an success flag (no overflow).
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
/**
* @dev Returns the subtraction of two unsigned integers, with an success flag (no overflow).
*/
function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
/**
* @dev Returns the multiplication of two unsigned integers, with an success flag (no overflow).
*/
function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
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 success flag (no division by zero).
*/
function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
/**
* @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).
*/
function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
unchecked {
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.
Panic.panic(Panic.DIVISION_BY_ZERO);
}
// The following calculation ensures accurate ceiling division without overflow.
// Since a is non-zero, (a - 1) / b will not overflow.
// The largest possible result occurs when (a - 1) / b is type(uint256).max,
// but the largest value we can obtain is type(uint256).max - 1, which happens
// when a = type(uint256).max and b = 1.
unchecked {
return a == 0 ? 0 : (a - 1) / b + 1;
}
}
/**
* @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or
* denominator == 0.
*
* Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by
* Uniswap Labs also under MIT license.
*/
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
// 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2²⁵⁶ and mod 2²⁵⁶ - 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²⁵⁶ + 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²⁵⁶. Also prevents denominator == 0.
if (denominator <= prod1) {
Panic.panic(denominator == 0 ? Panic.DIVISION_BY_ZERO : Panic.UNDER_OVERFLOW);
}
///////////////////////////////////////////////
// 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²⁵⁶ / 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²⁵⁶. Now that denominator is an odd number, it has an inverse modulo 2²⁵⁶ such
// that denominator * inv ≡ 1 mod 2²⁵⁶. Compute the inverse by starting with a seed that is correct for
// four bits. That is, denominator * inv ≡ 1 mod 2⁴.
uint256 inverse = (3 * denominator) ^ 2;
// Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also
// works in modular arithmetic, doubling the correct bits in each step.
inverse *= 2 - denominator * inverse; // inverse mod 2⁸
inverse *= 2 - denominator * inverse; // inverse mod 2¹⁶
inverse *= 2 - denominator * inverse; // inverse mod 2³²
inverse *= 2 - denominator * inverse; // inverse mod 2⁶⁴
inverse *= 2 - denominator * inverse; // inverse mod 2¹²⁸
inverse *= 2 - denominator * inverse; // inverse mod 2²⁵⁶
// Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
// This will give us the correct result modulo 2²⁵⁶. Since the preconditions guarantee that the outcome is
// less than 2²⁵⁶, this is the final result. We don't need to compute the high bits of the result and prod1
// is no longer required.
result = prod0 * inverse;
return result;
}
}
/**
* @dev Calculates x * y / denominator with full precision, following the selected rounding direction.
*/
function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);
}
/**
* @dev Calculate the modular multiplicative inverse of a number in Z/nZ.
*
* If n is a prime, then Z/nZ is a field. In that case all elements are inversible, expect 0.
* If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.
*
* If the input value is not inversible, 0 is returned.
*
* NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Ferma's little theorem and get the
* inverse using `Math.modExp(a, n - 2, n)`.
*/
function invMod(uint256 a, uint256 n) internal pure returns (uint256) {
unchecked {
if (n == 0) return 0;
// The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)
// Used to compute integers x and y such that: ax + ny = gcd(a, n).
// When the gcd is 1, then the inverse of a modulo n exists and it's x.
// ax + ny = 1
// ax = 1 + (-y)n
// ax ≡ 1 (mod n) # x is the inverse of a modulo n
// If the remainder is 0 the gcd is n right away.
uint256 remainder = a % n;
uint256 gcd = n;
// Therefore the initial coefficients are:
// ax + ny = gcd(a, n) = n
// 0a + 1n = n
int256 x = 0;
int256 y = 1;
while (remainder != 0) {
uint256 quotient = gcd / remainder;
(gcd, remainder) = (
// The old remainder is the next gcd to try.
remainder,
// Compute the next remainder.
// Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd
// where gcd is at most n (capped to type(uint256).max)
gcd - remainder * quotient
);
(x, y) = (
// Increment the coefficient of a.
y,
// Decrement the coefficient of n.
// Can overflow, but the result is casted to uint256 so that the
// next value of y is "wrapped around" to a value between 0 and n - 1.
x - y * int256(quotient)
);
}
if (gcd != 1) return 0; // No inverse exists.
return x < 0 ? (n - uint256(-x)) : uint256(x); // Wrap the result if it's negative.
}
}
/**
* @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)
*
* Requirements:
* - modulus can't be zero
* - underlying staticcall to precompile must succeed
*
* IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make
* sure the chain you're using it on supports the precompiled contract for modular exponentiation
* at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,
* the underlying function will succeed given the lack of a revert, but the result may be incorrectly
* interpreted as 0.
*/
function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {
(bool success, uint256 result) = tryModExp(b, e, m);
if (!success) {
Panic.panic(Panic.DIVISION_BY_ZERO);
}
return result;
}
/**
* @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).
* It includes a success flag indicating if the operation succeeded. Operation will be marked has failed if trying
* to operate modulo 0 or if the underlying precompile reverted.
*
* IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain
* you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in
* https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack
* of a revert, but the result may be incorrectly interpreted as 0.
*/
function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {
if (m == 0) return (false, 0);
/// @solidity memory-safe-assembly
assembly {
let ptr := mload(0x40)
// | Offset | Content | Content (Hex) |
// |-----------|------------|--------------------------------------------------------------------|
// | 0x00:0x1f | size of b | 0x0000000000000000000000000000000000000000000000000000000000000020 |
// | 0x20:0x3f | size of e | 0x0000000000000000000000000000000000000000000000000000000000000020 |
// | 0x40:0x5f | size of m | 0x0000000000000000000000000000000000000000000000000000000000000020 |
// | 0x60:0x7f | value of b | 0x<.............................................................b> |
// | 0x80:0x9f | value of e | 0x<.............................................................e> |
// | 0xa0:0xbf | value of m | 0x<.............................................................m> |
mstore(ptr, 0x20)
mstore(add(ptr, 0x20), 0x20)
mstore(add(ptr, 0x40), 0x20)
mstore(add(ptr, 0x60), b)
mstore(add(ptr, 0x80), e)
mstore(add(ptr, 0xa0), m)
// Given the result < m, it's guaranteed to fit in 32 bytes,
// so we can use the memory scratch space located at offset 0.
success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)
result := mload(0x00)
}
}
/**
* @dev Variant of {modExp} that supports inputs of arbitrary length.
*/
function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {
(bool success, bytes memory result) = tryModExp(b, e, m);
if (!success) {
Panic.panic(Panic.DIVISION_BY_ZERO);
}
return result;
}
/**
* @dev Variant of {tryModExp} that supports inputs of arbitrary length.
*/
function tryModExp(
bytes memory b,
bytes memory e,
bytes memory m
) internal view returns (bool success, bytes memory result) {
if (_zeroBytes(m)) return (false, new bytes(0));
uint256 mLen = m.length;
// Encode call args in result and move the free memory pointer
result = abi.encodePacked(b.length, e.length, mLen, b, e, m);
/// @solidity memory-safe-assembly
assembly {
let dataPtr := add(result, 0x20)
// Write result on top of args to avoid allocating extra memory.
success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)
// Overwrite the length.
// result.length > returndatasize() is guaranteed because returndatasize() == m.length
mstore(result, mLen)
// Set the memory pointer after the returned data.
mstore(0x40, add(dataPtr, mLen))
}
}
/**
* @dev Returns whether the provided byte array is zero.
*/
function _zeroBytes(bytes memory byteArray) private pure returns (bool) {
for (uint256 i = 0; i < byteArray.length; ++i) {
if (byteArray[i] != 0) {
return false;
}
}
return true;
}
/**
* @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded
* towards zero.
*
* This method is based on Newton's method for computing square roots; the algorithm is restricted to only
* using integer operations.
*/
function sqrt(uint256 a) internal pure returns (uint256) {
unchecked {
// Take care of easy edge cases when a == 0 or a == 1
if (a <= 1) {
return a;
}
// In this function, we use Newton's method to get a root of `f(x) := x² - a`. It involves building a
// sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between
// the current value as `ε_n = | x_n - sqrt(a) |`.
//
// For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root
// of the target. (i.e. `2**(e-1) ≤ sqrt(a) < 2**e`). We know that `e ≤ 128` because `(2¹²⁸)² = 2²⁵⁶` is
// bigger than any uint256.
//
// By noticing that
// `2**(e-1) ≤ sqrt(a) < 2**e → (2**(e-1))² ≤ a < (2**e)² → 2**(2*e-2) ≤ a < 2**(2*e)`
// we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar
// to the msb function.
uint256 aa = a;
uint256 xn = 1;
if (aa >= (1 << 128)) {
aa >>= 128;
xn <<= 64;
}
if (aa >= (1 << 64)) {
aa >>= 64;
xn <<= 32;
}
if (aa >= (1 << 32)) {
aa >>= 32;
xn <<= 16;
}
if (aa >= (1 << 16)) {
aa >>= 16;
xn <<= 8;
}
if (aa >= (1 << 8)) {
aa >>= 8;
xn <<= 4;
}
if (aa >= (1 << 4)) {
aa >>= 4;
xn <<= 2;
}
if (aa >= (1 << 2)) {
xn <<= 1;
}
// We now have x_n such that `x_n = 2**(e-1) ≤ sqrt(a) < 2**e = 2 * x_n`. This implies ε_n ≤ 2**(e-1).
//
// We can refine our estimation by noticing that the middle of that interval minimizes the error.
// If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to ε_n ≤ 2**(e-2).
// This is going to be our x_0 (and ε_0)
xn = (3 * xn) >> 1; // ε_0 := | x_0 - sqrt(a) | ≤ 2**(e-2)
// From here, Newton's method give us:
// x_{n+1} = (x_n + a / x_n) / 2
//
// One should note that:
// x_{n+1}² - a = ((x_n + a / x_n) / 2)² - a
// = ((x_n² + a) / (2 * x_n))² - a
// = (x_n⁴ + 2 * a * x_n² + a²) / (4 * x_n²) - a
// = (x_n⁴ + 2 * a * x_n² + a² - 4 * a * x_n²) / (4 * x_n²)
// = (x_n⁴ - 2 * a * x_n² + a²) / (4 * x_n²)
// = (x_n² - a)² / (2 * x_n)²
// = ((x_n² - a) / (2 * x_n))²
// ≥ 0
// Which proves that for all n ≥ 1, sqrt(a) ≤ x_n
//
// This gives us the proof of quadratic convergence of the sequence:
// ε_{n+1} = | x_{n+1} - sqrt(a) |
// = | (x_n + a / x_n) / 2 - sqrt(a) |
// = | (x_n² + a - 2*x_n*sqrt(a)) / (2 * x_n) |
// = | (x_n - sqrt(a))² / (2 * x_n) |
// = | ε_n² / (2 * x_n) |
// = ε_n² / | (2 * x_n) |
//
// For the first iteration, we have a special case where x_0 is known:
// ε_1 = ε_0² / | (2 * x_0) |
// ≤ (2**(e-2))² / (2 * (2**(e-1) + 2**(e-2)))
// ≤ 2**(2*e-4) / (3 * 2**(e-1))
// ≤ 2**(e-3) / 3
// ≤ 2**(e-3-log2(3))
// ≤ 2**(e-4.5)
//
// For the following iterations, we use the fact that, 2**(e-1) ≤ sqrt(a) ≤ x_n:
// ε_{n+1} = ε_n² / | (2 * x_n) |
// ≤ (2**(e-k))² / (2 * 2**(e-1))
// ≤ 2**(2*e-2*k) / 2**e
// ≤ 2**(e-2*k)
xn = (xn + a / xn) >> 1; // ε_1 := | x_1 - sqrt(a) | ≤ 2**(e-4.5) -- special case, see above
xn = (xn + a / xn) >> 1; // ε_2 := | x_2 - sqrt(a) | ≤ 2**(e-9) -- general case with k = 4.5
xn = (xn + a / xn) >> 1; // ε_3 := | x_3 - sqrt(a) | ≤ 2**(e-18) -- general case with k = 9
xn = (xn + a / xn) >> 1; // ε_4 := | x_4 - sqrt(a) | ≤ 2**(e-36) -- general case with k = 18
xn = (xn + a / xn) >> 1; // ε_5 := | x_5 - sqrt(a) | ≤ 2**(e-72) -- general case with k = 36
xn = (xn + a / xn) >> 1; // ε_6 := | x_6 - sqrt(a) | ≤ 2**(e-144) -- general case with k = 72
// Because e ≤ 128 (as discussed during the first estimation phase), we know have reached a precision
// ε_6 ≤ 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either
// sqrt(a) or sqrt(a) + 1.
return xn - SafeCast.toUint(xn > a / xn);
}
}
/**
* @dev Calculates sqrt(a), following the selected rounding direction.
*/
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);
}
}
/**
* @dev Return the log in base 2 of a positive value rounded towards zero.
* Returns 0 if given 0.
*/
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
uint256 exp;
unchecked {
exp = 128 * SafeCast.toUint(value > (1 << 128) - 1);
value >>= exp;
result += exp;
exp = 64 * SafeCast.toUint(value > (1 << 64) - 1);
value >>= exp;
result += exp;
exp = 32 * SafeCast.toUint(value > (1 << 32) - 1);
value >>= exp;
result += exp;
exp = 16 * SafeCast.toUint(value > (1 << 16) - 1);
value >>= exp;
result += exp;
exp = 8 * SafeCast.toUint(value > (1 << 8) - 1);
value >>= exp;
result += exp;
exp = 4 * SafeCast.toUint(value > (1 << 4) - 1);
value >>= exp;
result += exp;
exp = 2 * SafeCast.toUint(value > (1 << 2) - 1);
value >>= exp;
result += exp;
result += SafeCast.toUint(value > 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 + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);
}
}
/**
* @dev Return the log in base 10 of a positive value rounded towards zero.
* Returns 0 if given 0.
*/
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10 ** 64) {
value /= 10 ** 64;
result += 64;
}
if (value >= 10 ** 32) {
value /= 10 ** 32;
result += 32;
}
if (value >= 10 ** 16) {
value /= 10 ** 16;
result += 16;
}
if (value >= 10 ** 8) {
value /= 10 ** 8;
result += 8;
}
if (value >= 10 ** 4) {
value /= 10 ** 4;
result += 4;
}
if (value >= 10 ** 2) {
value /= 10 ** 2;
result += 2;
}
if (value >= 10 ** 1) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 10, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);
}
}
/**
* @dev Return the log in base 256 of a positive value rounded towards zero.
* Returns 0 if given 0.
*
* Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
*/
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
uint256 isGt;
unchecked {
isGt = SafeCast.toUint(value > (1 << 128) - 1);
value >>= isGt * 128;
result += isGt * 16;
isGt = SafeCast.toUint(value > (1 << 64) - 1);
value >>= isGt * 64;
result += isGt * 8;
isGt = SafeCast.toUint(value > (1 << 32) - 1);
value >>= isGt * 32;
result += isGt * 4;
isGt = SafeCast.toUint(value > (1 << 16) - 1);
value >>= isGt * 16;
result += isGt * 2;
result += SafeCast.toUint(value > (1 << 8) - 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 + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);
}
}
/**
* @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
*/
function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
return uint8(rounding) % 2 == 1;
}
}
// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.28;
import {Math} from "openzeppelin5/utils/math/Math.sol";
// solhint-disable private-vars-leading-underscore
library Rounding {
Math.Rounding internal constant UP = (Math.Rounding.Ceil);
Math.Rounding internal constant DOWN = (Math.Rounding.Floor);
Math.Rounding internal constant DEBT_TO_ASSETS = (Math.Rounding.Ceil);
// COLLATERAL_TO_ASSETS is used to calculate borrower collateral (so we want to round down)
Math.Rounding internal constant COLLATERAL_TO_ASSETS = (Math.Rounding.Floor);
// why DEPOSIT_TO_ASSETS is Up if COLLATERAL_TO_ASSETS is Down?
// DEPOSIT_TO_ASSETS is used for preview deposit and deposit, based on provided shares we want to pull "more" tokens
// so we rounding up, "token flow" is in different direction than for COLLATERAL_TO_ASSETS, that's why
// different rounding policy
Math.Rounding internal constant DEPOSIT_TO_ASSETS = (Math.Rounding.Ceil);
Math.Rounding internal constant DEPOSIT_TO_SHARES = (Math.Rounding.Floor);
Math.Rounding internal constant BORROW_TO_ASSETS = (Math.Rounding.Floor);
Math.Rounding internal constant BORROW_TO_SHARES = (Math.Rounding.Ceil);
Math.Rounding internal constant MAX_BORROW_TO_ASSETS = (Math.Rounding.Floor);
Math.Rounding internal constant MAX_BORROW_TO_SHARES = (Math.Rounding.Floor);
Math.Rounding internal constant MAX_BORROW_VALUE = (Math.Rounding.Floor);
Math.Rounding internal constant REPAY_TO_ASSETS = (Math.Rounding.Ceil);
Math.Rounding internal constant REPAY_TO_SHARES = (Math.Rounding.Floor);
Math.Rounding internal constant MAX_REPAY_TO_ASSETS = (Math.Rounding.Ceil);
Math.Rounding internal constant WITHDRAW_TO_ASSETS = (Math.Rounding.Floor);
Math.Rounding internal constant WITHDRAW_TO_SHARES = (Math.Rounding.Ceil);
Math.Rounding internal constant MAX_WITHDRAW_TO_ASSETS = (Math.Rounding.Floor);
Math.Rounding internal constant MAX_WITHDRAW_TO_SHARES = (Math.Rounding.Floor);
Math.Rounding internal constant LIQUIDATE_TO_SHARES = (Math.Rounding.Floor);
Math.Rounding internal constant LTV = (Math.Rounding.Ceil);
Math.Rounding internal constant ACCRUED_INTEREST = (Math.Rounding.Floor);
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC4626.sol)
pragma solidity ^0.8.20;
import {IERC20} from "../token/ERC20/IERC20.sol";
import {IERC20Metadata} from "../token/ERC20/extensions/IERC20Metadata.sol";
/**
* @dev Interface of the ERC-4626 "Tokenized Vault Standard", as defined in
* https://eips.ethereum.org/EIPS/eip-4626[ERC-4626].
*/
interface IERC4626 is IERC20, IERC20Metadata {
event Deposit(address indexed sender, address indexed owner, uint256 assets, uint256 shares);
event Withdraw(
address indexed sender,
address indexed receiver,
address indexed owner,
uint256 assets,
uint256 shares
);
/**
* @dev Returns the address of the underlying token used for the Vault for accounting, depositing, and withdrawing.
*
* - MUST be an ERC-20 token contract.
* - MUST NOT revert.
*/
function asset() external view returns (address assetTokenAddress);
/**
* @dev Returns the total amount of the underlying asset that is “managed” by Vault.
*
* - SHOULD include any compounding that occurs from yield.
* - MUST be inclusive of any fees that are charged against assets in the Vault.
* - MUST NOT revert.
*/
function totalAssets() external view returns (uint256 totalManagedAssets);
/**
* @dev Returns the amount of shares that the Vault would exchange for the amount of assets provided, in an ideal
* scenario where all the conditions are met.
*
* - MUST NOT be inclusive of any fees that are charged against assets in the Vault.
* - MUST NOT show any variations depending on the caller.
* - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.
* - MUST NOT revert.
*
* NOTE: This calculation MAY NOT reflect the “per-user” price-per-share, and instead should reflect the
* “average-user’s” price-per-share, meaning what the average user should expect to see when exchanging to and
* from.
*/
function convertToShares(uint256 assets) external view returns (uint256 shares);
/**
* @dev Returns the amount of assets that the Vault would exchange for the amount of shares provided, in an ideal
* scenario where all the conditions are met.
*
* - MUST NOT be inclusive of any fees that are charged against assets in the Vault.
* - MUST NOT show any variations depending on the caller.
* - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.
* - MUST NOT revert.
*
* NOTE: This calculation MAY NOT reflect the “per-user” price-per-share, and instead should reflect the
* “average-user’s” price-per-share, meaning what the average user should expect to see when exchanging to and
* from.
*/
function convertToAssets(uint256 shares) external view returns (uint256 assets);
/**
* @dev Returns the maximum amount of the underlying asset that can be deposited into the Vault for the receiver,
* through a deposit call.
*
* - MUST return a limited value if receiver is subject to some deposit limit.
* - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of assets that may be deposited.
* - MUST NOT revert.
*/
function maxDeposit(address receiver) external view returns (uint256 maxAssets);
/**
* @dev Allows an on-chain or off-chain user to simulate the effects of their deposit at the current block, given
* current on-chain conditions.
*
* - MUST return as close to and no more than the exact amount of Vault shares that would be minted in a deposit
* call in the same transaction. I.e. deposit should return the same or more shares as previewDeposit if called
* in the same transaction.
* - MUST NOT account for deposit limits like those returned from maxDeposit and should always act as though the
* deposit would be accepted, regardless if the user has enough tokens approved, etc.
* - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.
* - MUST NOT revert.
*
* NOTE: any unfavorable discrepancy between convertToShares and previewDeposit SHOULD be considered slippage in
* share price or some other type of condition, meaning the depositor will lose assets by depositing.
*/
function previewDeposit(uint256 assets) external view returns (uint256 shares);
/**
* @dev Mints shares Vault shares to receiver by depositing exactly amount of underlying tokens.
*
* - MUST emit the Deposit event.
* - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the
* deposit execution, and are accounted for during deposit.
* - MUST revert if all of assets cannot be deposited (due to deposit limit being reached, slippage, the user not
* approving enough underlying tokens to the Vault contract, etc).
*
* NOTE: most implementations will require pre-approval of the Vault with the Vault’s underlying asset token.
*/
function deposit(uint256 assets, address receiver) external returns (uint256 shares);
/**
* @dev Returns the maximum amount of the Vault shares that can be minted for the receiver, through a mint call.
* - MUST return a limited value if receiver is subject to some mint limit.
* - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of shares that may be minted.
* - MUST NOT revert.
*/
function maxMint(address receiver) external view returns (uint256 maxShares);
/**
* @dev Allows an on-chain or off-chain user to simulate the effects of their mint at the current block, given
* current on-chain conditions.
*
* - MUST return as close to and no fewer than the exact amount of assets that would be deposited in a mint call
* in the same transaction. I.e. mint should return the same or fewer assets as previewMint if called in the
* same transaction.
* - MUST NOT account for mint limits like those returned from maxMint and should always act as though the mint
* would be accepted, regardless if the user has enough tokens approved, etc.
* - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.
* - MUST NOT revert.
*
* NOTE: any unfavorable discrepancy between convertToAssets and previewMint SHOULD be considered slippage in
* share price or some other type of condition, meaning the depositor will lose assets by minting.
*/
function previewMint(uint256 shares) external view returns (uint256 assets);
/**
* @dev Mints exactly shares Vault shares to receiver by depositing amount of underlying tokens.
*
* - MUST emit the Deposit event.
* - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the mint
* execution, and are accounted for during mint.
* - MUST revert if all of shares cannot be minted (due to deposit limit being reached, slippage, the user not
* approving enough underlying tokens to the Vault contract, etc).
*
* NOTE: most implementations will require pre-approval of the Vault with the Vault’s underlying asset token.
*/
function mint(uint256 shares, address receiver) external returns (uint256 assets);
/**
* @dev Returns the maximum amount of the underlying asset that can be withdrawn from the owner balance in the
* Vault, through a withdraw call.
*
* - MUST return a limited value if owner is subject to some withdrawal limit or timelock.
* - MUST NOT revert.
*/
function maxWithdraw(address owner) external view returns (uint256 maxAssets);
/**
* @dev Allows an on-chain or off-chain user to simulate the effects of their withdrawal at the current block,
* given current on-chain conditions.
*
* - MUST return as close to and no fewer than the exact amount of Vault shares that would be burned in a withdraw
* call in the same transaction. I.e. withdraw should return the same or fewer shares as previewWithdraw if
* called
* in the same transaction.
* - MUST NOT account for withdrawal limits like those returned from maxWithdraw and should always act as though
* the withdrawal would be accepted, regardless if the user has enough shares, etc.
* - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.
* - MUST NOT revert.
*
* NOTE: any unfavorable discrepancy between convertToShares and previewWithdraw SHOULD be considered slippage in
* share price or some other type of condition, meaning the depositor will lose assets by depositing.
*/
function previewWithdraw(uint256 assets) external view returns (uint256 shares);
/**
* @dev Burns shares from owner and sends exactly assets of underlying tokens to receiver.
*
* - MUST emit the Withdraw event.
* - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the
* withdraw execution, and are accounted for during withdraw.
* - MUST revert if all of assets cannot be withdrawn (due to withdrawal limit being reached, slippage, the owner
* not having enough shares, etc).
*
* Note that some implementations will require pre-requesting to the Vault before a withdrawal may be performed.
* Those methods should be performed separately.
*/
function withdraw(uint256 assets, address receiver, address owner) external returns (uint256 shares);
/**
* @dev Returns the maximum amount of Vault shares that can be redeemed from the owner balance in the Vault,
* through a redeem call.
*
* - MUST return a limited value if owner is subject to some withdrawal limit or timelock.
* - MUST return balanceOf(owner) if owner is not subject to any withdrawal limit or timelock.
* - MUST NOT revert.
*/
function maxRedeem(address owner) external view returns (uint256 maxShares);
/**
* @dev Allows an on-chain or off-chain user to simulate the effects of their redeemption at the current block,
* given current on-chain conditions.
*
* - MUST return as close to and no more than the exact amount of assets that would be withdrawn in a redeem call
* in the same transaction. I.e. redeem should return the same or more assets as previewRedeem if called in the
* same transaction.
* - MUST NOT account for redemption limits like those returned from maxRedeem and should always act as though the
* redemption would be accepted, regardless if the user has enough shares, etc.
* - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.
* - MUST NOT revert.
*
* NOTE: any unfavorable discrepancy between convertToAssets and previewRedeem SHOULD be considered slippage in
* share price or some other type of condition, meaning the depositor will lose assets by redeeming.
*/
function previewRedeem(uint256 shares) external view returns (uint256 assets);
/**
* @dev Burns exactly shares from owner and sends assets of underlying tokens to receiver.
*
* - MUST emit the Withdraw event.
* - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the
* redeem execution, and are accounted for during redeem.
* - MUST revert if all of shares cannot be redeemed (due to withdrawal limit being reached, slippage, the owner
* not having enough shares, etc).
*
* NOTE: some implementations will require pre-requesting to the Vault before a withdrawal may be performed.
* Those methods should be performed separately.
*/
function redeem(uint256 shares, address receiver, address owner) external returns (uint256 assets);
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.5.0;
import {IERC3156FlashBorrower} from "./IERC3156FlashBorrower.sol";
/// @notice https://eips.ethereum.org/EIPS/eip-3156
interface IERC3156FlashLender {
/// @notice Protected deposits are not available for a flash loan.
/// During the execution of the flashloan, Silo methods are not taking into consideration the fact,
/// that some (or all) tokens were transferred as flashloan, therefore some methods can return invalid state
/// eg. maxWithdraw can return amount that are not available to withdraw during flashlon.
/// @dev Initiate a flash loan.
/// @param _receiver The receiver of the tokens in the loan, and the receiver of the callback.
/// @param _token The loan currency.
/// @param _amount The amount of tokens lent.
/// @param _data Arbitrary data structure, intended to contain user-defined parameters.
function flashLoan(IERC3156FlashBorrower _receiver, address _token, uint256 _amount, bytes calldata _data)
external
returns (bool);
/// @dev The amount of currency available to be lent.
/// @param _token The loan currency.
/// @return The amount of `token` that can be borrowed.
function maxFlashLoan(address _token) external view returns (uint256);
/// @dev The fee to be charged for a given loan.
/// @param _token The loan currency.
/// @param _amount The amount of tokens lent.
/// @return The amount of `token` to be charged for the loan, on top of the returned principal.
function flashFee(address _token, uint256 _amount) external view returns (uint256);
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.5.0;
import {ISilo} from "./ISilo.sol";
import {ICrossReentrancyGuard} from "./ICrossReentrancyGuard.sol";
interface ISiloConfig is ICrossReentrancyGuard {
struct InitData {
/// @notice Can be address zero if deployer fees are not to be collected. If deployer address is zero then
/// deployer fee must be zero as well. Deployer will be minted an NFT that gives the right to claim deployer
/// fees. NFT can be transferred with the right to claim.
address deployer;
/// @notice Address of the hook receiver called on every before/after action on Silo. Hook contract also
/// implements liquidation logic and veSilo gauge connection.
address hookReceiver;
/// @notice Deployer's fee in 18 decimals points. Deployer will earn this fee based on the interest earned
/// by the Silo. Max deployer fee is set by the DAO. At deployment it is 15%.
uint256 deployerFee;
/// @notice DAO's fee in 18 decimals points. DAO will earn this fee based on the interest earned
/// by the Silo. Acceptable fee range fee is set by the DAO. Default at deployment is 5% - 50%.
uint256 daoFee;
/// @notice Address of the first token
address token0;
/// @notice Address of the solvency oracle. Solvency oracle is used to calculate LTV when deciding if borrower
/// is solvent or should be liquidated. Solvency oracle is optional and if not set price of 1 will be assumed.
address solvencyOracle0;
/// @notice Address of the maxLtv oracle. Max LTV oracle is used to calculate LTV when deciding if borrower
/// can borrow given amount of assets. Max LTV oracle is optional and if not set it defaults to solvency
/// oracle. If neither is set price of 1 will be assumed.
address maxLtvOracle0;
/// @notice Address of the interest rate model
address interestRateModel0;
/// @notice Maximum LTV for first token. maxLTV is in 18 decimals points and is used to determine, if borrower
/// can borrow given amount of assets. MaxLtv is in 18 decimals points. MaxLtv must be lower or equal to LT.
uint256 maxLtv0;
/// @notice Liquidation threshold for first token. LT is used to calculate solvency. LT is in 18 decimals
/// points. LT must not be lower than maxLTV.
uint256 lt0;
/// @notice minimal acceptable LTV after liquidation, in 18 decimals points
uint256 liquidationTargetLtv0;
/// @notice Liquidation fee for the first token in 18 decimals points. Liquidation fee is what liquidator earns
/// for repaying insolvent loan.
uint256 liquidationFee0;
/// @notice Flashloan fee sets the cost of taking a flashloan in 18 decimals points
uint256 flashloanFee0;
/// @notice Indicates if a beforeQuote on oracle contract should be called before quoting price
bool callBeforeQuote0;
/// @notice Address of the second token
address token1;
/// @notice Address of the solvency oracle. Solvency oracle is used to calculate LTV when deciding if borrower
/// is solvent or should be liquidated. Solvency oracle is optional and if not set price of 1 will be assumed.
address solvencyOracle1;
/// @notice Address of the maxLtv oracle. Max LTV oracle is used to calculate LTV when deciding if borrower
/// can borrow given amount of assets. Max LTV oracle is optional and if not set it defaults to solvency
/// oracle. If neither is set price of 1 will be assumed.
address maxLtvOracle1;
/// @notice Address of the interest rate model
address interestRateModel1;
/// @notice Maximum LTV for first token. maxLTV is in 18 decimals points and is used to determine,
/// if borrower can borrow given amount of assets. maxLtv is in 18 decimals points
uint256 maxLtv1;
/// @notice Liquidation threshold for first token. LT is used to calculate solvency. LT is in 18 decimals points
uint256 lt1;
/// @notice minimal acceptable LTV after liquidation, in 18 decimals points
uint256 liquidationTargetLtv1;
/// @notice Liquidation fee is what liquidator earns for repaying insolvent loan.
uint256 liquidationFee1;
/// @notice Flashloan fee sets the cost of taking a flashloan in 18 decimals points
uint256 flashloanFee1;
/// @notice Indicates if a beforeQuote on oracle contract should be called before quoting price
bool callBeforeQuote1;
}
struct ConfigData {
uint256 daoFee;
uint256 deployerFee;
address silo;
address token;
address protectedShareToken;
address collateralShareToken;
address debtShareToken;
address solvencyOracle;
address maxLtvOracle;
address interestRateModel;
uint256 maxLtv;
uint256 lt;
uint256 liquidationTargetLtv;
uint256 liquidationFee;
uint256 flashloanFee;
address hookReceiver;
bool callBeforeQuote;
}
struct DepositConfig {
address silo;
address token;
address collateralShareToken;
address protectedShareToken;
uint256 daoFee;
uint256 deployerFee;
address interestRateModel;
}
error OnlySilo();
error OnlySiloOrTokenOrHookReceiver();
error WrongSilo();
error OnlyDebtShareToken();
error DebtExistInOtherSilo();
error FeeTooHigh();
/// @dev It should be called on debt transfer (debt share token transfer).
/// In the case if the`_recipient` doesn't have configured a collateral silo,
/// it will be set to the collateral silo of the `_sender`.
/// @param _sender sender address
/// @param _recipient recipient address
function onDebtTransfer(address _sender, address _recipient) external;
/// @notice Set collateral silo.
/// @dev Revert if msg.sender is not a SILO_0 or SILO_1.
/// @dev Always set collateral silo the same as msg.sender.
/// @param _borrower borrower address
function setThisSiloAsCollateralSilo(address _borrower) external;
/// @notice Set collateral silo
/// @dev Revert if msg.sender is not a SILO_0 or SILO_1.
/// @dev Always set collateral silo opposite to the msg.sender.
/// @param _borrower borrower address
function setOtherSiloAsCollateralSilo(address _borrower) external;
/// @notice Accrue interest for the silo
/// @param _silo silo for which accrue interest
function accrueInterestForSilo(address _silo) external;
/// @notice Accrue interest for both silos (SILO_0 and SILO_1 in a config)
function accrueInterestForBothSilos() external;
/// @notice Retrieves the collateral silo for a specific borrower.
/// @dev As a user can deposit into `Silo0` and `Silo1`, this property specifies which Silo
/// will be used as collateral for the debt. Later on, it will be used for max LTV and solvency checks.
/// After being set, the collateral silo is never set to `address(0)` again but such getters as
/// `getConfigsForSolvency`, `getConfigsForBorrow`, `getConfigsForWithdraw` will return empty
/// collateral silo config if borrower doesn't have debt.
///
/// In the SiloConfig collateral silo is set by the following functions:
/// `onDebtTransfer` - only if the recipient doesn't have collateral silo set (inherits it from the sender)
/// This function is called on debt share token transfer (debt transfer).
/// `setThisSiloAsCollateralSilo` - sets the same silo as the one that calls the function.
/// `setOtherSiloAsCollateralSilo` - sets the opposite silo as collateral from the one that calls the function.
///
/// In the Silo collateral silo is set by the following functions:
/// `borrow` - always sets opposite silo as collateral.
/// If Silo0 borrows, then Silo1 will be collateral and vice versa.
/// `borrowSameAsset` - always sets the same silo as collateral.
/// `switchCollateralToThisSilo` - always sets the same silo as collateral.
/// @param _borrower The address of the borrower for which the collateral silo is being retrieved
/// @return collateralSilo The address of the collateral silo for the specified borrower
function borrowerCollateralSilo(address _borrower) external view returns (address collateralSilo);
/// @notice Retrieves the silo ID
/// @dev Each silo is assigned a unique ID. ERC-721 token is minted with identical ID to deployer.
/// An owner of that token receives the deployer fees.
/// @return siloId The ID of the silo
function SILO_ID() external view returns (uint256 siloId); // solhint-disable-line func-name-mixedcase
/// @notice Retrieves the addresses of the two silos
/// @return silo0 The address of the first silo
/// @return silo1 The address of the second silo
function getSilos() external view returns (address silo0, address silo1);
/// @notice Retrieves the asset associated with a specific silo
/// @dev This function reverts for incorrect silo address input
/// @param _silo The address of the silo for which the associated asset is being retrieved
/// @return asset The address of the asset associated with the specified silo
function getAssetForSilo(address _silo) external view returns (address asset);
/// @notice Verifies if the borrower has debt in other silo by checking the debt share token balance
/// @param _thisSilo The address of the silo in respect of which the debt is checked
/// @param _borrower The address of the borrower for which the debt is checked
/// @return hasDebt true if the borrower has debt in other silo
function hasDebtInOtherSilo(address _thisSilo, address _borrower) external view returns (bool hasDebt);
/// @notice Retrieves the debt silo associated with a specific borrower
/// @dev This function reverts if debt present in two silo (should not happen)
/// @param _borrower The address of the borrower for which the debt silo is being retrieved
function getDebtSilo(address _borrower) external view returns (address debtSilo);
/// @notice Retrieves configuration data for both silos. First config is for the silo that is asking for configs.
/// @param borrower borrower address for which debtConfig will be returned
/// @return collateralConfig The configuration data for collateral silo (empty if there is no debt).
/// @return debtConfig The configuration data for debt silo (empty if there is no debt).
function getConfigsForSolvency(address borrower)
external
view
returns (ConfigData memory collateralConfig, ConfigData memory debtConfig);
/// @notice Retrieves configuration data for a specific silo
/// @dev This function reverts for incorrect silo address input.
/// @param _silo The address of the silo for which configuration data is being retrieved
/// @return config The configuration data for the specified silo
function getConfig(address _silo) external view returns (ConfigData memory config);
/// @notice Retrieves configuration data for a specific silo for withdraw fn.
/// @dev This function reverts for incorrect silo address input.
/// @param _silo The address of the silo for which configuration data is being retrieved
/// @return depositConfig The configuration data for the specified silo (always config for `_silo`)
/// @return collateralConfig The configuration data for the collateral silo (empty if there is no debt)
/// @return debtConfig The configuration data for the debt silo (empty if there is no debt)
function getConfigsForWithdraw(address _silo, address _borrower) external view returns (
DepositConfig memory depositConfig,
ConfigData memory collateralConfig,
ConfigData memory debtConfig
);
/// @notice Retrieves configuration data for a specific silo for borrow fn.
/// @dev This function reverts for incorrect silo address input.
/// @param _debtSilo The address of the silo for which configuration data is being retrieved
/// @return collateralConfig The configuration data for the collateral silo (always other than `_debtSilo`)
/// @return debtConfig The configuration data for the debt silo (always config for `_debtSilo`)
function getConfigsForBorrow(address _debtSilo)
external
view
returns (ConfigData memory collateralConfig, ConfigData memory debtConfig);
/// @notice Retrieves fee-related information for a specific silo
/// @dev This function reverts for incorrect silo address input
/// @param _silo The address of the silo for which fee-related information is being retrieved.
/// @return daoFee The DAO fee percentage in 18 decimals points.
/// @return deployerFee The deployer fee percentage in 18 decimals points.
/// @return flashloanFee The flashloan fee percentage in 18 decimals points.
/// @return asset The address of the asset associated with the specified silo.
function getFeesWithAsset(address _silo)
external
view
returns (uint256 daoFee, uint256 deployerFee, uint256 flashloanFee, address asset);
/// @notice Retrieves share tokens associated with a specific silo
/// @dev This function reverts for incorrect silo address input
/// @param _silo The address of the silo for which share tokens are being retrieved
/// @return protectedShareToken The address of the protected (non-borrowable) share token
/// @return collateralShareToken The address of the collateral share token
/// @return debtShareToken The address of the debt share token
function getShareTokens(address _silo)
external
view
returns (address protectedShareToken, address collateralShareToken, address debtShareToken);
/// @notice Retrieves the share token and the silo token associated with a specific silo
/// @param _silo The address of the silo for which the share token and silo token are being retrieved
/// @param _collateralType The type of collateral
/// @return shareToken The address of the share token (collateral or protected collateral)
/// @return asset The address of the silo token
function getCollateralShareTokenAndAsset(address _silo, ISilo.CollateralType _collateralType)
external
view
returns (address shareToken, address asset);
/// @notice Retrieves the share token and the silo token associated with a specific silo
/// @param _silo The address of the silo for which the share token and silo token are being retrieved
/// @return shareToken The address of the share token (debt)
/// @return asset The address of the silo token
function getDebtShareTokenAndAsset(address _silo)
external
view
returns (address shareToken, address asset);
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.5.0;
import {IERC721} from "openzeppelin5/interfaces/IERC721.sol";
import {ISiloConfig} from "./ISiloConfig.sol";
interface ISiloFactory is IERC721 {
struct Range {
uint128 min;
uint128 max;
}
/// @notice Emitted on the creation of a Silo.
/// @param implementation Address of the Silo implementation.
/// @param token0 Address of the first Silo token.
/// @param token1 Address of the second Silo token.
/// @param silo0 Address of the first Silo.
/// @param silo1 Address of the second Silo.
/// @param siloConfig Address of the SiloConfig.
event NewSilo(
address indexed implementation,
address indexed token0,
address indexed token1,
address silo0,
address silo1,
address siloConfig
);
event BaseURI(string newBaseURI);
/// @notice Emitted on the update of DAO fee.
/// @param minDaoFee Value of the new minimal DAO fee.
/// @param maxDaoFee Value of the new maximal DAO fee.
event DaoFeeChanged(uint128 minDaoFee, uint128 maxDaoFee);
/// @notice Emitted on the update of max deployer fee.
/// @param maxDeployerFee Value of the new max deployer fee.
event MaxDeployerFeeChanged(uint256 maxDeployerFee);
/// @notice Emitted on the update of max flashloan fee.
/// @param maxFlashloanFee Value of the new max flashloan fee.
event MaxFlashloanFeeChanged(uint256 maxFlashloanFee);
/// @notice Emitted on the update of max liquidation fee.
/// @param maxLiquidationFee Value of the new max liquidation fee.
event MaxLiquidationFeeChanged(uint256 maxLiquidationFee);
/// @notice Emitted on the change of DAO fee receiver.
/// @param daoFeeReceiver Address of the new DAO fee receiver.
event DaoFeeReceiverChanged(address daoFeeReceiver);
error MissingHookReceiver();
error ZeroAddress();
error DaoFeeReceiverZeroAddress();
error EmptyToken0();
error EmptyToken1();
error MaxFeeExceeded();
error InvalidFeeRange();
error SameAsset();
error SameRange();
error InvalidIrm();
error InvalidMaxLtv();
error InvalidLt();
error InvalidDeployer();
error DaoMinRangeExceeded();
error DaoMaxRangeExceeded();
error MaxDeployerFeeExceeded();
error MaxFlashloanFeeExceeded();
error MaxLiquidationFeeExceeded();
error InvalidCallBeforeQuote();
error OracleMisconfiguration();
error InvalidQuoteToken();
error HookIsZeroAddress();
error LiquidationTargetLtvTooHigh();
/// @notice Create a new Silo.
/// @param _initData Silo initialization data.
/// @param _siloConfig Silo configuration.
/// @param _siloImpl Address of the `Silo` implementation.
/// @param _shareProtectedCollateralTokenImpl Address of the `ShareProtectedCollateralToken` implementation.
/// @param _shareDebtTokenImpl Address of the `ShareDebtToken` implementation.
function createSilo(
ISiloConfig.InitData memory _initData,
ISiloConfig _siloConfig,
address _siloImpl,
address _shareProtectedCollateralTokenImpl,
address _shareDebtTokenImpl
)
external;
/// @notice NFT ownership represents the deployer fee receiver for the each Silo ID. After burning,
/// the deployer fee is sent to the DAO. Burning doesn't affect Silo's behavior. It is only about fee distribution.
/// @param _siloIdToBurn silo ID to burn.
function burn(uint256 _siloIdToBurn) external;
/// @notice Update the value of DAO fee. Updated value will be used only for a new Silos.
/// Previously deployed SiloConfigs are immutable.
/// @param _minFee Value of the new DAO minimal fee.
/// @param _maxFee Value of the new DAO maximal fee.
function setDaoFee(uint128 _minFee, uint128 _maxFee) external;
/// @notice Set the new DAO fee receiver.
/// @param _newDaoFeeReceiver Address of the new DAO fee receiver.
function setDaoFeeReceiver(address _newDaoFeeReceiver) external;
/// @notice Update the value of max deployer fee. Updated value will be used only for a new Silos max deployer
/// fee validation. Previously deployed SiloConfigs are immutable.
/// @param _newMaxDeployerFee Value of the new max deployer fee.
function setMaxDeployerFee(uint256 _newMaxDeployerFee) external;
/// @notice Update the value of max flashloan fee. Updated value will be used only for a new Silos max flashloan
/// fee validation. Previously deployed SiloConfigs are immutable.
/// @param _newMaxFlashloanFee Value of the new max flashloan fee.
function setMaxFlashloanFee(uint256 _newMaxFlashloanFee) external;
/// @notice Update the value of max liquidation fee. Updated value will be used only for a new Silos max
/// liquidation fee validation. Previously deployed SiloConfigs are immutable.
/// @param _newMaxLiquidationFee Value of the new max liquidation fee.
function setMaxLiquidationFee(uint256 _newMaxLiquidationFee) external;
/// @notice Update the base URI.
/// @param _newBaseURI Value of the new base URI.
function setBaseURI(string calldata _newBaseURI) external;
/// @notice Acceptable DAO fee range for new Silos. Denominated in 18 decimals points. 1e18 == 100%.
function daoFeeRange() external view returns (Range memory);
/// @notice Max deployer fee for a new Silos. Denominated in 18 decimals points. 1e18 == 100%.
function maxDeployerFee() external view returns (uint256);
/// @notice Max flashloan fee for a new Silos. Denominated in 18 decimals points. 1e18 == 100%.
function maxFlashloanFee() external view returns (uint256);
/// @notice Max liquidation fee for a new Silos. Denominated in 18 decimals points. 1e18 == 100%.
function maxLiquidationFee() external view returns (uint256);
/// @notice The recipient of DAO fees.
function daoFeeReceiver() external view returns (address);
/// @notice Get SiloConfig address by Silo id.
function idToSiloConfig(uint256 _id) external view returns (address);
/// @notice Do not use this method to check if silo is secure. Anyone can deploy silo with any configuration
/// and implementation. Most critical part of verification would be to check who deployed it.
/// @dev True if the address was deployed using SiloFactory.
function isSilo(address _silo) external view returns (bool);
/// @notice Id of a next Silo to be deployed. This is an ID of non-existing Silo outside of createSilo
/// function call. ID of a first Silo is 1.
function getNextSiloId() external view returns (uint256);
/// @notice Get the DAO and deployer fee receivers for a particular Silo address.
/// @param _silo Silo address.
/// @return dao DAO fee receiver.
/// @return deployer Deployer fee receiver.
function getFeeReceivers(address _silo) external view returns (address dao, address deployer);
/// @notice Validate InitData for a new Silo. Config will be checked for the fee limits, missing parameters.
/// @param _initData Silo init data.
function validateSiloInitData(ISiloConfig.InitData memory _initData) external view returns (bool);
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.5.0;
import {ISiloConfig} from "./ISiloConfig.sol";
interface IHookReceiver {
struct HookConfig {
uint24 hooksBefore;
uint24 hooksAfter;
}
event HookConfigured(address silo, uint24 hooksBefore, uint24 hooksAfter);
/// @notice Initialize a hook receiver
/// @param _siloConfig Silo configuration with all the details about the silo
/// @param _data Data to initialize the hook receiver (if needed)
function initialize(ISiloConfig _siloConfig, bytes calldata _data) external;
/// @notice state of Silo before action, can be also without interest, if you need them, call silo.accrueInterest()
function beforeAction(address _silo, uint256 _action, bytes calldata _input) external;
function afterAction(address _silo, uint256 _action, bytes calldata _inputAndOutput) external;
/// @notice return hooksBefore and hooksAfter configuration
function hookReceiverConfig(address _silo) external view returns (uint24 hooksBefore, uint24 hooksAfter);
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
/**
* @dev Helper library for emitting standardized panic codes.
*
* ```solidity
* contract Example {
* using Panic for uint256;
*
* // Use any of the declared internal constants
* function foo() { Panic.GENERIC.panic(); }
*
* // Alternatively
* function foo() { Panic.panic(Panic.GENERIC); }
* }
* ```
*
* Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].
*/
// slither-disable-next-line unused-state
library Panic {
/// @dev generic / unspecified error
uint256 internal constant GENERIC = 0x00;
/// @dev used by the assert() builtin
uint256 internal constant ASSERT = 0x01;
/// @dev arithmetic underflow or overflow
uint256 internal constant UNDER_OVERFLOW = 0x11;
/// @dev division or modulo by zero
uint256 internal constant DIVISION_BY_ZERO = 0x12;
/// @dev enum conversion error
uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;
/// @dev invalid encoding in storage
uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;
/// @dev empty array pop
uint256 internal constant EMPTY_ARRAY_POP = 0x31;
/// @dev array out of bounds access
uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;
/// @dev resource error (too large allocation or too large array)
uint256 internal constant RESOURCE_ERROR = 0x41;
/// @dev calling invalid internal function
uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;
/// @dev Reverts with a panic code. Recommended to use with
/// the internal constants with predefined codes.
function panic(uint256 code) internal pure {
/// @solidity memory-safe-assembly
assembly {
mstore(0x00, 0x4e487b71)
mstore(0x20, code)
revert(0x1c, 0x24)
}
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)
pragma solidity ^0.8.20;
/**
* @dev Interface of the ERC-20 standard as defined in the ERC.
*/
interface IERC20 {
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Returns the value of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the value of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves a `value` amount of tokens from the caller's account to `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address to, uint256 value) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets a `value` amount of tokens as the allowance of `spender` over the
* caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 value) external returns (bool);
/**
* @dev Moves a `value` amount of tokens from `from` to `to` using the
* allowance mechanism. `value` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address from, address to, uint256 value) external returns (bool);
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.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 ERC-20 standard.
*/
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.5.0;
interface IERC3156FlashBorrower {
/// @notice During the execution of the flashloan, Silo methods are not taking into consideration the fact,
/// that some (or all) tokens were transferred as flashloan, therefore some methods can return invalid state
/// eg. maxWithdraw can return amount that are not available to withdraw during flashlon.
/// @dev Receive a flash loan.
/// @param _initiator The initiator of the loan.
/// @param _token The loan currency.
/// @param _amount The amount of tokens lent.
/// @param _fee The additional amount of tokens to repay.
/// @param _data Arbitrary data structure, intended to contain user-defined parameters.
/// @return The keccak256 hash of "ERC3156FlashBorrower.onFlashLoan"
function onFlashLoan(address _initiator, address _token, uint256 _amount, uint256 _fee, bytes calldata _data)
external
returns (bytes32);
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.5.0;
interface ICrossReentrancyGuard {
error CrossReentrantCall();
error CrossReentrancyNotActive();
/// @notice only silo method for cross Silo reentrancy
function turnOnReentrancyProtection() external;
/// @notice only silo method for cross Silo reentrancy
function turnOffReentrancyProtection() external;
/// @notice view method for checking cross Silo reentrancy flag
/// @return entered true if the reentrancy guard is currently set to "entered", which indicates there is a
/// `nonReentrant` function in the call stack.
function reentrancyGuardEntered() external view returns (bool entered);
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC721.sol)
pragma solidity ^0.8.20;
import {IERC721} from "../token/ERC721/IERC721.sol";
// 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 ERC-721 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 ERC-721 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 ERC-721
* 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) (utils/introspection/IERC165.sol)
pragma solidity ^0.8.20;
/**
* @dev Interface of the ERC-165 standard, as defined in the
* https://eips.ethereum.org/EIPS/eip-165[ERC].
*
* Implementers can declare support of contract interfaces, which can then be
* queried by others ({ERC165Checker}).
*
* For an implementation, see {ERC165}.
*/
interface IERC165 {
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}