文件 1 的 1：AcrossLender.sol
pragma solidity 0.8.18;
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;
}
function _contextSuffixLength() internal view virtual returns (uint256) {
return 0;
}
}
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 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;
}
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())
}
}
}
}
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));
}
}
interface IHubPool {
function addLiquidity(address l1Token, uint256 l1TokenAmount) external payable;
function removeLiquidity(address l1Token, uint256 lpTokenAmount, bool sendEth) external;
function pooledTokens(address l1Token) external view returns (address lpToken, bool isEnabled, uint32 lastLpFeeUpdate, int256 utilizedReserves, uint256 liquidReserves, uint256 undistributedLpFees);
function exchangeRateCurrent(address l1Token) external returns (uint256);
}
interface IStaking {
function stake(address stakedToken, uint256 amount) external;
function unstake(address stakedToken, uint256 amount) external;
function withdrawReward(address stakedToken) external;
function getUserStake(address stakedToken, address account) external view returns (uint256 cumulativeBalance, uint256 averageDepositTime, uint256 rewardsAccumulatedPerToken, uint256 rewardsOutstanding);
function getOutstandingRewards(address stakedToken, address account) external view returns (uint256);
function stakingTokens(address stakedToken) external view returns (bool enabled, uint256 baseEmissionRate, uint256 maxMultiplier, uint256 secondsToMaxMultiplier, uint256 cumulativeStaked, uint256 rewardPerTokenStored, uint256 lastUpdateTime);
}
interface IUniswapV3SwapCallback {
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata data
) external;
}
interface ISwapRouter is IUniswapV3SwapCallback {
struct ExactInputSingleParams {
address tokenIn;
address tokenOut;
uint24 fee;
address recipient;
uint256 deadline;
uint256 amountIn;
uint256 amountOutMinimum;
uint160 sqrtPriceLimitX96;
}
function exactInputSingle(
ExactInputSingleParams calldata params
) external payable returns (uint256 amountOut);
struct ExactInputParams {
bytes path;
address recipient;
uint256 deadline;
uint256 amountIn;
uint256 amountOutMinimum;
}
function exactInput(
ExactInputParams calldata params
) external payable returns (uint256 amountOut);
struct ExactOutputSingleParams {
address tokenIn;
address tokenOut;
uint24 fee;
address recipient;
uint256 deadline;
uint256 amountOut;
uint256 amountInMaximum;
uint160 sqrtPriceLimitX96;
}
function exactOutputSingle(
ExactOutputSingleParams calldata params
) external payable returns (uint256 amountIn);
struct ExactOutputParams {
bytes path;
address recipient;
uint256 deadline;
uint256 amountOut;
uint256 amountInMaximum;
}
function exactOutput(
ExactOutputParams calldata params
) external payable returns (uint256 amountIn);
function refundETH() external payable;
}
contract UniswapV3Swapper {
using SafeERC20 for ERC20;
uint256 public minAmountToSell;
address public base = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address public router = 0xE592427A0AEce92De3Edee1F18E0157C05861564;
mapping(address => mapping(address => uint24)) public uniFees;
function _setUniFees(
address _token0,
address _token1,
uint24 _fee
) internal virtual {
uniFees[_token0][_token1] = _fee;
uniFees[_token1][_token0] = _fee;
}
function _swapFrom(
address _from,
address _to,
uint256 _amountIn,
uint256 _minAmountOut
) internal virtual returns (uint256 _amountOut) {
if (_amountIn > minAmountToSell) {
_checkAllowance(router, _from, _amountIn);
if (_from == base || _to == base) {
ISwapRouter.ExactInputSingleParams memory params = ISwapRouter
.ExactInputSingleParams(
_from,
_to,
uniFees[_from][_to],
address(this),
block.timestamp,
_amountIn,
_minAmountOut,
0
);
_amountOut = ISwapRouter(router).exactInputSingle(params);
} else {
bytes memory path = abi.encodePacked(
_from,
uniFees[_from][base],
base,
uniFees[base][_to],
_to
);
_amountOut = ISwapRouter(router).exactInput(
ISwapRouter.ExactInputParams(
path,
address(this),
block.timestamp,
_amountIn,
_minAmountOut
)
);
}
}
}
function _swapTo(
address _from,
address _to,
uint256 _amountTo,
uint256 _maxAmountFrom
) internal virtual returns (uint256 _amountIn) {
if (_maxAmountFrom > minAmountToSell) {
_checkAllowance(router, _from, _maxAmountFrom);
if (_from == base || _to == base) {
ISwapRouter.ExactOutputSingleParams memory params = ISwapRouter
.ExactOutputSingleParams(
_from,
_to,
uniFees[_from][_to],
address(this),
block.timestamp,
_amountTo,
_maxAmountFrom,
0
);
_amountIn = ISwapRouter(router).exactOutputSingle(params);
} else {
bytes memory path = abi.encodePacked(
_to,
uniFees[base][_to],
base,
uniFees[_from][base],
_from
);
_amountIn = ISwapRouter(router).exactOutput(
ISwapRouter.ExactOutputParams(
path,
address(this),
block.timestamp,
_amountTo,
_maxAmountFrom
)
);
}
}
}
function _checkAllowance(
address _contract,
address _token,
uint256 _amount
) internal virtual {
if (ERC20(_token).allowance(address(this), _contract) < _amount) {
ERC20(_token).safeApprove(_contract, 0);
ERC20(_token).safeApprove(_contract, _amount);
}
}
}
contract AcrossLender is BaseStrategy, UniswapV3Swapper {
using SafeERC20 for ERC20;
address internal constant HUBPOOL = 0xc186fA914353c44b2E33eBE05f21846F1048bEda;
address internal constant STAKING = 0x9040e41eF5E8b281535a96D9a48aCb8cfaBD9a48;
address internal immutable lpToken;
address internal constant rewardToken = 0x44108f0223A3C3028F5Fe7AEC7f9bb2E66beF82F;
address internal constant weth = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
bool public claimRewards = true;
uint256 internal constant WAD = 1e18;
uint256 internal constant ASSET_DUST = 100;
constructor(address _asset, uint24 _feeBaseToAsset, string memory _name) BaseStrategy(_asset, _name) {
(address _lpToken, bool isEnabled, , , , ) = IHubPool(HUBPOOL).pooledTokens(address(asset));
(bool enabled, , , , , , ) = IStaking(STAKING).stakingTokens(_lpToken);
require(isEnabled && enabled, "!enabled");
lpToken = _lpToken;
asset.forceApprove(HUBPOOL, type(uint256).max);
ERC20(lpToken).forceApprove(STAKING, type(uint256).max);
_setUniFees(rewardToken, base, 10000);
_setUniFees(base, address(asset), _feeBaseToAsset);
minAmountToSell = 50e18;
}
function _deployFunds(uint256 _amount) internal override {
IHubPool(HUBPOOL).addLiquidity(address(asset), _amount);
IStaking(STAKING).stake(lpToken, balanceOfLp());
}
function _freeFunds(uint256 _amount) internal override {
uint256 lpAmount = _assetToLp(_amount);
lpAmount = _min(lpAmount, balanceOfStake());
require(lpAmount > 0, "withdraw amount too small");
IStaking(STAKING).unstake(lpToken, lpAmount);
lpAmount = _min(lpAmount, balanceOfLp());
IHubPool(HUBPOOL).removeLiquidity(address(asset), lpAmount, false);
}
function _harvestAndReport() internal override returns (uint256 _totalAssets) {
if (claimRewards) {
IStaking(STAKING).withdrawReward(lpToken);
_swapFrom(rewardToken, address(asset), balanceOfRewards(), 0);
}
uint256 balance = balanceOfAsset();
if (TokenizedStrategy.isShutdown()) {
_totalAssets = balance + _lpToAsset(balanceOfStake());
} else {
if (balance > ASSET_DUST) {
_deployFunds(balance);
}
_totalAssets = _lpToAsset(balanceOfStake());
}
}
function availableDepositLimit(address ) public view override returns (uint256) {
(, bool isEnabled, , , , ) = IHubPool(HUBPOOL).pooledTokens(address(asset));
(bool enabled, , , , , , ) = IStaking(STAKING).stakingTokens(lpToken);
if (isEnabled && enabled) return type(uint256).max;
return 0;
}
function availableWithdrawLimit(address ) public view override returns (uint256) {
(, , , , uint256 liquidReserves, ) = IHubPool(HUBPOOL).pooledTokens(address(asset));
return balanceOfAsset() + liquidReserves;
}
function balanceOfAsset() public view returns (uint256) {
return asset.balanceOf(address(this));
}
function balanceOfLp() public view returns (uint256) {
return ERC20(lpToken).balanceOf(address(this));
}
function balanceOfStake() public view returns (uint256 _amount) {
(_amount, , , ) = IStaking(STAKING).getUserStake(lpToken, address(this));
}
function balanceOfRewards() public view returns (uint256) {
return ERC20(rewardToken).balanceOf(address(this));
}
function claimableRewards() public view returns (uint256) {
return IStaking(STAKING).getOutstandingRewards(lpToken, address(this));
}
function _assetToLp(uint256 _assetAmount) internal returns (uint256) {
return _assetAmount * WAD / IHubPool(HUBPOOL).exchangeRateCurrent(address(asset)) + 1;
}
function _lpToAsset(uint256 _lpAmount) internal returns (uint256) {
return _lpAmount * IHubPool(HUBPOOL).exchangeRateCurrent(address(asset)) / WAD;
}
function _min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function setUniFees(uint24 _rewardToBase, uint24 _baseToAsset) external onlyManagement {
_setUniFees(rewardToken, base, _rewardToBase);
_setUniFees(base, address(asset), _baseToAsset);
}
function setMinAmountToSell(uint256 _minAmountToSell) external onlyManagement {
minAmountToSell = _minAmountToSell;
}
function swapBase() external onlyManagement {
base = base == address(asset) ? weth : address(asset);
}
function setClaimRewards(bool _claimRewards) external onlyManagement {
claimRewards = _claimRewards;
}
function _emergencyWithdraw(uint256 _amount) internal override {
_amount = _min(_amount, TokenizedStrategy.totalAssets());
_freeFunds(_amount);
}
}
