File 1 of 1: SturdySiloStrategy.sol
pragma solidity 0.8.21;
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);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
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 {}
}
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);
}
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);
}
interface ITokenizedStrategy is IERC4626, IERC20Permit {
event UpdatePendingManagement(address indexed newPendingManagement);
event UpdateManagement(address indexed newManagement);
event UpdateKeeper(address indexed newKeeper);
event UpdateEmergencyAdmin(address indexed newEmergencyAdmin);
event UpdatePerformanceFee(uint16 newPerformanceFee);
event UpdatePerformanceFeeRecipient(
address indexed newPerformanceFeeRecipient
);
event UpdateProfitMaxUnlockTime(uint256 newProfitMaxUnlockTime);
event StrategyShutdown();
event Reported(
uint256 profit,
uint256 loss,
uint256 protocolFees,
uint256 performanceFees
);
function init(
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 isManagement(address _sender) external view returns (bool);
function isKeeperOrManagement(address _sender) external view returns (bool);
function isEmergencyAuthorized(
address _sender
) external view returns (bool);
function tend() external;
function report() external returns (uint256 _profit, uint256 _loss);
function MIN_FEE() external view returns (uint16);
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 totalIdle() external view returns (uint256);
function totalDebt() 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;
function decreaseAllowance(
address spender,
uint256 subtractedValue
) external returns (bool);
function increaseAllowance(
address spender,
uint256 addedValue
) external returns (bool);
}
abstract contract BaseStrategy {
modifier onlySelf() {
_onlySelf();
_;
}
modifier onlyManagement() {
TokenizedStrategy.isManagement(msg.sender);
_;
}
modifier onlyKeepers() {
TokenizedStrategy.isKeeperOrManagement(msg.sender);
_;
}
modifier onlyEmergencyAuthorized() {
TokenizedStrategy.isEmergencyAuthorized(msg.sender);
_;
}
function _onlySelf() internal view {
require(msg.sender == address(this), "!self");
}
address public constant tokenizedStrategyAddress =
0xDFC8cD9F2f2d306b7C0d109F005DF661E14f4ff2;
ITokenizedStrategy internal immutable TokenizedStrategy;
ERC20 internal immutable asset;
constructor(address _asset, string memory _name) {
asset = ERC20(_asset);
TokenizedStrategy = ITokenizedStrategy(address(this));
_delegateCall(
abi.encodeCall(
ITokenizedStrategy.init,
(_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 maxLTV() external view virtual returns (uint256);
function collateral() external view virtual returns (address);
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())
}
}
}
}
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);
}
}
}
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));
}
}
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);
}
}
}
struct VaultAccount {
uint128 amount;
uint128 shares;
}
interface ISturdyPair {
struct CurrentRateInfo {
uint32 lastBlock;
uint32 feeToProtocolRate;
uint64 lastTimestamp;
uint64 ratePerSec;
uint64 fullUtilizationRate;
}
function CIRCUIT_BREAKER_ADDRESS() external view returns (address);
function COMPTROLLER_ADDRESS() external view returns (address);
function DEPLOYER_ADDRESS() external view returns (address);
function FRAXLEND_WHITELIST_ADDRESS() external view returns (address);
function timelockAddress() external view returns (address);
function addCollateral(uint256 _collateralAmount, address _borrower) external;
function addInterest(
bool _returnAccounting
)
external
returns (
uint256 _interestEarned,
uint256 _feesAmount,
uint256 _feesShare,
CurrentRateInfo memory _currentRateInfo,
VaultAccount memory _totalAsset,
VaultAccount memory _totalBorrow
);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function approvedBorrowers(address) external view returns (bool);
function approvedLenders(address) external view returns (bool);
function approveBorrowDelegation(address _delegatee, uint256 _amount) external;
function asset() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function borrowAsset(
uint256 _borrowAmount,
uint256 _collateralAmount,
address _receiver
) external returns (uint256 _shares);
function borrowAssetOnBehalfOf(
uint256 _borrowAmount,
address _onBehalfOf
) external returns (uint256 _shares);
function borrowerWhitelistActive() external view returns (bool);
function changeFee(uint32 _newFee) external;
function cleanLiquidationFee() external view returns (uint256);
function collateralContract() external view returns (address);
function currentRateInfo()
external
view
returns (
uint32 lastBlock,
uint32 feeToProtocolRate,
uint64 lastTimestamp,
uint64 ratePerSec,
uint64 fullUtilizationRate
);
function decimals() external view returns (uint8);
function decreaseAllowance(address spender, uint256 subtractedValue) external returns (bool);
function deposit(uint256 _amount, address _receiver) external returns (uint256 _sharesReceived);
function dirtyLiquidationFee() external view returns (uint256);
function exchangeRateInfo() external view returns (address oracle, uint32 maxOracleDeviation, uint184 lastTimestamp, uint256 lowExchangeRate, uint256 highExchangeRate);
function getConstants()
external
pure
returns (
uint256 _LTV_PRECISION,
uint256 _LIQ_PRECISION,
uint256 _UTIL_PREC,
uint256 _FEE_PRECISION,
uint256 _EXCHANGE_PRECISION,
uint256 _DEVIATION_PRECISION,
uint256 _RATE_PRECISION,
uint256 _MAX_PROTOCOL_FEE
);
function getImmutableAddressBool()
external
view
returns (
address _assetContract,
address _collateralContract,
address _oracleMultiply,
address _oracleDivide,
address _rateContract,
address _DEPLOYER_CONTRACT,
address _COMPTROLLER_ADDRESS,
address _FRAXLEND_WHITELIST,
bool _borrowerWhitelistActive,
bool _lenderWhitelistActive
);
function getImmutableUint256()
external
view
returns (
uint256 _oracleNormalization,
uint256 _maxLTV,
uint256 _cleanLiquidationFee,
uint256 _maturityDate,
uint256 _penaltyRate
);
function getPairAccounting()
external
view
returns (
uint128 _totalAssetAmount,
uint128 _totalAssetShares,
uint128 _totalBorrowAmount,
uint128 _totalBorrowShares,
uint256 _totalCollateral
);
function getUserSnapshot(
address _address
) external view returns (uint256 _userAssetShares, uint256 _userBorrowShares, uint256 _userCollateralBalance);
function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
function lenderWhitelistActive() external view returns (bool);
function leveragedPosition(
address _swapperAddress,
uint256 _borrowAmount,
uint256 _initialCollateralAmount,
uint256 _amountCollateralOutMin,
address[] memory _path
) external returns (uint256 _totalCollateralBalance);
function liquidate(
uint128 _sharesToLiquidate,
uint256 _deadline,
address _borrower
) external returns (uint256 _collateralForLiquidator);
function maturityDate() external view returns (uint256);
function maxLTV() external view returns (uint256);
function maxOracleDelay() external view returns (uint256);
function name() external view returns (string memory);
function oracleDivide() external view returns (address);
function oracleMultiply() external view returns (address);
function oracleNormalization() external view returns (uint256);
function owner() external view returns (address);
function pause() external;
function paused() external view returns (bool);
function penaltyRate() external view returns (uint256);
function rateContract() external view returns (address);
function redeem(uint256 _shares, address _receiver, address _owner) external returns (uint256 _amountToReturn);
function removeCollateral(uint256 _collateralAmount, address _receiver) external;
function removeCollateralFrom(
uint256 _collateralAmount,
address _receiver,
address _borrower
) external;
function setWhitelistedDelegators(address _delegator, bool _enabled) external;
function renounceOwnership() external;
function repayAsset(uint256 _shares, address _borrower) external returns (uint256 _amountToRepay);
function repayAssetWithCollateral(
address _swapperAddress,
uint256 _collateralToSwap,
uint256 _amountAssetOutMin,
address[] memory _path
) external returns (uint256 _amountAssetOut);
function setApprovedBorrowers(address[] memory _borrowers, bool _approval) external;
function setApprovedLenders(address[] memory _lenders, bool _approval) external;
function setMaxOracleDelay(uint256 _newDelay) external;
function setSwapper(address _swapper, bool _approval) external;
function setTimelock(address _newAddress) external;
function swappers(address) external view returns (bool);
function symbol() external view returns (string memory);
function toAssetAmount(
uint256 _shares,
bool _roundUp,
bool _previewInterest
) external view returns (uint256);
function toAssetShares(
uint256 _amount,
bool _roundUp,
bool _previewInterest
) external view returns (uint256);
function toBorrowAmount(
uint256 _shares,
bool _roundUp,
bool _previewInterest
) external view returns (uint256 _amount);
function toBorrowShares(
uint256 _amount,
bool _roundUp,
bool _previewInterest
) external view returns (uint256 _shares);
function totalAsset() external view returns (uint128 amount, uint128 shares);
function totalBorrow() external view returns (uint128 amount, uint128 shares);
function totalCollateral() external view returns (uint256);
function totalSupply() external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
function transferOwnership(address newOwner) external;
function unpause() external;
function updateExchangeRate()
external
returns (bool _isBorrowAllowed, uint256 _lowExchangeRate, uint256 _highExchangeRate);
function userBorrowShares(address) external view returns (uint256);
function userCollateralBalance(address) external view returns (uint256);
function version() external pure returns (uint256 _major, uint256 _minor, uint256 _patch);
function withdrawFees(uint128 _shares, address _recipient) external returns (uint256 _amountToTransfer);
function isInterestPaused() external view returns (bool);
}
contract SturdySiloStrategy is BaseStrategy {
using SafeERC20 for ERC20;
ISturdyPair public immutable pair;
uint256 public immutable depositThreshold;
bool public thresholdMet;
uint256 public timeToUnlock;
bool public freezeTimeToUnlock;
constructor(
address _asset,
address _pair,
string memory _name,
uint256 _depositThreshold,
uint256 _timeToUnlock
) BaseStrategy(_asset, _name) {
pair = ISturdyPair(_pair);
depositThreshold = _depositThreshold;
timeToUnlock = _timeToUnlock;
ERC20(_asset).safeApprove(address(pair), type(uint256).max);
}
function _deployFunds(uint256 _amount) internal override {
if (thresholdMet) {
pair.deposit(_amount, address(this));
} else if (_amount > depositThreshold) {
thresholdMet = true;
pair.deposit(_amount, address(this));
}
}
function _freeFunds(uint256 _amount) internal override {
if (block.timestamp >= timeToUnlock) {
pair.addInterest(false);
pair.redeem(
pair.toAssetShares(_amount, false, false),
address(this),
address(this)
);
} else {
require(false, "Locked!");
}
}
function _harvestAndReport()
internal
override
returns (uint256 _totalAssets)
{
pair.addInterest(false);
_totalAssets =
asset.balanceOf(address(this)) +
pair.toAssetAmount(pair.balanceOf(address(this)), false, false);
}
function availableWithdrawLimit(
address _owner
) public view override returns (uint256) {
if (block.timestamp >= timeToUnlock) {
return
TokenizedStrategy.totalIdle() +
asset.balanceOf(address(pair));
} else {
return TokenizedStrategy.totalIdle();
}
}
function _emergencyWithdraw(uint256 _amount) internal override {
pair.addInterest(false);
uint256 shares = pair.toAssetShares(_amount, true, false);
shares = Math.min(shares, pair.balanceOf(address(this)));
pair.redeem(shares, address(this), address(this));
}
function setTimeToUnlock(uint256 _newTime) external onlyManagement {
require(!freezeTimeToUnlock, "lock frozen");
timeToUnlock = _newTime;
}
function freezeUnlock() external onlyManagement {
freezeTimeToUnlock = true;
}
function maxLTV() external view override returns (uint256) {
return pair.maxLTV();
}
function collateral() external view override returns (address) {
return pair.collateralContract();
}
}
