Contract Source Code:
File 1 of 1 : IporOracle
// SPDX-License-Identifier: BUSL-1.1
// File: contracts/libraries/errors/MiltonErrors.sol
pragma solidity 0.8.16;
/// @title Errors which occur inside Milton's method execution.
library MiltonErrors {
// 300-399-milton
/// @notice Liquidity Pool balance is equal 0.
string public constant LIQUIDITY_POOL_IS_EMPTY = "IPOR_300";
/// @notice Liquidity Pool balance is too low, should be equal or higher than 0.
string public constant LIQUIDITY_POOL_AMOUNT_TOO_LOW = "IPOR_301";
/// @notice Liquidity Pool Utilization exceeded. Liquidity Pool utilization is higher than configured in Milton maximum liquidity pool utilization.
string public constant LP_UTILIZATION_EXCEEDED = "IPOR_302";
/// @notice Liquidity Pool Utilization Per Leg exceeded. Liquidity Pool utilization per leg is higher than configured in Milton maximu liquidity pool utilization per leg.
string public constant LP_UTILIZATION_PER_LEG_EXCEEDED = "IPOR_303";
/// @notice Liquidity Pool Balance is too high
string public constant LIQUIDITY_POOL_BALANCE_IS_TOO_HIGH = "IPOR_304";
/// @notice Liquidity Pool account contribution is too high.
string public constant LP_ACCOUNT_CONTRIBUTION_IS_TOO_HIGH = "IPOR_305";
/// @notice Swap id used in input has incorrect value (like 0) or not exists.
string public constant INCORRECT_SWAP_ID = "IPOR_306";
/// @notice Swap has incorrect status.
string public constant INCORRECT_SWAP_STATUS = "IPOR_307";
/// @notice Leverage given as a parameter when opening swap is lower than configured in Milton minimum leverage.
string public constant LEVERAGE_TOO_LOW = "IPOR_308";
/// @notice Leverage given as a parameter when opening swap is higher than configured in Milton maxumum leverage.
string public constant LEVERAGE_TOO_HIGH = "IPOR_309";
/// @notice Total amount given as a parameter when opening swap is too low. Cannot be equal zero.
string public constant TOTAL_AMOUNT_TOO_LOW = "IPOR_310";
/// @notice Total amount given as a parameter when opening swap is lower than sum of liquidation deposit amount and ipor publication fee.
string public constant TOTAL_AMOUNT_LOWER_THAN_FEE = "IPOR_311";
/// @notice Amount of collateral used to open swap is higher than configured in Milton max swap collateral amount
string public constant COLLATERAL_AMOUNT_TOO_HIGH = "IPOR_312";
/// @notice Acceptable fixed interest rate defined by traded exceeded.
string public constant ACCEPTABLE_FIXED_INTEREST_RATE_EXCEEDED = "IPOR_313";
/// @notice Swap Notional Amount is higher than Total Notional for specific leg.
string public constant SWAP_NOTIONAL_HIGHER_THAN_TOTAL_NOTIONAL = "IPOR_314";
/// @notice Number of swaps per leg which are going to be liquidated is too high, is higher than configured in Milton liquidation leg limit.
string public constant LIQUIDATION_LEG_LIMIT_EXCEEDED = "IPOR_315";
/// @notice Sum of SOAP and Liquidity Pool Balance is lower than zero.
/// @dev SOAP can be negative, Sum of SOAP and Liquidity Pool Balance can be negative, but this is undesirable.
string public constant SOAP_AND_LP_BALANCE_SUM_IS_TOO_LOW = "IPOR_316";
/// @notice Calculation timestamp is earlier than last SOAP rebalance timestamp.
string public constant CALC_TIMESTAMP_LOWER_THAN_SOAP_REBALANCE_TIMESTAMP = "IPOR_317";
/// @notice Calculation timestamp is lower than Swap's open timestamp.
string public constant CALC_TIMESTAMP_LOWER_THAN_SWAP_OPEN_TIMESTAMP = "IPOR_318";
/// @notice Closing timestamp is lower than Swap's open timestamp.
string public constant CLOSING_TIMESTAMP_LOWER_THAN_SWAP_OPEN_TIMESTAMP = "IPOR_319";
/// @notice Swap cannot be closed because liquidity pool is too low for payid out cash. Situation should never happen where Liquidity Pool is insolvent.
string public constant CANNOT_CLOSE_SWAP_LP_IS_TOO_LOW = "IPOR_320";
/// @notice Swap cannot be closed because sender is not an owner of derivative and derivative maturity not achieved.
string public constant CANNOT_CLOSE_SWAP_SENDER_IS_NOT_BUYER_AND_NO_MATURITY = "IPOR_321";
/// @notice Interest from Strategy is below zero.
string public constant INTEREST_FROM_STRATEGY_BELOW_ZERO = "IPOR_322";
/// @notice Accrued Liquidity Pool is equal zero.
string public constant LIQUIDITY_POOL_ACCRUED_IS_EQUAL_ZERO = "IPOR_323";
/// @notice During spread calculation - Exponential Weighted Moving Variance cannot be higher than 1.
string public constant SPREAD_EMVAR_CANNOT_BE_HIGHER_THAN_ONE = "IPOR_324";
/// @notice During spread calculation - Alpha param cannot be higher than 1.
string public constant SPREAD_ALPHA_CANNOT_BE_HIGHER_THAN_ONE = "IPOR_325";
/// @notice IPOR publication fee balance is too low.
string public constant PUBLICATION_FEE_BALANCE_IS_TOO_LOW = "IPOR_326";
/// @notice The caller must be the Joseph (Smart Contract responsible for managing Milton's tokens and balances).
string public constant CALLER_NOT_JOSEPH = "IPOR_327";
/// @notice Deposit amount is too low.
string public constant DEPOSIT_AMOUNT_IS_TOO_LOW = "IPOR_328";
/// @notice Vault balance is lower than deposit value.
string public constant VAULT_BALANCE_LOWER_THAN_DEPOSIT_VALUE = "IPOR_329";
/// @notice Treasury balance is too low.
string public constant TREASURY_BALANCE_IS_TOO_LOW = "IPOR_330";
}
// File: contracts/interfaces/IIporAlgorithm.sol
pragma solidity 0.8.16;
/// @title Interface for interaction with IPOR calculation algorithm.
interface IIporAlgorithm {
/// @notice Returns current version of IPOR algorithm.
/// @return Current IPOR algorithm version.
function getVersion() external pure returns (uint256);
/// @notice Calculates IPOR index by given asset address
/// @param asset Asset address
/// @return iporIndex IPOR index value represented in 18 decimals
function calculateIpor(address asset) external view returns (uint256 iporIndex);
}
// File: contracts/libraries/math/IporMath.sol
pragma solidity 0.8.16;
library IporMath {
//@notice Division with rounding up on last position, x, and y is with MD
function division(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = (x + (y / 2)) / y;
}
function divisionInt(int256 x, int256 y) internal pure returns (int256 z) {
z = (x + (y / 2)) / y;
}
function divisionWithoutRound(uint256 x, uint256 y) internal pure returns (uint256 z) {
z = x / y;
}
function convertWadToAssetDecimals(uint256 value, uint256 assetDecimals)
internal
pure
returns (uint256)
{
if (assetDecimals == 18) {
return value;
} else if (assetDecimals > 18) {
return value * 10**(assetDecimals - 18);
} else {
return division(value, 10**(18 - assetDecimals));
}
}
function convertWadToAssetDecimalsWithoutRound(uint256 value, uint256 assetDecimals)
internal
pure
returns (uint256)
{
if (assetDecimals == 18) {
return value;
} else if (assetDecimals > 18) {
return value * 10**(assetDecimals - 18);
} else {
return divisionWithoutRound(value, 10**(18 - assetDecimals));
}
}
function convertToWad(uint256 value, uint256 assetDecimals) internal pure returns (uint256) {
if (value > 0) {
if (assetDecimals == 18) {
return value;
} else if (assetDecimals > 18) {
return division(value, 10**(assetDecimals - 18));
} else {
return value * 10**(18 - assetDecimals);
}
} else {
return value;
}
}
function absoluteValue(int256 value) internal pure returns (uint256) {
return (uint256)(value < 0 ? -value : value);
}
function percentOf(uint256 value, uint256 rate) internal pure returns (uint256) {
return division(value * rate, 1e18);
}
}
// File: contracts/libraries/Constants.sol
pragma solidity 0.8.16;
library Constants {
uint256 public constant MAX_VALUE =
115792089237316195423570985008687907853269984665640564039457584007913129639935;
uint256 public constant D18 = 1e18;
uint256 public constant D21 = 1e21;
int256 public constant D18_INT = 1e18;
uint256 public constant D36 = 1e36;
uint256 public constant D54 = 1e54;
uint256 public constant YEAR_IN_SECONDS = 365 days;
uint256 public constant WAD_YEAR_IN_SECONDS = D18 * YEAR_IN_SECONDS;
int256 public constant WAD_YEAR_IN_SECONDS_INT = int256(WAD_YEAR_IN_SECONDS);
uint256 public constant WAD_P2_YEAR_IN_SECONDS = D18 * D18 * YEAR_IN_SECONDS;
int256 public constant WAD_P2_YEAR_IN_SECONDS_INT = int256(WAD_P2_YEAR_IN_SECONDS);
uint256 public constant MAX_CHUNK_SIZE = 50;
//@notice By default every swap takes 28 days, this variable show this value in seconds
uint256 public constant SWAP_DEFAULT_PERIOD_IN_SECONDS = 60 * 60 * 24 * 28;
}
// File: contracts/interfaces/types/IporOracleTypes.sol
pragma solidity 0.8.16;
/// @title Structs used in IporOracle smart contract
library IporOracleTypes {
//@notice IPOR Index Structure for a given asset
struct IPOR {
//@notice Quasi Interest Bearing Token Price - IBT Price without division by year in seconds
uint128 quasiIbtPrice;
/// @notice Exponential Moving Average
/// @dev used in calculating spread in MiltonSpreadModel smart contract
uint64 exponentialMovingAverage;
//@notice exponential weighted moving variance - required for calculating spread in Milton
uint64 exponentialWeightedMovingVariance;
//@notice IPOR Index value.
uint64 indexValue;
//@notice Tiestamp of most recent IPOR index update, action performed by Charlie (refer to the documentation for more details)
uint32 lastUpdateTimestamp;
}
}
// File: contracts/interfaces/types/IporTypes.sol
pragma solidity 0.8.16;
/// @title Struct used across various interfaces in IPOR Protocol.
library IporTypes {
/// @notice The struct describing the IPOR and its params calculated for the time when it was most recently updated and the change that took place since the update.
/// Namely, the interest that would be computed into IBT should the rebalance occur.
struct AccruedIpor {
/// @notice IPOR Index Value
/// @dev value represented in 18 decimals
uint256 indexValue;
/// @notice IBT Price (IBT - Interest Bearing Token). For more information reffer to the documentation:
/// https://ipor-labs.gitbook.io/ipor-labs/interest-rate-derivatives/ibt
/// @dev value represented in 18 decimals
uint256 ibtPrice;
/// @notice Exponential Moving Average
/// @dev value represented in 18 decimals
uint256 exponentialMovingAverage;
/// @notice Exponential Weighted Moving Variance
/// @dev value represented in 18 decimals
uint256 exponentialWeightedMovingVariance;
}
/// @notice Struct representing swap item, used for listing and in internal calculations
struct IporSwapMemory {
/// @notice Swap's unique ID
uint256 id;
/// @notice Swap's buyer
address buyer;
/// @notice Swap opening epoch timestamp
uint256 openTimestamp;
/// @notice Epoch when the swap will reach its maturity
uint256 endTimestamp;
/// @notice Index position of this Swap in an array of swaps' identification associated to swap buyer
/// @dev Field used for gas optimization purposes, it allows for quick removal by id in the array.
/// During removal the last item in the array is switched with the one that just has been removed.
uint256 idsIndex;
/// @notice Swap's collateral
/// @dev value represented in 18 decimals
uint256 collateral;
/// @notice Swap's notional amount
/// @dev value represented in 18 decimals
uint256 notional;
/// @notice Swap's notional amount denominated in the Interest Bearing Token (IBT)
/// @dev value represented in 18 decimals
uint256 ibtQuantity;
/// @notice Fixed interest rate at which the position has been opened
/// @dev value represented in 18 decimals
uint256 fixedInterestRate;
/// @notice Liquidation deposit amount
/// @dev value represented in 18 decimals
uint256 liquidationDepositAmount;
/// @notice State of the swap
/// @dev 0 - INACTIVE, 1 - ACTIVE
uint256 state;
}
/// @notice Struct representing balances used internally for asset calculations
/// @dev all balances in 18 decimals
struct MiltonBalancesMemory {
/// @notice Sum of all collateral put forward by the derivative buyer's on Pay Fixed & Receive Floating leg.
uint256 totalCollateralPayFixed;
/// @notice Sum of all collateral put forward by the derivative buyer's on Pay Floating & Receive Fixed leg.
uint256 totalCollateralReceiveFixed;
/// @notice Liquidity Pool Balance. This balance is where the liquidity from liquidity providers and the opening fee are accounted for,
/// @dev Amount of opening fee accounted in this balance is defined by _OPENING_FEE_FOR_TREASURY_PORTION_RATE param.
uint256 liquidityPool;
/// @notice Vault's balance, describes how much asset has been transfered to Asset Management Vault (Stanley)
uint256 vault;
}
}
// File: contracts/interfaces/IIporOracle.sol
pragma solidity 0.8.16;
/// @title Interface for interaction with IporOracle, smart contract responsible for managing IPOR Index.
interface IIporOracle {
/// @notice Returns current version of IporOracle's
/// @dev Increase number when implementation inside source code is different that implementation deployed on Mainnet
/// @return current IporOracle version
function getVersion() external pure returns (uint256);
/// @notice Gets IPOR Index indicators for a given asset
/// @dev all returned values represented in 18 decimals
/// @param asset underlying / stablecoin address supported in Ipor Protocol
/// @return value IPOR Index value for a given asset
/// @return ibtPrice Interest Bearing Token Price for a given IPOR Index
/// @return exponentialMovingAverage Exponential moving average for a given IPOR Index
/// @return exponentialWeightedMovingVariance Exponential weighted movien variance for a given IPOR Index
/// @return lastUpdateTimestamp Last IPOR Index update done by Charlie off-chain service
function getIndex(address asset)
external
view
returns (
uint256 value,
uint256 ibtPrice,
uint256 exponentialMovingAverage,
uint256 exponentialWeightedMovingVariance,
uint256 lastUpdateTimestamp
);
/// @notice Gets accrued IPOR Index indicators for a given timestamp and asset .
/// @param calculateTimestamp time of accrued IPOR Index calculation
/// @param asset underlying / stablecoin address supported by IPOR Protocol.
/// @return accruedIpor structure {IporTypes.AccruedIpor}
function getAccruedIndex(uint256 calculateTimestamp, address asset)
external
view
returns (IporTypes.AccruedIpor memory accruedIpor);
/// @notice Gets IporAlgorithm address.
function getIporAlgorithmFacade() external view returns (address);
/// @notice Calculates accrued Interest Bearing Token price for a given asset and timestamp.
/// @param asset underlying / stablecoin address supported by IPOR Protocol.
/// @param calculateTimestamp time of accrued Interest Bearing Token price calculation
/// @return accrued IBT price, represented in 18 decimals
function calculateAccruedIbtPrice(address asset, uint256 calculateTimestamp)
external
view
returns (uint256);
/// @notice Updates IPOR Index for a given asset based on value returned from iporAlgorithm.
/// @dev Emmits {IporIndexUpdate} event.
/// @param asset underlying / stablecoin address supported by IPOR Protocol
function updateIndex(address asset) external returns (IporTypes.AccruedIpor memory accruedIpor);
/// @notice Updates IPOR Index for a given asset. Function available only for Updater
/// @dev Emmits {IporIndexUpdate} event.
/// @param asset underlying / stablecoin address supported by IPOR Protocol
/// @param indexValue new IPOR Index value represented in 18 decimals
function updateIndex(address asset, uint256 indexValue) external;
/// @notice Updates IPOR indexes for a given assets. Function available only for Updater
/// @dev Emmits {IporIndexUpdate} event.
/// @param assets underlying / stablecoin addresses supported by IPOR Protocol
/// @param indexValues new IPOR Index values
function updateIndexes(address[] memory assets, uint256[] memory indexValues) external;
/// @notice Adds new Updater. Updater has right to update IPOR Index. Function available only for Owner.
/// @param newUpdater new updater address
function addUpdater(address newUpdater) external;
/// @notice Removes Updater. Function available only for Owner.
/// @param updater updater address
function removeUpdater(address updater) external;
/// @notice Checks if given account is an Updater.
/// @param account account for checking
/// @return 0 if account is not updater, 1 if account is updater.
function isUpdater(address account) external view returns (uint256);
/// @notice setup ipor algorithm address
/// @param newAlgorithmAddress ipor algorithm address
function setIporAlgorithmFacade(address newAlgorithmAddress) external;
/// @notice Adds new asset which IPOR Protocol will support. Function available only for Owner.
/// @param newAsset new asset address
/// @param updateTimestamp Time for which exponential moving average and exponential weighted moving variance was calculated
/// @param exponentialMovingAverage initial Exponential Moving Average for this asset
/// @param exponentialWeightedMovingVariance initial Exponential Weighted Moving Variance for asset.
function addAsset(
address newAsset,
uint256 updateTimestamp,
uint256 exponentialMovingAverage,
uint256 exponentialWeightedMovingVariance
) external;
/// @notice Removes asset which IPOR Protocol will not support. Function available only for Owner.
/// @param asset underlying / stablecoin address which current is supported by IPOR Protocol.
function removeAsset(address asset) external;
/// @notice Checks if given asset is supported by IPOR Protocol.
/// @param asset underlying / stablecoin address
function isAssetSupported(address asset) external view returns (bool);
/// @notice Pauses current smart contract, it can be executed only by the Owner
/// @dev Emits {Paused} event from IporOracle.
function pause() external;
/// @notice Unpauses current smart contract, it can be executed only by the Owner
/// @dev Emits {Unpaused} event from IporOracle.
function unpause() external;
/// @notice Emmited when Charlie update IPOR Index.
/// @param asset underlying / stablecoin address
/// @param indexValue IPOR Index value represented in 18 decimals
/// @param quasiIbtPrice quasi Interest Bearing Token price represented in 18 decimals.
/// @param exponentialMovingAverage Exponential Moving Average represented in 18 decimals.
/// @param exponentialWeightedMovingVariance Exponential Weighted Moving Variance
/// @param updateTimestamp moment when IPOR Index was updated.
event IporIndexUpdate(
address asset,
uint256 indexValue,
uint256 quasiIbtPrice,
uint256 exponentialMovingAverage,
uint256 exponentialWeightedMovingVariance,
uint256 updateTimestamp
);
/// @notice event emitted when IPOR Index Updater is added by Owner
/// @param newUpdater new Updater address
event IporIndexAddUpdater(address newUpdater);
/// @notice event emitted when IPOR Index Updater is removed by Owner
/// @param updater updater address
event IporIndexRemoveUpdater(address updater);
/// @notice event emitted when new asset is added by Owner to list of assets supported in IPOR Protocol.
/// @param newAsset new asset address
/// @param updateTimestamp update timestamp
/// @param exponentialMovingAverage Exponential Moving Average for asset
/// @param exponentialWeightedMovingVariance Exponential Weighted Moving Variance for asset
event IporIndexAddAsset(
address newAsset,
uint256 updateTimestamp,
uint256 exponentialMovingAverage,
uint256 exponentialWeightedMovingVariance
);
/// @notice event emitted when asset is removed by Owner from list of assets supported in IPOR Protocol.
/// @param asset asset address
event IporIndexRemoveAsset(address asset);
/// @notice event emitted when ipor algorithm address is changed
/// @param changedBy address of the account that changed the ipor algorithm address
/// @param oldIporAlgorithmFacade old ipor algorithm address
/// @param newIporAlgorithmFacade new ipor algorithm address
event IporAlgorithmFacadeChanged(
address indexed changedBy,
address indexed oldIporAlgorithmFacade,
address indexed newIporAlgorithmFacade
);
}
// File: contracts/libraries/errors/IporOracleErrors.sol
pragma solidity 0.8.16;
library IporOracleErrors {
// 200-299- iporOracle
//@notice Asset address not supported
//@dev Address is not supported when quasiIbtPrice < Constants.WAD_YEAR_IN_SECONDS.
//When quasiIbtPrice is lower than WAD_YEAR_IN_SECONDS (ibtPrice lower than 1), then we assume that asset is not supported.
string public constant ASSET_NOT_SUPPORTED = "IPOR_200";
//@notice Cannot add new asset to asset list, because already exists
string public constant CANNOT_ADD_ASSET_ASSET_ALREADY_EXISTS = "IPOR_201";
//@notice The caller must be the IporOracle updater
string public constant CALLER_NOT_UPDATER = "IPOR_202";
//@notice Actual IPOR Index timestamp is higher than accrue timestamp
string public constant INDEX_TIMESTAMP_HIGHER_THAN_ACCRUE_TIMESTAMP = "IPOR_203";
//@notice Address of algorithm used to calculate IPOR Index is not set
string public constant IPOR_ALGORITHM_ADDRESS_NOT_SET = "IPOR_204";
}
// File: contracts/oracles/libraries/IporLogic.sol
pragma solidity 0.8.16;
library IporLogic {
function accrueQuasiIbtPrice(IporOracleTypes.IPOR memory ipor, uint256 accrueTimestamp)
internal
pure
returns (uint256)
{
return
accrueQuasiIbtPrice(
ipor.indexValue,
ipor.quasiIbtPrice,
ipor.lastUpdateTimestamp,
accrueTimestamp
);
}
//@param indexValue indexValue represent in WAD
//@param quasiIbtPrice quasiIbtPrice represent in WAD, quasi inform that IBT Price doesn't have final value, is required to divide by number of seconds in year
//@dev return value represented in WAD
function accrueQuasiIbtPrice(
uint256 indexValue,
uint256 quasiIbtPrice,
uint256 indexTimestamp,
uint256 accrueTimestamp
) internal pure returns (uint256) {
require(
accrueTimestamp >= indexTimestamp,
IporOracleErrors.INDEX_TIMESTAMP_HIGHER_THAN_ACCRUE_TIMESTAMP
);
return quasiIbtPrice + (indexValue * (accrueTimestamp - indexTimestamp));
}
//@notice ExpMovAv(n) = ExpMovAv(n-1) * (1 - d) + IPOR * d
//@dev return value represented in WAD
function calculateExponentialMovingAverage(
uint256 lastExponentialMovingAverage,
uint256 indexValue,
uint256 alpha
) internal pure returns (uint256) {
return
IporMath.division(
lastExponentialMovingAverage * alpha + indexValue * (Constants.D18 - alpha),
Constants.D18
);
}
function calculateExponentialWeightedMovingVariance(
uint256 lastExponentialWeightedMovingVariance,
uint256 exponentialMovingAverage,
uint256 indexValue,
uint256 alpha
) internal pure returns (uint256 result) {
require(alpha <= Constants.D18, MiltonErrors.SPREAD_ALPHA_CANNOT_BE_HIGHER_THAN_ONE);
if (indexValue > exponentialMovingAverage) {
result = IporMath.division(
alpha *
(lastExponentialWeightedMovingVariance *
Constants.D36 +
(Constants.D18 - alpha) *
(indexValue - exponentialMovingAverage) *
(indexValue - exponentialMovingAverage)),
Constants.D54
);
} else {
result = IporMath.division(
alpha *
(lastExponentialWeightedMovingVariance *
Constants.D36 +
(Constants.D18 - alpha) *
(exponentialMovingAverage - indexValue) *
(exponentialMovingAverage - indexValue)),
Constants.D54
);
}
require(result <= Constants.D18, MiltonErrors.SPREAD_EMVAR_CANNOT_BE_HIGHER_THAN_ONE);
}
}
// File: contracts/libraries/errors/IporErrors.sol
pragma solidity 0.8.16;
library IporErrors {
// 000-199 - general codes
/// @notice General problem, address is wrong
string public constant WRONG_ADDRESS = "IPOR_000";
/// @notice General problem. Wrong decimals
string public constant WRONG_DECIMALS = "IPOR_001";
string public constant ADDRESSES_MISMATCH = "IPOR_002";
//@notice Trader doesnt have enought tokens to execute transaction
string public constant ASSET_BALANCE_TOO_LOW = "IPOR_003";
string public constant VALUE_NOT_GREATER_THAN_ZERO = "IPOR_004";
string public constant INPUT_ARRAYS_LENGTH_MISMATCH = "IPOR_005";
//@notice Amount is too low to transfer
string public constant NOT_ENOUGH_AMOUNT_TO_TRANSFER = "IPOR_006";
//@notice msg.sender is not an appointed owner, so cannot confirm his appointment to be an owner of a specific smart contract
string public constant SENDER_NOT_APPOINTED_OWNER = "IPOR_007";
//only milton can have access to function
string public constant CALLER_NOT_MILTON = "IPOR_008";
string public constant CHUNK_SIZE_EQUAL_ZERO = "IPOR_009";
string public constant CHUNK_SIZE_TOO_BIG = "IPOR_010";
}
// File: @openzeppelin/contracts/utils/math/SafeCast.sol
// OpenZeppelin Contracts (last updated v4.7.0) (utils/math/SafeCast.sol)
pragma solidity ^0.8.0;
/**
* @dev Wrappers over Solidity's uintXX/intXX 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.
*
* Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing
* all math on `uint256` and `int256` and then downcasting.
*/
library SafeCast {
/**
* @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
*
* _Available since v4.7._
*/
function toUint248(uint256 value) internal pure returns (uint248) {
require(value <= type(uint248).max, "SafeCast: value doesn't fit in 248 bits");
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
*
* _Available since v4.7._
*/
function toUint240(uint256 value) internal pure returns (uint240) {
require(value <= type(uint240).max, "SafeCast: value doesn't fit in 240 bits");
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
*
* _Available since v4.7._
*/
function toUint232(uint256 value) internal pure returns (uint232) {
require(value <= type(uint232).max, "SafeCast: value doesn't fit in 232 bits");
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
*
* _Available since v4.2._
*/
function toUint224(uint256 value) internal pure returns (uint224) {
require(value <= type(uint224).max, "SafeCast: value doesn't fit in 224 bits");
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
*
* _Available since v4.7._
*/
function toUint216(uint256 value) internal pure returns (uint216) {
require(value <= type(uint216).max, "SafeCast: value doesn't fit in 216 bits");
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
*
* _Available since v4.7._
*/
function toUint208(uint256 value) internal pure returns (uint208) {
require(value <= type(uint208).max, "SafeCast: value doesn't fit in 208 bits");
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
*
* _Available since v4.7._
*/
function toUint200(uint256 value) internal pure returns (uint200) {
require(value <= type(uint200).max, "SafeCast: value doesn't fit in 200 bits");
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
*
* _Available since v4.7._
*/
function toUint192(uint256 value) internal pure returns (uint192) {
require(value <= type(uint192).max, "SafeCast: value doesn't fit in 192 bits");
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
*
* _Available since v4.7._
*/
function toUint184(uint256 value) internal pure returns (uint184) {
require(value <= type(uint184).max, "SafeCast: value doesn't fit in 184 bits");
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
*
* _Available since v4.7._
*/
function toUint176(uint256 value) internal pure returns (uint176) {
require(value <= type(uint176).max, "SafeCast: value doesn't fit in 176 bits");
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
*
* _Available since v4.7._
*/
function toUint168(uint256 value) internal pure returns (uint168) {
require(value <= type(uint168).max, "SafeCast: value doesn't fit in 168 bits");
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
*
* _Available since v4.7._
*/
function toUint160(uint256 value) internal pure returns (uint160) {
require(value <= type(uint160).max, "SafeCast: value doesn't fit in 160 bits");
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
*
* _Available since v4.7._
*/
function toUint152(uint256 value) internal pure returns (uint152) {
require(value <= type(uint152).max, "SafeCast: value doesn't fit in 152 bits");
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
*
* _Available since v4.7._
*/
function toUint144(uint256 value) internal pure returns (uint144) {
require(value <= type(uint144).max, "SafeCast: value doesn't fit in 144 bits");
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
*
* _Available since v4.7._
*/
function toUint136(uint256 value) internal pure returns (uint136) {
require(value <= type(uint136).max, "SafeCast: value doesn't fit in 136 bits");
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
*
* _Available since v2.5._
*/
function toUint128(uint256 value) internal pure returns (uint128) {
require(value <= type(uint128).max, "SafeCast: value doesn't fit in 128 bits");
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
*
* _Available since v4.7._
*/
function toUint120(uint256 value) internal pure returns (uint120) {
require(value <= type(uint120).max, "SafeCast: value doesn't fit in 120 bits");
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
*
* _Available since v4.7._
*/
function toUint112(uint256 value) internal pure returns (uint112) {
require(value <= type(uint112).max, "SafeCast: value doesn't fit in 112 bits");
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
*
* _Available since v4.7._
*/
function toUint104(uint256 value) internal pure returns (uint104) {
require(value <= type(uint104).max, "SafeCast: value doesn't fit in 104 bits");
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
*
* _Available since v4.2._
*/
function toUint96(uint256 value) internal pure returns (uint96) {
require(value <= type(uint96).max, "SafeCast: value doesn't fit in 96 bits");
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
*
* _Available since v4.7._
*/
function toUint88(uint256 value) internal pure returns (uint88) {
require(value <= type(uint88).max, "SafeCast: value doesn't fit in 88 bits");
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
*
* _Available since v4.7._
*/
function toUint80(uint256 value) internal pure returns (uint80) {
require(value <= type(uint80).max, "SafeCast: value doesn't fit in 80 bits");
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
*
* _Available since v4.7._
*/
function toUint72(uint256 value) internal pure returns (uint72) {
require(value <= type(uint72).max, "SafeCast: value doesn't fit in 72 bits");
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
*
* _Available since v2.5._
*/
function toUint64(uint256 value) internal pure returns (uint64) {
require(value <= type(uint64).max, "SafeCast: value doesn't fit in 64 bits");
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
*
* _Available since v4.7._
*/
function toUint56(uint256 value) internal pure returns (uint56) {
require(value <= type(uint56).max, "SafeCast: value doesn't fit in 56 bits");
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
*
* _Available since v4.7._
*/
function toUint48(uint256 value) internal pure returns (uint48) {
require(value <= type(uint48).max, "SafeCast: value doesn't fit in 48 bits");
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
*
* _Available since v4.7._
*/
function toUint40(uint256 value) internal pure returns (uint40) {
require(value <= type(uint40).max, "SafeCast: value doesn't fit in 40 bits");
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
*
* _Available since v2.5._
*/
function toUint32(uint256 value) internal pure returns (uint32) {
require(value <= type(uint32).max, "SafeCast: value doesn't fit in 32 bits");
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
*
* _Available since v4.7._
*/
function toUint24(uint256 value) internal pure returns (uint24) {
require(value <= type(uint24).max, "SafeCast: value doesn't fit in 24 bits");
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
*
* _Available since v2.5._
*/
function toUint16(uint256 value) internal pure returns (uint16) {
require(value <= type(uint16).max, "SafeCast: value doesn't fit in 16 bits");
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
*
* _Available since v2.5._
*/
function toUint8(uint256 value) internal pure returns (uint8) {
require(value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits");
return uint8(value);
}
/**
* @dev Converts a signed int256 into an unsigned uint256.
*
* Requirements:
*
* - input must be greater than or equal to 0.
*
* _Available since v3.0._
*/
function toUint256(int256 value) internal pure returns (uint256) {
require(value >= 0, "SafeCast: value must be positive");
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
*
* _Available since v4.7._
*/
function toInt248(int256 value) internal pure returns (int248) {
require(value >= type(int248).min && value <= type(int248).max, "SafeCast: value doesn't fit in 248 bits");
return int248(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
*
* _Available since v4.7._
*/
function toInt240(int256 value) internal pure returns (int240) {
require(value >= type(int240).min && value <= type(int240).max, "SafeCast: value doesn't fit in 240 bits");
return int240(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
*
* _Available since v4.7._
*/
function toInt232(int256 value) internal pure returns (int232) {
require(value >= type(int232).min && value <= type(int232).max, "SafeCast: value doesn't fit in 232 bits");
return int232(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
*
* _Available since v4.7._
*/
function toInt224(int256 value) internal pure returns (int224) {
require(value >= type(int224).min && value <= type(int224).max, "SafeCast: value doesn't fit in 224 bits");
return int224(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
*
* _Available since v4.7._
*/
function toInt216(int256 value) internal pure returns (int216) {
require(value >= type(int216).min && value <= type(int216).max, "SafeCast: value doesn't fit in 216 bits");
return int216(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
*
* _Available since v4.7._
*/
function toInt208(int256 value) internal pure returns (int208) {
require(value >= type(int208).min && value <= type(int208).max, "SafeCast: value doesn't fit in 208 bits");
return int208(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
*
* _Available since v4.7._
*/
function toInt200(int256 value) internal pure returns (int200) {
require(value >= type(int200).min && value <= type(int200).max, "SafeCast: value doesn't fit in 200 bits");
return int200(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
*
* _Available since v4.7._
*/
function toInt192(int256 value) internal pure returns (int192) {
require(value >= type(int192).min && value <= type(int192).max, "SafeCast: value doesn't fit in 192 bits");
return int192(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
*
* _Available since v4.7._
*/
function toInt184(int256 value) internal pure returns (int184) {
require(value >= type(int184).min && value <= type(int184).max, "SafeCast: value doesn't fit in 184 bits");
return int184(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
*
* _Available since v4.7._
*/
function toInt176(int256 value) internal pure returns (int176) {
require(value >= type(int176).min && value <= type(int176).max, "SafeCast: value doesn't fit in 176 bits");
return int176(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
*
* _Available since v4.7._
*/
function toInt168(int256 value) internal pure returns (int168) {
require(value >= type(int168).min && value <= type(int168).max, "SafeCast: value doesn't fit in 168 bits");
return int168(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
*
* _Available since v4.7._
*/
function toInt160(int256 value) internal pure returns (int160) {
require(value >= type(int160).min && value <= type(int160).max, "SafeCast: value doesn't fit in 160 bits");
return int160(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
*
* _Available since v4.7._
*/
function toInt152(int256 value) internal pure returns (int152) {
require(value >= type(int152).min && value <= type(int152).max, "SafeCast: value doesn't fit in 152 bits");
return int152(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
*
* _Available since v4.7._
*/
function toInt144(int256 value) internal pure returns (int144) {
require(value >= type(int144).min && value <= type(int144).max, "SafeCast: value doesn't fit in 144 bits");
return int144(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
*
* _Available since v4.7._
*/
function toInt136(int256 value) internal pure returns (int136) {
require(value >= type(int136).min && value <= type(int136).max, "SafeCast: value doesn't fit in 136 bits");
return int136(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
*
* _Available since v3.1._
*/
function toInt128(int256 value) internal pure returns (int128) {
require(value >= type(int128).min && value <= type(int128).max, "SafeCast: value doesn't fit in 128 bits");
return int128(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
*
* _Available since v4.7._
*/
function toInt120(int256 value) internal pure returns (int120) {
require(value >= type(int120).min && value <= type(int120).max, "SafeCast: value doesn't fit in 120 bits");
return int120(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
*
* _Available since v4.7._
*/
function toInt112(int256 value) internal pure returns (int112) {
require(value >= type(int112).min && value <= type(int112).max, "SafeCast: value doesn't fit in 112 bits");
return int112(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
*
* _Available since v4.7._
*/
function toInt104(int256 value) internal pure returns (int104) {
require(value >= type(int104).min && value <= type(int104).max, "SafeCast: value doesn't fit in 104 bits");
return int104(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
*
* _Available since v4.7._
*/
function toInt96(int256 value) internal pure returns (int96) {
require(value >= type(int96).min && value <= type(int96).max, "SafeCast: value doesn't fit in 96 bits");
return int96(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
*
* _Available since v4.7._
*/
function toInt88(int256 value) internal pure returns (int88) {
require(value >= type(int88).min && value <= type(int88).max, "SafeCast: value doesn't fit in 88 bits");
return int88(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
*
* _Available since v4.7._
*/
function toInt80(int256 value) internal pure returns (int80) {
require(value >= type(int80).min && value <= type(int80).max, "SafeCast: value doesn't fit in 80 bits");
return int80(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
*
* _Available since v4.7._
*/
function toInt72(int256 value) internal pure returns (int72) {
require(value >= type(int72).min && value <= type(int72).max, "SafeCast: value doesn't fit in 72 bits");
return int72(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
*
* _Available since v3.1._
*/
function toInt64(int256 value) internal pure returns (int64) {
require(value >= type(int64).min && value <= type(int64).max, "SafeCast: value doesn't fit in 64 bits");
return int64(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
*
* _Available since v4.7._
*/
function toInt56(int256 value) internal pure returns (int56) {
require(value >= type(int56).min && value <= type(int56).max, "SafeCast: value doesn't fit in 56 bits");
return int56(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
*
* _Available since v4.7._
*/
function toInt48(int256 value) internal pure returns (int48) {
require(value >= type(int48).min && value <= type(int48).max, "SafeCast: value doesn't fit in 48 bits");
return int48(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
*
* _Available since v4.7._
*/
function toInt40(int256 value) internal pure returns (int40) {
require(value >= type(int40).min && value <= type(int40).max, "SafeCast: value doesn't fit in 40 bits");
return int40(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
*
* _Available since v3.1._
*/
function toInt32(int256 value) internal pure returns (int32) {
require(value >= type(int32).min && value <= type(int32).max, "SafeCast: value doesn't fit in 32 bits");
return int32(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
*
* _Available since v4.7._
*/
function toInt24(int256 value) internal pure returns (int24) {
require(value >= type(int24).min && value <= type(int24).max, "SafeCast: value doesn't fit in 24 bits");
return int24(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
*
* _Available since v3.1._
*/
function toInt16(int256 value) internal pure returns (int16) {
require(value >= type(int16).min && value <= type(int16).max, "SafeCast: value doesn't fit in 16 bits");
return int16(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
*
* _Available since v3.1._
*/
function toInt8(int256 value) internal pure returns (int8) {
require(value >= type(int8).min && value <= type(int8).max, "SafeCast: value doesn't fit in 8 bits");
return int8(value);
}
/**
* @dev Converts an unsigned uint256 into a signed int256.
*
* Requirements:
*
* - input must be less than or equal to maxInt256.
*
* _Available since v3.0._
*/
function toInt256(uint256 value) internal pure returns (int256) {
// Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive
require(value <= uint256(type(int256).max), "SafeCast: value doesn't fit in an int256");
return int256(value);
}
}
// File: contracts/oracles/libraries/DecayFactorCalculation.sol
pragma solidity 0.8.16;
uint256 constant END_INTERVAL_ONE = 179666;
uint256 constant END_INTERVAL_TWO = 596832;
uint256 constant END_INTERVAL_THREE = 1346513;
// Line One Parameters in wand
int256 constant SLOPE_FACTOR_ONE = -2782991070840;
int256 constant BASE_ONE = 1000000000000000000;
// Line two Parameters in wand
int256 constant SLOPE_FACTOR_TWO = -958849469240;
int256 constant BASE_TWO = 672268604625703800;
// Line three Parameters in wand
int256 constant SLOPE_FACTOR_THREE = -133388866004;
int256 constant BASE_THREE = 179609917339805645;
library DecayFactorCalculation {
using SafeCast for uint256;
using SafeCast for int256;
//@param variable represent in int, NOT in WAD
//@dev return value represented in WAD
function calculate(uint256 timeInterval) internal pure returns (uint256 decayFactor) {
if (timeInterval < END_INTERVAL_ONE) {
return linearFunction(SLOPE_FACTOR_ONE, BASE_ONE, timeInterval.toInt256()).toUint256();
}
if (timeInterval < END_INTERVAL_TWO) {
return linearFunction(SLOPE_FACTOR_TWO, BASE_TWO, timeInterval.toInt256()).toUint256();
}
if (timeInterval < END_INTERVAL_THREE) {
return
linearFunction(SLOPE_FACTOR_THREE, BASE_THREE, timeInterval.toInt256()).toUint256();
}
decayFactor = 0;
}
//@param slope represent in WAD
//@param base represent in WAD
//@param variable represent in int, NOT in WAD
//@dev return value represented in WAD
function linearFunction(
int256 slope,
int256 base,
int256 variable
) internal pure returns (int256) {
return slope * variable + base;
}
}
// File: @openzeppelin/contracts-upgradeable/utils/StorageSlotUpgradeable.sol
// OpenZeppelin Contracts (last updated v4.7.0) (utils/StorageSlot.sol)
pragma solidity ^0.8.0;
/**
* @dev Library for reading and writing primitive types to specific storage slots.
*
* Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
* This library helps with reading and writing to such slots without the need for inline assembly.
*
* The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
*
* Example usage to set ERC1967 implementation slot:
* ```
* contract ERC1967 {
* bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
*
* function _getImplementation() internal view returns (address) {
* return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
* }
*
* function _setImplementation(address newImplementation) internal {
* require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
* StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
* }
* }
* ```
*
* _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._
*/
library StorageSlotUpgradeable {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
/**
* @dev Returns an `AddressSlot` with member `value` located at `slot`.
*/
function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
/**
* @dev Returns an `BooleanSlot` with member `value` located at `slot`.
*/
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
/**
* @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
*/
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
/**
* @dev Returns an `Uint256Slot` with member `value` located at `slot`.
*/
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
}
// File: @openzeppelin/contracts-upgradeable/proxy/beacon/IBeaconUpgradeable.sol
// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)
pragma solidity ^0.8.0;
/**
* @dev This is the interface that {BeaconProxy} expects of its beacon.
*/
interface IBeaconUpgradeable {
/**
* @dev Must return an address that can be used as a delegate call target.
*
* {BeaconProxy} will check that this address is a contract.
*/
function implementation() external view returns (address);
}
// File: @openzeppelin/contracts-upgradeable/interfaces/draft-IERC1822Upgradeable.sol
// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)
pragma solidity ^0.8.0;
/**
* @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified
* proxy whose upgrades are fully controlled by the current implementation.
*/
interface IERC1822ProxiableUpgradeable {
/**
* @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation
* address.
*
* IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
* bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
* function revert if invoked through a proxy.
*/
function proxiableUUID() external view returns (bytes32);
}
// File: @openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)
pragma solidity ^0.8.1;
/**
* @dev Collection of functions related to the address type
*/
library AddressUpgradeable {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*
* [IMPORTANT]
* ====
* You shouldn't rely on `isContract` to protect against flash loan attacks!
*
* Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
* like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
* constructor.
* ====
*/
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
/**
* @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason using the provided one.
*
* _Available since v4.3._
*/
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
// File: @openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol
// OpenZeppelin Contracts (last updated v4.7.0) (proxy/utils/Initializable.sol)
pragma solidity ^0.8.2;
/**
* @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
* behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
* external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
* function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
*
* The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
* reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
* case an upgrade adds a module that needs to be initialized.
*
* For example:
*
* [.hljs-theme-light.nopadding]
* ```
* contract MyToken is ERC20Upgradeable {
* function initialize() initializer public {
* __ERC20_init("MyToken", "MTK");
* }
* }
* contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
* function initializeV2() reinitializer(2) public {
* __ERC20Permit_init("MyToken");
* }
* }
* ```
*
* TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
* possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
*
* CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
* that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
*
* [CAUTION]
* ====
* Avoid leaving a contract uninitialized.
*
* An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
* contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
* the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
*
* [.hljs-theme-light.nopadding]
* ```
* /// @custom:oz-upgrades-unsafe-allow constructor
* constructor() {
* _disableInitializers();
* }
* ```
* ====
*/
abstract contract Initializable {
/**
* @dev Indicates that the contract has been initialized.
* @custom:oz-retyped-from bool
*/
uint8 private _initialized;
/**
* @dev Indicates that the contract is in the process of being initialized.
*/
bool private _initializing;
/**
* @dev Triggered when the contract has been initialized or reinitialized.
*/
event Initialized(uint8 version);
/**
* @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
* `onlyInitializing` functions can be used to initialize parent contracts. Equivalent to `reinitializer(1)`.
*/
modifier initializer() {
bool isTopLevelCall = !_initializing;
require(
(isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
"Initializable: contract is already initialized"
);
_initialized = 1;
if (isTopLevelCall) {
_initializing = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
emit Initialized(1);
}
}
/**
* @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
* contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
* used to initialize parent contracts.
*
* `initializer` is equivalent to `reinitializer(1)`, so a reinitializer may be used after the original
* initialization step. This is essential to configure modules that are added through upgrades and that require
* initialization.
*
* Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
* a contract, executing them in the right order is up to the developer or operator.
*/
modifier reinitializer(uint8 version) {
require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
_initialized = version;
_initializing = true;
_;
_initializing = false;
emit Initialized(version);
}
/**
* @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
* {initializer} and {reinitializer} modifiers, directly or indirectly.
*/
modifier onlyInitializing() {
require(_initializing, "Initializable: contract is not initializing");
_;
}
/**
* @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
* Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
* to any version. It is recommended to use this to lock implementation contracts that are designed to be called
* through proxies.
*/
function _disableInitializers() internal virtual {
require(!_initializing, "Initializable: contract is initializing");
if (_initialized < type(uint8).max) {
_initialized = type(uint8).max;
emit Initialized(type(uint8).max);
}
}
}
// File: @openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol
// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)
pragma solidity ^0.8.0;
/**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/
abstract contract ReentrancyGuardUpgradeable is Initializable {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
function __ReentrancyGuard_init() internal onlyInitializing {
__ReentrancyGuard_init_unchained();
}
function __ReentrancyGuard_init_unchained() internal onlyInitializing {
_status = _NOT_ENTERED;
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and making it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
// On the first call to nonReentrant, _notEntered will be true
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
// Any calls to nonReentrant after this point will fail
_status = _ENTERED;
_;
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = _NOT_ENTERED;
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[49] private __gap;
}
// File: @openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
pragma solidity ^0.8.0;
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal onlyInitializing {
}
function __Context_init_unchained() internal onlyInitializing {
}
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[50] private __gap;
}
// File: @openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol
// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)
pragma solidity ^0.8.0;
/**
* @dev Contract module which provides a basic access control mechanism, where
* there is an account (an owner) that can be granted exclusive access to
* specific functions.
*
* By default, the owner account will be the one that deploys the contract. This
* can later be changed with {transferOwnership}.
*
* This module is used through inheritance. It will make available the modifier
* `onlyOwner`, which can be applied to your functions to restrict their use to
* the owner.
*/
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
function __Ownable_init() internal onlyInitializing {
__Ownable_init_unchained();
}
function __Ownable_init_unchained() internal onlyInitializing {
_transferOwnership(_msgSender());
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
_checkOwner();
_;
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
return _owner;
}
/**
* @dev Throws if the sender is not the owner.
*/
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[49] private __gap;
}
// File: contracts/security/IporOwnableUpgradeable.sol
pragma solidity 0.8.16;
contract IporOwnableUpgradeable is OwnableUpgradeable {
address private _appointedOwner;
event AppointedToTransferOwnership(address indexed appointedOwner);
function transferOwnership(address appointedOwner) public override onlyOwner {
require(appointedOwner != address(0), IporErrors.WRONG_ADDRESS);
_appointedOwner = appointedOwner;
emit AppointedToTransferOwnership(appointedOwner);
}
function confirmTransferOwnership() public onlyAppointedOwner {
_appointedOwner = address(0);
_transferOwnership(_msgSender());
}
modifier onlyAppointedOwner() {
require(_appointedOwner == _msgSender(), IporErrors.SENDER_NOT_APPOINTED_OWNER);
_;
}
}
// File: @openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol
// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)
pragma solidity ^0.8.0;
/**
* @dev Contract module which allows children to implement an emergency stop
* mechanism that can be triggered by an authorized account.
*
* This module is used through inheritance. It will make available the
* modifiers `whenNotPaused` and `whenPaused`, which can be applied to
* the functions of your contract. Note that they will not be pausable by
* simply including this module, only once the modifiers are put in place.
*/
abstract contract PausableUpgradeable is Initializable, ContextUpgradeable {
/**
* @dev Emitted when the pause is triggered by `account`.
*/
event Paused(address account);
/**
* @dev Emitted when the pause is lifted by `account`.
*/
event Unpaused(address account);
bool private _paused;
/**
* @dev Initializes the contract in unpaused state.
*/
function __Pausable_init() internal onlyInitializing {
__Pausable_init_unchained();
}
function __Pausable_init_unchained() internal onlyInitializing {
_paused = false;
}
/**
* @dev Modifier to make a function callable only when the contract is not paused.
*
* Requirements:
*
* - The contract must not be paused.
*/
modifier whenNotPaused() {
_requireNotPaused();
_;
}
/**
* @dev Modifier to make a function callable only when the contract is paused.
*
* Requirements:
*
* - The contract must be paused.
*/
modifier whenPaused() {
_requirePaused();
_;
}
/**
* @dev Returns true if the contract is paused, and false otherwise.
*/
function paused() public view virtual returns (bool) {
return _paused;
}
/**
* @dev Throws if the contract is paused.
*/
function _requireNotPaused() internal view virtual {
require(!paused(), "Pausable: paused");
}
/**
* @dev Throws if the contract is not paused.
*/
function _requirePaused() internal view virtual {
require(paused(), "Pausable: not paused");
}
/**
* @dev Triggers stopped state.
*
* Requirements:
*
* - The contract must not be paused.
*/
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
/**
* @dev Returns to normal state.
*
* Requirements:
*
* - The contract must be paused.
*/
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[49] private __gap;
}
// File: @openzeppelin/contracts-upgradeable/proxy/ERC1967/ERC1967UpgradeUpgradeable.sol
// OpenZeppelin Contracts (last updated v4.5.0) (proxy/ERC1967/ERC1967Upgrade.sol)
pragma solidity ^0.8.2;
/**
* @dev This abstract contract provides getters and event emitting update functions for
* https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.
*
* _Available since v4.1._
*
* @custom:oz-upgrades-unsafe-allow delegatecall
*/
abstract contract ERC1967UpgradeUpgradeable is Initializable {
function __ERC1967Upgrade_init() internal onlyInitializing {
}
function __ERC1967Upgrade_init_unchained() internal onlyInitializing {
}
// This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1
bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;
/**
* @dev Storage slot with the address of the current implementation.
* This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is
* validated in the constructor.
*/
bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
/**
* @dev Emitted when the implementation is upgraded.
*/
event Upgraded(address indexed implementation);
/**
* @dev Returns the current implementation address.
*/
function _getImplementation() internal view returns (address) {
return StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value;
}
/**
* @dev Stores a new address in the EIP1967 implementation slot.
*/
function _setImplementation(address newImplementation) private {
require(AddressUpgradeable.isContract(newImplementation), "ERC1967: new implementation is not a contract");
StorageSlotUpgradeable.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
}
/**
* @dev Perform implementation upgrade
*
* Emits an {Upgraded} event.
*/
function _upgradeTo(address newImplementation) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
/**
* @dev Perform implementation upgrade with additional setup call.
*
* Emits an {Upgraded} event.
*/
function _upgradeToAndCall(
address newImplementation,
bytes memory data,
bool forceCall
) internal {
_upgradeTo(newImplementation);
if (data.length > 0 || forceCall) {
_functionDelegateCall(newImplementation, data);
}
}
/**
* @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.
*
* Emits an {Upgraded} event.
*/
function _upgradeToAndCallUUPS(
address newImplementation,
bytes memory data,
bool forceCall
) internal {
// Upgrades from old implementations will perform a rollback test. This test requires the new
// implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing
// this special case will break upgrade paths from old UUPS implementation to new ones.
if (StorageSlotUpgradeable.getBooleanSlot(_ROLLBACK_SLOT).value) {
_setImplementation(newImplementation);
} else {
try IERC1822ProxiableUpgradeable(newImplementation).proxiableUUID() returns (bytes32 slot) {
require(slot == _IMPLEMENTATION_SLOT, "ERC1967Upgrade: unsupported proxiableUUID");
} catch {
revert("ERC1967Upgrade: new implementation is not UUPS");
}
_upgradeToAndCall(newImplementation, data, forceCall);
}
}
/**
* @dev Storage slot with the admin of the contract.
* This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is
* validated in the constructor.
*/
bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
/**
* @dev Emitted when the admin account has changed.
*/
event AdminChanged(address previousAdmin, address newAdmin);
/**
* @dev Returns the current admin.
*/
function _getAdmin() internal view returns (address) {
return StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value;
}
/**
* @dev Stores a new address in the EIP1967 admin slot.
*/
function _setAdmin(address newAdmin) private {
require(newAdmin != address(0), "ERC1967: new admin is the zero address");
StorageSlotUpgradeable.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
}
/**
* @dev Changes the admin of the proxy.
*
* Emits an {AdminChanged} event.
*/
function _changeAdmin(address newAdmin) internal {
emit AdminChanged(_getAdmin(), newAdmin);
_setAdmin(newAdmin);
}
/**
* @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.
* This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.
*/
bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;
/**
* @dev Emitted when the beacon is upgraded.
*/
event BeaconUpgraded(address indexed beacon);
/**
* @dev Returns the current beacon.
*/
function _getBeacon() internal view returns (address) {
return StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value;
}
/**
* @dev Stores a new beacon in the EIP1967 beacon slot.
*/
function _setBeacon(address newBeacon) private {
require(AddressUpgradeable.isContract(newBeacon), "ERC1967: new beacon is not a contract");
require(
AddressUpgradeable.isContract(IBeaconUpgradeable(newBeacon).implementation()),
"ERC1967: beacon implementation is not a contract"
);
StorageSlotUpgradeable.getAddressSlot(_BEACON_SLOT).value = newBeacon;
}
/**
* @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does
* not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).
*
* Emits a {BeaconUpgraded} event.
*/
function _upgradeBeaconToAndCall(
address newBeacon,
bytes memory data,
bool forceCall
) internal {
_setBeacon(newBeacon);
emit BeaconUpgraded(newBeacon);
if (data.length > 0 || forceCall) {
_functionDelegateCall(IBeaconUpgradeable(newBeacon).implementation(), data);
}
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function _functionDelegateCall(address target, bytes memory data) private returns (bytes memory) {
require(AddressUpgradeable.isContract(target), "Address: delegate call to non-contract");
// solhint-disable-next-line avoid-low-level-calls
(bool success, bytes memory returndata) = target.delegatecall(data);
return AddressUpgradeable.verifyCallResult(success, returndata, "Address: low-level delegate call failed");
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[50] private __gap;
}
// File: @openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol
// OpenZeppelin Contracts (last updated v4.5.0) (proxy/utils/UUPSUpgradeable.sol)
pragma solidity ^0.8.0;
/**
* @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an
* {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy.
*
* A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is
* reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing
* `UUPSUpgradeable` with a custom implementation of upgrades.
*
* The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism.
*
* _Available since v4.1._
*/
abstract contract UUPSUpgradeable is Initializable, IERC1822ProxiableUpgradeable, ERC1967UpgradeUpgradeable {
function __UUPSUpgradeable_init() internal onlyInitializing {
}
function __UUPSUpgradeable_init_unchained() internal onlyInitializing {
}
/// @custom:oz-upgrades-unsafe-allow state-variable-immutable state-variable-assignment
address private immutable __self = address(this);
/**
* @dev Check that the execution is being performed through a delegatecall call and that the execution context is
* a proxy contract with an implementation (as defined in ERC1967) pointing to self. This should only be the case
* for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a
* function through ERC1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to
* fail.
*/
modifier onlyProxy() {
require(address(this) != __self, "Function must be called through delegatecall");
require(_getImplementation() == __self, "Function must be called through active proxy");
_;
}
/**
* @dev Check that the execution is not being performed through a delegate call. This allows a function to be
* callable on the implementing contract but not through proxies.
*/
modifier notDelegated() {
require(address(this) == __self, "UUPSUpgradeable: must not be called through delegatecall");
_;
}
/**
* @dev Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the
* implementation. It is used to validate that the this implementation remains valid after an upgrade.
*
* IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
* bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
* function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier.
*/
function proxiableUUID() external view virtual override notDelegated returns (bytes32) {
return _IMPLEMENTATION_SLOT;
}
/**
* @dev Upgrade the implementation of the proxy to `newImplementation`.
*
* Calls {_authorizeUpgrade}.
*
* Emits an {Upgraded} event.
*/
function upgradeTo(address newImplementation) external virtual onlyProxy {
_authorizeUpgrade(newImplementation);
_upgradeToAndCallUUPS(newImplementation, new bytes(0), false);
}
/**
* @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call
* encoded in `data`.
*
* Calls {_authorizeUpgrade}.
*
* Emits an {Upgraded} event.
*/
function upgradeToAndCall(address newImplementation, bytes memory data) external payable virtual onlyProxy {
_authorizeUpgrade(newImplementation);
_upgradeToAndCallUUPS(newImplementation, data, true);
}
/**
* @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by
* {upgradeTo} and {upgradeToAndCall}.
*
* Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}.
*
* ```solidity
* function _authorizeUpgrade(address) internal override onlyOwner {}
* ```
*/
function _authorizeUpgrade(address newImplementation) internal virtual;
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[50] private __gap;
}
// File: contracts/oracles/IporOracle.sol
pragma solidity 0.8.16;
/**
* @title IPOR Index Oracle Contract
*
* @author IPOR Labs
*/
contract IporOracle is
Initializable,
PausableUpgradeable,
UUPSUpgradeable,
IporOwnableUpgradeable,
IIporOracle
{
using SafeCast for uint256;
using IporLogic for IporOracleTypes.IPOR;
mapping(address => uint256) internal _updaters;
mapping(address => IporOracleTypes.IPOR) internal _indexes;
address internal _iporAlgorithmFacade;
modifier onlyUpdater() {
require(_updaters[_msgSender()] == 1, IporOracleErrors.CALLER_NOT_UPDATER);
_;
}
/// @custom:oz-upgrades-unsafe-allow constructor
constructor() {
_disableInitializers();
}
function initialize(
address[] memory assets,
uint32[] memory updateTimestamps,
uint64[] memory exponentialMovingAverages,
uint64[] memory exponentialWeightedMovingVariances
) public initializer {
__Pausable_init_unchained();
__Ownable_init_unchained();
__UUPSUpgradeable_init_unchained();
uint256 assetsLength = assets.length;
for (uint256 i; i != assetsLength; ++i) {
require(assets[i] != address(0), IporErrors.WRONG_ADDRESS);
_indexes[assets[i]] = IporOracleTypes.IPOR(
Constants.WAD_YEAR_IN_SECONDS.toUint128(),
exponentialMovingAverages[i],
exponentialWeightedMovingVariances[i],
0,
updateTimestamps[i]
);
}
}
function getVersion() external pure virtual override returns (uint256) {
return 3;
}
function getIndex(address asset)
external
view
override
returns (
uint256 indexValue,
uint256 ibtPrice,
uint256 exponentialMovingAverage,
uint256 exponentialWeightedMovingVariance,
uint256 lastUpdateTimestamp
)
{
IporOracleTypes.IPOR memory ipor = _indexes[asset];
require(ipor.quasiIbtPrice > 0, IporOracleErrors.ASSET_NOT_SUPPORTED);
return (
indexValue = ipor.indexValue,
ibtPrice = IporMath.division(ipor.quasiIbtPrice, Constants.YEAR_IN_SECONDS),
exponentialMovingAverage = ipor.exponentialMovingAverage,
exponentialWeightedMovingVariance = ipor.exponentialWeightedMovingVariance,
lastUpdateTimestamp = ipor.lastUpdateTimestamp
);
}
function getAccruedIndex(uint256 calculateTimestamp, address asset)
external
view
virtual
override
returns (IporTypes.AccruedIpor memory accruedIpor)
{
IporOracleTypes.IPOR memory ipor = _indexes[asset];
require(ipor.quasiIbtPrice > 0, IporOracleErrors.ASSET_NOT_SUPPORTED);
accruedIpor = IporTypes.AccruedIpor(
ipor.indexValue,
_calculateAccruedIbtPrice(calculateTimestamp, asset),
ipor.exponentialMovingAverage,
ipor.exponentialWeightedMovingVariance
);
}
function getIporAlgorithmFacade() external view override returns (address) {
return _iporAlgorithmFacade;
}
function setIporAlgorithmFacade(address newIporAlgorithmFacade) external onlyOwner {
require(newIporAlgorithmFacade != address(0), IporErrors.WRONG_ADDRESS);
address oldIporAlgorithmFacade = _iporAlgorithmFacade;
_iporAlgorithmFacade = newIporAlgorithmFacade;
emit IporAlgorithmFacadeChanged(
_msgSender(),
oldIporAlgorithmFacade,
newIporAlgorithmFacade
);
}
function calculateAccruedIbtPrice(address asset, uint256 calculateTimestamp)
external
view
override
returns (uint256)
{
return _calculateAccruedIbtPrice(calculateTimestamp, asset);
}
function updateIndex(address asset, uint256 indexValue)
external
override
onlyUpdater
whenNotPaused
{
uint256[] memory indexes = new uint256[](1);
indexes[0] = indexValue;
address[] memory assets = new address[](1);
assets[0] = asset;
_updateIndexes(assets, indexes, block.timestamp);
}
function updateIndex(address asset)
external
override
onlyUpdater
whenNotPaused
returns (IporTypes.AccruedIpor memory accruedIpor)
{
IporOracleTypes.IPOR memory ipor = _indexes[asset];
require(ipor.quasiIbtPrice > 0, IporOracleErrors.ASSET_NOT_SUPPORTED);
address iporAlgorithmFacade = _iporAlgorithmFacade;
require(iporAlgorithmFacade != address(0), IporOracleErrors.IPOR_ALGORITHM_ADDRESS_NOT_SET);
uint256 newIndexValue = IIporAlgorithm(iporAlgorithmFacade).calculateIpor(asset);
(
accruedIpor.indexValue,
accruedIpor.ibtPrice,
accruedIpor.exponentialMovingAverage,
accruedIpor.exponentialWeightedMovingVariance,
) = _updateIndex(asset, newIndexValue, block.timestamp);
}
function updateIndexes(address[] memory assets, uint256[] memory indexValues)
external
override
onlyUpdater
whenNotPaused
{
_updateIndexes(assets, indexValues, block.timestamp);
}
function addUpdater(address updater) external override onlyOwner whenNotPaused {
_updaters[updater] = 1;
emit IporIndexAddUpdater(updater);
}
function removeUpdater(address updater) external override onlyOwner whenNotPaused {
_updaters[updater] = 0;
emit IporIndexRemoveUpdater(updater);
}
function isUpdater(address updater) external view override returns (uint256) {
return _updaters[updater];
}
function addAsset(
address asset,
uint256 updateTimestamp,
uint256 exponentialMovingAverage,
uint256 exponentialWeightedMovingVariance
) external override onlyOwner whenNotPaused {
require(asset != address(0), IporErrors.WRONG_ADDRESS);
require(
_indexes[asset].quasiIbtPrice == 0,
IporOracleErrors.CANNOT_ADD_ASSET_ASSET_ALREADY_EXISTS
);
_indexes[asset] = IporOracleTypes.IPOR(
Constants.WAD_YEAR_IN_SECONDS.toUint128(),
exponentialMovingAverage.toUint64(),
exponentialWeightedMovingVariance.toUint64(),
0,
updateTimestamp.toUint32()
);
emit IporIndexAddAsset(
asset,
exponentialMovingAverage,
exponentialWeightedMovingVariance,
updateTimestamp
);
}
function removeAsset(address asset) external override onlyOwner whenNotPaused {
require(asset != address(0), IporErrors.WRONG_ADDRESS);
require(_indexes[asset].quasiIbtPrice > 0, IporOracleErrors.ASSET_NOT_SUPPORTED);
delete _indexes[asset];
emit IporIndexRemoveAsset(asset);
}
function isAssetSupported(address asset) external view override returns (bool) {
return _indexes[asset].quasiIbtPrice > 0;
}
function pause() external override onlyOwner {
_pause();
}
function unpause() external override onlyOwner {
_unpause();
}
function _updateIndexes(
address[] memory assets,
uint256[] memory indexValues,
uint256 updateTimestamp
) internal onlyUpdater {
require(assets.length == indexValues.length, IporErrors.INPUT_ARRAYS_LENGTH_MISMATCH);
for (uint256 i; i != assets.length; ++i) {
_updateIndex(assets[i], indexValues[i], updateTimestamp);
}
}
function _updateIndex(
address asset,
uint256 indexValue,
uint256 updateTimestamp
)
internal
returns (
uint256 newIndexValue,
uint256 newIbtPrice,
uint256 newExponentialMovingAverage,
uint256 newExponentialWeightedMovingVariance,
uint256 lastUpdateTimestamp
)
{
IporOracleTypes.IPOR memory ipor = _indexes[asset];
require(ipor.quasiIbtPrice > 0, IporOracleErrors.ASSET_NOT_SUPPORTED);
require(
ipor.lastUpdateTimestamp <= updateTimestamp,
IporOracleErrors.INDEX_TIMESTAMP_HIGHER_THAN_ACCRUE_TIMESTAMP
);
newExponentialMovingAverage = IporLogic.calculateExponentialMovingAverage(
ipor.exponentialMovingAverage,
indexValue,
_decayFactorValue(updateTimestamp - ipor.lastUpdateTimestamp)
);
newExponentialWeightedMovingVariance = IporLogic.calculateExponentialWeightedMovingVariance(
ipor.exponentialWeightedMovingVariance,
newExponentialMovingAverage,
indexValue,
_decayFactorValue(updateTimestamp - ipor.lastUpdateTimestamp)
);
uint256 newQuasiIbtPrice = ipor.accrueQuasiIbtPrice(updateTimestamp);
_indexes[asset] = IporOracleTypes.IPOR(
newQuasiIbtPrice.toUint128(),
newExponentialMovingAverage.toUint64(),
newExponentialWeightedMovingVariance.toUint64(),
indexValue.toUint64(),
updateTimestamp.toUint32()
);
newIndexValue = indexValue;
newIbtPrice = IporMath.division(newQuasiIbtPrice, Constants.YEAR_IN_SECONDS);
lastUpdateTimestamp = updateTimestamp;
emit IporIndexUpdate(
asset,
indexValue,
newQuasiIbtPrice,
newExponentialMovingAverage,
newExponentialWeightedMovingVariance,
updateTimestamp
);
}
function _decayFactorValue(uint256 timeFromLastPublication)
internal
view
virtual
returns (uint256)
{
return DecayFactorCalculation.calculate(timeFromLastPublication);
}
function _calculateAccruedIbtPrice(uint256 calculateTimestamp, address asset)
internal
view
returns (uint256)
{
return
IporMath.division(
_indexes[asset].accrueQuasiIbtPrice(calculateTimestamp),
Constants.YEAR_IN_SECONDS
);
}
//solhint-disable no-empty-blocks
function _authorizeUpgrade(address) internal override onlyOwner {}
}