编译器
0.8.18+commit.87f61d96
文件 1 的 68：Address.sol
pragma solidity ^0.8.1;
library Address {
function isContract(address account) internal view returns (bool) {
return account.code.length > 0;
}
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");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
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");
}
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");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
文件 2 的 68：AjnaProxyActions.sol
pragma solidity ^0.8.18;
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {IERC20Pool} from "@ajna-core/interfaces/pool/erc20/IERC20Pool.sol";
import {IWETH} from "../IWETH.sol";
interface IAjnaPoolUtilsInfo {
function priceToIndex(uint256 price_) external pure returns (uint256);
function borrowerInfo(address pool_, address borrower_)
external
view
returns (
uint256 debt_,
uint256 collateral_,
uint256 index_
);
function poolPricesInfo(address ajnaPool_)
external
view
returns (
uint256 hpb_,
uint256 hpbIndex_,
uint256 htp_,
uint256 htpIndex_,
uint256 lup_,
uint256 lupIndex_
);
function lpToQuoteTokens(
address ajnaPool_,
uint256 lp_,
uint256 index_
) external view returns (uint256 quoteAmount_);
function bucketInfo(address ajnaPool_, uint256 index_)
external
view
returns (
uint256 price_,
uint256 quoteTokens_,
uint256 collateral_,
uint256 bucketLP_,
uint256 scale_,
uint256 exchangeRate_
);
}
interface IAccountGuard {
function owners(address) external view returns (address);
function owner() external view returns (address);
function setWhitelist(address target, bool status) external;
function canCall(address proxy, address operator)
external
view
returns (bool);
function permit(
address caller,
address target,
bool allowance
) external;
function isWhitelisted(address target) external view returns (bool);
function isWhitelistedSend(address target) external view returns (bool);
}
contract AjnaProxyActions {
IAjnaPoolUtilsInfo public immutable poolInfoUtils;
IERC20 public immutable ajnaToken;
address public immutable WETH;
address public immutable GUARD;
address public immutable deployer;
string public constant ajnaVersion = "Ajna_rc14";
using SafeERC20 for IERC20;
constructor(
IAjnaPoolUtilsInfo _poolInfoUtils,
IERC20 _ajnaToken,
address _WETH,
address _GUARD
) {
require(
address(_poolInfoUtils) != address(0),
"apa/pool-info-utils-zero-address"
);
require(
address(_ajnaToken) != address(0) || block.chainid != 1,
"apa/ajna-token-zero-address"
);
require(_WETH != address(0), "apa/weth-zero-address");
require(_GUARD != address(0), "apa/guard-zero-address");
poolInfoUtils = _poolInfoUtils;
ajnaToken = _ajnaToken;
WETH = _WETH;
GUARD = _GUARD;
deployer = msg.sender;
}
event ProxyActionsOperation(bytes32 indexed name);
event CreatePosition(
address indexed proxyAddress,
string protocol,
string positionType,
address collateralToken,
address debtToken
);
function _send(address token, uint256 amount) internal {
if (token == WETH) {
IWETH(WETH).withdraw(amount);
payable(msg.sender).transfer(amount);
} else {
IERC20(token).safeTransfer(msg.sender, amount);
}
}
function _pull(address token, uint256 amount) internal {
if (token == WETH) {
IWETH(WETH).deposit{value: amount}();
} else {
IERC20(token).safeTransferFrom(msg.sender, address(this), amount);
}
}
function _stampLoan(IERC20Pool pool, bool stamploanEnabled) internal {
if (stamploanEnabled) {
pool.stampLoan();
}
}
function _supplyQuote(
IERC20Pool pool,
uint256 amount,
uint256 price
) internal returns (uint256 bucketLP, uint256 addedAmount) {
address debtToken = pool.quoteTokenAddress();
_pull(debtToken, amount);
uint256 index = convertPriceToIndex(price);
IERC20(debtToken).approve(address(pool), amount);
(bucketLP, addedAmount) = pool.addQuoteToken(
amount * pool.quoteTokenScale(),
index,
block.timestamp + 1
);
}
function _moveQuote(
IERC20Pool pool,
uint256 oldPrice,
uint256 newPrice
) internal {
uint256 oldIndex = convertPriceToIndex(oldPrice);
pool.moveQuoteToken(
type(uint256).max,
oldIndex,
convertPriceToIndex(newPrice),
block.timestamp + 1
);
}
function _withdrawQuote(
IERC20Pool pool,
uint256 amount,
uint256 price
) internal {
address debtToken = pool.quoteTokenAddress();
uint256 index = convertPriceToIndex(price);
uint256 withdrawnBalanceWAD;
if (amount == type(uint256).max) {
(withdrawnBalanceWAD, ) = pool.removeQuoteToken(
type(uint256).max,
index
);
} else {
(withdrawnBalanceWAD, ) = pool.removeQuoteToken(
(amount * pool.quoteTokenScale()),
index
);
}
uint256 withdrawnBalance = _roundToScale(
withdrawnBalanceWAD,
pool.quoteTokenScale()
) / pool.quoteTokenScale();
_send(debtToken, withdrawnBalance);
}
function _removeCollateral(IERC20Pool pool, uint256 price)
internal
returns (uint256 withdrawnBalance)
{
address collateralToken = pool.collateralAddress();
uint256 index = convertPriceToIndex(price);
(uint256 withdrawnBalanceWAD, ) = pool.removeCollateral(
type(uint256).max,
index
);
withdrawnBalance =
_roundToScale(withdrawnBalanceWAD, pool.collateralScale()) /
pool.collateralScale();
_send(collateralToken, withdrawnBalance);
}
function depositCollateral(
IERC20Pool pool,
uint256 collateralAmount,
uint256 price,
bool stamploanEnabled
) public payable {
address collateralToken = pool.collateralAddress();
_pull(collateralToken, collateralAmount);
uint256 index = convertPriceToIndex(price);
IERC20(collateralToken).approve(address(pool), collateralAmount);
pool.drawDebt(
address(this),
0,
index,
collateralAmount * pool.collateralScale()
);
_stampLoan(pool, stamploanEnabled);
emit ProxyActionsOperation("AjnaDeposit");
}
function drawDebt(
IERC20Pool pool,
uint256 debtAmount,
uint256 price
) public {
address debtToken = pool.quoteTokenAddress();
uint256 index = convertPriceToIndex(price);
pool.drawDebt(
address(this),
debtAmount * pool.quoteTokenScale(),
index,
0
);
_send(debtToken, debtAmount);
emit ProxyActionsOperation("AjnaBorrow");
}
function depositCollateralAndDrawDebt(
IERC20Pool pool,
uint256 debtAmount,
uint256 collateralAmount,
uint256 price
) public {
address debtToken = pool.quoteTokenAddress();
address collateralToken = pool.collateralAddress();
uint256 index = convertPriceToIndex(price);
_pull(collateralToken, collateralAmount);
IERC20(collateralToken).approve(address(pool), collateralAmount);
pool.drawDebt(
address(this),
debtAmount * pool.quoteTokenScale(),
index,
collateralAmount * pool.collateralScale()
);
_send(debtToken, debtAmount);
emit ProxyActionsOperation("AjnaDepositBorrow");
}
function depositAndDraw(
IERC20Pool pool,
uint256 debtAmount,
uint256 collateralAmount,
uint256 price,
bool stamploanEnabled
) public payable {
if (debtAmount > 0 && collateralAmount > 0) {
depositCollateralAndDrawDebt(
pool,
debtAmount,
collateralAmount,
price
);
} else if (debtAmount > 0) {
drawDebt(pool, debtAmount, price);
} else if (collateralAmount > 0) {
depositCollateral(pool, collateralAmount, price, stamploanEnabled);
}
}
function repayDebt(
IERC20Pool pool,
uint256 amount,
bool stamploanEnabled
) public payable {
address debtToken = pool.quoteTokenAddress();
_pull(debtToken, amount);
IERC20(debtToken).approve(address(pool), amount);
(, , , , , uint256 lupIndex_) = poolInfoUtils.poolPricesInfo(
address(pool)
);
uint256 repaidAmountWAD = pool.repayDebt(
address(this),
amount * pool.quoteTokenScale(),
0,
address(this),
lupIndex_
);
_stampLoan(pool, stamploanEnabled);
uint256 repaidAmount = _roundUpToScale(
repaidAmountWAD,
pool.quoteTokenScale()
) / pool.quoteTokenScale();
uint256 leftoverBalance = amount - repaidAmount;
if (leftoverBalance > 0) {
_send(debtToken, leftoverBalance);
}
IERC20(debtToken).safeApprove(address(pool), 0);
emit ProxyActionsOperation("AjnaRepay");
}
function withdrawCollateral(IERC20Pool pool, uint256 amount) public {
address collateralToken = pool.collateralAddress();
(, , , , , uint256 lupIndex_) = poolInfoUtils.poolPricesInfo(
address(pool)
);
pool.repayDebt(
address(this),
0,
amount * pool.collateralScale(),
address(this),
lupIndex_
);
_send(collateralToken, amount);
emit ProxyActionsOperation("AjnaWithdraw");
}
function repayDebtAndWithdrawCollateral(
IERC20Pool pool,
uint256 debtAmount,
uint256 collateralAmount
) public {
address debtToken = pool.quoteTokenAddress();
address collateralToken = pool.collateralAddress();
_pull(debtToken, debtAmount);
IERC20(debtToken).approve(address(pool), debtAmount);
(, , , , , uint256 lupIndex_) = poolInfoUtils.poolPricesInfo(
address(pool)
);
uint256 repaidAmountWAD = pool.repayDebt(
address(this),
debtAmount * pool.quoteTokenScale(),
collateralAmount * pool.collateralScale(),
address(this),
lupIndex_
);
_send(collateralToken, collateralAmount);
uint256 repaidAmount = _roundUpToScale(
repaidAmountWAD,
pool.quoteTokenScale()
) / pool.quoteTokenScale();
uint256 quoteLeftoverBalance = debtAmount - repaidAmount;
if (quoteLeftoverBalance > 0) {
_send(debtToken, quoteLeftoverBalance);
}
IERC20(debtToken).safeApprove(address(pool), 0);
emit ProxyActionsOperation("AjnaRepayWithdraw");
}
function repayWithdraw(
IERC20Pool pool,
uint256 debtAmount,
uint256 collateralAmount,
bool stamploanEnabled
) external payable {
if (debtAmount > 0 && collateralAmount > 0) {
repayDebtAndWithdrawCollateral(pool, debtAmount, collateralAmount);
} else if (debtAmount > 0) {
repayDebt(pool, debtAmount, stamploanEnabled);
} else if (collateralAmount > 0) {
withdrawCollateral(pool, collateralAmount);
}
}
function repayAndClose(IERC20Pool pool) public payable {
address collateralToken = pool.collateralAddress();
address debtToken = pool.quoteTokenAddress();
(uint256 debt, uint256 collateral, ) = poolInfoUtils.borrowerInfo(
address(pool),
address(this)
);
uint256 debtPlusBuffer = _roundUpToScale(debt, pool.quoteTokenScale());
uint256 amountDebt = debtPlusBuffer / pool.quoteTokenScale();
_pull(debtToken, amountDebt);
IERC20(debtToken).approve(address(pool), amountDebt);
(, , , , , uint256 lupIndex_) = poolInfoUtils.poolPricesInfo(
address(pool)
);
pool.repayDebt(
address(this),
debtPlusBuffer,
collateral,
address(this),
lupIndex_
);
uint256 amountCollateral = collateral / pool.collateralScale();
_send(collateralToken, amountCollateral);
IERC20(debtToken).safeApprove(address(pool), 0);
emit ProxyActionsOperation("AjnaRepayAndClose");
}
function openPosition(
IERC20Pool pool,
uint256 debtAmount,
uint256 collateralAmount,
uint256 price
) public payable {
emit CreatePosition(
address(this),
ajnaVersion,
"Borrow",
pool.collateralAddress(),
pool.quoteTokenAddress()
);
depositAndDraw(pool, debtAmount, collateralAmount, price, false);
}
function openEarnPosition(
IERC20Pool pool,
uint256 depositAmount,
uint256 price
) public payable {
emit CreatePosition(
address(this),
ajnaVersion,
"Earn",
pool.collateralAddress(),
pool.quoteTokenAddress()
);
_validateBucketState(pool, convertPriceToIndex(price));
_supplyQuote(pool, depositAmount, price);
emit ProxyActionsOperation("AjnaSupplyQuote");
}
function supplyQuote(
IERC20Pool pool,
uint256 amount,
uint256 price
) public payable {
_validateBucketState(pool, convertPriceToIndex(price));
_supplyQuote(pool, amount, price);
emit ProxyActionsOperation("AjnaSupplyQuote");
}
function withdrawQuote(
IERC20Pool pool,
uint256 amount,
uint256 price
) public {
_withdrawQuote(pool, amount, price);
emit ProxyActionsOperation("AjnaWithdrawQuote");
}
function moveQuote(
IERC20Pool pool,
uint256 oldPrice,
uint256 newPrice
) public {
_validateBucketState(pool, convertPriceToIndex(newPrice));
_moveQuote(pool, oldPrice, newPrice);
emit ProxyActionsOperation("AjnaMoveQuote");
}
function supplyAndMoveQuote(
IERC20Pool pool,
uint256 amountToAdd,
uint256 oldPrice,
uint256 newPrice
) public payable {
uint256 newIndex = convertPriceToIndex(newPrice);
_validateBucketState(pool, newIndex);
_supplyQuote(pool, amountToAdd, newPrice);
_validateBucketState(pool, newIndex);
_moveQuote(pool, oldPrice, newPrice);
emit ProxyActionsOperation("AjnaSupplyAndMoveQuote");
}
function withdrawAndMoveQuote(
IERC20Pool pool,
uint256 amountToWithdraw,
uint256 oldPrice,
uint256 newPrice
) public {
_withdrawQuote(pool, amountToWithdraw, oldPrice);
_validateBucketState(pool, convertPriceToIndex(newPrice));
_moveQuote(pool, oldPrice, newPrice);
emit ProxyActionsOperation("AjnaWithdrawAndMoveQuote");
}
function removeCollateral(IERC20Pool pool, uint256 price) public {
_removeCollateral(pool, price);
emit ProxyActionsOperation("AjnaRemoveCollateral");
}
function convertPriceToIndex(uint256 price) public view returns (uint256) {
return poolInfoUtils.priceToIndex(price);
}
function _validateBucketState(IERC20Pool pool, uint256 bucket) public view {
(, , , uint256 bucketLP_, , ) = poolInfoUtils.bucketInfo(
address(pool),
bucket
);
require(
bucketLP_ == 0 || bucketLP_ > 1_000_000,
"apa/bucket-lps-invalid"
);
}
function getQuoteAmount(IERC20Pool pool, uint256 price)
public
view
returns (uint256 quoteAmount)
{
uint256 index = convertPriceToIndex(price);
(uint256 lpCount, ) = pool.lenderInfo(index, address(this));
quoteAmount = poolInfoUtils.lpToQuoteTokens(
address(pool),
lpCount,
index
);
}
function _roundToScale(uint256 amount_, uint256 tokenScale_)
internal
pure
returns (uint256 scaledAmount_)
{
scaledAmount_ = (amount_ / tokenScale_) * tokenScale_;
}
function _roundUpToScale(uint256 amount_, uint256 tokenScale_)
internal
pure
returns (uint256 scaledAmount_)
{
if (amount_ % tokenScale_ == 0) scaledAmount_ = amount_;
else scaledAmount_ = _roundToScale(amount_, tokenScale_) + tokenScale_;
}
}
文件 3 的 68：Auction.sol
pragma solidity >=0.8.18;
import {Maths} from "../libraries/Maths.sol";
import {Governance} from "../utils/Governance.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import {ITaker} from "../interfaces/ITaker.sol";
interface IHook {
function kickable(address _fromToken) external view returns (uint256);
function auctionKicked(address _fromToken) external returns (uint256);
function preTake(
address _fromToken,
uint256 _amountToTake,
uint256 _amountToPay
) external;
function postTake(
address _toToken,
uint256 _amountTaken,
uint256 _amountPayed
) external;
}
contract Auction is Governance, ReentrancyGuard {
using SafeERC20 for ERC20;
event AuctionEnabled(
bytes32 auctionId,
address indexed from,
address indexed to,
address indexed auctionAddress
);
event AuctionDisabled(
bytes32 auctionId,
address indexed from,
address indexed to,
address indexed auctionAddress
);
event AuctionKicked(bytes32 auctionId, uint256 available);
event AuctionTaken(
bytes32 auctionId,
uint256 amountTaken,
uint256 amountLeft
);
struct TokenInfo {
address tokenAddress;
uint96 scaler;
}
struct AuctionInfo {
TokenInfo fromInfo;
uint96 kicked;
address receiver;
uint128 initialAvailable;
uint128 currentAvailable;
}
struct Hook {
address hook;
bool kickable;
bool kick;
bool preTake;
bool postTake;
}
uint256 internal constant WAD = 1e18;
uint256 internal constant MINUTE_HALF_LIFE =
0.988514020352896135_356867505 * 1e27;
TokenInfo internal wantInfo;
Hook internal hook_;
uint256 public startingPrice;
uint256 public auctionLength;
uint256 public auctionCooldown;
mapping(bytes32 => AuctionInfo) public auctions;
bytes32[] public enabledAuctions;
constructor() Governance(msg.sender) {}
function initialize(
address _want,
address _hook,
address _governance,
uint256 _auctionLength,
uint256 _auctionCooldown,
uint256 _startingPrice
) external virtual {
require(auctionLength == 0, "initialized");
require(_want != address(0), "ZERO ADDRESS");
require(_auctionLength != 0, "length");
require(_auctionLength < _auctionCooldown, "cooldown");
require(_startingPrice != 0, "starting price");
uint256 decimals = ERC20(_want).decimals();
require(decimals <= 18, "unsupported decimals");
wantInfo = TokenInfo({
tokenAddress: _want,
scaler: uint96(WAD / 10 ** decimals)
});
if (_hook != address(0)) {
hook_ = Hook({
hook: _hook,
kickable: true,
kick: true,
preTake: true,
postTake: true
});
}
governance = _governance;
auctionLength = _auctionLength;
auctionCooldown = _auctionCooldown;
startingPrice = _startingPrice;
}
function want() public view virtual returns (address) {
return wantInfo.tokenAddress;
}
function hook() external view virtual returns (address) {
return hook_.hook;
}
function getHookFlags()
external
view
virtual
returns (bool, bool, bool, bool)
{
Hook memory _hook = hook_;
return (_hook.kickable, _hook.kick, _hook.preTake, _hook.postTake);
}
function numberOfEnabledAuctions() external view virtual returns (uint256) {
return enabledAuctions.length;
}
function getAuctionId(address _from) public view virtual returns (bytes32) {
return keccak256(abi.encodePacked(_from, want(), address(this)));
}
function auctionInfo(
bytes32 _auctionId
)
public
view
virtual
returns (
address _from,
address _to,
uint256 _kicked,
uint256 _available
)
{
AuctionInfo memory auction = auctions[_auctionId];
return (
auction.fromInfo.tokenAddress,
want(),
auction.kicked,
auction.kicked + auctionLength > block.timestamp
? auction.currentAvailable
: 0
);
}
function kickable(
bytes32 _auctionId
) external view virtual returns (uint256) {
if (auctions[_auctionId].kicked + auctionCooldown > block.timestamp) {
return 0;
}
Hook memory _hook = hook_;
if (_hook.kickable) {
return
IHook(_hook.hook).kickable(
auctions[_auctionId].fromInfo.tokenAddress
);
} else {
return
ERC20(auctions[_auctionId].fromInfo.tokenAddress).balanceOf(
address(this)
);
}
}
function getAmountNeeded(
bytes32 _auctionId,
uint256 _amountToTake
) external view virtual returns (uint256) {
return
_getAmountNeeded(
auctions[_auctionId],
_amountToTake,
block.timestamp
);
}
function getAmountNeeded(
bytes32 _auctionId,
uint256 _amountToTake,
uint256 _timestamp
) external view virtual returns (uint256) {
return
_getAmountNeeded(auctions[_auctionId], _amountToTake, _timestamp);
}
function _getAmountNeeded(
AuctionInfo memory _auction,
uint256 _amountToTake,
uint256 _timestamp
) internal view virtual returns (uint256) {
return
(_amountToTake *
_auction.fromInfo.scaler *
_price(
_auction.kicked,
_auction.initialAvailable * _auction.fromInfo.scaler,
_timestamp
)) /
1e18 /
wantInfo.scaler;
}
function price(bytes32 _auctionId) external view virtual returns (uint256) {
return price(_auctionId, block.timestamp);
}
function price(
bytes32 _auctionId,
uint256 _timestamp
) public view virtual returns (uint256) {
return
_price(
auctions[_auctionId].kicked,
auctions[_auctionId].initialAvailable *
auctions[_auctionId].fromInfo.scaler,
_timestamp
) / wantInfo.scaler;
}
function _price(
uint256 _kicked,
uint256 _available,
uint256 _timestamp
) internal view virtual returns (uint256) {
if (_available == 0) return 0;
uint256 secondsElapsed = _timestamp - _kicked;
if (secondsElapsed > auctionLength) return 0;
uint256 hoursComponent = 1e27 >> (secondsElapsed / 3600);
uint256 minutesComponent = Maths.rpow(
MINUTE_HALF_LIFE,
(secondsElapsed % 3600) / 60
);
uint256 initialPrice = Maths.wdiv(startingPrice * 1e18, _available);
return
(initialPrice * Maths.rmul(hoursComponent, minutesComponent)) /
1e27;
}
function enable(address _from) external virtual returns (bytes32) {
return enable(_from, msg.sender);
}
function enable(
address _from,
address _receiver
) public virtual onlyGovernance returns (bytes32 _auctionId) {
address _want = want();
require(_from != address(0) && _from != _want, "ZERO ADDRESS");
require(
_receiver != address(0) && _receiver != address(this),
"receiver"
);
uint256 decimals = ERC20(_from).decimals();
require(decimals <= 18, "unsupported decimals");
_auctionId = getAuctionId(_from);
require(
auctions[_auctionId].fromInfo.tokenAddress == address(0),
"already enabled"
);
auctions[_auctionId].fromInfo = TokenInfo({
tokenAddress: _from,
scaler: uint96(WAD / 10 ** decimals)
});
auctions[_auctionId].receiver = _receiver;
enabledAuctions.push(_auctionId);
emit AuctionEnabled(_auctionId, _from, _want, address(this));
}
function disable(address _from) external virtual {
disable(_from, 0);
}
function disable(
address _from,
uint256 _index
) public virtual onlyGovernance {
bytes32 _auctionId = getAuctionId(_from);
require(
auctions[_auctionId].fromInfo.tokenAddress != address(0),
"not enabled"
);
delete auctions[_auctionId];
bytes32[] memory _enabledAuctions = enabledAuctions;
if (_enabledAuctions[_index] != _auctionId) {
for (uint256 i = 0; i < _enabledAuctions.length; ++i) {
if (_enabledAuctions[i] == _auctionId) {
_index = i;
break;
}
}
}
if (_index < _enabledAuctions.length - 1) {
_enabledAuctions[_index] = _enabledAuctions[
_enabledAuctions.length - 1
];
enabledAuctions = _enabledAuctions;
}
enabledAuctions.pop();
emit AuctionDisabled(_auctionId, _from, want(), address(this));
}
function setHookFlags(
bool _kickable,
bool _kick,
bool _preTake,
bool _postTake
) external virtual onlyGovernance {
address _hook = hook_.hook;
require(_hook != address(0), "no hook set");
hook_ = Hook({
hook: _hook,
kickable: _kickable,
kick: _kick,
preTake: _preTake,
postTake: _postTake
});
}
function kick(
bytes32 _auctionId
) external virtual nonReentrant returns (uint256 available) {
address _fromToken = auctions[_auctionId].fromInfo.tokenAddress;
require(_fromToken != address(0), "not enabled");
require(
block.timestamp > auctions[_auctionId].kicked + auctionCooldown,
"too soon"
);
Hook memory _hook = hook_;
if (_hook.kick) {
available = IHook(_hook.hook).auctionKicked(_fromToken);
} else {
available = ERC20(_fromToken).balanceOf(address(this));
}
require(available != 0, "nothing to kick");
auctions[_auctionId].kicked = uint96(block.timestamp);
auctions[_auctionId].initialAvailable = uint128(available);
auctions[_auctionId].currentAvailable = uint128(available);
emit AuctionKicked(_auctionId, available);
}
function take(bytes32 _auctionId) external virtual returns (uint256) {
return _take(_auctionId, type(uint256).max, msg.sender, new bytes(0));
}
function take(
bytes32 _auctionId,
uint256 _maxAmount
) external virtual returns (uint256) {
return _take(_auctionId, _maxAmount, msg.sender, new bytes(0));
}
function take(
bytes32 _auctionId,
uint256 _maxAmount,
address _receiver
) external virtual returns (uint256) {
return _take(_auctionId, _maxAmount, _receiver, new bytes(0));
}
function take(
bytes32 _auctionId,
uint256 _maxAmount,
address _receiver,
bytes calldata _data
) external virtual returns (uint256) {
return _take(_auctionId, _maxAmount, _receiver, _data);
}
function _take(
bytes32 _auctionId,
uint256 _maxAmount,
address _receiver,
bytes memory _data
) internal virtual nonReentrant returns (uint256 _amountTaken) {
AuctionInfo memory auction = auctions[_auctionId];
require(
auction.kicked + auctionLength >= block.timestamp,
"not kicked"
);
_amountTaken = auction.currentAvailable > _maxAmount
? _maxAmount
: auction.currentAvailable;
uint256 needed = _getAmountNeeded(
auction,
_amountTaken,
block.timestamp
);
require(needed != 0, "zero needed");
uint256 left;
unchecked {
left = auction.currentAvailable - _amountTaken;
}
auctions[_auctionId].currentAvailable = uint128(left);
Hook memory _hook = hook_;
if (_hook.preTake) {
IHook(_hook.hook).preTake(
auction.fromInfo.tokenAddress,
_amountTaken,
needed
);
}
ERC20(auction.fromInfo.tokenAddress).safeTransfer(
_receiver,
_amountTaken
);
if (_data.length != 0) {
ITaker(_receiver).auctionTakeCallback(
_auctionId,
msg.sender,
_amountTaken,
needed,
_data
);
}
address _want = want();
ERC20(_want).safeTransferFrom(msg.sender, auction.receiver, needed);
if (_hook.postTake) {
IHook(_hook.hook).postTake(_want, _amountTaken, needed);
}
emit AuctionTaken(_auctionId, _amountTaken, left);
}
}
文件 4 的 68：AuctionFactory.sol
pragma solidity >=0.8.18;
import {Auction} from "./Auction.sol";
import {Clonable} from "../utils/Clonable.sol";
contract AuctionFactory is Clonable {
event DeployedNewAuction(address indexed auction, address indexed want);
uint256 public constant DEFAULT_AUCTION_LENGTH = 1 days;
uint256 public constant DEFAULT_AUCTION_COOLDOWN = 5 days;
uint256 public constant DEFAULT_STARTING_PRICE = 1_000_000;
address[] public auctions;
constructor() {
original = address(new Auction());
}
function createNewAuction(address _want) external returns (address) {
return
_createNewAuction(
_want,
address(0),
msg.sender,
DEFAULT_AUCTION_LENGTH,
DEFAULT_AUCTION_COOLDOWN,
DEFAULT_STARTING_PRICE
);
}
function createNewAuction(
address _want,
address _hook
) external returns (address) {
return
_createNewAuction(
_want,
_hook,
msg.sender,
DEFAULT_AUCTION_LENGTH,
DEFAULT_AUCTION_COOLDOWN,
DEFAULT_STARTING_PRICE
);
}
function createNewAuction(
address _want,
address _hook,
address _governance
) external returns (address) {
return
_createNewAuction(
_want,
_hook,
_governance,
DEFAULT_AUCTION_LENGTH,
DEFAULT_AUCTION_COOLDOWN,
DEFAULT_STARTING_PRICE
);
}
function createNewAuction(
address _want,
address _hook,
address _governance,
uint256 _auctionLength
) external returns (address) {
return
_createNewAuction(
_want,
_hook,
_governance,
_auctionLength,
DEFAULT_AUCTION_COOLDOWN,
DEFAULT_STARTING_PRICE
);
}
function createNewAuction(
address _want,
address _hook,
address _governance,
uint256 _auctionLength,
uint256 _auctionCooldown
) external returns (address) {
return
_createNewAuction(
_want,
_hook,
_governance,
_auctionLength,
_auctionCooldown,
DEFAULT_STARTING_PRICE
);
}
function createNewAuction(
address _want,
address _hook,
address _governance,
uint256 _auctionLength,
uint256 _auctionCooldown,
uint256 _startingPrice
) external returns (address) {
return
_createNewAuction(
_want,
_hook,
_governance,
_auctionLength,
_auctionCooldown,
_startingPrice
);
}
function _createNewAuction(
address _want,
address _hook,
address _governance,
uint256 _auctionLength,
uint256 _auctionCooldown,
uint256 _startingPrice
) internal returns (address _newAuction) {
_newAuction = _clone();
Auction(_newAuction).initialize(
_want,
_hook,
_governance,
_auctionLength,
_auctionCooldown,
_startingPrice
);
auctions.push(_newAuction);
emit DeployedNewAuction(_newAuction, _want);
}
function getAllAuctions() external view returns (address[] memory) {
return auctions;
}
function numberOfAuctions() external view returns (uint256) {
return auctions.length;
}
}
文件 5 的 68：AuctionSwapper.sol
pragma solidity >=0.8.18;
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {AuctionFactory, Auction} from "../Auctions/AuctionFactory.sol";
contract AuctionSwapper {
using SafeERC20 for ERC20;
modifier onlyAuction() {
_isAuction();
_;
}
function _isAuction() internal view virtual {
require(msg.sender == auction, "!auction");
}
address public constant auctionFactory =
0xE6aB098E8582178A76DC80d55ca304d1Dec11AD8;
address public auction;
function _enableAuction(
address _from,
address _want
) internal virtual returns (bytes32) {
return _enableAuction(_from, _want, 1 days, 3 days, 1e6);
}
function _enableAuction(
address _from,
address _want,
uint256 _auctionLength,
uint256 _auctionCooldown,
uint256 _startingPrice
) internal virtual returns (bytes32) {
address _auction = auction;
if (_auction == address(0)) {
_auction = AuctionFactory(auctionFactory).createNewAuction(
_want,
address(this),
address(this),
_auctionLength,
_auctionCooldown,
_startingPrice
);
auction = _auction;
} else {
require(Auction(_auction).want() == _want, "wrong want");
}
return Auction(_auction).enable(_from);
}
function _disableAuction(address _from) internal virtual {
Auction(auction).disable(_from);
}
function kickable(address _token) public view virtual returns (uint256) {
return ERC20(_token).balanceOf(address(this));
}
function _auctionKicked(address _token) internal virtual returns (uint256) {
uint256 balance = ERC20(_token).balanceOf(address(this));
if (balance != 0) ERC20(_token).safeTransfer(auction, balance);
return ERC20(_token).balanceOf(auction);
}
function _preTake(
address _token,
uint256 _amountToTake,
uint256 _amountToPay
) internal virtual {}
function _postTake(
address _token,
uint256 _amountTaken,
uint256 _amountPayed
) internal virtual {}
function auctionKicked(
address _token
) external virtual onlyAuction returns (uint256) {
return _auctionKicked(_token);
}
function preTake(
address _token,
uint256 _amountToTake,
uint256 _amountToPay
) external virtual onlyAuction {
_preTake(_token, _amountToTake, _amountToPay);
}
function postTake(
address _token,
uint256 _amountTaken,
uint256 _amountPayed
) external virtual onlyAuction {
_postTake(_token, _amountTaken, _amountPayed);
}
}
文件 6 的 68：BaseHealthCheck.sol
pragma solidity >=0.8.18;
import {BaseStrategy, ERC20} from "@tokenized-strategy/BaseStrategy.sol";
abstract contract BaseHealthCheck is BaseStrategy {
bool public doHealthCheck = true;
uint256 internal constant MAX_BPS = 10_000;
uint16 private _profitLimitRatio = uint16(MAX_BPS);
uint16 private _lossLimitRatio;
constructor(
address _asset,
string memory _name
) BaseStrategy(_asset, _name) {}
function profitLimitRatio() public view returns (uint256) {
return _profitLimitRatio;
}
function lossLimitRatio() public view returns (uint256) {
return _lossLimitRatio;
}
function setProfitLimitRatio(
uint256 _newProfitLimitRatio
) external onlyManagement {
_setProfitLimitRatio(_newProfitLimitRatio);
}
function _setProfitLimitRatio(uint256 _newProfitLimitRatio) internal {
require(_newProfitLimitRatio > 0, "!zero profit");
require(_newProfitLimitRatio <= type(uint16).max, "!too high");
_profitLimitRatio = uint16(_newProfitLimitRatio);
}
function setLossLimitRatio(
uint256 _newLossLimitRatio
) external onlyManagement {
_setLossLimitRatio(_newLossLimitRatio);
}
function _setLossLimitRatio(uint256 _newLossLimitRatio) internal {
require(_newLossLimitRatio < MAX_BPS, "!loss limit");
_lossLimitRatio = uint16(_newLossLimitRatio);
}
function setDoHealthCheck(bool _doHealthCheck) public onlyManagement {
doHealthCheck = _doHealthCheck;
}
function harvestAndReport()
external
override
onlySelf
returns (uint256 _totalAssets)
{
_totalAssets = _harvestAndReport();
_executeHealthCheck(_totalAssets);
}
function _executeHealthCheck(uint256 _newTotalAssets) internal virtual {
if (!doHealthCheck) {
doHealthCheck = true;
return;
}
uint256 currentTotalAssets = TokenizedStrategy.totalAssets();
if (_newTotalAssets > currentTotalAssets) {
require(
((_newTotalAssets - currentTotalAssets) <=
(currentTotalAssets * uint256(_profitLimitRatio)) /
MAX_BPS),
"healthCheck"
);
} else if (currentTotalAssets > _newTotalAssets) {
require(
(currentTotalAssets - _newTotalAssets <=
((currentTotalAssets * uint256(_lossLimitRatio)) /
MAX_BPS)),
"healthCheck"
);
}
}
}
文件 7 的 68：BaseStrategy.sol
pragma solidity >=0.8.18;
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {ITokenizedStrategy} from "./interfaces/ITokenizedStrategy.sol";
abstract contract BaseStrategy {
modifier onlySelf() {
_onlySelf();
_;
}
modifier onlyManagement() {
TokenizedStrategy.requireManagement(msg.sender);
_;
}
modifier onlyKeepers() {
TokenizedStrategy.requireKeeperOrManagement(msg.sender);
_;
}
modifier onlyEmergencyAuthorized() {
TokenizedStrategy.requireEmergencyAuthorized(msg.sender);
_;
}
function _onlySelf() internal view {
require(msg.sender == address(this), "!self");
}
address public constant tokenizedStrategyAddress =
0xBB51273D6c746910C7C06fe718f30c936170feD0;
ERC20 internal immutable asset;
ITokenizedStrategy internal immutable TokenizedStrategy;
constructor(address _asset, string memory _name) {
asset = ERC20(_asset);
TokenizedStrategy = ITokenizedStrategy(address(this));
_delegateCall(
abi.encodeCall(
ITokenizedStrategy.initialize,
(_asset, _name, msg.sender, msg.sender, msg.sender)
)
);
assembly {
sstore(
0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc,
tokenizedStrategyAddress
)
}
}
function _deployFunds(uint256 _amount) internal virtual;
function _freeFunds(uint256 _amount) internal virtual;
function _harvestAndReport()
internal
virtual
returns (uint256 _totalAssets);
function _tend(uint256 _totalIdle) internal virtual {}
function _tendTrigger() internal view virtual returns (bool) {
return false;
}
function tendTrigger() external view virtual returns (bool, bytes memory) {
return (
_tendTrigger(),
abi.encodeWithSelector(ITokenizedStrategy.tend.selector)
);
}
function availableDepositLimit(
address
) public view virtual returns (uint256) {
return type(uint256).max;
}
function availableWithdrawLimit(
address
) public view virtual returns (uint256) {
return type(uint256).max;
}
function _emergencyWithdraw(uint256 _amount) internal virtual {}
function deployFunds(uint256 _amount) external virtual onlySelf {
_deployFunds(_amount);
}
function freeFunds(uint256 _amount) external virtual onlySelf {
_freeFunds(_amount);
}
function harvestAndReport() external virtual onlySelf returns (uint256) {
return _harvestAndReport();
}
function tendThis(uint256 _totalIdle) external virtual onlySelf {
_tend(_totalIdle);
}
function shutdownWithdraw(uint256 _amount) external virtual onlySelf {
_emergencyWithdraw(_amount);
}
function _delegateCall(
bytes memory _calldata
) internal returns (bytes memory) {
(bool success, bytes memory result) = tokenizedStrategyAddress
.delegatecall(_calldata);
if (!success) {
assembly {
let ptr := mload(0x40)
let size := returndatasize()
returndatacopy(ptr, 0, size)
revert(ptr, size)
}
}
return result;
}
fallback() external {
address _tokenizedStrategyAddress = tokenizedStrategyAddress;
assembly {
calldatacopy(0, 0, calldatasize())
let result := delegatecall(
gas(),
_tokenizedStrategyAddress,
0,
calldatasize(),
0,
0
)
returndatacopy(0, 0, returndatasize())
switch result
case 0 {
revert(0, returndatasize())
}
default {
return(0, returndatasize())
}
}
}
}
文件 8 的 68：Buckets.sol
pragma solidity 0.8.18;
import { Math } from '@openzeppelin/contracts/utils/math/Math.sol';
import { Bucket, Lender } from '../../interfaces/pool/commons/IPoolState.sol';
import { Maths } from './Maths.sol';
library Buckets {
error BucketBankruptcyBlock();
function addCollateral(
Bucket storage bucket_,
address lender_,
uint256 deposit_,
uint256 collateralAmountToAdd_,
uint256 bucketPrice_
) internal returns (uint256 addedLP_) {
uint256 bankruptcyTime = bucket_.bankruptcyTime;
if (bankruptcyTime == block.timestamp) revert BucketBankruptcyBlock();
addedLP_ = collateralToLP(
bucket_.collateral,
bucket_.lps,
deposit_,
collateralAmountToAdd_,
bucketPrice_,
Math.Rounding.Down
);
bucket_.collateral += collateralAmountToAdd_;
bucket_.lps += addedLP_;
addLenderLP(bucket_, bankruptcyTime, lender_, addedLP_);
}
function addLenderLP(
Bucket storage bucket_,
uint256 bankruptcyTime_,
address lender_,
uint256 lpAmount_
) internal {
if (lpAmount_ != 0) {
Lender storage lender = bucket_.lenders[lender_];
if (bankruptcyTime_ >= lender.depositTime) lender.lps = lpAmount_;
else lender.lps += lpAmount_;
lender.depositTime = block.timestamp;
}
}
function collateralToLP(
uint256 bucketCollateral_,
uint256 bucketLP_,
uint256 deposit_,
uint256 collateral_,
uint256 bucketPrice_,
Math.Rounding rounding_
) internal pure returns (uint256) {
if (deposit_ == 0 && bucketCollateral_ == 0) return Maths.wmul(collateral_, bucketPrice_);
if (bucketLP_ == 0) return Maths.wmul(collateral_, bucketPrice_);
return Math.mulDiv(
bucketLP_,
collateral_ * bucketPrice_,
deposit_ * Maths.WAD + bucketCollateral_ * bucketPrice_,
rounding_
);
}
function quoteTokensToLP(
uint256 bucketCollateral_,
uint256 bucketLP_,
uint256 deposit_,
uint256 quoteTokens_,
uint256 bucketPrice_,
Math.Rounding rounding_
) internal pure returns (uint256) {
if (deposit_ == 0 && bucketCollateral_ == 0) return quoteTokens_;
if (bucketLP_ == 0) return quoteTokens_;
return Math.mulDiv(
bucketLP_,
quoteTokens_ * Maths.WAD,
deposit_ * Maths.WAD + bucketCollateral_ * bucketPrice_,
rounding_
);
}
function lpToCollateral(
uint256 bucketCollateral_,
uint256 bucketLP_,
uint256 deposit_,
uint256 lp_,
uint256 bucketPrice_,
Math.Rounding rounding_
) internal pure returns (uint256) {
if (deposit_ == 0 && bucketCollateral_ == 0) return Maths.wdiv(lp_, bucketPrice_);
if (bucketLP_ == 0) return Maths.wdiv(lp_, bucketPrice_);
return Math.mulDiv(
deposit_ * Maths.WAD + bucketCollateral_ * bucketPrice_,
lp_,
bucketLP_ * bucketPrice_,
rounding_
);
}
function lpToQuoteTokens(
uint256 bucketCollateral_,
uint256 bucketLP_,
uint256 deposit_,
uint256 lp_,
uint256 bucketPrice_,
Math.Rounding rounding_
) internal pure returns (uint256) {
if (deposit_ == 0 && bucketCollateral_ == 0) return lp_;
if (bucketLP_ == 0) return lp_;
return Math.mulDiv(
deposit_ * Maths.WAD + bucketCollateral_ * bucketPrice_,
lp_,
bucketLP_ * Maths.WAD,
rounding_
);
}
function getExchangeRate(
uint256 bucketCollateral_,
uint256 bucketLP_,
uint256 bucketDeposit_,
uint256 bucketPrice_
) internal pure returns (uint256) {
return lpToQuoteTokens(
bucketCollateral_,
bucketLP_,
bucketDeposit_,
Maths.WAD,
bucketPrice_,
Math.Rounding.Up
);
}
}
文件 9 的 68：Clonable.sol
pragma solidity >=0.8.18;
contract Clonable {
address public original;
function _clone() internal virtual returns (address) {
return _clone(original);
}
function _clone(
address _original
) internal virtual returns (address _newContract) {
bytes20 addressBytes = bytes20(_original);
assembly {
let clone_code := mload(0x40)
mstore(
clone_code,
0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000
)
mstore(add(clone_code, 0x14), addressBytes)
mstore(
add(clone_code, 0x28),
0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000
)
_newContract := create(0, clone_code, 0x37)
}
}
}
文件 10 的 68：Context.sol
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
function _contextSuffixLength() internal view virtual returns (uint256) {
return 0;
}
}
文件 11 的 68：Deposits.sol
pragma solidity 0.8.18;
import { Math } from '@openzeppelin/contracts/utils/math/Math.sol';
import { DepositsState } from '../../interfaces/pool/commons/IPoolState.sol';
import { _priceAt, MAX_FENWICK_INDEX } from '../helpers/PoolHelper.sol';
import { Maths } from './Maths.sol';
library Deposits {
uint256 internal constant SIZE = 8192;
error InvalidAmount();
function unscaledAdd(
DepositsState storage deposits_,
uint256 index_,
uint256 unscaledAddAmount_
) internal {
if (unscaledAddAmount_ == 0) revert InvalidAmount();
++index_;
uint256 value;
uint256 scaling;
uint256 newValue;
while (index_ <= SIZE) {
value = deposits_.values[index_];
scaling = deposits_.scaling[index_];
newValue = value + unscaledAddAmount_;
if (scaling != 0) unscaledAddAmount_ = Maths.wmul(newValue, scaling) - Maths.wmul(value, scaling);
deposits_.values[index_] = newValue;
index_ += lsb(index_);
}
}
function findIndexAndSumOfSum(
DepositsState storage deposits_,
uint256 targetSum_
) internal view returns (uint256 sumIndex_, uint256 sumIndexSum_, uint256 sumIndexScale_) {
uint256 i = 4096;
uint256 runningScale = Maths.WAD;
uint256 lowerIndexSum;
uint256 curIndex;
uint256 value;
uint256 scaling;
uint256 scaledValue;
while (i > 0) {
curIndex = sumIndex_ + i;
value = deposits_.values[curIndex];
scaling = deposits_.scaling[curIndex];
scaledValue =
lowerIndexSum +
(
scaling != 0 ? Math.mulDiv(
runningScale * scaling,
value,
1e36
) : Maths.wmul(runningScale, value)
);
if (scaledValue < targetSum_) {
if (curIndex <= MAX_FENWICK_INDEX) {
sumIndex_ = curIndex;
lowerIndexSum = scaledValue;
}
} else {
if (scaling != 0) runningScale = Maths.floorWmul(runningScale, scaling);
sumIndexSum_ = scaledValue;
sumIndexScale_ = runningScale;
}
i = i >> 1;
}
}
function findIndexOfSum(
DepositsState storage deposits_,
uint256 sum_
) internal view returns (uint256 sumIndex_) {
(sumIndex_,,) = findIndexAndSumOfSum(deposits_, sum_);
}
function lsb(
uint256 i_
) internal pure returns (uint256 lsb_) {
if (i_ != 0) {
lsb_ = i_ & ((i_ ^ 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) + 1);
}
}
function mult(
DepositsState storage deposits_,
uint256 index_,
uint256 factor_
) internal {
++index_;
uint256 sum;
uint256 value;
uint256 scaling;
uint256 bit = lsb(index_);
while (bit <= SIZE) {
if ((bit & index_) != 0) {
value = deposits_.values[index_];
scaling = deposits_.scaling[index_];
if (scaling != 0) {
uint256 scaledFactor = Maths.wmul(factor_, scaling);
sum += Maths.wmul(scaledFactor, value) - Maths.wmul(scaling, value);
deposits_.scaling[index_] = scaledFactor;
} else {
sum += Maths.wmul(factor_, value) - value;
deposits_.scaling[index_] = factor_;
}
index_ -= bit;
} else {
uint256 superRangeIndex = index_ + bit;
value = (deposits_.values[superRangeIndex] += sum);
scaling = deposits_.scaling[superRangeIndex];
if (scaling != 0) sum = Maths.wmul(value, scaling) - Maths.wmul(value - sum, scaling);
}
bit = bit << 1;
}
}
function prefixSum(
DepositsState storage deposits_,
uint256 sumIndex_
) internal view returns (uint256 sum_) {
++sumIndex_;
uint256 runningScale = Maths.WAD;
uint256 j = SIZE;
uint256 index = 0;
uint256 indexLSB = lsb(sumIndex_);
uint256 curIndex;
while (j >= indexLSB) {
curIndex = index + j;
if (curIndex > SIZE) continue;
uint256 scaled = deposits_.scaling[curIndex];
if (sumIndex_ & j != 0) {
uint256 value = deposits_.values[curIndex];
sum_ += scaled != 0 ? Math.mulDiv(
runningScale * scaled,
value,
1e36
) : Maths.wmul(runningScale, value);
index = curIndex;
if (index == sumIndex_) break;
} else {
if (scaled != 0) runningScale = Maths.floorWmul(runningScale, scaled);
}
j = j >> 1;
}
}
function unscaledRemove(
DepositsState storage deposits_,
uint256 index_,
uint256 unscaledRemoveAmount_
) internal {
if (unscaledRemoveAmount_ == 0) revert InvalidAmount();
++index_;
while (index_ <= SIZE) {
uint256 value = (deposits_.values[index_] -= unscaledRemoveAmount_);
uint256 scaling = deposits_.scaling[index_];
if (scaling != 0) unscaledRemoveAmount_ = Maths.wmul(value + unscaledRemoveAmount_, scaling) - Maths.wmul(value, scaling);
index_ += lsb(index_);
}
}
function scale(
DepositsState storage deposits_,
uint256 index_
) internal view returns (uint256 scaled_) {
++index_;
scaled_ = Maths.WAD;
while (index_ <= SIZE) {
uint256 scaling = deposits_.scaling[index_];
if (scaling != 0) scaled_ = Maths.wmul(scaled_, scaling);
index_ += lsb(index_);
}
}
function treeSum(
DepositsState storage deposits_
) internal view returns (uint256) {
return deposits_.values[SIZE];
}
function valueAt(
DepositsState storage deposits_,
uint256 index_
) internal view returns (uint256 depositValue_) {
depositValue_ = Maths.wmul(unscaledValueAt(deposits_, index_), scale(deposits_,index_));
}
function unscaledValueAt(
DepositsState storage deposits_,
uint256 index_
) internal view returns (uint256 unscaledDepositValue_) {
++index_;
uint256 j = 1;
unscaledDepositValue_ = deposits_.values[index_];
uint256 curIndex;
uint256 value;
uint256 scaling;
while (j & index_ == 0) {
curIndex = index_ - j;
value = deposits_.values[curIndex];
scaling = deposits_.scaling[curIndex];
unscaledDepositValue_ -= scaling != 0 ? Maths.wmul(scaling, value) : value;
j = j << 1;
}
}
function getLup(
DepositsState storage deposits_,
uint256 debt_
) internal view returns (uint256) {
return _priceAt(findIndexOfSum(deposits_, debt_));
}
}
文件 12 的 68：ERC20.sol
pragma solidity ^0.8.0;
import "./IERC20.sol";
import "./extensions/IERC20Metadata.sol";
import "../../utils/Context.sol";
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address from, address to, uint256 amount) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
_balances[to] += amount;
}
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
unchecked {
_balances[account] += amount;
}
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
_totalSupply -= amount;
}
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}
文件 13 的 68：Governance.sol
pragma solidity >=0.8.18;
contract Governance {
event GovernanceTransferred(
address indexed previousGovernance,
address indexed newGovernance
);
modifier onlyGovernance() {
_checkGovernance();
_;
}
function _checkGovernance() internal view virtual {
require(governance == msg.sender, "!governance");
}
address public governance;
constructor(address _governance) {
governance = _governance;
emit GovernanceTransferred(address(0), _governance);
}
function transferGovernance(
address _newGovernance
) external virtual onlyGovernance {
require(_newGovernance != address(0), "ZERO ADDRESS");
address oldGovernance = governance;
governance = _newGovernance;
emit GovernanceTransferred(oldGovernance, _newGovernance);
}
}
文件 14 的 68：IAccount.sol
pragma solidity ^0.8.18;
interface IAccount {
function send(address _target, bytes calldata _data) external payable;
function execute(address _target, bytes memory _data)
external
payable
returns (bytes32);
}
文件 15 的 68：IAccountFactory.sol
pragma solidity ^0.8.18;
interface IAccountFactory {
function createAccount() external returns (address);
function createAccount(address _user) external returns (address);
}
文件 16 的 68：IAjnaRedeemer.sol
pragma solidity ^0.8.18;
interface IAjnaRedeemer {
function deploymentWeek() external returns (uint256);
function getCurrentWeek() external view returns (uint256);
function addRoot(uint256 week, bytes32 root) external;
function getRoot(uint256 week) external view returns (bytes32);
function claimMultiple(
uint256[] calldata _weeks,
uint256[] calldata amounts,
bytes32[][] calldata proofs
) external;
function canClaim(
bytes32[] memory proof,
uint256 week,
uint256 amount
) external view returns (bool);
function emergencyWithdraw() external;
}
文件 17 的 68：IChainlinkAggregator.sol
pragma solidity >=0.6.12;
interface IChainlinkAggregator {
function latestAnswer() external view returns (int256);
function latestTimestamp() external view returns (uint256);
function latestRound() external view returns (uint256);
function latestRoundData() external view returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);
function getAnswer(uint256 roundId) external view returns (int256);
function getTimestamp(uint256 roundId) external view returns (uint256);
event AnswerUpdated(
int256 indexed current,
uint256 indexed roundId,
uint256 updatedAt
);
event NewRound(
uint256 indexed roundId,
address indexed startedBy,
uint256 startedAt
);
}
文件 18 的 68：IERC165.sol
pragma solidity ^0.8.0;
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
文件 19 的 68：IERC20.sol
pragma solidity ^0.8.0;
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
文件 20 的 68：IERC20Metadata.sol
pragma solidity ^0.8.0;
import "../IERC20.sol";
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
文件 21 的 68：IERC20Permit.sol
pragma solidity ^0.8.0;
interface IERC20Permit {
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
function nonces(address owner) external view returns (uint256);
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
文件 22 的 68：IERC20Pool.sol
pragma solidity 0.8.18;
import { IPool } from '../IPool.sol';
import { IERC20PoolBorrowerActions } from './IERC20PoolBorrowerActions.sol';
import { IERC20PoolLenderActions } from './IERC20PoolLenderActions.sol';
import { IERC20PoolImmutables } from './IERC20PoolImmutables.sol';
import { IERC20PoolEvents } from './IERC20PoolEvents.sol';
interface IERC20Pool is
IPool,
IERC20PoolLenderActions,
IERC20PoolBorrowerActions,
IERC20PoolImmutables,
IERC20PoolEvents
{
function initialize(uint256 rate_) external;
function bucketCollateralDust(
uint256 bucketIndex_
) external pure returns (uint256);
}
文件 23 的 68：IERC20PoolBorrowerActions.sol
pragma solidity 0.8.18;
interface IERC20PoolBorrowerActions {
function drawDebt(
address borrowerAddress_,
uint256 amountToBorrow_,
uint256 limitIndex_,
uint256 collateralToPledge_
) external;
function repayDebt(
address borrowerAddress_,
uint256 maxQuoteTokenAmountToRepay_,
uint256 collateralAmountToPull_,
address recipient_,
uint256 limitIndex_
) external returns (uint256 amountRepaid_);
}
文件 24 的 68：IERC20PoolEvents.sol
pragma solidity 0.8.18;
interface IERC20PoolEvents {
event AddCollateral(
address indexed actor,
uint256 indexed index,
uint256 amount,
uint256 lpAwarded
);
event DrawDebt(
address indexed borrower,
uint256 amountBorrowed,
uint256 collateralPledged,
uint256 lup
);
}
文件 25 的 68：IERC20PoolImmutables.sol
pragma solidity 0.8.18;
interface IERC20PoolImmutables {
function collateralScale() external view returns (uint256);
}文件 26 的 68：IERC20PoolLenderActions.sol
pragma solidity 0.8.18;
interface IERC20PoolLenderActions {
function addCollateral(
uint256 amountToAdd_,
uint256 index_,
uint256 expiry_
) external returns (uint256 bucketLP_);
}文件 27 的 68：IERC3156FlashBorrower.sol
pragma solidity 0.8.18;
interface IERC3156FlashBorrower {
function onFlashLoan(
address initiator,
address token,
uint256 amount,
uint256 fee,
bytes calldata data
) external returns (bytes32);
}文件 28 的 68：IERC3156FlashLender.sol
pragma solidity 0.8.18;
import { IERC3156FlashBorrower } from "./IERC3156FlashBorrower.sol";
interface IERC3156FlashLender {
function maxFlashLoan(
address token_
) external view returns (uint256);
function flashFee(
address token_,
uint256 amount_
) external view returns (uint256);
function flashLoan(
IERC3156FlashBorrower receiver_,
address token_,
uint256 amount_,
bytes calldata data_
) external returns (bool);
}文件 29 的 68：IERC4626.sol
pragma solidity ^0.8.0;
import "../token/ERC20/IERC20.sol";
import "../token/ERC20/extensions/IERC20Metadata.sol";
interface IERC4626 is IERC20, IERC20Metadata {
event Deposit(address indexed sender, address indexed owner, uint256 assets, uint256 shares);
event Withdraw(
address indexed sender,
address indexed receiver,
address indexed owner,
uint256 assets,
uint256 shares
);
function asset() external view returns (address assetTokenAddress);
function totalAssets() external view returns (uint256 totalManagedAssets);
function convertToShares(uint256 assets) external view returns (uint256 shares);
function convertToAssets(uint256 shares) external view returns (uint256 assets);
function maxDeposit(address receiver) external view returns (uint256 maxAssets);
function previewDeposit(uint256 assets) external view returns (uint256 shares);
function deposit(uint256 assets, address receiver) external returns (uint256 shares);
function maxMint(address receiver) external view returns (uint256 maxShares);
function previewMint(uint256 shares) external view returns (uint256 assets);
function mint(uint256 shares, address receiver) external returns (uint256 assets);
function maxWithdraw(address owner) external view returns (uint256 maxAssets);
function previewWithdraw(uint256 assets) external view returns (uint256 shares);
function withdraw(uint256 assets, address receiver, address owner) external returns (uint256 shares);
function maxRedeem(address owner) external view returns (uint256 maxShares);
function previewRedeem(uint256 shares) external view returns (uint256 assets);
function redeem(uint256 shares, address receiver, address owner) external returns (uint256 assets);
}
文件 30 的 68：IERC721.sol
pragma solidity ^0.8.0;
import "../../utils/introspection/IERC165.sol";
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
function safeTransferFrom(address from, address to, uint256 tokenId) external;
function transferFrom(address from, address to, uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function setApprovalForAll(address operator, bool approved) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function isApprovedForAll(address owner, address operator) external view returns (bool);
}
文件 31 的 68：IPool.sol
pragma solidity 0.8.18;
import { IPoolBorrowerActions } from './commons/IPoolBorrowerActions.sol';
import { IPoolLPActions } from './commons/IPoolLPActions.sol';
import { IPoolLenderActions } from './commons/IPoolLenderActions.sol';
import { IPoolKickerActions } from './commons/IPoolKickerActions.sol';
import { IPoolTakerActions } from './commons/IPoolTakerActions.sol';
import { IPoolSettlerActions } from './commons/IPoolSettlerActions.sol';
import { IPoolImmutables } from './commons/IPoolImmutables.sol';
import { IPoolState } from './commons/IPoolState.sol';
import { IPoolDerivedState } from './commons/IPoolDerivedState.sol';
import { IPoolEvents } from './commons/IPoolEvents.sol';
import { IPoolErrors } from './commons/IPoolErrors.sol';
import { IERC3156FlashLender } from './IERC3156FlashLender.sol';
interface IPool is
IPoolBorrowerActions,
IPoolLPActions,
IPoolLenderActions,
IPoolKickerActions,
IPoolTakerActions,
IPoolSettlerActions,
IPoolImmutables,
IPoolState,
IPoolDerivedState,
IPoolEvents,
IPoolErrors,
IERC3156FlashLender
{
}
enum PoolType { ERC20, ERC721 }
interface IERC20Token {
function balanceOf(address account) external view returns (uint256);
function burn(uint256 amount) external;
function decimals() external view returns (uint8);
}
interface IERC721Token {
function transferFrom(
address from,
address to,
uint256 tokenId
) external;
}
文件 32 的 68：IPoolBorrowerActions.sol
pragma solidity 0.8.18;
interface IPoolBorrowerActions {
function stampLoan() external;
}
文件 33 的 68：IPoolDerivedState.sol
pragma solidity 0.8.18;
interface IPoolDerivedState {
function bucketExchangeRate(
uint256 index_
) external view returns (uint256 exchangeRate_);
function depositUpToIndex(
uint256 index_
) external view returns (uint256);
function depositIndex(
uint256 debt_
) external view returns (uint256);
function depositSize() external view returns (uint256);
function depositUtilization() external view returns (uint256);
function depositScale(
uint256 index_
) external view returns (uint256);
}
文件 34 的 68：IPoolErrors.sol
pragma solidity 0.8.18;
interface IPoolErrors {
error AddAboveAuctionPrice();
error AuctionActive();
error AuctionNotClearable();
error AuctionNotTakeable();
error AuctionNotCleared();
error AuctionPriceGtBucketPrice();
error AlreadyInitialized();
error AmountLTMinDebt();
error BorrowerNotSender();
error BorrowerOk();
error BorrowerUnderCollateralized();
error BucketBankruptcyBlock();
error CannotMergeToHigherPrice();
error DustAmountNotExceeded();
error FlashloanCallbackFailed();
error FlashloanIncorrectBalance();
error FlashloanUnavailableForToken();
error InsufficientCollateral();
error InsufficientLP();
error InsufficientLiquidity();
error InvalidAllowancesInput();
error InvalidIndex();
error InvalidAmount();
error LimitIndexExceeded();
error LUPBelowHTP();
error MoveToSameIndex();
error NoAllowance();
error NoAuction();
error NoReserves();
error NoReservesAuction();
error NoClaim();
error NoDebt();
error PriceBelowLUP();
error RemoveDepositLockedByAuctionDebt();
error ReserveAuctionTooSoon();
error TransactionExpired();
error TransferorNotApproved();
error TransferToSameOwner();
error ZeroDebtToCollateral();
}
文件 35 的 68：IPoolEvents.sol
pragma solidity 0.8.18;
interface IPoolEvents {
event AddQuoteToken(
address indexed lender,
uint256 indexed index,
uint256 amount,
uint256 lpAwarded,
uint256 lup
);
event MoveQuoteToken(
address indexed lender,
uint256 indexed from,
uint256 indexed to,
uint256 amount,
uint256 lpRedeemedFrom,
uint256 lpAwardedTo,
uint256 lup
);
event RemoveQuoteToken(
address indexed lender,
uint256 indexed index,
uint256 amount,
uint256 lpRedeemed,
uint256 lup
);
event RemoveCollateral(
address indexed claimer,
uint256 indexed index,
uint256 amount,
uint256 lpRedeemed
);
event RepayDebt(
address indexed borrower,
uint256 quoteRepaid,
uint256 collateralPulled,
uint256 lup
);
event Kick(
address indexed borrower,
uint256 debt,
uint256 collateral,
uint256 bond
);
event BondWithdrawn(
address indexed kicker,
address indexed reciever,
uint256 amount
);
event BucketTake(
address indexed borrower,
uint256 index,
uint256 amount,
uint256 collateral,
uint256 bondChange,
bool isReward
);
event BucketTakeLPAwarded(
address indexed taker,
address indexed kicker,
uint256 lpAwardedTaker,
uint256 lpAwardedKicker
);
event Take(
address indexed borrower,
uint256 amount,
uint256 collateral,
uint256 bondChange,
bool isReward
);
event Settle(
address indexed borrower,
uint256 settledDebt
);
event AuctionSettle(
address indexed borrower,
uint256 collateral
);
event AuctionNFTSettle(
address indexed borrower,
uint256 collateral,
uint256 lp,
uint256 index
);
event KickReserveAuction(
uint256 claimableReservesRemaining,
uint256 auctionPrice,
uint256 currentBurnEpoch
);
event ReserveAuction(
uint256 claimableReservesRemaining,
uint256 auctionPrice,
uint256 currentBurnEpoch
);
event IncreaseLPAllowance(
address indexed owner,
address indexed spender,
uint256[] indexes,
uint256[] amounts
);
event DecreaseLPAllowance(
address indexed owner,
address indexed spender,
uint256[] indexes,
uint256[] amounts
);
event RevokeLPAllowance(
address indexed owner,
address indexed spender,
uint256[] indexes
);
event ApproveLPTransferors(
address indexed lender,
address[] transferors
);
event RevokeLPTransferors(
address indexed lender,
address[] transferors
);
event TransferLP(
address owner,
address newOwner,
uint256[] indexes,
uint256 lp
);
event BucketBankruptcy(
uint256 indexed index,
uint256 lpForfeited
);
event Flashloan(
address indexed receiver,
address indexed token,
uint256 amount
);
event LoanStamped(
address indexed borrower
);
event ResetInterestRate(
uint256 oldRate,
uint256 newRate
);
event UpdateInterestRate(
uint256 oldRate,
uint256 newRate
);
event InterestUpdateFailure();
}文件 36 的 68：IPoolImmutables.sol
pragma solidity 0.8.18;
interface IPoolImmutables {
function poolType() external pure returns (uint8);
function collateralAddress() external pure returns (address);
function quoteTokenAddress() external pure returns (address);
function quoteTokenScale() external pure returns (uint256);
}文件 37 的 68：IPoolKickerActions.sol
pragma solidity 0.8.18;
interface IPoolKickerActions {
function kick(
address borrower_,
uint256 npLimitIndex_
) external;
function lenderKick(
uint256 index_,
uint256 npLimitIndex_
) external;
function withdrawBonds(
address recipient_,
uint256 maxAmount_
) external returns (uint256 withdrawnAmount_);
function kickReserveAuction() external;
}文件 38 的 68：IPoolLPActions.sol
pragma solidity 0.8.18;
interface IPoolLPActions {
function increaseLPAllowance(
address spender_,
uint256[] calldata indexes_,
uint256[] calldata amounts_
) external;
function decreaseLPAllowance(
address spender_,
uint256[] calldata indexes_,
uint256[] calldata amounts_
) external;
function revokeLPAllowance(
address spender_,
uint256[] calldata indexes_
) external;
function approveLPTransferors(
address[] calldata transferors_
) external;
function revokeLPTransferors(
address[] calldata transferors_
) external;
function transferLP(
address owner_,
address newOwner_,
uint256[] calldata indexes_
) external;
}
文件 39 的 68：IPoolLenderActions.sol
pragma solidity 0.8.18;
interface IPoolLenderActions {
function addQuoteToken(
uint256 amount_,
uint256 index_,
uint256 expiry_
) external returns (uint256 bucketLP_, uint256 addedAmount_);
function moveQuoteToken(
uint256 maxAmount_,
uint256 fromIndex_,
uint256 toIndex_,
uint256 expiry_
) external returns (uint256 fromBucketLP_, uint256 toBucketLP_, uint256 movedAmount_);
function removeCollateral(
uint256 maxAmount_,
uint256 index_
) external returns (uint256 removedAmount_, uint256 redeemedLP_);
function removeQuoteToken(
uint256 maxAmount_,
uint256 index_
) external returns (uint256 removedAmount_, uint256 redeemedLP_);
function updateInterest() external;
}
文件 40 的 68：IPoolSettlerActions.sol
pragma solidity 0.8.18;
interface IPoolSettlerActions {
function settle(
address borrowerAddress_,
uint256 maxDepth_
) external returns (uint256 collateralSettled_, bool isBorrowerSettled_);
}文件 41 的 68：IPoolState.sol
pragma solidity 0.8.18;
interface IPoolState {
function auctionInfo(address borrower_)
external
view
returns (
address kicker_,
uint256 bondFactor_,
uint256 bondSize_,
uint256 kickTime_,
uint256 referencePrice_,
uint256 neutralPrice_,
uint256 debtToCollateral_,
address head_,
address next_,
address prev_
);
function debtInfo()
external
view
returns (
uint256 debt_,
uint256 accruedDebt_,
uint256 debtInAuction_,
uint256 t0Debt2ToCollateral_
);
function borrowerInfo(address borrower_)
external
view
returns (
uint256 t0Debt_,
uint256 collateral_,
uint256 npTpRatio_
);
function bucketInfo(uint256 index_)
external
view
returns (
uint256 lpAccumulator_,
uint256 availableCollateral_,
uint256 bankruptcyTime_,
uint256 bucketDeposit_,
uint256 bucketScale_
);
function burnInfo(uint256 burnEventEpoch_) external view returns (uint256, uint256, uint256);
function currentBurnEpoch() external view returns (uint256);
function emasInfo()
external
view
returns (
uint256 debtColEma_,
uint256 lupt0DebtEma_,
uint256 debtEma_,
uint256 depositEma_
);
function inflatorInfo()
external
view
returns (
uint256 inflator_,
uint256 lastUpdate_
);
function interestRateInfo()
external
view
returns (
uint256 interestRate_,
uint256 interestRateUpdate_
);
function kickerInfo(address kicker_)
external
view
returns (
uint256 claimable_,
uint256 locked_
);
function lenderInfo(
uint256 index_,
address lender_
)
external
view
returns (
uint256 lpBalance_,
uint256 depositTime_
);
function lpAllowance(
uint256 index_,
address spender_,
address owner_
) external view returns (uint256 allowance_);
function loanInfo(
uint256 loanId_
)
external
view
returns (
address borrower_,
uint256 t0DebtToCollateral_
);
function loansInfo()
external
view
returns (
address maxBorrower_,
uint256 maxT0DebtToCollateral_,
uint256 noOfLoans_
);
function reservesInfo()
external
view
returns (
uint256 liquidationBondEscrowed_,
uint256 reserveAuctionUnclaimed_,
uint256 reserveAuctionKicked_,
uint256 lastKickedReserves_,
uint256 totalInterestEarned_
);
function pledgedCollateral() external view returns (uint256);
function totalAuctionsInPool() external view returns (uint256);
function totalT0Debt() external view returns (uint256);
function totalT0DebtInAuction() external view returns (uint256);
function approvedTransferors(
address lender_,
address transferor_
) external view returns (bool);
}
struct InflatorState {
uint208 inflator;
uint48 inflatorUpdate;
}
struct InterestState {
uint208 interestRate;
uint48 interestRateUpdate;
uint256 debt;
uint256 meaningfulDeposit;
uint256 t0Debt2ToCollateral;
uint256 debtCol;
uint256 lupt0Debt;
}
struct EmaState {
uint256 debtEma;
uint256 depositEma;
uint256 debtColEma;
uint256 lupt0DebtEma;
uint256 emaUpdate;
}
struct PoolBalancesState {
uint256 pledgedCollateral;
uint256 t0DebtInAuction;
uint256 t0Debt;
}
struct PoolState {
uint8 poolType;
uint256 t0Debt;
uint256 t0DebtInAuction;
uint256 debt;
uint256 collateral;
uint256 inflator;
bool isNewInterestAccrued;
uint256 rate;
uint256 quoteTokenScale;
}
struct Lender {
uint256 lps;
uint256 depositTime;
}
struct Bucket {
uint256 lps;
uint256 collateral;
uint256 bankruptcyTime;
mapping(address => Lender) lenders;
}
struct DepositsState {
uint256[8193] values;
uint256[8193] scaling;
}
struct LoansState {
Loan[] loans;
mapping (address => uint) indices;
mapping (address => Borrower) borrowers;
}
struct Loan {
address borrower;
uint96 t0DebtToCollateral;
}
struct Borrower {
uint256 t0Debt;
uint256 collateral;
uint256 npTpRatio;
}
struct AuctionsState {
uint96 noOfAuctions;
address head;
address tail;
uint256 totalBondEscrowed;
mapping(address => Liquidation) liquidations;
mapping(address => Kicker) kickers;
}
struct Liquidation {
address kicker;
uint96 bondFactor;
uint96 kickTime;
address prev;
uint96 referencePrice;
address next;
uint160 bondSize;
uint96 neutralPrice;
uint256 debtToCollateral;
uint256 t0ReserveSettleAmount;
}
struct Kicker {
uint256 claimable;
uint256 locked;
}
struct ReserveAuctionState {
uint256 kicked;
uint256 lastKickedReserves;
uint256 unclaimed;
uint256 latestBurnEventEpoch;
uint256 totalAjnaBurned;
uint256 totalInterestEarned;
mapping (uint256 => BurnEvent) burnEvents;
}
struct BurnEvent {
uint256 timestamp;
uint256 totalInterest;
uint256 totalBurned;
}文件 42 的 68：IPoolTakerActions.sol
pragma solidity 0.8.18;
interface IPoolTakerActions {
function bucketTake(
address borrowerAddress_,
bool depositTake_,
uint256 index_
) external;
function take(
address borrowerAddress_,
uint256 maxAmount_,
address callee_,
bytes calldata data_
) external returns (uint256 collateralTaken_);
function takeReserves(
uint256 maxAmount_
) external returns (uint256 amount_);
}文件 43 的 68：ITaker.sol
pragma solidity >=0.8.18;
interface ITaker {
function auctionTakeCallback(
bytes32 _auctionId,
address _sender,
uint256 _amountTaken,
uint256 _amountNeeded,
bytes calldata _data
) external;
}
文件 44 的 68：ITokenizedStrategy.sol
pragma solidity >=0.8.18;
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IERC4626} from "@openzeppelin/contracts/interfaces/IERC4626.sol";
import {IERC20Permit} from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Permit.sol";
interface ITokenizedStrategy is IERC4626, IERC20Permit {
event StrategyShutdown();
event NewTokenizedStrategy(
address indexed strategy,
address indexed asset,
string apiVersion
);
event Reported(
uint256 profit,
uint256 loss,
uint256 protocolFees,
uint256 performanceFees
);
event UpdatePerformanceFeeRecipient(
address indexed newPerformanceFeeRecipient
);
event UpdateKeeper(address indexed newKeeper);
event UpdatePerformanceFee(uint16 newPerformanceFee);
event UpdateManagement(address indexed newManagement);
event UpdateEmergencyAdmin(address indexed newEmergencyAdmin);
event UpdateProfitMaxUnlockTime(uint256 newProfitMaxUnlockTime);
event UpdatePendingManagement(address indexed newPendingManagement);
function initialize(
address _asset,
string memory _name,
address _management,
address _performanceFeeRecipient,
address _keeper
) external;
function withdraw(
uint256 assets,
address receiver,
address owner,
uint256 maxLoss
) external returns (uint256);
function redeem(
uint256 shares,
address receiver,
address owner,
uint256 maxLoss
) external returns (uint256);
function requireManagement(address _sender) external view;
function requireKeeperOrManagement(address _sender) external view;
function requireEmergencyAuthorized(address _sender) external view;
function tend() external;
function report() external returns (uint256 _profit, uint256 _loss);
function MAX_FEE() external view returns (uint16);
function FACTORY() external view returns (address);
function apiVersion() external view returns (string memory);
function pricePerShare() external view returns (uint256);
function management() external view returns (address);
function pendingManagement() external view returns (address);
function keeper() external view returns (address);
function emergencyAdmin() external view returns (address);
function performanceFee() external view returns (uint16);
function performanceFeeRecipient() external view returns (address);
function fullProfitUnlockDate() external view returns (uint256);
function profitUnlockingRate() external view returns (uint256);
function profitMaxUnlockTime() external view returns (uint256);
function lastReport() external view returns (uint256);
function isShutdown() external view returns (bool);
function unlockedShares() external view returns (uint256);
function setPendingManagement(address) external;
function acceptManagement() external;
function setKeeper(address _keeper) external;
function setEmergencyAdmin(address _emergencyAdmin) external;
function setPerformanceFee(uint16 _performanceFee) external;
function setPerformanceFeeRecipient(
address _performanceFeeRecipient
) external;
function setProfitMaxUnlockTime(uint256 _profitMaxUnlockTime) external;
function shutdownStrategy() external;
function emergencyWithdraw(uint256 _amount) external;
}
文件 45 的 68：IUniswapV3Factory.sol
pragma solidity >=0.5.0;
interface IUniswapV3Factory {
event OwnerChanged(address indexed oldOwner, address indexed newOwner);
event PoolCreated(
address indexed token0,
address indexed token1,
uint24 indexed fee,
int24 tickSpacing,
address pool
);
event FeeAmountEnabled(uint24 indexed fee, int24 indexed tickSpacing);
function owner() external view returns (address);
function feeAmountTickSpacing(uint24 fee) external view returns (int24);
function getPool(
address tokenA,
address tokenB,
uint24 fee
) external view returns (address pool);
function createPool(
address tokenA,
address tokenB,
uint24 fee
) external returns (address pool);
function setOwner(address _owner) external;
function enableFeeAmount(uint24 fee, int24 tickSpacing) external;
}
文件 46 的 68：IUniswapV3Pool.sol
pragma solidity >=0.5.0;
import {IUniswapV3PoolImmutables} from './pool/IUniswapV3PoolImmutables.sol';
import {IUniswapV3PoolState} from './pool/IUniswapV3PoolState.sol';
import {IUniswapV3PoolDerivedState} from './pool/IUniswapV3PoolDerivedState.sol';
import {IUniswapV3PoolActions} from './pool/IUniswapV3PoolActions.sol';
import {IUniswapV3PoolOwnerActions} from './pool/IUniswapV3PoolOwnerActions.sol';
import {IUniswapV3PoolErrors} from './pool/IUniswapV3PoolErrors.sol';
import {IUniswapV3PoolEvents} from './pool/IUniswapV3PoolEvents.sol';
interface IUniswapV3Pool is
IUniswapV3PoolImmutables,
IUniswapV3PoolState,
IUniswapV3PoolDerivedState,
IUniswapV3PoolActions,
IUniswapV3PoolOwnerActions,
IUniswapV3PoolErrors,
IUniswapV3PoolEvents
{
}
文件 47 的 68：IUniswapV3PoolActions.sol
pragma solidity >=0.5.0;
interface IUniswapV3PoolActions {
function initialize(uint160 sqrtPriceX96) external;
function mint(
address recipient,
int24 tickLower,
int24 tickUpper,
uint128 amount,
bytes calldata data
) external returns (uint256 amount0, uint256 amount1);
function collect(
address recipient,
int24 tickLower,
int24 tickUpper,
uint128 amount0Requested,
uint128 amount1Requested
) external returns (uint128 amount0, uint128 amount1);
function burn(
int24 tickLower,
int24 tickUpper,
uint128 amount
) external returns (uint256 amount0, uint256 amount1);
function swap(
address recipient,
bool zeroForOne,
int256 amountSpecified,
uint160 sqrtPriceLimitX96,
bytes calldata data
) external returns (int256 amount0, int256 amount1);
function flash(
address recipient,
uint256 amount0,
uint256 amount1,
bytes calldata data
) external;
function increaseObservationCardinalityNext(uint16 observationCardinalityNext) external;
}
文件 48 的 68：IUniswapV3PoolDerivedState.sol
pragma solidity >=0.5.0;
interface IUniswapV3PoolDerivedState {
function observe(uint32[] calldata secondsAgos)
external
view
returns (int56[] memory tickCumulatives, uint160[] memory secondsPerLiquidityCumulativeX128s);
function snapshotCumulativesInside(int24 tickLower, int24 tickUpper)
external
view
returns (
int56 tickCumulativeInside,
uint160 secondsPerLiquidityInsideX128,
uint32 secondsInside
);
}
文件 49 的 68：IUniswapV3PoolErrors.sol
pragma solidity >=0.5.0;
interface IUniswapV3PoolErrors {
error LOK();
error TLU();
error TLM();
error TUM();
error AI();
error M0();
error M1();
error AS();
error IIA();
error L();
error F0();
error F1();
}
文件 50 的 68：IUniswapV3PoolEvents.sol
pragma solidity >=0.5.0;
interface IUniswapV3PoolEvents {
event Initialize(uint160 sqrtPriceX96, int24 tick);
event Mint(
address sender,
address indexed owner,
int24 indexed tickLower,
int24 indexed tickUpper,
uint128 amount,
uint256 amount0,
uint256 amount1
);
event Collect(
address indexed owner,
address recipient,
int24 indexed tickLower,
int24 indexed tickUpper,
uint128 amount0,
uint128 amount1
);
event Burn(
address indexed owner,
int24 indexed tickLower,
int24 indexed tickUpper,
uint128 amount,
uint256 amount0,
uint256 amount1
);
event Swap(
address indexed sender,
address indexed recipient,
int256 amount0,
int256 amount1,
uint160 sqrtPriceX96,
uint128 liquidity,
int24 tick
);
event Flash(
address indexed sender,
address indexed recipient,
uint256 amount0,
uint256 amount1,
uint256 paid0,
uint256 paid1
);
event IncreaseObservationCardinalityNext(
uint16 observationCardinalityNextOld,
uint16 observationCardinalityNextNew
);
event SetFeeProtocol(uint8 feeProtocol0Old, uint8 feeProtocol1Old, uint8 feeProtocol0New, uint8 feeProtocol1New);
event CollectProtocol(address indexed sender, address indexed recipient, uint128 amount0, uint128 amount1);
}
文件 51 的 68：IUniswapV3PoolImmutables.sol
pragma solidity >=0.5.0;
interface IUniswapV3PoolImmutables {
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function fee() external view returns (uint24);
function tickSpacing() external view returns (int24);
function maxLiquidityPerTick() external view returns (uint128);
}
文件 52 的 68：IUniswapV3PoolOwnerActions.sol
pragma solidity >=0.5.0;
interface IUniswapV3PoolOwnerActions {
function setFeeProtocol(uint8 feeProtocol0, uint8 feeProtocol1) external;
function collectProtocol(
address recipient,
uint128 amount0Requested,
uint128 amount1Requested
) external returns (uint128 amount0, uint128 amount1);
}
文件 53 的 68：IUniswapV3PoolState.sol
pragma solidity >=0.5.0;
interface IUniswapV3PoolState {
function slot0()
external
view
returns (
uint160 sqrtPriceX96,
int24 tick,
uint16 observationIndex,
uint16 observationCardinality,
uint16 observationCardinalityNext,
uint8 feeProtocol,
bool unlocked
);
function feeGrowthGlobal0X128() external view returns (uint256);
function feeGrowthGlobal1X128() external view returns (uint256);
function protocolFees() external view returns (uint128 token0, uint128 token1);
function liquidity() external view returns (uint128);
function ticks(int24 tick)
external
view
returns (
uint128 liquidityGross,
int128 liquidityNet,
uint256 feeGrowthOutside0X128,
uint256 feeGrowthOutside1X128,
int56 tickCumulativeOutside,
uint160 secondsPerLiquidityOutsideX128,
uint32 secondsOutside,
bool initialized
);
function tickBitmap(int16 wordPosition) external view returns (uint256);
function positions(bytes32 key)
external
view
returns (
uint128 liquidity,
uint256 feeGrowthInside0LastX128,
uint256 feeGrowthInside1LastX128,
uint128 tokensOwed0,
uint128 tokensOwed1
);
function observations(uint256 index)
external
view
returns (
uint32 blockTimestamp,
int56 tickCumulative,
uint160 secondsPerLiquidityCumulativeX128,
bool initialized
);
}
文件 54 的 68：IUniswapV3SwapCallback.sol
pragma solidity >=0.5.0;
interface IUniswapV3SwapCallback {
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata data
) external;
}
文件 55 的 68：IWETH.sol
pragma solidity ^0.8.18;
interface IWETH {
function deposit() external payable;
function transfer(address to, uint256 value) external returns (bool);
function withdraw(uint256) external;
}
文件 56 的 68：IWeth.sol
pragma solidity ^0.8.18;
interface IWETH {
function deposit() external payable;
function transfer(address to, uint256 value) external returns (bool);
function withdraw(uint256) external;
}
文件 57 的 68：Loans.sol
pragma solidity 0.8.18;
import { SafeCast } from "@openzeppelin/contracts/utils/math/SafeCast.sol";
import { PRBMathSD59x18 } from "@prb-math/contracts/PRBMathSD59x18.sol";
import {
AuctionsState,
Borrower,
DepositsState,
Loan,
LoansState
} from '../../interfaces/pool/commons/IPoolState.sol';
import { _priceAt } from '../helpers/PoolHelper.sol';
import { Deposits } from './Deposits.sol';
import { Maths } from './Maths.sol';
library Loans {
uint256 constant ROOT_INDEX = 1;
error ZeroDebtToCollateral();
function init(LoansState storage loans_) internal {
loans_.loans.push(Loan(address(0), 0));
}
function update(
LoansState storage loans_,
Borrower memory borrower_,
address borrowerAddress_,
uint256 poolRate_,
bool inAuction_,
bool npTpRatioUpdate_
) internal {
bool activeBorrower = borrower_.t0Debt != 0 && borrower_.collateral != 0;
uint256 t0DebtToCollateral = activeBorrower ? Maths.wdiv(borrower_.t0Debt, borrower_.collateral) : 0;
if (!inAuction_ ) {
uint256 loanId = loans_.indices[borrowerAddress_];
if (activeBorrower) {
if (t0DebtToCollateral == 0) revert ZeroDebtToCollateral();
_upsert(loans_, borrowerAddress_, loanId, SafeCast.toUint96(t0DebtToCollateral));
} else if (loanId != 0) {
remove(loans_, borrowerAddress_, loanId);
}
}
if (npTpRatioUpdate_) {
borrower_.npTpRatio = 1e18 + uint256(PRBMathSD59x18.sqrt(int256(poolRate_))) / 2;
}
loans_.borrowers[borrowerAddress_] = borrower_;
}
function _bubbleUp(LoansState storage loans_, Loan memory loan_, uint index_) private {
uint256 count = loans_.loans.length;
if (index_ == ROOT_INDEX || loan_.t0DebtToCollateral <= loans_.loans[index_ / 2].t0DebtToCollateral){
_insert(loans_, loan_, index_, count);
} else {
_insert(loans_, loans_.loans[index_ / 2], index_, count);
_bubbleUp(loans_, loan_, index_ / 2);
}
}
function _bubbleDown(LoansState storage loans_, Loan memory loan_, uint index_) private {
uint cIndex = index_ * 2;
uint256 count = loans_.loans.length;
if (count <= cIndex) {
_insert(loans_, loan_, index_, count);
} else {
Loan memory largestChild = loans_.loans[cIndex];
if (count > cIndex + 1 && loans_.loans[cIndex + 1].t0DebtToCollateral > largestChild.t0DebtToCollateral) {
largestChild = loans_.loans[++cIndex];
}
if (largestChild.t0DebtToCollateral <= loan_.t0DebtToCollateral) {
_insert(loans_, loan_, index_, count);
} else {
_insert(loans_, largestChild, index_, count);
_bubbleDown(loans_, loan_, cIndex);
}
}
}
function _insert(LoansState storage loans_, Loan memory loan_, uint index_, uint256 count_) private {
if (index_ == count_) loans_.loans.push(loan_);
else loans_.loans[index_] = loan_;
loans_.indices[loan_.borrower] = index_;
}
function remove(LoansState storage loans_, address borrower_, uint256 index_) internal {
delete loans_.indices[borrower_];
uint256 tailIndex = loans_.loans.length - 1;
if (index_ == tailIndex) loans_.loans.pop();
else {
Loan memory tail = loans_.loans[tailIndex];
loans_.loans.pop();
_bubbleUp(loans_, tail, index_);
_bubbleDown(loans_, loans_.loans[index_], index_);
}
}
function _upsert(
LoansState storage loans_,
address borrower_,
uint256 index_,
uint96 t0DebtToCollateral_
) internal {
if (index_ != 0) {
Loan memory currentLoan = loans_.loans[index_];
if (currentLoan.t0DebtToCollateral > t0DebtToCollateral_) {
currentLoan.t0DebtToCollateral = t0DebtToCollateral_;
_bubbleDown(loans_, currentLoan, index_);
} else {
currentLoan.t0DebtToCollateral = t0DebtToCollateral_;
_bubbleUp(loans_, currentLoan, index_);
}
} else {
_bubbleUp(loans_, Loan(borrower_, t0DebtToCollateral_), loans_.loans.length);
}
}
function getByIndex(LoansState storage loans_, uint256 index_) internal view returns(Loan memory) {
return loans_.loans.length > index_ ? loans_.loans[index_] : Loan(address(0), 0);
}
function getMax(LoansState storage loans_) internal view returns(Loan memory) {
return getByIndex(loans_, ROOT_INDEX);
}
function noOfLoans(LoansState storage loans_) internal view returns (uint256) {
return loans_.loans.length - 1;
}
}
文件 58 的 68：Math.sol
pragma solidity ^0.8.0;
library Math {
enum Rounding {
Down,
Up,
Zero
}
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
return (a & b) + (a ^ b) / 2;
}
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
return a == 0 ? 0 : (a - 1) / b + 1;
}
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
uint256 prod0;
uint256 prod1;
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
if (prod1 == 0) {
return prod0 / denominator;
}
require(denominator > prod1, "Math: mulDiv overflow");
uint256 remainder;
assembly {
remainder := mulmod(x, y, denominator)
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
uint256 twos = denominator & (~denominator + 1);
assembly {
denominator := div(denominator, twos)
prod0 := div(prod0, twos)
twos := add(div(sub(0, twos), twos), 1)
}
prod0 |= prod1 * twos;
uint256 inverse = (3 * denominator) ^ 2;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
result = prod0 * inverse;
return result;
}
}
function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 result = 1 << (log2(a) >> 1);
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
}
}
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
}
}
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10 ** 64) {
value /= 10 ** 64;
result += 64;
}
if (value >= 10 ** 32) {
value /= 10 ** 32;
result += 32;
}
if (value >= 10 ** 16) {
value /= 10 ** 16;
result += 16;
}
if (value >= 10 ** 8) {
value /= 10 ** 8;
result += 8;
}
if (value >= 10 ** 4) {
value /= 10 ** 4;
result += 4;
}
if (value >= 10 ** 2) {
value /= 10 ** 2;
result += 2;
}
if (value >= 10 ** 1) {
result += 1;
}
}
return result;
}
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
}
}
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
}
}
}
文件 59 的 68：Maths.sol
pragma solidity 0.8.18;
library Maths {
uint256 internal constant WAD = 1e18;
uint256 internal constant RAY = 1e27;
function wmul(uint256 x, uint256 y) internal pure returns (uint256) {
return (x * y + WAD / 2) / WAD;
}
function floorWmul(uint256 x, uint256 y) internal pure returns (uint256) {
return (x * y) / WAD;
}
function ceilWmul(uint256 x, uint256 y) internal pure returns (uint256) {
return (x * y + WAD - 1) / WAD;
}
function wdiv(uint256 x, uint256 y) internal pure returns (uint256) {
return (x * WAD + y / 2) / y;
}
function floorWdiv(uint256 x, uint256 y) internal pure returns (uint256) {
return (x * WAD) / y;
}
function ceilWdiv(uint256 x, uint256 y) internal pure returns (uint256) {
return (x * WAD + y - 1) / y;
}
function ceilDiv(uint256 x, uint256 y) internal pure returns (uint256) {
return (x + y - 1) / y;
}
function max(uint256 x, uint256 y) internal pure returns (uint256) {
return x >= y ? x : y;
}
function min(uint256 x, uint256 y) internal pure returns (uint256) {
return x <= y ? x : y;
}
function wad(uint256 x) internal pure returns (uint256) {
return x * WAD;
}
function rmul(uint256 x, uint256 y) internal pure returns (uint256) {
return (x * y + RAY / 2) / RAY;
}
function rpow(uint256 x, uint256 n) internal pure returns (uint256 z) {
z = n % 2 != 0 ? x : RAY;
for (n /= 2; n != 0; n /= 2) {
x = rmul(x, x);
if (n % 2 != 0) {
z = rmul(z, x);
}
}
}
function maxInt(int256 x, int256 y) internal pure returns (int256) {
return x >= y ? x : y;
}
function minInt(int256 x, int256 y) internal pure returns (int256) {
return x <= y ? x : y;
}
}
文件 60 的 68：PRBMath.sol
pragma solidity >=0.8.4;
error PRBMath__MulDivFixedPointOverflow(uint256 prod1);
error PRBMath__MulDivOverflow(uint256 prod1, uint256 denominator);
error PRBMath__MulDivSignedInputTooSmall();
error PRBMath__MulDivSignedOverflow(uint256 rAbs);
error PRBMathSD59x18__AbsInputTooSmall();
error PRBMathSD59x18__CeilOverflow(int256 x);
error PRBMathSD59x18__DivInputTooSmall();
error PRBMathSD59x18__DivOverflow(uint256 rAbs);
error PRBMathSD59x18__ExpInputTooBig(int256 x);
error PRBMathSD59x18__Exp2InputTooBig(int256 x);
error PRBMathSD59x18__FloorUnderflow(int256 x);
error PRBMathSD59x18__FromIntOverflow(int256 x);
error PRBMathSD59x18__FromIntUnderflow(int256 x);
error PRBMathSD59x18__GmNegativeProduct(int256 x, int256 y);
error PRBMathSD59x18__GmOverflow(int256 x, int256 y);
error PRBMathSD59x18__LogInputTooSmall(int256 x);
error PRBMathSD59x18__MulInputTooSmall();
error PRBMathSD59x18__MulOverflow(uint256 rAbs);
error PRBMathSD59x18__PowuOverflow(uint256 rAbs);
error PRBMathSD59x18__SqrtNegativeInput(int256 x);
error PRBMathSD59x18__SqrtOverflow(int256 x);
error PRBMathUD60x18__AddOverflow(uint256 x, uint256 y);
error PRBMathUD60x18__CeilOverflow(uint256 x);
error PRBMathUD60x18__ExpInputTooBig(uint256 x);
error PRBMathUD60x18__Exp2InputTooBig(uint256 x);
error PRBMathUD60x18__FromUintOverflow(uint256 x);
error PRBMathUD60x18__GmOverflow(uint256 x, uint256 y);
error PRBMathUD60x18__LogInputTooSmall(uint256 x);
error PRBMathUD60x18__SqrtOverflow(uint256 x);
error PRBMathUD60x18__SubUnderflow(uint256 x, uint256 y);
library PRBMath {
struct SD59x18 {
int256 value;
}
struct UD60x18 {
uint256 value;
}
uint256 internal constant SCALE = 1e18;
uint256 internal constant SCALE_LPOTD = 262144;
uint256 internal constant SCALE_INVERSE =
78156646155174841979727994598816262306175212592076161876661_508869554232690281;
function exp2(uint256 x) internal pure returns (uint256 result) {
unchecked {
result = 0x800000000000000000000000000000000000000000000000;
if (x & 0x8000000000000000 > 0) {
result = (result * 0x16A09E667F3BCC909) >> 64;
}
if (x & 0x4000000000000000 > 0) {
result = (result * 0x1306FE0A31B7152DF) >> 64;
}
if (x & 0x2000000000000000 > 0) {
result = (result * 0x1172B83C7D517ADCE) >> 64;
}
if (x & 0x1000000000000000 > 0) {
result = (result * 0x10B5586CF9890F62A) >> 64;
}
if (x & 0x800000000000000 > 0) {
result = (result * 0x1059B0D31585743AE) >> 64;
}
if (x & 0x400000000000000 > 0) {
result = (result * 0x102C9A3E778060EE7) >> 64;
}
if (x & 0x200000000000000 > 0) {
result = (result * 0x10163DA9FB33356D8) >> 64;
}
if (x & 0x100000000000000 > 0) {
result = (result * 0x100B1AFA5ABCBED61) >> 64;
}
if (x & 0x80000000000000 > 0) {
result = (result * 0x10058C86DA1C09EA2) >> 64;
}
if (x & 0x40000000000000 > 0) {
result = (result * 0x1002C605E2E8CEC50) >> 64;
}
if (x & 0x20000000000000 > 0) {
result = (result * 0x100162F3904051FA1) >> 64;
}
if (x & 0x10000000000000 > 0) {
result = (result * 0x1000B175EFFDC76BA) >> 64;
}
if (x & 0x8000000000000 > 0) {
result = (result * 0x100058BA01FB9F96D) >> 64;
}
if (x & 0x4000000000000 > 0) {
result = (result * 0x10002C5CC37DA9492) >> 64;
}
if (x & 0x2000000000000 > 0) {
result = (result * 0x1000162E525EE0547) >> 64;
}
if (x & 0x1000000000000 > 0) {
result = (result * 0x10000B17255775C04) >> 64;
}
if (x & 0x800000000000 > 0) {
result = (result * 0x1000058B91B5BC9AE) >> 64;
}
if (x & 0x400000000000 > 0) {
result = (result * 0x100002C5C89D5EC6D) >> 64;
}
if (x & 0x200000000000 > 0) {
result = (result * 0x10000162E43F4F831) >> 64;
}
if (x & 0x100000000000 > 0) {
result = (result * 0x100000B1721BCFC9A) >> 64;
}
if (x & 0x80000000000 > 0) {
result = (result * 0x10000058B90CF1E6E) >> 64;
}
if (x & 0x40000000000 > 0) {
result = (result * 0x1000002C5C863B73F) >> 64;
}
if (x & 0x20000000000 > 0) {
result = (result * 0x100000162E430E5A2) >> 64;
}
if (x & 0x10000000000 > 0) {
result = (result * 0x1000000B172183551) >> 64;
}
if (x & 0x8000000000 > 0) {
result = (result * 0x100000058B90C0B49) >> 64;
}
if (x & 0x4000000000 > 0) {
result = (result * 0x10000002C5C8601CC) >> 64;
}
if (x & 0x2000000000 > 0) {
result = (result * 0x1000000162E42FFF0) >> 64;
}
if (x & 0x1000000000 > 0) {
result = (result * 0x10000000B17217FBB) >> 64;
}
if (x & 0x800000000 > 0) {
result = (result * 0x1000000058B90BFCE) >> 64;
}
if (x & 0x400000000 > 0) {
result = (result * 0x100000002C5C85FE3) >> 64;
}
if (x & 0x200000000 > 0) {
result = (result * 0x10000000162E42FF1) >> 64;
}
if (x & 0x100000000 > 0) {
result = (result * 0x100000000B17217F8) >> 64;
}
if (x & 0x80000000 > 0) {
result = (result * 0x10000000058B90BFC) >> 64;
}
if (x & 0x40000000 > 0) {
result = (result * 0x1000000002C5C85FE) >> 64;
}
if (x & 0x20000000 > 0) {
result = (result * 0x100000000162E42FF) >> 64;
}
if (x & 0x10000000 > 0) {
result = (result * 0x1000000000B17217F) >> 64;
}
if (x & 0x8000000 > 0) {
result = (result * 0x100000000058B90C0) >> 64;
}
if (x & 0x4000000 > 0) {
result = (result * 0x10000000002C5C860) >> 64;
}
if (x & 0x2000000 > 0) {
result = (result * 0x1000000000162E430) >> 64;
}
if (x & 0x1000000 > 0) {
result = (result * 0x10000000000B17218) >> 64;
}
if (x & 0x800000 > 0) {
result = (result * 0x1000000000058B90C) >> 64;
}
if (x & 0x400000 > 0) {
result = (result * 0x100000000002C5C86) >> 64;
}
if (x & 0x200000 > 0) {
result = (result * 0x10000000000162E43) >> 64;
}
if (x & 0x100000 > 0) {
result = (result * 0x100000000000B1721) >> 64;
}
if (x & 0x80000 > 0) {
result = (result * 0x10000000000058B91) >> 64;
}
if (x & 0x40000 > 0) {
result = (result * 0x1000000000002C5C8) >> 64;
}
if (x & 0x20000 > 0) {
result = (result * 0x100000000000162E4) >> 64;
}
if (x & 0x10000 > 0) {
result = (result * 0x1000000000000B172) >> 64;
}
if (x & 0x8000 > 0) {
result = (result * 0x100000000000058B9) >> 64;
}
if (x & 0x4000 > 0) {
result = (result * 0x10000000000002C5D) >> 64;
}
if (x & 0x2000 > 0) {
result = (result * 0x1000000000000162E) >> 64;
}
if (x & 0x1000 > 0) {
result = (result * 0x10000000000000B17) >> 64;
}
if (x & 0x800 > 0) {
result = (result * 0x1000000000000058C) >> 64;
}
if (x & 0x400 > 0) {
result = (result * 0x100000000000002C6) >> 64;
}
if (x & 0x200 > 0) {
result = (result * 0x10000000000000163) >> 64;
}
if (x & 0x100 > 0) {
result = (result * 0x100000000000000B1) >> 64;
}
if (x & 0x80 > 0) {
result = (result * 0x10000000000000059) >> 64;
}
if (x & 0x40 > 0) {
result = (result * 0x1000000000000002C) >> 64;
}
if (x & 0x20 > 0) {
result = (result * 0x10000000000000016) >> 64;
}
if (x & 0x10 > 0) {
result = (result * 0x1000000000000000B) >> 64;
}
if (x & 0x8 > 0) {
result = (result * 0x10000000000000006) >> 64;
}
if (x & 0x4 > 0) {
result = (result * 0x10000000000000003) >> 64;
}
if (x & 0x2 > 0) {
result = (result * 0x10000000000000001) >> 64;
}
if (x & 0x1 > 0) {
result = (result * 0x10000000000000001) >> 64;
}
result *= SCALE;
result >>= (191 - (x >> 64));
}
}
function mostSignificantBit(uint256 x) internal pure returns (uint256 msb) {
if (x >= 2**128) {
x >>= 128;
msb += 128;
}
if (x >= 2**64) {
x >>= 64;
msb += 64;
}
if (x >= 2**32) {
x >>= 32;
msb += 32;
}
if (x >= 2**16) {
x >>= 16;
msb += 16;
}
if (x >= 2**8) {
x >>= 8;
msb += 8;
}
if (x >= 2**4) {
x >>= 4;
msb += 4;
}
if (x >= 2**2) {
x >>= 2;
msb += 2;
}
if (x >= 2**1) {
msb += 1;
}
}
function mulDiv(
uint256 x,
uint256 y,
uint256 denominator
) internal pure returns (uint256 result) {
uint256 prod0;
uint256 prod1;
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
if (prod1 == 0) {
unchecked {
result = prod0 / denominator;
}
return result;
}
if (prod1 >= denominator) {
revert PRBMath__MulDivOverflow(prod1, denominator);
}
uint256 remainder;
assembly {
remainder := mulmod(x, y, denominator)
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
unchecked {
uint256 lpotdod = denominator & (~denominator + 1);
assembly {
denominator := div(denominator, lpotdod)
prod0 := div(prod0, lpotdod)
lpotdod := add(div(sub(0, lpotdod), lpotdod), 1)
}
prod0 |= prod1 * lpotdod;
uint256 inverse = (3 * denominator) ^ 2;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
result = prod0 * inverse;
return result;
}
}
function mulDivFixedPoint(uint256 x, uint256 y) internal pure returns (uint256 result) {
uint256 prod0;
uint256 prod1;
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
if (prod1 >= SCALE) {
revert PRBMath__MulDivFixedPointOverflow(prod1);
}
uint256 remainder;
uint256 roundUpUnit;
assembly {
remainder := mulmod(x, y, SCALE)
roundUpUnit := gt(remainder, 499999999999999999)
}
if (prod1 == 0) {
unchecked {
result = (prod0 / SCALE) + roundUpUnit;
return result;
}
}
assembly {
result := add(
mul(
or(
div(sub(prod0, remainder), SCALE_LPOTD),
mul(sub(prod1, gt(remainder, prod0)), add(div(sub(0, SCALE_LPOTD), SCALE_LPOTD), 1))
),
SCALE_INVERSE
),
roundUpUnit
)
}
}
function mulDivSigned(
int256 x,
int256 y,
int256 denominator
) internal pure returns (int256 result) {
if (x == type(int256).min || y == type(int256).min || denominator == type(int256).min) {
revert PRBMath__MulDivSignedInputTooSmall();
}
uint256 ax;
uint256 ay;
uint256 ad;
unchecked {
ax = x < 0 ? uint256(-x) : uint256(x);
ay = y < 0 ? uint256(-y) : uint256(y);
ad = denominator < 0 ? uint256(-denominator) : uint256(denominator);
}
uint256 rAbs = mulDiv(ax, ay, ad);
if (rAbs > uint256(type(int256).max)) {
revert PRBMath__MulDivSignedOverflow(rAbs);
}
uint256 sx;
uint256 sy;
uint256 sd;
assembly {
sx := sgt(x, sub(0, 1))
sy := sgt(y, sub(0, 1))
sd := sgt(denominator, sub(0, 1))
}
result = sx ^ sy ^ sd == 0 ? -int256(rAbs) : int256(rAbs);
}
function sqrt(uint256 x) internal pure returns (uint256 result) {
if (x == 0) {
return 0;
}
uint256 xAux = uint256(x);
result = 1;
if (xAux >= 0x100000000000000000000000000000000) {
xAux >>= 128;
result <<= 64;
}
if (xAux >= 0x10000000000000000) {
xAux >>= 64;
result <<= 32;
}
if (xAux >= 0x100000000) {
xAux >>= 32;
result <<= 16;
}
if (xAux >= 0x10000) {
xAux >>= 16;
result <<= 8;
}
if (xAux >= 0x100) {
xAux >>= 8;
result <<= 4;
}
if (xAux >= 0x10) {
xAux >>= 4;
result <<= 2;
}
if (xAux >= 0x8) {
result <<= 1;
}
unchecked {
result = (result + x / result) >> 1;
result = (result + x / result) >> 1;
result = (result + x / result) >> 1;
result = (result + x / result) >> 1;
result = (result + x / result) >> 1;
result = (result + x / result) >> 1;
result = (result + x / result) >> 1;
uint256 roundedDownResult = x / result;
return result >= roundedDownResult ? roundedDownResult : result;
}
}
}
文件 61 的 68：PRBMathSD59x18.sol
pragma solidity >=0.8.4;
import "./PRBMath.sol";
library PRBMathSD59x18 {
int256 internal constant LOG2_E = 1_442695040888963407;
int256 internal constant HALF_SCALE = 5e17;
int256 internal constant MAX_SD59x18 =
57896044618658097711785492504343953926634992332820282019728_792003956564819967;
int256 internal constant MAX_WHOLE_SD59x18 =
57896044618658097711785492504343953926634992332820282019728_000000000000000000;
int256 internal constant MIN_SD59x18 =
-57896044618658097711785492504343953926634992332820282019728_792003956564819968;
int256 internal constant MIN_WHOLE_SD59x18 =
-57896044618658097711785492504343953926634992332820282019728_000000000000000000;
int256 internal constant SCALE = 1e18;
function abs(int256 x) internal pure returns (int256 result) {
unchecked {
if (x == MIN_SD59x18) {
revert PRBMathSD59x18__AbsInputTooSmall();
}
result = x < 0 ? -x : x;
}
}
function avg(int256 x, int256 y) internal pure returns (int256 result) {
unchecked {
int256 sum = (x >> 1) + (y >> 1);
if (sum < 0) {
assembly {
result := add(sum, and(or(x, y), 1))
}
} else {
result = sum + (x & y & 1);
}
}
}
function ceil(int256 x) internal pure returns (int256 result) {
if (x > MAX_WHOLE_SD59x18) {
revert PRBMathSD59x18__CeilOverflow(x);
}
unchecked {
int256 remainder = x % SCALE;
if (remainder == 0) {
result = x;
} else {
result = x - remainder;
if (x > 0) {
result += SCALE;
}
}
}
}
function div(int256 x, int256 y) internal pure returns (int256 result) {
if (x == MIN_SD59x18 || y == MIN_SD59x18) {
revert PRBMathSD59x18__DivInputTooSmall();
}
uint256 ax;
uint256 ay;
unchecked {
ax = x < 0 ? uint256(-x) : uint256(x);
ay = y < 0 ? uint256(-y) : uint256(y);
}
uint256 rAbs = PRBMath.mulDiv(ax, uint256(SCALE), ay);
if (rAbs > uint256(MAX_SD59x18)) {
revert PRBMathSD59x18__DivOverflow(rAbs);
}
uint256 sx;
uint256 sy;
assembly {
sx := sgt(x, sub(0, 1))
sy := sgt(y, sub(0, 1))
}
result = sx ^ sy == 1 ? -int256(rAbs) : int256(rAbs);
}
function e() internal pure returns (int256 result) {
result = 2_718281828459045235;
}
function exp(int256 x) internal pure returns (int256 result) {
if (x < -41_446531673892822322) {
return 0;
}
if (x >= 133_084258667509499441) {
revert PRBMathSD59x18__ExpInputTooBig(x);
}
unchecked {
int256 doubleScaleProduct = x * LOG2_E;
result = exp2((doubleScaleProduct + HALF_SCALE) / SCALE);
}
}
function exp2(int256 x) internal pure returns (int256 result) {
if (x < 0) {
if (x < -59_794705707972522261) {
return 0;
}
unchecked {
result = 1e36 / exp2(-x);
}
} else {
if (x >= 192e18) {
revert PRBMathSD59x18__Exp2InputTooBig(x);
}
unchecked {
uint256 x192x64 = (uint256(x) << 64) / uint256(SCALE);
result = int256(PRBMath.exp2(x192x64));
}
}
}
function floor(int256 x) internal pure returns (int256 result) {
if (x < MIN_WHOLE_SD59x18) {
revert PRBMathSD59x18__FloorUnderflow(x);
}
unchecked {
int256 remainder = x % SCALE;
if (remainder == 0) {
result = x;
} else {
result = x - remainder;
if (x < 0) {
result -= SCALE;
}
}
}
}
function frac(int256 x) internal pure returns (int256 result) {
unchecked {
result = x % SCALE;
}
}
function fromInt(int256 x) internal pure returns (int256 result) {
unchecked {
if (x < MIN_SD59x18 / SCALE) {
revert PRBMathSD59x18__FromIntUnderflow(x);
}
if (x > MAX_SD59x18 / SCALE) {
revert PRBMathSD59x18__FromIntOverflow(x);
}
result = x * SCALE;
}
}
function gm(int256 x, int256 y) internal pure returns (int256 result) {
if (x == 0) {
return 0;
}
unchecked {
int256 xy = x * y;
if (xy / x != y) {
revert PRBMathSD59x18__GmOverflow(x, y);
}
if (xy < 0) {
revert PRBMathSD59x18__GmNegativeProduct(x, y);
}
result = int256(PRBMath.sqrt(uint256(xy)));
}
}
function inv(int256 x) internal pure returns (int256 result) {
unchecked {
result = 1e36 / x;
}
}
function ln(int256 x) internal pure returns (int256 result) {
unchecked {
result = (log2(x) * SCALE) / LOG2_E;
}
}
function log10(int256 x) internal pure returns (int256 result) {
if (x <= 0) {
revert PRBMathSD59x18__LogInputTooSmall(x);
}
assembly {
switch x
case 1 { result := mul(SCALE, sub(0, 18)) }
case 10 { result := mul(SCALE, sub(1, 18)) }
case 100 { result := mul(SCALE, sub(2, 18)) }
case 1000 { result := mul(SCALE, sub(3, 18)) }
case 10000 { result := mul(SCALE, sub(4, 18)) }
case 100000 { result := mul(SCALE, sub(5, 18)) }
case 1000000 { result := mul(SCALE, sub(6, 18)) }
case 10000000 { result := mul(SCALE, sub(7, 18)) }
case 100000000 { result := mul(SCALE, sub(8, 18)) }
case 1000000000 { result := mul(SCALE, sub(9, 18)) }
case 10000000000 { result := mul(SCALE, sub(10, 18)) }
case 100000000000 { result := mul(SCALE, sub(11, 18)) }
case 1000000000000 { result := mul(SCALE, sub(12, 18)) }
case 10000000000000 { result := mul(SCALE, sub(13, 18)) }
case 100000000000000 { result := mul(SCALE, sub(14, 18)) }
case 1000000000000000 { result := mul(SCALE, sub(15, 18)) }
case 10000000000000000 { result := mul(SCALE, sub(16, 18)) }
case 100000000000000000 { result := mul(SCALE, sub(17, 18)) }
case 1000000000000000000 { result := 0 }
case 10000000000000000000 { result := SCALE }
case 100000000000000000000 { result := mul(SCALE, 2) }
case 1000000000000000000000 { result := mul(SCALE, 3) }
case 10000000000000000000000 { result := mul(SCALE, 4) }
case 100000000000000000000000 { result := mul(SCALE, 5) }
case 1000000000000000000000000 { result := mul(SCALE, 6) }
case 10000000000000000000000000 { result := mul(SCALE, 7) }
case 100000000000000000000000000 { result := mul(SCALE, 8) }
case 1000000000000000000000000000 { result := mul(SCALE, 9) }
case 10000000000000000000000000000 { result := mul(SCALE, 10) }
case 100000000000000000000000000000 { result := mul(SCALE, 11) }
case 1000000000000000000000000000000 { result := mul(SCALE, 12) }
case 10000000000000000000000000000000 { result := mul(SCALE, 13) }
case 100000000000000000000000000000000 { result := mul(SCALE, 14) }
case 1000000000000000000000000000000000 { result := mul(SCALE, 15) }
case 10000000000000000000000000000000000 { result := mul(SCALE, 16) }
case 100000000000000000000000000000000000 { result := mul(SCALE, 17) }
case 1000000000000000000000000000000000000 { result := mul(SCALE, 18) }
case 10000000000000000000000000000000000000 { result := mul(SCALE, 19) }
case 100000000000000000000000000000000000000 { result := mul(SCALE, 20) }
case 1000000000000000000000000000000000000000 { result := mul(SCALE, 21) }
case 10000000000000000000000000000000000000000 { result := mul(SCALE, 22) }
case 100000000000000000000000000000000000000000 { result := mul(SCALE, 23) }
case 1000000000000000000000000000000000000000000 { result := mul(SCALE, 24) }
case 10000000000000000000000000000000000000000000 { result := mul(SCALE, 25) }
case 100000000000000000000000000000000000000000000 { result := mul(SCALE, 26) }
case 1000000000000000000000000000000000000000000000 { result := mul(SCALE, 27) }
case 10000000000000000000000000000000000000000000000 { result := mul(SCALE, 28) }
case 100000000000000000000000000000000000000000000000 { result := mul(SCALE, 29) }
case 1000000000000000000000000000000000000000000000000 { result := mul(SCALE, 30) }
case 10000000000000000000000000000000000000000000000000 { result := mul(SCALE, 31) }
case 100000000000000000000000000000000000000000000000000 { result := mul(SCALE, 32) }
case 1000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 33) }
case 10000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 34) }
case 100000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 35) }
case 1000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 36) }
case 10000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 37) }
case 100000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 38) }
case 1000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 39) }
case 10000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 40) }
case 100000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 41) }
case 1000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 42) }
case 10000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 43) }
case 100000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 44) }
case 1000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 45) }
case 10000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 46) }
case 100000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 47) }
case 1000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 48) }
case 10000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 49) }
case 100000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 50) }
case 1000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 51) }
case 10000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 52) }
case 100000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 53) }
case 1000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 54) }
case 10000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 55) }
case 100000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 56) }
case 1000000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 57) }
case 10000000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 58) }
default {
result := MAX_SD59x18
}
}
if (result == MAX_SD59x18) {
unchecked {
result = (log2(x) * SCALE) / 3_321928094887362347;
}
}
}
function log2(int256 x) internal pure returns (int256 result) {
if (x <= 0) {
revert PRBMathSD59x18__LogInputTooSmall(x);
}
unchecked {
int256 sign;
if (x >= SCALE) {
sign = 1;
} else {
sign = -1;
assembly {
x := div(1000000000000000000000000000000000000, x)
}
}
uint256 n = PRBMath.mostSignificantBit(uint256(x / SCALE));
result = int256(n) * SCALE;
int256 y = x >> n;
if (y == SCALE) {
return result * sign;
}
for (int256 delta = int256(HALF_SCALE); delta > 0; delta >>= 1) {
y = (y * y) / SCALE;
if (y >= 2 * SCALE) {
result += delta;
y >>= 1;
}
}
result *= sign;
}
}
function mul(int256 x, int256 y) internal pure returns (int256 result) {
if (x == MIN_SD59x18 || y == MIN_SD59x18) {
revert PRBMathSD59x18__MulInputTooSmall();
}
unchecked {
uint256 ax;
uint256 ay;
ax = x < 0 ? uint256(-x) : uint256(x);
ay = y < 0 ? uint256(-y) : uint256(y);
uint256 rAbs = PRBMath.mulDivFixedPoint(ax, ay);
if (rAbs > uint256(MAX_SD59x18)) {
revert PRBMathSD59x18__MulOverflow(rAbs);
}
uint256 sx;
uint256 sy;
assembly {
sx := sgt(x, sub(0, 1))
sy := sgt(y, sub(0, 1))
}
result = sx ^ sy == 1 ? -int256(rAbs) : int256(rAbs);
}
}
function pi() internal pure returns (int256 result) {
result = 3_141592653589793238;
}
function pow(int256 x, int256 y) internal pure returns (int256 result) {
if (x == 0) {
result = y == 0 ? SCALE : int256(0);
} else {
result = exp2(mul(log2(x), y));
}
}
function powu(int256 x, uint256 y) internal pure returns (int256 result) {
uint256 xAbs = uint256(abs(x));
uint256 rAbs = y & 1 > 0 ? xAbs : uint256(SCALE);
uint256 yAux = y;
for (yAux >>= 1; yAux > 0; yAux >>= 1) {
xAbs = PRBMath.mulDivFixedPoint(xAbs, xAbs);
if (yAux & 1 > 0) {
rAbs = PRBMath.mulDivFixedPoint(rAbs, xAbs);
}
}
if (rAbs > uint256(MAX_SD59x18)) {
revert PRBMathSD59x18__PowuOverflow(rAbs);
}
bool isNegative = x < 0 && y & 1 == 1;
result = isNegative ? -int256(rAbs) : int256(rAbs);
}
function scale() internal pure returns (int256 result) {
result = SCALE;
}
function sqrt(int256 x) internal pure returns (int256 result) {
unchecked {
if (x < 0) {
revert PRBMathSD59x18__SqrtNegativeInput(x);
}
if (x > MAX_SD59x18 / SCALE) {
revert PRBMathSD59x18__SqrtOverflow(x);
}
result = int256(PRBMath.sqrt(uint256(x * SCALE)));
}
}
function toInt(int256 x) internal pure returns (int256 result) {
unchecked {
result = x / SCALE;
}
}
}
文件 62 的 68：PRBMathUD60x18.sol
pragma solidity >=0.8.4;
import "./PRBMath.sol";
library PRBMathUD60x18 {
uint256 internal constant HALF_SCALE = 5e17;
uint256 internal constant LOG2_E = 1_442695040888963407;
uint256 internal constant MAX_UD60x18 =
115792089237316195423570985008687907853269984665640564039457_584007913129639935;
uint256 internal constant MAX_WHOLE_UD60x18 =
115792089237316195423570985008687907853269984665640564039457_000000000000000000;
uint256 internal constant SCALE = 1e18;
function avg(uint256 x, uint256 y) internal pure returns (uint256 result) {
unchecked {
result = (x >> 1) + (y >> 1) + (x & y & 1);
}
}
function ceil(uint256 x) internal pure returns (uint256 result) {
if (x > MAX_WHOLE_UD60x18) {
revert PRBMathUD60x18__CeilOverflow(x);
}
assembly {
let remainder := mod(x, SCALE)
let delta := sub(SCALE, remainder)
result := add(x, mul(delta, gt(remainder, 0)))
}
}
function div(uint256 x, uint256 y) internal pure returns (uint256 result) {
result = PRBMath.mulDiv(x, SCALE, y);
}
function e() internal pure returns (uint256 result) {
result = 2_718281828459045235;
}
function exp(uint256 x) internal pure returns (uint256 result) {
if (x >= 133_084258667509499441) {
revert PRBMathUD60x18__ExpInputTooBig(x);
}
unchecked {
uint256 doubleScaleProduct = x * LOG2_E;
result = exp2((doubleScaleProduct + HALF_SCALE) / SCALE);
}
}
function exp2(uint256 x) internal pure returns (uint256 result) {
if (x >= 192e18) {
revert PRBMathUD60x18__Exp2InputTooBig(x);
}
unchecked {
uint256 x192x64 = (x << 64) / SCALE;
result = PRBMath.exp2(x192x64);
}
}
function floor(uint256 x) internal pure returns (uint256 result) {
assembly {
let remainder := mod(x, SCALE)
result := sub(x, mul(remainder, gt(remainder, 0)))
}
}
function frac(uint256 x) internal pure returns (uint256 result) {
assembly {
result := mod(x, SCALE)
}
}
function fromUint(uint256 x) internal pure returns (uint256 result) {
unchecked {
if (x > MAX_UD60x18 / SCALE) {
revert PRBMathUD60x18__FromUintOverflow(x);
}
result = x * SCALE;
}
}
function gm(uint256 x, uint256 y) internal pure returns (uint256 result) {
if (x == 0) {
return 0;
}
unchecked {
uint256 xy = x * y;
if (xy / x != y) {
revert PRBMathUD60x18__GmOverflow(x, y);
}
result = PRBMath.sqrt(xy);
}
}
function inv(uint256 x) internal pure returns (uint256 result) {
unchecked {
result = 1e36 / x;
}
}
function ln(uint256 x) internal pure returns (uint256 result) {
unchecked {
result = (log2(x) * SCALE) / LOG2_E;
}
}
function log10(uint256 x) internal pure returns (uint256 result) {
if (x < SCALE) {
revert PRBMathUD60x18__LogInputTooSmall(x);
}
assembly {
switch x
case 1 { result := mul(SCALE, sub(0, 18)) }
case 10 { result := mul(SCALE, sub(1, 18)) }
case 100 { result := mul(SCALE, sub(2, 18)) }
case 1000 { result := mul(SCALE, sub(3, 18)) }
case 10000 { result := mul(SCALE, sub(4, 18)) }
case 100000 { result := mul(SCALE, sub(5, 18)) }
case 1000000 { result := mul(SCALE, sub(6, 18)) }
case 10000000 { result := mul(SCALE, sub(7, 18)) }
case 100000000 { result := mul(SCALE, sub(8, 18)) }
case 1000000000 { result := mul(SCALE, sub(9, 18)) }
case 10000000000 { result := mul(SCALE, sub(10, 18)) }
case 100000000000 { result := mul(SCALE, sub(11, 18)) }
case 1000000000000 { result := mul(SCALE, sub(12, 18)) }
case 10000000000000 { result := mul(SCALE, sub(13, 18)) }
case 100000000000000 { result := mul(SCALE, sub(14, 18)) }
case 1000000000000000 { result := mul(SCALE, sub(15, 18)) }
case 10000000000000000 { result := mul(SCALE, sub(16, 18)) }
case 100000000000000000 { result := mul(SCALE, sub(17, 18)) }
case 1000000000000000000 { result := 0 }
case 10000000000000000000 { result := SCALE }
case 100000000000000000000 { result := mul(SCALE, 2) }
case 1000000000000000000000 { result := mul(SCALE, 3) }
case 10000000000000000000000 { result := mul(SCALE, 4) }
case 100000000000000000000000 { result := mul(SCALE, 5) }
case 1000000000000000000000000 { result := mul(SCALE, 6) }
case 10000000000000000000000000 { result := mul(SCALE, 7) }
case 100000000000000000000000000 { result := mul(SCALE, 8) }
case 1000000000000000000000000000 { result := mul(SCALE, 9) }
case 10000000000000000000000000000 { result := mul(SCALE, 10) }
case 100000000000000000000000000000 { result := mul(SCALE, 11) }
case 1000000000000000000000000000000 { result := mul(SCALE, 12) }
case 10000000000000000000000000000000 { result := mul(SCALE, 13) }
case 100000000000000000000000000000000 { result := mul(SCALE, 14) }
case 1000000000000000000000000000000000 { result := mul(SCALE, 15) }
case 10000000000000000000000000000000000 { result := mul(SCALE, 16) }
case 100000000000000000000000000000000000 { result := mul(SCALE, 17) }
case 1000000000000000000000000000000000000 { result := mul(SCALE, 18) }
case 10000000000000000000000000000000000000 { result := mul(SCALE, 19) }
case 100000000000000000000000000000000000000 { result := mul(SCALE, 20) }
case 1000000000000000000000000000000000000000 { result := mul(SCALE, 21) }
case 10000000000000000000000000000000000000000 { result := mul(SCALE, 22) }
case 100000000000000000000000000000000000000000 { result := mul(SCALE, 23) }
case 1000000000000000000000000000000000000000000 { result := mul(SCALE, 24) }
case 10000000000000000000000000000000000000000000 { result := mul(SCALE, 25) }
case 100000000000000000000000000000000000000000000 { result := mul(SCALE, 26) }
case 1000000000000000000000000000000000000000000000 { result := mul(SCALE, 27) }
case 10000000000000000000000000000000000000000000000 { result := mul(SCALE, 28) }
case 100000000000000000000000000000000000000000000000 { result := mul(SCALE, 29) }
case 1000000000000000000000000000000000000000000000000 { result := mul(SCALE, 30) }
case 10000000000000000000000000000000000000000000000000 { result := mul(SCALE, 31) }
case 100000000000000000000000000000000000000000000000000 { result := mul(SCALE, 32) }
case 1000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 33) }
case 10000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 34) }
case 100000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 35) }
case 1000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 36) }
case 10000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 37) }
case 100000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 38) }
case 1000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 39) }
case 10000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 40) }
case 100000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 41) }
case 1000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 42) }
case 10000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 43) }
case 100000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 44) }
case 1000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 45) }
case 10000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 46) }
case 100000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 47) }
case 1000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 48) }
case 10000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 49) }
case 100000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 50) }
case 1000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 51) }
case 10000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 52) }
case 100000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 53) }
case 1000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 54) }
case 10000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 55) }
case 100000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 56) }
case 1000000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 57) }
case 10000000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 58) }
case 100000000000000000000000000000000000000000000000000000000000000000000000000000 { result := mul(SCALE, 59) }
default {
result := MAX_UD60x18
}
}
if (result == MAX_UD60x18) {
unchecked {
result = (log2(x) * SCALE) / 3_321928094887362347;
}
}
}
function log2(uint256 x) internal pure returns (uint256 result) {
if (x < SCALE) {
revert PRBMathUD60x18__LogInputTooSmall(x);
}
unchecked {
uint256 n = PRBMath.mostSignificantBit(x / SCALE);
result = n * SCALE;
uint256 y = x >> n;
if (y == SCALE) {
return result;
}
for (uint256 delta = HALF_SCALE; delta > 0; delta >>= 1) {
y = (y * y) / SCALE;
if (y >= 2 * SCALE) {
result += delta;
y >>= 1;
}
}
}
}
function mul(uint256 x, uint256 y) internal pure returns (uint256 result) {
result = PRBMath.mulDivFixedPoint(x, y);
}
function pi() internal pure returns (uint256 result) {
result = 3_141592653589793238;
}
function pow(uint256 x, uint256 y) internal pure returns (uint256 result) {
if (x == 0) {
result = y == 0 ? SCALE : uint256(0);
} else {
result = exp2(mul(log2(x), y));
}
}
function powu(uint256 x, uint256 y) internal pure returns (uint256 result) {
result = y & 1 > 0 ? x : SCALE;
for (y >>= 1; y > 0; y >>= 1) {
x = PRBMath.mulDivFixedPoint(x, x);
if (y & 1 > 0) {
result = PRBMath.mulDivFixedPoint(result, x);
}
}
}
function scale() internal pure returns (uint256 result) {
result = SCALE;
}
function sqrt(uint256 x) internal pure returns (uint256 result) {
unchecked {
if (x > MAX_UD60x18 / SCALE) {
revert PRBMathUD60x18__SqrtOverflow(x);
}
result = PRBMath.sqrt(x * SCALE);
}
}
function toUint(uint256 x) internal pure returns (uint256 result) {
unchecked {
result = x / SCALE;
}
}
}
文件 63 的 68：PoolCommons.sol
pragma solidity 0.8.18;
import { PRBMathSD59x18 } from "@prb-math/contracts/PRBMathSD59x18.sol";
import { PRBMathUD60x18 } from "@prb-math/contracts/PRBMathUD60x18.sol";
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {
DepositsState,
EmaState,
InflatorState,
InterestState,
PoolBalancesState,
PoolState
} from '../../interfaces/pool/commons/IPoolState.sol';
import { IERC3156FlashBorrower } from '../../interfaces/pool/IERC3156FlashBorrower.sol';
import {
_dwatp,
_htp,
_indexOf,
MAX_FENWICK_INDEX,
MIN_PRICE, MAX_PRICE
} from '../helpers/PoolHelper.sol';
import { Deposits } from '../internal/Deposits.sol';
import { Buckets } from '../internal/Buckets.sol';
import { Loans } from '../internal/Loans.sol';
import { Maths } from '../internal/Maths.sol';
library PoolCommons {
using SafeERC20 for IERC20;
uint256 internal constant CUBIC_ROOT_1000000 = 100 * 1e18;
uint256 internal constant ONE_THIRD = 0.333333333333333334 * 1e18;
uint256 internal constant INCREASE_COEFFICIENT = 1.1 * 1e18;
uint256 internal constant DECREASE_COEFFICIENT = 0.9 * 1e18;
int256 internal constant PERCENT_102 = 1.02 * 1e18;
int256 internal constant NEG_H_MAU_HOURS = -0.057762265046662105 * 1e18;
int256 internal constant NEG_H_TU_HOURS = -0.008251752149523158 * 1e18;
event Flashloan(address indexed receiver, address indexed token, uint256 amount);
event ResetInterestRate(uint256 oldRate, uint256 newRate);
event UpdateInterestRate(uint256 oldRate, uint256 newRate);
error FlashloanCallbackFailed();
error FlashloanIncorrectBalance();
struct UpdateInterestLocalVars {
uint256 debtEma;
uint256 depositEma;
uint256 debtColEma;
uint256 lupt0DebtEma;
uint256 t0Debt2ToCollateral;
uint256 newMeaningfulDeposit;
uint256 newDebt;
uint256 newDebtCol;
uint256 newLupt0Debt;
uint256 lastEmaUpdate;
int256 elapsed;
int256 weightMau;
int256 weightTu;
uint256 newInterestRate;
uint256 nonAuctionedT0Debt;
}
function updateInterestState(
InterestState storage interestParams_,
EmaState storage emaParams_,
DepositsState storage deposits_,
PoolState memory poolState_,
uint256 lup_
) external {
UpdateInterestLocalVars memory vars;
vars.debtEma = emaParams_.debtEma;
vars.depositEma = emaParams_.depositEma;
vars.debtColEma = emaParams_.debtColEma;
vars.lupt0DebtEma = emaParams_.lupt0DebtEma;
vars.lastEmaUpdate = emaParams_.emaUpdate;
vars.t0Debt2ToCollateral = interestParams_.t0Debt2ToCollateral;
vars.nonAuctionedT0Debt = poolState_.t0Debt - poolState_.t0DebtInAuction;
vars.newDebt = Maths.wmul(vars.nonAuctionedT0Debt, poolState_.inflator);
vars.newMeaningfulDeposit = Maths.max(
_meaningfulDeposit(
deposits_,
poolState_.t0DebtInAuction,
vars.nonAuctionedT0Debt,
poolState_.inflator,
vars.t0Debt2ToCollateral
),
vars.newDebt
);
vars.newDebtCol = Maths.wmul(poolState_.inflator, vars.t0Debt2ToCollateral);
vars.newLupt0Debt = Maths.wmul(lup_, vars.nonAuctionedT0Debt);
if (vars.lastEmaUpdate != block.timestamp) {
if (vars.lastEmaUpdate == 0) {
vars.debtEma = vars.newDebt;
vars.depositEma = vars.newMeaningfulDeposit;
vars.debtColEma = vars.newDebtCol;
vars.lupt0DebtEma = vars.newLupt0Debt;
} else {
vars.elapsed = int256(Maths.wdiv(block.timestamp - vars.lastEmaUpdate, 1 hours));
vars.weightMau = PRBMathSD59x18.exp(PRBMathSD59x18.mul(NEG_H_MAU_HOURS, vars.elapsed));
vars.weightTu = PRBMathSD59x18.exp(PRBMathSD59x18.mul(NEG_H_TU_HOURS, vars.elapsed));
vars.debtEma = uint256(
PRBMathSD59x18.mul(vars.weightMau, int256(vars.debtEma)) +
PRBMathSD59x18.mul(1e18 - vars.weightMau, int256(interestParams_.debt))
);
vars.depositEma = uint256(
PRBMathSD59x18.mul(vars.weightMau, int256(vars.depositEma)) +
PRBMathSD59x18.mul(1e18 - vars.weightMau, int256(interestParams_.meaningfulDeposit))
);
vars.debtColEma = uint256(
PRBMathSD59x18.mul(vars.weightTu, int256(vars.debtColEma)) +
PRBMathSD59x18.mul(1e18 - vars.weightTu, int256(interestParams_.debtCol))
);
vars.lupt0DebtEma = uint256(
PRBMathSD59x18.mul(vars.weightTu, int256(vars.lupt0DebtEma)) +
PRBMathSD59x18.mul(1e18 - vars.weightTu, int256(interestParams_.lupt0Debt))
);
}
emaParams_.debtEma = vars.debtEma;
emaParams_.depositEma = vars.depositEma;
emaParams_.debtColEma = vars.debtColEma;
emaParams_.lupt0DebtEma = vars.lupt0DebtEma;
emaParams_.emaUpdate = block.timestamp;
}
if (
poolState_.rate > 0.1 * 1e18
&&
vars.debtEma < Maths.wmul(vars.depositEma, 0.05 * 1e18)
) {
interestParams_.interestRate = uint208(0.1 * 1e18);
interestParams_.interestRateUpdate = uint48(block.timestamp);
emit ResetInterestRate(
poolState_.rate,
0.1 * 1e18
);
}
else if (block.timestamp - interestParams_.interestRateUpdate > 12 hours) {
vars.newInterestRate = _calculateInterestRate(
poolState_,
vars.debtEma,
vars.depositEma,
vars.debtColEma,
vars.lupt0DebtEma
);
if (poolState_.rate != vars.newInterestRate) {
interestParams_.interestRate = uint208(vars.newInterestRate);
interestParams_.interestRateUpdate = uint48(block.timestamp);
emit UpdateInterestRate(
poolState_.rate,
vars.newInterestRate
);
}
}
interestParams_.debt = vars.newDebt;
interestParams_.meaningfulDeposit = vars.newMeaningfulDeposit;
interestParams_.debtCol = vars.newDebtCol;
interestParams_.lupt0Debt = vars.newLupt0Debt;
}
function accrueInterest(
EmaState storage emaParams_,
DepositsState storage deposits_,
PoolState calldata poolState_,
uint256 maxT0DebtToCollateral_,
uint256 elapsed_
) external returns (uint256 newInflator_, uint256 newInterest_) {
uint256 pendingFactor = PRBMathUD60x18.exp((poolState_.rate * elapsed_) / 365 days);
newInflator_ = Maths.wmul(poolState_.inflator, pendingFactor);
uint256 htp = _htp(maxT0DebtToCollateral_, poolState_.inflator);
uint256 accrualIndex;
if (htp > MAX_PRICE) accrualIndex = 1;
else if (htp < MIN_PRICE) accrualIndex = MAX_FENWICK_INDEX;
else accrualIndex = _indexOf(htp);
uint256 lupIndex = Deposits.findIndexOfSum(deposits_, poolState_.debt);
if (lupIndex > accrualIndex) accrualIndex = lupIndex;
uint256 interestEarningDeposit = Deposits.prefixSum(deposits_, accrualIndex);
if (interestEarningDeposit != 0) {
newInterest_ = Maths.wmul(
_lenderInterestMargin(_utilization(emaParams_.debtEma, emaParams_.depositEma)),
Maths.wmul(pendingFactor - Maths.WAD, poolState_.debt)
);
uint256 lenderFactor = Maths.min(
Maths.floorWdiv(newInterest_, interestEarningDeposit),
Maths.wmul(pendingFactor - Maths.WAD, Maths.wad(10))
) + Maths.WAD;
Deposits.mult(deposits_, accrualIndex, lenderFactor);
}
}
function flashLoan(
IERC3156FlashBorrower receiver_,
address token_,
uint256 amount_,
bytes calldata data_
) external {
IERC20 tokenContract = IERC20(token_);
uint256 initialBalance = tokenContract.balanceOf(address(this));
tokenContract.safeTransfer(
address(receiver_),
amount_
);
if (receiver_.onFlashLoan(msg.sender, token_, amount_, 0, data_) !=
keccak256("ERC3156FlashBorrower.onFlashLoan")) revert FlashloanCallbackFailed();
tokenContract.safeTransferFrom(
address(receiver_),
address(this),
amount_
);
if (tokenContract.balanceOf(address(this)) != initialBalance) revert FlashloanIncorrectBalance();
emit Flashloan(address(receiver_), token_, amount_);
}
function _calculateInterestRate(
PoolState memory poolState_,
uint256 debtEma_,
uint256 depositEma_,
uint256 debtColEma_,
uint256 lupt0DebtEma_
) internal pure returns (uint256 newInterestRate_) {
int256 mau;
int256 mau102;
if (poolState_.debt != 0) {
mau = int256(_utilization(debtEma_, depositEma_));
mau102 = (mau * PERCENT_102) / 1e18;
}
int256 tu = (lupt0DebtEma_ != 0) ?
int256(Maths.wdiv(debtColEma_, lupt0DebtEma_)) : int(Maths.WAD);
newInterestRate_ = poolState_.rate;
if (4 * (tu - mau102) < (((tu + mau102 - 1e18) / 1e9) ** 2) - 1e18) {
newInterestRate_ = Maths.wmul(poolState_.rate, INCREASE_COEFFICIENT);
} else if (4 * (tu - mau) > 1e18 - ((tu + mau - 1e18) / 1e9) ** 2) {
newInterestRate_ = Maths.wmul(poolState_.rate, DECREASE_COEFFICIENT);
}
newInterestRate_ = Maths.min(4 * 1e18, Maths.max(0.001 * 1e18, newInterestRate_));
}
function _utilization(
uint256 debtEma_,
uint256 depositEma_
) internal pure returns (uint256 utilization_) {
if (depositEma_ != 0) utilization_ = Maths.wdiv(debtEma_, depositEma_);
}
function _lenderInterestMargin(
uint256 mau_
) internal pure returns (uint256) {
uint256 base = 1_000_000 * 1e18 - Maths.min(mau_, 1e18) * 1_000_000;
if (base < 1e18) {
return 1e18;
} else {
uint256 crpud = PRBMathUD60x18.pow(base, ONE_THIRD);
return 1e18 - Maths.wdiv(Maths.wmul(crpud, 0.15 * 1e18), CUBIC_ROOT_1000000);
}
}
function _meaningfulDeposit(
DepositsState storage deposits_,
uint256 t0DebtInAuction_,
uint256 nonAuctionedT0Debt_,
uint256 inflator_,
uint256 t0Debt2ToCollateral_
) internal view returns (uint256 meaningfulDeposit_) {
uint256 dwatp = _dwatp(nonAuctionedT0Debt_, inflator_, t0Debt2ToCollateral_);
if (dwatp == 0) {
meaningfulDeposit_ = Deposits.treeSum(deposits_);
} else {
if (dwatp >= MAX_PRICE) meaningfulDeposit_ = 0;
else if (dwatp >= MIN_PRICE) meaningfulDeposit_ = Deposits.prefixSum(deposits_, _indexOf(dwatp));
else meaningfulDeposit_ = Deposits.treeSum(deposits_);
}
meaningfulDeposit_ -= Maths.min(
meaningfulDeposit_,
Maths.wmul(t0DebtInAuction_, inflator_)
);
}
function debtInfo(
PoolBalancesState memory poolBalances_,
InflatorState memory inflatorState_,
InterestState memory interestState_
) external view returns (uint256, uint256, uint256, uint256) {
uint256 t0Debt = poolBalances_.t0Debt;
uint256 inflator = inflatorState_.inflator;
return (
Maths.ceilWmul(
t0Debt,
pendingInflator(inflator, inflatorState_.inflatorUpdate, interestState_.interestRate)
),
Maths.ceilWmul(t0Debt, inflator),
Maths.ceilWmul(poolBalances_.t0DebtInAuction, inflator),
interestState_.t0Debt2ToCollateral
);
}
function pendingInterestFactor(
uint256 interestRate_,
uint256 elapsed_
) external pure returns (uint256) {
return PRBMathUD60x18.exp((interestRate_ * elapsed_) / 365 days);
}
function pendingInflator(
uint256 inflator_,
uint256 inflatorUpdate,
uint256 interestRate_
) public view returns (uint256) {
return Maths.wmul(
inflator_,
PRBMathUD60x18.exp((interestRate_ * (block.timestamp - inflatorUpdate)) / 365 days)
);
}
function lenderInterestMargin(
uint256 mau_
) external pure returns (uint256) {
return _lenderInterestMargin(mau_);
}
function utilization(
EmaState storage emaParams_
) external view returns (uint256 utilization_) {
return _utilization(emaParams_.debtEma, emaParams_.depositEma);
}
}
文件 64 的 68：PoolHelper.sol
pragma solidity 0.8.18;
import { PRBMathSD59x18 } from "@prb-math/contracts/PRBMathSD59x18.sol";
import { Math } from '@openzeppelin/contracts/utils/math/Math.sol';
import { SafeCast } from "@openzeppelin/contracts/utils/math/SafeCast.sol";
import { PoolType } from '../../interfaces/pool/IPool.sol';
import { InflatorState, PoolState } from '../../interfaces/pool/commons/IPoolState.sol';
import { Buckets } from '../internal/Buckets.sol';
import { Maths } from '../internal/Maths.sol';
error BucketIndexOutOfBounds();
error BucketPriceOutOfBounds();
int256 constant MAX_BUCKET_INDEX = 4_156;
int256 constant MIN_BUCKET_INDEX = -3_232;
uint256 constant MAX_FENWICK_INDEX = 7_388;
uint256 constant MIN_PRICE = 99_836_282_890;
uint256 constant MAX_PRICE = 1_004_968_987.606512354182109771 * 1e18;
uint256 constant MAX_INFLATED_PRICE = 50_248_449_380.325617709105488550 * 1e18;
uint256 constant DEPOSIT_BUFFER = 1.000000001 * 1e18;
int256 constant FLOAT_STEP_INT = 1.005 * 1e18;
uint256 constant COLLATERALIZATION_FACTOR = 1.04 * 1e18;
function _priceAt(
uint256 index_
) pure returns (uint256) {
int256 bucketIndex = MAX_BUCKET_INDEX - int256(index_);
if (bucketIndex < MIN_BUCKET_INDEX || bucketIndex > MAX_BUCKET_INDEX) revert BucketIndexOutOfBounds();
return uint256(
PRBMathSD59x18.exp2(
PRBMathSD59x18.mul(
PRBMathSD59x18.fromInt(bucketIndex),
PRBMathSD59x18.log2(FLOAT_STEP_INT)
)
)
);
}
function _indexOf(
uint256 price_
) pure returns (uint256) {
if (price_ < MIN_PRICE || price_ > MAX_PRICE) revert BucketPriceOutOfBounds();
int256 index = PRBMathSD59x18.div(
PRBMathSD59x18.log2(int256(price_)),
PRBMathSD59x18.log2(FLOAT_STEP_INT)
);
int256 ceilIndex = PRBMathSD59x18.ceil(index);
if (index < 0 && ceilIndex - index > 0.5 * 1e18) {
return uint256(4157 - PRBMathSD59x18.toInt(ceilIndex));
}
return uint256(4156 - PRBMathSD59x18.toInt(ceilIndex));
}
function _minDebtAmount(
uint256 debt_,
uint256 loansCount_
) pure returns (uint256 minDebtAmount_) {
if (loansCount_ != 0) {
minDebtAmount_ = Maths.wdiv(Maths.wdiv(debt_, Maths.wad(loansCount_)), 10**19);
}
}
function _borrowFeeRate(
uint256 interestRate_
) pure returns (uint256) {
return Maths.max(Maths.wdiv(interestRate_, 52 * 1e18), 0.0005 * 1e18);
}
function _depositFeeRate(
uint256 interestRate_
) pure returns (uint256) {
return Maths.wdiv(interestRate_, 365 * 3e18);
}
function _determineInflatorState(
PoolState memory poolState_,
InflatorState memory inflatorState_
) view returns (uint208 newInflator_, bool updateTimestamp_) {
newInflator_ = inflatorState_.inflator;
if (poolState_.isNewInterestAccrued) {
newInflator_ = SafeCast.toUint208(poolState_.inflator);
updateTimestamp_ = true;
} else if (poolState_.debt == 0) {
newInflator_ = SafeCast.toUint208(Maths.WAD);
updateTimestamp_ = true;
} else if (inflatorState_.inflator == Maths.WAD && inflatorState_.inflatorUpdate != block.timestamp){
updateTimestamp_ = true;
}
}
function _htp(
uint256 maxT0DebtToCollateral_,
uint256 inflator_
) pure returns (uint256) {
return Maths.wmul(
Maths.wmul(maxT0DebtToCollateral_, inflator_),
COLLATERALIZATION_FACTOR
);
}
function _dwatp(
uint256 t0Debt_,
uint256 inflator_,
uint256 t0Debt2ToCollateral_
) pure returns (uint256) {
return t0Debt_ == 0 ? 0 : Maths.wdiv(
Maths.wmul(
Maths.wmul(inflator_, t0Debt2ToCollateral_),
COLLATERALIZATION_FACTOR
),
t0Debt_
);
}
function _isCollateralized(
uint256 debt_,
uint256 collateral_,
uint256 price_,
uint8 type_
) pure returns (bool) {
if (price_ == MIN_PRICE && debt_ != 0) return false;
if (type_ == uint8(PoolType.ERC721)) {
collateral_ = (collateral_ / Maths.WAD) * Maths.WAD;
}
return Maths.wmul(collateral_, price_) >= Maths.wmul(COLLATERALIZATION_FACTOR, debt_);
}
function _getCollateralDustPricePrecisionAdjustment(
uint256 bucketIndex_
) pure returns (uint256 pricePrecisionAdjustment_) {
if (bucketIndex_ > 3900) {
int256 bucketOffset = int256(bucketIndex_ - 3900);
int256 result = PRBMathSD59x18.sqrt(PRBMathSD59x18.div(bucketOffset * 1e18, int256(36 * 1e18)));
pricePrecisionAdjustment_ = uint256(result / 1e18);
}
}
function _lpToCollateral(
uint256 bucketCollateral_,
uint256 bucketLP_,
uint256 deposit_,
uint256 lenderLPBalance_,
uint256 bucketPrice_
) pure returns (uint256 collateralAmount_) {
collateralAmount_ = Buckets.lpToCollateral(
bucketCollateral_,
bucketLP_,
deposit_,
lenderLPBalance_,
bucketPrice_,
Math.Rounding.Down
);
if (collateralAmount_ > bucketCollateral_) {
collateralAmount_ = bucketCollateral_;
}
}
function _lpToQuoteToken(
uint256 bucketLP_,
uint256 bucketCollateral_,
uint256 deposit_,
uint256 lenderLPBalance_,
uint256 bucketPrice_
) pure returns (uint256 quoteTokenAmount_) {
quoteTokenAmount_ = Buckets.lpToQuoteTokens(
bucketCollateral_,
bucketLP_,
deposit_,
lenderLPBalance_,
bucketPrice_,
Math.Rounding.Down
);
if (quoteTokenAmount_ > deposit_) quoteTokenAmount_ = deposit_;
}
function _roundToScale(
uint256 amount_,
uint256 tokenScale_
) pure returns (uint256 scaledAmount_) {
scaledAmount_ = (amount_ / tokenScale_) * tokenScale_;
}
function _roundUpToScale(
uint256 amount_,
uint256 tokenScale_
) pure returns (uint256 scaledAmount_) {
if (amount_ % tokenScale_ == 0)
scaledAmount_ = amount_;
else
scaledAmount_ = _roundToScale(amount_, tokenScale_) + tokenScale_;
}
uint256 constant MINUTE_HALF_LIFE = 0.988514020352896135_356867505 * 1e27;
function _claimableReserves(
uint256 debt_,
uint256 poolSize_,
uint256 totalBondEscrowed_,
uint256 reserveAuctionUnclaimed_,
uint256 quoteTokenBalance_
) pure returns (uint256 claimable_) {
uint256 guaranteedFunds = totalBondEscrowed_ + reserveAuctionUnclaimed_;
if (quoteTokenBalance_ > guaranteedFunds) {
claimable_ = debt_ + quoteTokenBalance_;
claimable_ -= Maths.min(
claimable_,
Maths.wmul(DEPOSIT_BUFFER, poolSize_) + guaranteedFunds
);
claimable_ = Maths.min(
claimable_,
quoteTokenBalance_ - guaranteedFunds
);
}
}
function _reserveAuctionPrice(
uint256 reserveAuctionKicked_,
uint256 lastKickedReserves_
) view returns (uint256 price_) {
if (reserveAuctionKicked_ != 0) {
uint256 secondsElapsed = block.timestamp - reserveAuctionKicked_;
uint256 hoursComponent = 1e27 >> secondsElapsed / 3600;
uint256 minutesComponent = Maths.rpow(MINUTE_HALF_LIFE, secondsElapsed % 3600 / 60);
uint256 initialPrice = lastKickedReserves_ == 0 ? 0 : Maths.wdiv(1_000_000_000 * 1e18, lastKickedReserves_);
price_ = initialPrice * Maths.rmul(hoursComponent, minutesComponent) / 1e27;
}
}
uint256 constant MIN_BOND_FACTOR = 0.005 * 1e18;
uint256 constant MAX_BOND_FACTOR = 0.03 * 1e18;
function _auctionPrice(
uint256 referencePrice_,
uint256 kickTime_
) view returns (uint256 price_) {
uint256 elapsedMinutes = Maths.wdiv((block.timestamp - kickTime_) * 1e18, 1 minutes * 1e18);
int256 timeAdjustment;
if (elapsedMinutes < 120 * 1e18) {
timeAdjustment = PRBMathSD59x18.mul(-1 * 1e18, int256(elapsedMinutes / 20));
price_ = 256 * Maths.wmul(referencePrice_, uint256(PRBMathSD59x18.exp2(timeAdjustment)));
} else if (elapsedMinutes < 840 * 1e18) {
timeAdjustment = PRBMathSD59x18.mul(-1 * 1e18, int256((elapsedMinutes - 120 * 1e18) / 120));
price_ = 4 * Maths.wmul(referencePrice_, uint256(PRBMathSD59x18.exp2(timeAdjustment)));
} else {
timeAdjustment = PRBMathSD59x18.mul(-1 * 1e18, int256((elapsedMinutes - 840 * 1e18) / 60));
price_ = Maths.wmul(referencePrice_, uint256(PRBMathSD59x18.exp2(timeAdjustment))) / 16;
}
}
function _bpf(
uint256 debtToCollateral_,
uint256 neutralPrice_,
uint256 bondFactor_,
uint256 auctionPrice_
) pure returns (int256) {
int256 sign;
if (debtToCollateral_ < neutralPrice_) {
sign = Maths.minInt(
1e18,
Maths.maxInt(
-1 * 1e18,
PRBMathSD59x18.div(
int256(neutralPrice_) - int256(auctionPrice_),
int256(neutralPrice_) - int256(debtToCollateral_)
)
)
);
} else {
int256 val = int256(neutralPrice_) - int256(auctionPrice_);
if (val < 0 ) sign = -1e18;
else if (val != 0) sign = 1e18;
}
return PRBMathSD59x18.mul(int256(bondFactor_), sign);
}
function _bondParams(
uint256 borrowerDebt_,
uint256 npTpRatio_
) pure returns (uint256 bondFactor_, uint256 bondSize_) {
bondFactor_ = Maths.max(
Maths.min(
MAX_BOND_FACTOR,
(npTpRatio_ - 1e18) / 10
),
MIN_BOND_FACTOR
);
bondSize_ = Maths.wmul(bondFactor_, borrowerDebt_);
}
文件 65 的 68：ReentrancyGuard.sol
pragma solidity ^0.8.0;
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
_nonReentrantBefore();
_;
_nonReentrantAfter();
}
function _nonReentrantBefore() private {
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
_status = _ENTERED;
}
function _nonReentrantAfter() private {
_status = _NOT_ENTERED;
}
function _reentrancyGuardEntered() internal view returns (bool) {
return _status == _ENTERED;
}
}
文件 66 的 68：SafeCast.sol
pragma solidity ^0.8.0;
library SafeCast {
function toUint248(uint256 value) internal pure returns (uint248) {
require(value <= type(uint248).max, "SafeCast: value doesn't fit in 248 bits");
return uint248(value);
}
function toUint240(uint256 value) internal pure returns (uint240) {
require(value <= type(uint240).max, "SafeCast: value doesn't fit in 240 bits");
return uint240(value);
}
function toUint232(uint256 value) internal pure returns (uint232) {
require(value <= type(uint232).max, "SafeCast: value doesn't fit in 232 bits");
return uint232(value);
}
function toUint224(uint256 value) internal pure returns (uint224) {
require(value <= type(uint224).max, "SafeCast: value doesn't fit in 224 bits");
return uint224(value);
}
function toUint216(uint256 value) internal pure returns (uint216) {
require(value <= type(uint216).max, "SafeCast: value doesn't fit in 216 bits");
return uint216(value);
}
function toUint208(uint256 value) internal pure returns (uint208) {
require(value <= type(uint208).max, "SafeCast: value doesn't fit in 208 bits");
return uint208(value);
}
function toUint200(uint256 value) internal pure returns (uint200) {
require(value <= type(uint200).max, "SafeCast: value doesn't fit in 200 bits");
return uint200(value);
}
function toUint192(uint256 value) internal pure returns (uint192) {
require(value <= type(uint192).max, "SafeCast: value doesn't fit in 192 bits");
return uint192(value);
}
function toUint184(uint256 value) internal pure returns (uint184) {
require(value <= type(uint184).max, "SafeCast: value doesn't fit in 184 bits");
return uint184(value);
}
function toUint176(uint256 value) internal pure returns (uint176) {
require(value <= type(uint176).max, "SafeCast: value doesn't fit in 176 bits");
return uint176(value);
}
function toUint168(uint256 value) internal pure returns (uint168) {
require(value <= type(uint168).max, "SafeCast: value doesn't fit in 168 bits");
return uint168(value);
}
function toUint160(uint256 value) internal pure returns (uint160) {
require(value <= type(uint160).max, "SafeCast: value doesn't fit in 160 bits");
return uint160(value);
}
function toUint152(uint256 value) internal pure returns (uint152) {
require(value <= type(uint152).max, "SafeCast: value doesn't fit in 152 bits");
return uint152(value);
}
function toUint144(uint256 value) internal pure returns (uint144) {
require(value <= type(uint144).max, "SafeCast: value doesn't fit in 144 bits");
return uint144(value);
}
function toUint136(uint256 value) internal pure returns (uint136) {
require(value <= type(uint136).max, "SafeCast: value doesn't fit in 136 bits");
return uint136(value);
}
function toUint128(uint256 value) internal pure returns (uint128) {
require(value <= type(uint128).max, "SafeCast: value doesn't fit in 128 bits");
return uint128(value);
}
function toUint120(uint256 value) internal pure returns (uint120) {
require(value <= type(uint120).max, "SafeCast: value doesn't fit in 120 bits");
return uint120(value);
}
function toUint112(uint256 value) internal pure returns (uint112) {
require(value <= type(uint112).max, "SafeCast: value doesn't fit in 112 bits");
return uint112(value);
}
function toUint104(uint256 value) internal pure returns (uint104) {
require(value <= type(uint104).max, "SafeCast: value doesn't fit in 104 bits");
return uint104(value);
}
function toUint96(uint256 value) internal pure returns (uint96) {
require(value <= type(uint96).max, "SafeCast: value doesn't fit in 96 bits");
return uint96(value);
}
function toUint88(uint256 value) internal pure returns (uint88) {
require(value <= type(uint88).max, "SafeCast: value doesn't fit in 88 bits");
return uint88(value);
}
function toUint80(uint256 value) internal pure returns (uint80) {
require(value <= type(uint80).max, "SafeCast: value doesn't fit in 80 bits");
return uint80(value);
}
function toUint72(uint256 value) internal pure returns (uint72) {
require(value <= type(uint72).max, "SafeCast: value doesn't fit in 72 bits");
return uint72(value);
}
function toUint64(uint256 value) internal pure returns (uint64) {
require(value <= type(uint64).max, "SafeCast: value doesn't fit in 64 bits");
return uint64(value);
}
function toUint56(uint256 value) internal pure returns (uint56) {
require(value <= type(uint56).max, "SafeCast: value doesn't fit in 56 bits");
return uint56(value);
}
function toUint48(uint256 value) internal pure returns (uint48) {
require(value <= type(uint48).max, "SafeCast: value doesn't fit in 48 bits");
return uint48(value);
}
function toUint40(uint256 value) internal pure returns (uint40) {
require(value <= type(uint40).max, "SafeCast: value doesn't fit in 40 bits");
return uint40(value);
}
function toUint32(uint256 value) internal pure returns (uint32) {
require(value <= type(uint32).max, "SafeCast: value doesn't fit in 32 bits");
return uint32(value);
}
function toUint24(uint256 value) internal pure returns (uint24) {
require(value <= type(uint24).max, "SafeCast: value doesn't fit in 24 bits");
return uint24(value);
}
function toUint16(uint256 value) internal pure returns (uint16) {
require(value <= type(uint16).max, "SafeCast: value doesn't fit in 16 bits");
return uint16(value);
}
function toUint8(uint256 value) internal pure returns (uint8) {
require(value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits");
return uint8(value);
}
function toUint256(int256 value) internal pure returns (uint256) {
require(value >= 0, "SafeCast: value must be positive");
return uint256(value);
}
function toInt248(int256 value) internal pure returns (int248 downcasted) {
downcasted = int248(value);
require(downcasted == value, "SafeCast: value doesn't fit in 248 bits");
}
function toInt240(int256 value) internal pure returns (int240 downcasted) {
downcasted = int240(value);
require(downcasted == value, "SafeCast: value doesn't fit in 240 bits");
}
function toInt232(int256 value) internal pure returns (int232 downcasted) {
downcasted = int232(value);
require(downcasted == value, "SafeCast: value doesn't fit in 232 bits");
}
function toInt224(int256 value) internal pure returns (int224 downcasted) {
downcasted = int224(value);
require(downcasted == value, "SafeCast: value doesn't fit in 224 bits");
}
function toInt216(int256 value) internal pure returns (int216 downcasted) {
downcasted = int216(value);
require(downcasted == value, "SafeCast: value doesn't fit in 216 bits");
}
function toInt208(int256 value) internal pure returns (int208 downcasted) {
downcasted = int208(value);
require(downcasted == value, "SafeCast: value doesn't fit in 208 bits");
}
function toInt200(int256 value) internal pure returns (int200 downcasted) {
downcasted = int200(value);
require(downcasted == value, "SafeCast: value doesn't fit in 200 bits");
}
function toInt192(int256 value) internal pure returns (int192 downcasted) {
downcasted = int192(value);
require(downcasted == value, "SafeCast: value doesn't fit in 192 bits");
}
function toInt184(int256 value) internal pure returns (int184 downcasted) {
downcasted = int184(value);
require(downcasted == value, "SafeCast: value doesn't fit in 184 bits");
}
function toInt176(int256 value) internal pure returns (int176 downcasted) {
downcasted = int176(value);
require(downcasted == value, "SafeCast: value doesn't fit in 176 bits");
}
function toInt168(int256 value) internal pure returns (int168 downcasted) {
downcasted = int168(value);
require(downcasted == value, "SafeCast: value doesn't fit in 168 bits");
}
function toInt160(int256 value) internal pure returns (int160 downcasted) {
downcasted = int160(value);
require(downcasted == value, "SafeCast: value doesn't fit in 160 bits");
}
function toInt152(int256 value) internal pure returns (int152 downcasted) {
downcasted = int152(value);
require(downcasted == value, "SafeCast: value doesn't fit in 152 bits");
}
function toInt144(int256 value) internal pure returns (int144 downcasted) {
downcasted = int144(value);
require(downcasted == value, "SafeCast: value doesn't fit in 144 bits");
}
function toInt136(int256 value) internal pure returns (int136 downcasted) {
downcasted = int136(value);
require(downcasted == value, "SafeCast: value doesn't fit in 136 bits");
}
function toInt128(int256 value) internal pure returns (int128 downcasted) {
downcasted = int128(value);
require(downcasted == value, "SafeCast: value doesn't fit in 128 bits");
}
function toInt120(int256 value) internal pure returns (int120 downcasted) {
downcasted = int120(value);
require(downcasted == value, "SafeCast: value doesn't fit in 120 bits");
}
function toInt112(int256 value) internal pure returns (int112 downcasted) {
downcasted = int112(value);
require(downcasted == value, "SafeCast: value doesn't fit in 112 bits");
}
function toInt104(int256 value) internal pure returns (int104 downcasted) {
downcasted = int104(value);
require(downcasted == value, "SafeCast: value doesn't fit in 104 bits");
}
function toInt96(int256 value) internal pure returns (int96 downcasted) {
downcasted = int96(value);
require(downcasted == value, "SafeCast: value doesn't fit in 96 bits");
}
function toInt88(int256 value) internal pure returns (int88 downcasted) {
downcasted = int88(value);
require(downcasted == value, "SafeCast: value doesn't fit in 88 bits");
}
function toInt80(int256 value) internal pure returns (int80 downcasted) {
downcasted = int80(value);
require(downcasted == value, "SafeCast: value doesn't fit in 80 bits");
}
function toInt72(int256 value) internal pure returns (int72 downcasted) {
downcasted = int72(value);
require(downcasted == value, "SafeCast: value doesn't fit in 72 bits");
}
function toInt64(int256 value) internal pure returns (int64 downcasted) {
downcasted = int64(value);
require(downcasted == value, "SafeCast: value doesn't fit in 64 bits");
}
function toInt56(int256 value) internal pure returns (int56 downcasted) {
downcasted = int56(value);
require(downcasted == value, "SafeCast: value doesn't fit in 56 bits");
}
function toInt48(int256 value) internal pure returns (int48 downcasted) {
downcasted = int48(value);
require(downcasted == value, "SafeCast: value doesn't fit in 48 bits");
}
function toInt40(int256 value) internal pure returns (int40 downcasted) {
downcasted = int40(value);
require(downcasted == value, "SafeCast: value doesn't fit in 40 bits");
}
function toInt32(int256 value) internal pure returns (int32 downcasted) {
downcasted = int32(value);
require(downcasted == value, "SafeCast: value doesn't fit in 32 bits");
}
function toInt24(int256 value) internal pure returns (int24 downcasted) {
downcasted = int24(value);
require(downcasted == value, "SafeCast: value doesn't fit in 24 bits");
}
function toInt16(int256 value) internal pure returns (int16 downcasted) {
downcasted = int16(value);
require(downcasted == value, "SafeCast: value doesn't fit in 16 bits");
}
function toInt8(int256 value) internal pure returns (int8 downcasted) {
downcasted = int8(value);
require(downcasted == value, "SafeCast: value doesn't fit in 8 bits");
}
function toInt256(uint256 value) internal pure returns (int256) {
require(value <= uint256(type(int256).max), "SafeCast: value doesn't fit in an int256");
return int256(value);
}
}
文件 67 的 68：SafeERC20.sol
pragma solidity ^0.8.0;
import "../IERC20.sol";
import "../extensions/IERC20Permit.sol";
import "../../../utils/Address.sol";
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require(
(value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 oldAllowance = token.allowance(address(this), spender);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));
}
}
function forceApprove(IERC20 token, address spender, uint256 value) internal {
bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);
if (!_callOptionalReturnBool(token, approvalCall)) {
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));
_callOptionalReturn(token, approvalCall);
}
}
function safePermit(
IERC20Permit token,
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) internal {
uint256 nonceBefore = token.nonces(owner);
token.permit(owner, spender, value, deadline, v, r, s);
uint256 nonceAfter = token.nonces(owner);
require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
require(returndata.length == 0 || abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
(bool success, bytes memory returndata) = address(token).call(data);
return
success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token));
}
}
文件 68 的 68：Strategy.sol
pragma solidity ^0.8.18;
import {ERC20} from "@tokenized-strategy/BaseStrategy.sol";
import {BaseHealthCheck} from "@periphery/Bases/HealthCheck/BaseHealthCheck.sol";
import {Auction, AuctionSwapper} from "@periphery/swappers/AuctionSwapper.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
import {IERC20Pool} from "@ajna-core/interfaces/pool/erc20/IERC20Pool.sol";
import {COLLATERALIZATION_FACTOR} from "@ajna-core/libraries/helpers/PoolHelper.sol";
import {Maths} from "@ajna-core/libraries/internal/Maths.sol";
import {PoolCommons} from "@ajna-core/libraries/external/PoolCommons.sol";
import {IUniswapV3Pool} from "@uniswap-v3-core/interfaces/IUniswapV3Pool.sol";
import {IUniswapV3SwapCallback} from "@uniswap-v3-core/interfaces/callback/IUniswapV3SwapCallback.sol";
import {IUniswapV3Factory} from "@uniswap-v3-core/interfaces/IUniswapV3Factory.sol";
import {IWETH} from "./interfaces/IWeth.sol";
import {IAccount} from "./interfaces/summerfi/IAccount.sol";
import {IAccountFactory} from "./interfaces/summerfi/IAccountFactory.sol";
import {AjnaProxyActions} from "./interfaces/summerfi/AjnaProxyActions.sol";
import {IAjnaRedeemer} from "./interfaces/summerfi/IAjnaRedeemer.sol";
import {IChainlinkAggregator} from "./interfaces/chainlink/IChainlinkAggregator.sol";
contract Strategy is BaseHealthCheck, IUniswapV3SwapCallback, AuctionSwapper {
using SafeERC20 for ERC20;
IAccountFactory private constant SUMMERFI_ACCOUNT_FACTORY =
IAccountFactory(0xF7B75183A2829843dB06266c114297dfbFaeE2b6);
AjnaProxyActions private constant SUMMERFI_AJNA_PROXY_ACTIONS =
AjnaProxyActions(0x3637DF43F938b05A71bb828f13D9f14498E6883c);
IAjnaRedeemer private constant SUMMERFI_REWARDS =
IAjnaRedeemer(0xf309EE5603bF05E5614dB930E4EAB661662aCeE6);
IUniswapV3Factory private constant UNISWAP_FACTORY =
IUniswapV3Factory(0x1F98431c8aD98523631AE4a59f267346ea31F984);
address private constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address private constant AJNA_TOKEN =
0x9a96ec9B57Fb64FbC60B423d1f4da7691Bd35079;
IAccount public immutable summerfiAccount;
IERC20Pool public immutable ajnaPool;
IChainlinkAggregator public immutable chainlinkOracle;
bool public immutable oracleWrapped;
bytes4 public immutable unwrappedToWrappedSelector;
bool private immutable uniswapAsset0Weth1;
uint96 public minAjnaToAuction = 1_000e18;
IUniswapV3Pool public uniswapPool;
bool public positionOpen;
uint16 public slippageAllowedBps = 50;
uint64 public maxTendBasefee = 30e9;
uint256 public depositLimit;
struct LTVConfig {
uint64 targetLTV;
uint64 minAdjustThreshold;
uint64 warningThreshold;
uint64 emergencyThreshold;
}
LTVConfig public ltvs;
uint256 private constant ONE_WAD = 1e18;
uint64 internal constant DEFAULT_MIN_ADJUST_THRESHOLD = 0.005e18;
uint64 internal constant DEFAULT_WARNING_THRESHOLD = 0.01e18;
uint64 internal constant DEFAULT_EMERGENCY_THRESHOLD = 0.02e18;
uint64 internal constant DUST_THRESHOLD = 100;
uint160 internal constant UNISWAP_MIN_SQRT_RATIO = 4295128739;
uint160 internal constant UNISWAP_MAX_SQRT_RATIO =
1461446703485210103287273052203988822378723970342;
constructor(
address _asset,
string memory _name,
address _ajnaPool,
uint24 _uniswapFee,
bytes4 _unwrappedToWrappedSelector,
address _chainlinkOracle,
bool _oracleWrapped
) BaseHealthCheck(_asset, _name) {
require(_asset == IERC20Pool(_ajnaPool).collateralAddress(), "!collat");
require(WETH == IERC20Pool(_ajnaPool).quoteTokenAddress(), "!weth");
address _summerfiAccount = SUMMERFI_ACCOUNT_FACTORY.createAccount();
ajnaPool = IERC20Pool(_ajnaPool);
summerfiAccount = IAccount(_summerfiAccount);
unwrappedToWrappedSelector = _unwrappedToWrappedSelector;
chainlinkOracle = IChainlinkAggregator(_chainlinkOracle);
oracleWrapped = _oracleWrapped;
uniswapAsset0Weth1 = address(asset) < WETH;
ERC20(_asset).safeApprove(_summerfiAccount, type(uint256).max);
LTVConfig memory _ltvs;
_ltvs.minAdjustThreshold = DEFAULT_MIN_ADJUST_THRESHOLD;
_ltvs.warningThreshold = DEFAULT_WARNING_THRESHOLD;
_ltvs.emergencyThreshold = DEFAULT_EMERGENCY_THRESHOLD;
ltvs = _ltvs;
_setUniswapFee(_uniswapFee);
}
function positionInfo()
external
view
returns (
uint256 _debt,
uint256 _collateral,
uint256 _t0Np,
uint256 _thresholdPrice
)
{
return _positionInfo();
}
function currentLTV() external view returns (uint256) {
(uint256 _debt, uint256 _collateral, , ) = _positionInfo();
return _calculateLTV(_debt, _collateral, _getAssetPerWeth());
}
function estimatedTotalAssets() external view returns (uint256) {
(uint256 _debt, uint256 _collateral, , ) = _positionInfo();
uint256 _idle = _looseAssets();
return
_calculateNetPositionWithMaxSlippage(
_debt,
_collateral,
_getAssetPerWeth()
) + _idle;
}
function estimatedTotalAssetsNoSlippage() external view returns (uint256) {
(uint256 _debt, uint256 _collateral, , ) = _positionInfo();
uint256 _idle = _looseAssets();
return
_calculateNetPosition(_debt, _collateral, _getAssetPerWeth()) +
_idle;
}
function setLtvConfig(LTVConfig memory _ltvs) external onlyManagement {
require(_ltvs.warningThreshold < _ltvs.emergencyThreshold);
require(_ltvs.minAdjustThreshold < _ltvs.warningThreshold);
ltvs = _ltvs;
}
function setUniswapFee(uint24 _fee) external onlyManagement {
_setUniswapFee(_fee);
}
function setDepositLimit(uint256 _depositLimit) external onlyManagement {
depositLimit = _depositLimit;
}
function setSlippageAllowedBps(uint16 _slippageAllowedBps)
external
onlyManagement
{
require(_slippageAllowedBps <= MAX_BPS);
slippageAllowedBps = _slippageAllowedBps;
}
function setMaxTendBasefee(uint64 _maxTendBasefee) external onlyManagement {
maxTendBasefee = _maxTendBasefee;
}
function setMinAjnaToAuction(uint96 _minAjnaToAuction)
external
onlyManagement
{
minAjnaToAuction = _minAjnaToAuction;
}
function setAuction(address _auction) external onlyEmergencyAuthorized {
if (_auction != address(0)) {
require(Auction(_auction).want() == address(asset));
}
auction = _auction;
}
function _deployFunds(uint256 _amount) internal override {
if (!positionOpen) {
return;
}
_depositAndDraw(0, _amount, ONE_WAD, false);
}
function _freeFunds(uint256 _amount) internal override {
(uint256 _debt, uint256 _collateral, , ) = _positionInfo();
uint256 _price = _getAssetPerWeth();
uint256 _positionValue = _calculateNetPosition(
_debt,
_collateral,
_price
) + _looseAssets();
uint256 _totalAssets = TokenizedStrategy.totalAssets();
uint256 _deployed = _deployedAssets(_totalAssets);
if (_amount != _deployed && _positionValue < _totalAssets) {
_amount = (_amount * _positionValue) / _totalAssets;
}
LTVConfig memory _ltvs = ltvs;
_leverDown(_debt, _collateral, _amount, _ltvs, _price, _deployed);
(_debt, _collateral, , ) = _positionInfo();
require(
_calculateLTV(_debt, _collateral, _price) <
_ltvs.targetLTV + _ltvs.minAdjustThreshold,
"!ltv"
);
}
function _harvestAndReport()
internal
override
returns (uint256 _totalAssets)
{
_adjustPosition(_looseAssets());
(uint256 _debt, uint256 _collateral, , ) = _positionInfo();
_totalAssets =
_calculateNetPositionWithMaxSlippage(
_debt,
_collateral,
_getAssetPerWeth()
) +
_looseAssets();
}
function _tend(uint256 _idle) internal override {
_adjustPosition(_idle);
}
function _tendTrigger() internal view override returns (bool) {
if (TokenizedStrategy.totalAssets() == 0 || !positionOpen) {
return false;
}
(
uint256 _debt,
uint256 _collateral,
,
uint256 _thresholdPrice
) = _positionInfo();
LTVConfig memory _ltvs = ltvs;
uint256 _assetPerWeth = _getAssetPerWeth();
uint256 _wethPerAsset = (ONE_WAD**2) / _assetPerWeth;
uint256 _currentLtv = _calculateLTV(_debt, _collateral, _assetPerWeth);
if (
_currentLtv >= _ltvs.targetLTV + _ltvs.emergencyThreshold ||
_wethPerAsset <= _thresholdPrice
) {
return true;
}
if (block.basefee >= maxTendBasefee) {
return false;
}
if (_currentLtv >= _ltvs.targetLTV + _ltvs.warningThreshold) {
return true;
}
if (TokenizedStrategy.isShutdown()) {
return false;
}
if (
_currentLtv != 0 &&
_currentLtv <= _ltvs.targetLTV - _ltvs.minAdjustThreshold &&
_availableWethBorrow() > DUST_THRESHOLD
) {
return true;
}
return false;
}
function availableDepositLimit(
address
) public view override returns (uint256) {
uint256 _totalAssets = TokenizedStrategy.totalAssets();
return _totalAssets >= depositLimit ? 0 : depositLimit - _totalAssets;
}
function _emergencyWithdraw(uint256 _amount) internal override {
(uint256 _debt, uint256 _collateral, , ) = _positionInfo();
uint256 _price = _getAssetPerWeth();
LTVConfig memory _ltvs = ltvs;
_leverDown(
_debt,
_collateral,
_amount,
_ltvs,
_price,
_deployedAssets()
);
(_debt, _collateral, , ) = _positionInfo();
require(
_calculateLTV(_debt, _collateral, _price) <
_ltvs.targetLTV + _ltvs.minAdjustThreshold,
"!ltv"
);
}
function _auctionKicked(address _token)
internal
virtual
override
returns (uint256 _kicked)
{
require(_token == AJNA_TOKEN);
_kicked = super._auctionKicked(_token);
require(_kicked >= minAjnaToAuction);
}
function manualLeverDown(
uint256 _toLoose,
uint64 _targetLTV,
bool _force
) external onlyEmergencyAuthorized {
(uint256 _debt, uint256 _collateral, , ) = _positionInfo();
uint256 _price = _getAssetPerWeth();
LTVConfig memory _ltvs = ltvs;
require(_force || _targetLTV <= ltvs.targetLTV);
_ltvs.targetLTV = _targetLTV;
_leverDown(
_debt,
_collateral,
_toLoose,
_ltvs,
_price,
_deployedAssets()
);
(_debt, _collateral, , ) = _positionInfo();
require(
_force ||
_calculateLTV(_debt, _collateral, _price) <
_ltvs.targetLTV + _ltvs.minAdjustThreshold,
"!ltv"
);
}
function manualRepayWithdraw(
uint256 _debtAmount,
uint256 _collateralAmount,
bool _stamp
) external onlyEmergencyAuthorized {
_repayWithdraw(_debtAmount, _collateralAmount, _stamp);
}
function manualSwap(
uint256 _amountIn,
uint64 _minOut,
bool _assetForWeth
) external onlyEmergencyAuthorized {
bool zeroForOne = uniswapAsset0Weth1 ? _assetForWeth : !_assetForWeth;
bytes memory _data = abi.encode(
LeverData(LeverAction.ManualSwap, 0, 0, 0)
);
(int256 amount0, int256 amount1) = uniswapPool.swap(
address(this),
zeroForOne,
int256(_amountIn),
(
zeroForOne
? UNISWAP_MIN_SQRT_RATIO + 1
: UNISWAP_MAX_SQRT_RATIO - 1
),
_data
);
require(uint256(zeroForOne ? amount1 : amount0) >= _minOut);
}
function redeemSummerAjnaRewards(
uint256[] calldata _weeks,
uint256[] calldata _amounts,
bytes32[][] calldata _proofs
) external {
SUMMERFI_REWARDS.claimMultiple(_weeks, _amounts, _proofs);
}
function _adjustPosition(uint256 _idle) internal {
(
uint256 _debt,
uint256 _collateral,
,
uint256 _thresholdPrice
) = _positionInfo();
LTVConfig memory _ltvs = ltvs;
uint256 _assetPerWeth = _getAssetPerWeth();
uint256 _wethPerAsset = ONE_WAD**2 / _assetPerWeth;
uint256 _currentLtv = _calculateLTV(_debt, _collateral, _assetPerWeth);
if (
positionOpen &&
(_wethPerAsset <= _thresholdPrice ||
_currentLtv >= _ltvs.targetLTV + _ltvs.minAdjustThreshold)
) {
_leverDown(
_debt,
_collateral,
0,
_ltvs,
_assetPerWeth,
_deployedAssets()
);
} else if (_currentLtv + _ltvs.minAdjustThreshold <= _ltvs.targetLTV) {
_leverUp(_debt, _collateral, _idle, _ltvs, _assetPerWeth);
} else {
return;
}
(_debt, _collateral, , _thresholdPrice) = _positionInfo();
_currentLtv = _calculateLTV(_debt, _collateral, _assetPerWeth);
require(
_currentLtv < _ltvs.targetLTV + _ltvs.minAdjustThreshold,
"!ltv"
);
}
enum LeverAction {
LeverUp,
LeverDown,
ClosePosition,
ManualSwap
}
struct LeverData {
LeverAction action;
uint256 assetToFree;
uint256 assetPerWeth;
uint256 totalCollateral;
}
function _leverUp(
uint256 _debt,
uint256 _collateral,
uint256 _idle,
LTVConfig memory _ltvs,
uint256 _assetPerWeth
) internal {
uint256 _supply = _calculateNetPosition(
_debt,
_collateral,
_assetPerWeth
);
uint256 _targetBorrow = _getBorrowFromSupply(
_supply + _idle,
_ltvs.targetLTV,
_assetPerWeth
);
require(_targetBorrow > _debt);
uint256 _toBorrow = _targetBorrow - _debt;
uint256 _availableBorrow = _availableWethBorrow();
if (_availableBorrow < _toBorrow) {
_toBorrow = _availableBorrow;
}
if (_toBorrow < DUST_THRESHOLD || _debt + _toBorrow < _minLoanSize()) {
return;
}
_swapAndLeverUp(_toBorrow, _assetPerWeth);
}
function _leverDown(
uint256 _debt,
uint256 _collateral,
uint256 _assetToFree,
LTVConfig memory _ltvs,
uint256 _assetPerWeth,
uint256 _deployedAssets
) internal {
uint256 _supply = _calculateNetPosition(
_debt,
_collateral,
_assetPerWeth
);
uint256 _targetBorrow;
if (_supply > _assetToFree) {
_targetBorrow = _getBorrowFromSupply(
_supply - _assetToFree,
_ltvs.targetLTV,
_assetPerWeth
);
} else {
_assetToFree = _supply;
}
if (_debt <= _targetBorrow) {
if (_assetToFree > DUST_THRESHOLD) {
_repayWithdraw(0, _assetToFree, false);
}
return;
}
uint256 _repaymentAmount;
unchecked {
_repaymentAmount = _debt - _targetBorrow;
}
if (_targetBorrow < _minLoanSize(-int256(_repaymentAmount))) {
_targetBorrow = 0;
_repaymentAmount = _debt;
}
bool _closePosition = _repaymentAmount == _debt &&
(_assetToFree == 0 ||
_assetToFree == _supply ||
_assetToFree >= _deployedAssets);
_swapAndLeverDown(
_repaymentAmount,
_assetToFree,
_closePosition,
_assetPerWeth,
_collateral
);
}
function _swapAndLeverUp(uint256 _borrowAmount, uint256 _assetPerWeth)
private
{
bool zeroForOne = !uniswapAsset0Weth1;
bytes memory _data = abi.encode(
LeverData(
LeverAction.LeverUp,
uint256(0),
_assetPerWeth,
uint256(0)
)
);
uniswapPool.swap(
address(this),
zeroForOne,
int256(_borrowAmount),
(
zeroForOne
? UNISWAP_MIN_SQRT_RATIO + 1
: UNISWAP_MAX_SQRT_RATIO - 1
),
_data
);
}
function _swapAndLeverDown(
uint256 _repaymentAmount,
uint256 _assetToLoose,
bool _close,
uint256 _assetPerWeth,
uint256 _totalCollateral
) private {
bool zeroForOne = uniswapAsset0Weth1;
bytes memory _data = abi.encode(
LeverData(
_close ? LeverAction.ClosePosition : LeverAction.LeverDown,
_assetToLoose,
_assetPerWeth,
_totalCollateral
)
);
(int256 amount0Delta, int256 amount1Delta) = uniswapPool.swap(
address(this),
zeroForOne,
-int256(_repaymentAmount),
(
zeroForOne
? UNISWAP_MIN_SQRT_RATIO + 1
: UNISWAP_MAX_SQRT_RATIO - 1
),
_data
);
uint256 _wethOut = uint256(zeroForOne ? -amount1Delta : -amount0Delta);
require(_wethOut == _repaymentAmount);
}
function uniswapV3SwapCallback(
int256 _amount0Delta,
int256 _amount1Delta,
bytes calldata _data
) external {
require(msg.sender == address(uniswapPool));
require(_amount0Delta > 0 || _amount1Delta > 0);
(
bool _isExactInput,
uint256 _amountToPay,
uint256 _amountReceived
) = _amount0Delta > 0
? (
!uniswapAsset0Weth1,
uint256(_amount0Delta),
uint256(-_amount1Delta)
)
: (
uniswapAsset0Weth1,
uint256(_amount1Delta),
uint256(-_amount0Delta)
);
LeverData memory _leverData = abi.decode(_data, (LeverData));
if (_leverData.action == LeverAction.LeverUp) {
require(_isExactInput);
uint256 _leastAssetReceived = (((_amountToPay *
(MAX_BPS - slippageAllowedBps)) / MAX_BPS) *
_leverData.assetPerWeth) / ONE_WAD;
require(_amountReceived >= _leastAssetReceived, "!slippage");
uint256 _collateralToAdd = _looseAssets();
if (!positionOpen) {
positionOpen = true;
_openPosition(_amountToPay, _collateralToAdd, ONE_WAD);
} else {
_depositAndDraw(_amountToPay, _collateralToAdd, ONE_WAD, false);
}
ERC20(WETH).transfer(msg.sender, _amountToPay);
} else if (
_leverData.action == LeverAction.LeverDown ||
_leverData.action == LeverAction.ClosePosition
) {
require(!_isExactInput);
uint256 _expectedAssetToPay = (_amountReceived *
_leverData.assetPerWeth) / ONE_WAD;
uint256 _mostAssetToPay = (_expectedAssetToPay *
(MAX_BPS + slippageAllowedBps)) / MAX_BPS;
require(_amountToPay <= _mostAssetToPay, "!slippage");
if (_amountToPay > _expectedAssetToPay) {
uint256 _slippage = _amountToPay - _expectedAssetToPay;
if (_leverData.assetToFree > _slippage) {
_leverData.assetToFree -= _slippage;
} else {
_leverData.assetToFree = 0;
}
}
if (_leverData.action == LeverAction.LeverDown) {
_repayWithdraw(
_amountReceived,
Math.min(
_amountToPay + _leverData.assetToFree,
_leverData.totalCollateral
),
false
);
} else if (_leverData.action == LeverAction.ClosePosition) {
positionOpen = false;
_repayAndClose(_amountReceived);
}
asset.transfer(msg.sender, _amountToPay);
} else if (_leverData.action == LeverAction.ManualSwap) {
if (
(_amount0Delta > 0 && uniswapAsset0Weth1) ||
(_amount1Delta > 0 && !uniswapAsset0Weth1)
) {
asset.transfer(msg.sender, _amountToPay);
} else {
ERC20(WETH).transfer(msg.sender, _amountToPay);
}
}
}
function _looseAssets() internal view returns (uint256) {
return asset.balanceOf(address(this));
}
function _deployedAssets() internal view returns (uint256) {
return _deployedAssets(TokenizedStrategy.totalAssets());
}
function _deployedAssets(uint256 _totalAssets)
internal
view
returns (uint256)
{
uint256 _idle = _looseAssets();
if (_idle >= _totalAssets) return 0;
return _totalAssets - _idle;
}
function _positionInfo()
internal
view
returns (
uint256 _debt,
uint256 _collateral,
uint256 _t0Np,
uint256 _thresholdPrice
)
{
IERC20Pool _ajnaPool = ajnaPool;
(uint256 inflator, uint256 lastInflatorUpdate) = _ajnaPool
.inflatorInfo();
(uint256 interestRate, ) = _ajnaPool.interestRateInfo();
uint256 pendingInflator = PoolCommons.pendingInflator(
inflator,
lastInflatorUpdate,
interestRate
);
uint256 t0Debt;
uint256 npTpRatio;
(t0Debt, _collateral, npTpRatio) = _ajnaPool.borrowerInfo(
address(summerfiAccount)
);
_t0Np = _collateral == 0
? 0
: Math.mulDiv(
Maths.wmul(t0Debt, COLLATERALIZATION_FACTOR),
npTpRatio,
_collateral
);
_debt = Maths.ceilWmul(t0Debt, pendingInflator);
_thresholdPrice = _collateral == 0
? 0
: Maths.wmul(
Maths.wdiv(_debt, _collateral),
COLLATERALIZATION_FACTOR
);
}
function _availableWethBorrow() internal view returns (uint256 _amount) {
IERC20Pool _ajnaPool = ajnaPool;
(uint256 bondEscrowed, uint256 unclaimedReserve, , , ) = _ajnaPool
.reservesInfo();
uint256 escrowedAmounts = bondEscrowed + unclaimedReserve;
uint256 poolBalance = ERC20(WETH).balanceOf(address(_ajnaPool)) *
_ajnaPool.quoteTokenScale();
if (poolBalance > escrowedAmounts)
_amount = poolBalance - escrowedAmounts;
}
function _getAssetPerWeth() internal view returns (uint256) {
uint256 _answer = (ONE_WAD**2) /
uint256(chainlinkOracle.latestAnswer());
if (oracleWrapped) {
return _answer;
}
return _unwrappedToWrappedAsset(_answer);
}
function _setUniswapFee(uint24 _fee) internal {
IUniswapV3Pool _uniswapPool = IUniswapV3Pool(
UNISWAP_FACTORY.getPool(address(asset), WETH, _fee)
);
require(
_uniswapPool.token0() == address(asset) ||
_uniswapPool.token1() == address(asset)
);
require(
_uniswapPool.token0() == address(WETH) ||
_uniswapPool.token1() == address(WETH)
);
uniswapPool = _uniswapPool;
}
function _openPosition(
uint256 _debtAmount,
uint256 _collateralAmount,
uint256 _price
) internal {
summerfiAccount.execute(
address(SUMMERFI_AJNA_PROXY_ACTIONS),
abi.encodeCall(
SUMMERFI_AJNA_PROXY_ACTIONS.openPosition,
(ajnaPool, _debtAmount, _collateralAmount, _price)
)
);
IWETH(WETH).deposit{value: address(this).balance}();
}
function _depositAndDraw(
uint256 _debtAmount,
uint256 _collateralAmount,
uint256 _price,
bool _stamp
) internal {
summerfiAccount.execute(
address(SUMMERFI_AJNA_PROXY_ACTIONS),
abi.encodeCall(
SUMMERFI_AJNA_PROXY_ACTIONS.depositAndDraw,
(ajnaPool, _debtAmount, _collateralAmount, _price, _stamp)
)
);
IWETH(WETH).deposit{value: address(this).balance}();
}
function _repayWithdraw(
uint256 _debtAmount,
uint256 _collateralAmount,
bool _stamp
) internal {
if (_debtAmount != 0) {
IWETH(WETH).withdraw(_debtAmount);
}
summerfiAccount.execute{value: _debtAmount}(
address(SUMMERFI_AJNA_PROXY_ACTIONS),
abi.encodeCall(
SUMMERFI_AJNA_PROXY_ACTIONS.repayWithdraw,
(ajnaPool, _debtAmount, _collateralAmount, _stamp)
)
);
}
function _repayAndClose(uint256 _debtAmount) internal {
if (_debtAmount != 0) {
IWETH(WETH).withdraw(_debtAmount);
}
summerfiAccount.execute{value: _debtAmount}(
address(SUMMERFI_AJNA_PROXY_ACTIONS),
abi.encodeCall(
SUMMERFI_AJNA_PROXY_ACTIONS.repayAndClose,
(ajnaPool)
)
);
uint256 _balance = address(this).balance;
if (_balance != 0) {
IWETH(WETH).deposit{value: _balance}();
}
}
function _unwrappedToWrappedAsset(uint256 _amount)
internal
view
returns (uint256)
{
(bool success, bytes memory data) = address(asset).staticcall(
abi.encodeWithSelector(unwrappedToWrappedSelector, _amount)
);
require(success, "!success");
return abi.decode(data, (uint256));
}
function _minLoanSize() internal view returns (uint256) {
return _minLoanSize(0);
}
function _minLoanSize(int256 _debtDelta)
internal
view
returns (uint256 _minDebtAmount)
{
IERC20Pool _ajnaPool = ajnaPool;
(uint256 _poolDebt, , , ) = _ajnaPool.debtInfo();
(, , uint256 _noOfLoans) = _ajnaPool.loansInfo();
if (_noOfLoans >= 10) {
_minDebtAmount =
(uint256(int256(_poolDebt) + _debtDelta) / _noOfLoans) /
10;
}
}
function _getBorrowFromSupply(
uint256 _supply,
uint256 _collatRatio,
uint256 _assetPerWeth
) internal pure returns (uint256) {
if (_collatRatio == 0) {
return 0;
}
return
(((_supply * _collatRatio) / (ONE_WAD - _collatRatio)) * ONE_WAD) /
_assetPerWeth;
}
function _calculateLTV(
uint256 _debt,
uint256 _collateral,
uint256 _assetPerWeth
) internal pure returns (uint256) {
if (_debt == 0 || _collateral == 0) {
return 0;
}
return (_debt * _assetPerWeth) / _collateral;
}
function _calculateNetPositionWithMaxSlippage(
uint256 _debt,
uint256 _collateral,
uint256 _assetPerWeth
) internal view returns (uint256) {
_debt = (_debt * (MAX_BPS + slippageAllowedBps)) / MAX_BPS;
return _calculateNetPosition(_debt, _collateral, _assetPerWeth);
}
function _calculateNetPosition(
uint256 _debt,
uint256 _collateral,
uint256 _assetPerWeth
) internal pure returns (uint256) {
_debt = (_debt * _assetPerWeth) / ONE_WAD;
if (_debt >= _collateral || _collateral == 0) {
return 0;
}
unchecked {
return _collateral - _debt;
}
}
receive() external payable {}
}
{
"compilationTarget": {
"src/Strategy.sol": "Strategy"
},
"evmVersion": "paris",
"libraries": {
"lib/ajna-core/src/libraries/external/PoolCommons.sol:PoolCommons": "0xe88aaf46c9124b7b08c2dcc2505429ce72979648"
},
"metadata": {
"bytecodeHash": "ipfs"
},
"optimizer": {
"enabled": true,
"runs": 2000
},
"remappings": [
":@ajna-core/=lib/ajna-core/src/",
":@base64-sol/=lib/ajna-core/lib/base64/",
":@clones/=lib/ajna-core/lib/clones-with-immutable-args/src/",
":@openzeppelin/=lib/openzeppelin-contracts/",
":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
":@periphery/=lib/tokenized-strategy-periphery/src/",
":@prb-math/=lib/ajna-core/lib/prb-math/",
":@solmate/=lib/ajna-core/lib/solmate/src/",
":@std/=lib/ajna-core/lib/forge-std/src/",
":@tokenized-strategy/=lib/tokenized-strategy/src/",
":@uniswap-v3-core/=lib/v3-core/contracts/",
":@uniswap-v3-periphery/=lib/v3-periphery/contracts/",
":@uniswap/v3-core/=lib/v3-core/",
":@yearn-vaults/=lib/tokenized-strategy-periphery/lib/yearn-vaults-v3/contracts/",
":ajna-core/=lib/ajna-core/",
":base64/=lib/ajna-core/lib/base64/",
":clones-with-immutable-args/=lib/ajna-core/lib/clones-with-immutable-args/src/",
":ds-test/=lib/tokenized-strategy-periphery/lib/forge-std/lib/ds-test/src/",
":erc4626-tests/=lib/tokenized-strategy/lib/erc4626-tests/",
":forge-std/=lib/forge-std/src/",
":openzeppelin-contracts/=lib/openzeppelin-contracts/",
":openzeppelin/=lib/openzeppelin-contracts/contracts/",
":prb-math/=lib/ajna-core/lib/prb-math/contracts/",
":src/=src/",
":tokenized-strategy-periphery/=lib/tokenized-strategy-periphery/",
":tokenized-strategy/=lib/tokenized-strategy/",
":v3-core/=lib/v3-core/contracts/",
":v3-periphery/=lib/v3-periphery/contracts/",
":yearn-vaults-v3/=lib/tokenized-strategy-periphery/lib/yearn-vaults-v3/"
],
"viaIR": true
}[{"inputs":[{"internalType":"address","name":"_asset","type":"address"},{"internalType":"string","name":"_name","type":"string"},{"internalType":"address","name":"_ajnaPool","type":"address"},{"internalType":"uint24","name":"_uniswapFee","type":"uint24"},{"internalType":"bytes4","name":"_unwrappedToWrappedSelector","type":"bytes4"},{"internalType":"address","name":"_chainlinkOracle","type":"address"},{"internalType":"bool","name":"_oracleWrapped","type":"bool"}],"stateMutability":"nonpayable","type":"constructor"},{"stateMutability":"nonpayable","type":"fallback"},{"inputs":[],"name":"ajnaPool","outputs":[{"internalType":"contract IERC20Pool","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"auction","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"auctionFactory","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"}],"name":"auctionKicked","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"availableDepositLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"availableWithdrawLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"chainlinkOracle","outputs":[{"internalType":"contract IChainlinkAggregator","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"currentLTV","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"deployFunds","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"depositLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"doHealthCheck","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"estimatedTotalAssets","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"estimatedTotalAssetsNoSlippage","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"freeFunds","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"harvestAndReport","outputs":[{"internalType":"uint256","name":"_totalAssets","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"}],"name":"kickable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lossLimitRatio","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ltvs","outputs":[{"internalType":"uint64","name":"targetLTV","type":"uint64"},{"internalType":"uint64","name":"minAdjustThreshold","type":"uint64"},{"internalType":"uint64","name":"warningThreshold","type":"uint64"},{"internalType":"uint64","name":"emergencyThreshold","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_toLoose","type":"uint256"},{"internalType":"uint64","name":"_targetLTV","type":"uint64"},{"internalType":"bool","name":"_force","type":"bool"}],"name":"manualLeverDown","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_debtAmount","type":"uint256"},{"internalType":"uint256","name":"_collateralAmount","type":"uint256"},{"internalType":"bool","name":"_stamp","type":"bool"}],"name":"manualRepayWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amountIn","type":"uint256"},{"internalType":"uint64","name":"_minOut","type":"uint64"},{"internalType":"bool","name":"_assetForWeth","type":"bool"}],"name":"manualSwap","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"maxTendBasefee","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minAjnaToAuction","outputs":[{"internalType":"uint96","name":"","type":"uint96"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"oracleWrapped","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"positionInfo","outputs":[{"internalType":"uint256","name":"_debt","type":"uint256"},{"internalType":"uint256","name":"_collateral","type":"uint256"},{"internalType":"uint256","name":"_t0Np","type":"uint256"},{"internalType":"uint256","name":"_thresholdPrice","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"positionOpen","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"uint256","name":"_amountTaken","type":"uint256"},{"internalType":"uint256","name":"_amountPayed","type":"uint256"}],"name":"postTake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"uint256","name":"_amountToTake","type":"uint256"},{"internalType":"uint256","name":"_amountToPay","type":"uint256"}],"name":"preTake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"profitLimitRatio","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_weeks","type":"uint256[]"},{"internalType":"uint256[]","name":"_amounts","type":"uint256[]"},{"internalType":"bytes32[][]","name":"_proofs","type":"bytes32[][]"}],"name":"redeemSummerAjnaRewards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_auction","type":"address"}],"name":"setAuction","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_depositLimit","type":"uint256"}],"name":"setDepositLimit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_doHealthCheck","type":"bool"}],"name":"setDoHealthCheck","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newLossLimitRatio","type":"uint256"}],"name":"setLossLimitRatio","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"uint64","name":"targetLTV","type":"uint64"},{"internalType":"uint64","name":"minAdjustThreshold","type":"uint64"},{"internalType":"uint64","name":"warningThreshold","type":"uint64"},{"internalType":"uint64","name":"emergencyThreshold","type":"uint64"}],"internalType":"struct Strategy.LTVConfig","name":"_ltvs","type":"tuple"}],"name":"setLtvConfig","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint64","name":"_maxTendBasefee","type":"uint64"}],"name":"setMaxTendBasefee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint96","name":"_minAjnaToAuction","type":"uint96"}],"name":"setMinAjnaToAuction","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newProfitLimitRatio","type":"uint256"}],"name":"setProfitLimitRatio","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16","name":"_slippageAllowedBps","type":"uint16"}],"name":"setSlippageAllowedBps","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint24","name":"_fee","type":"uint24"}],"name":"setUniswapFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"shutdownWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"slippageAllowedBps","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"summerfiAccount","outputs":[{"internalType":"contract IAccount","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_totalIdle","type":"uint256"}],"name":"tendThis","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"tendTrigger","outputs":[{"internalType":"bool","name":"","type":"bool"},{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokenizedStrategyAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"uniswapPool","outputs":[{"internalType":"contract IUniswapV3Pool","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"int256","name":"_amount0Delta","type":"int256"},{"internalType":"int256","name":"_amount1Delta","type":"int256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"uniswapV3SwapCallback","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unwrappedToWrappedSelector","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]
