文件 1 的 1：OneStepLeverageStETH.f.sol
pragma solidity 0.8.19;
interface IERC3156FlashBorrower {
function onFlashLoan(
address initiator,
address token,
uint256 amount,
uint256 fee,
bytes calldata data
) external returns (bytes32);
}
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 IWstETH is IERC20 {
function stETH() external returns (IERC20);
function wrap(uint256 stETHAmount) external returns (uint256);
function unwrap(uint256 wstETHAmount) external returns (uint256);
function getWstETHByStETH(uint256 stETHAmount) external view returns (uint256);
function getStETHByWstETH(uint256 wstETHAmount) external view returns (uint256);
function stEthPerToken() external view returns (uint256);
function tokensPerStEth() external view returns (uint256);
}
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);
}
struct ERC20PermitSignature {
IERC20Permit token;
uint256 value;
uint256 deadline;
uint8 v;
bytes32 r;
bytes32 s;
}
library PermitHelper {
function applyPermit(
ERC20PermitSignature calldata p,
address owner,
address spender
) internal {
p.token.permit(owner, spender, p.value, p.deadline, p.v, p.r, p.s);
}
function applyPermits(
ERC20PermitSignature[] calldata permits,
address owner,
address spender
) internal {
for (uint256 i = 0; i < permits.length; i++) {
applyPermit(permits[i], owner, spender);
}
}
}
interface IPositionManagerDependent {
error PositionManagerCannotBeZero();
error CallerIsNotPositionManager(address caller);
function positionManager() external view returns (address);
}
interface IERC20Indexable is IERC20, IPositionManagerDependent {
event ERC20IndexableDeployed(address positionManager);
event IndexUpdated(uint256 newIndex);
error NotSupported();
function INDEX_PRECISION() external view returns (uint256);
function currentIndex() external view returns (uint256);
function setIndex(uint256 backingAmount) external;
function mint(address to, uint256 amount) external;
function burn(address from, uint256 amount) external;
}
interface IFeeCollector {
event FeeRecipientChanged(address feeRecipient);
error InvalidFeeRecipient();
function feeRecipient() external view returns (address);
function setFeeRecipient(address newFeeRecipient) external;
}
interface IPriceOracle {
error InvalidDeviation();
struct PriceOracleResponse {
bool isBrokenOrFrozen;
bool priceChangeAboveMax;
uint256 price;
}
function getPriceOracleResponse() external returns (PriceOracleResponse memory);
function timeout() external view returns (uint256);
function TARGET_DIGITS() external view returns (uint256);
function DEVIATION() external view returns (uint256);
}
interface IPriceFeed {
event LastGoodPriceUpdated(uint256 lastGoodPrice);
event PriceDifferenceBetweenOraclesUpdated(uint256 priceDifferenceBetweenOracles);
event PrimaryOracleUpdated(IPriceOracle primaryOracle);
event SecondaryOracleUpdated(IPriceOracle secondaryOracle);
error InvalidPrimaryOracle();
error InvalidSecondaryOracle();
error PrimaryOracleBrokenOrFrozenOrBadResult();
error InvalidPriceDifferenceBetweenOracles();
function primaryOracle() external returns (IPriceOracle);
function secondaryOracle() external returns (IPriceOracle);
function lastGoodPrice() external returns (uint256);
function priceDifferenceBetweenOracles() external returns (uint256);
function setPrimaryOracle(IPriceOracle newPrimaryOracle) external;
function setSecondaryOracle(IPriceOracle newSecondaryOracle) external;
function setPriceDifferenceBetweenOracles(uint256 newPriceDifferenceBetweenOracles) external;
function fetchPrice() external returns (uint256 currentPrice, uint256 deviation);
}
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);
}
interface IRToken is IERC20, IERC20Permit, IERC3156FlashLender, IFeeCollector, IPositionManagerDependent {
event RDeployed(address positionManager, address flashMintFeeRecipient);
event FlashMintFeePercentageChanged(uint256 flashMintFeePercentage);
error FlashFeePercentageTooBig(uint256 feePercentage);
function PERCENTAGE_BASE() external view returns (uint256);
function mint(address to, uint256 amount) external;
function burn(address from, uint256 amount) external;
function MAX_FLASH_MINT_FEE_PERCENTAGE() external view returns (uint256);
function flashMintFeePercentage() external view returns (uint256);
function setFlashMintFeePercentage(uint256 feePercentage) external;
}
interface ISplitLiquidationCollateral {
function LOW_TOTAL_DEBT() external view returns (uint256);
function MCR() external view returns (uint256);
function split(
uint256 totalCollateral,
uint256 totalDebt,
uint256 price,
bool isRedistribution
)
external
view
returns (uint256 collateralToSendToProtocol, uint256 collateralToSentToLiquidator);
}
interface IPositionManager is IFeeCollector {
struct CollateralTokenInfo {
IERC20Indexable collateralToken;
IERC20Indexable debtToken;
IPriceFeed priceFeed;
ISplitLiquidationCollateral splitLiquidation;
bool isEnabled;
uint256 lastFeeOperationTime;
uint256 borrowingSpread;
uint256 baseRate;
uint256 redemptionSpread;
uint256 redemptionRebate;
}
event PositionManagerDeployed(IRToken rToken, address feeRecipient);
event CollateralTokenAdded(
IERC20 collateralToken,
IERC20Indexable raftCollateralToken,
IERC20Indexable raftDebtToken,
IPriceFeed priceFeed
);
event CollateralTokenModified(IERC20 collateralToken, bool isEnabled);
event DelegateWhitelisted(address indexed position, address indexed delegate, bool whitelisted);
event PositionCreated(address indexed position, IERC20 indexed collateralToken);
event PositionClosed(address indexed position);
event CollateralChanged(
address indexed position, IERC20 indexed collateralToken, uint256 collateralAmount, bool isCollateralIncrease
);
event DebtChanged(
address indexed position, IERC20 indexed collateralToken, uint256 debtAmount, bool isDebtIncrease
);
event RBorrowingFeePaid(IERC20 collateralToken, address indexed position, uint256 feeAmount);
event Liquidation(
address indexed liquidator,
address indexed position,
IERC20 indexed collateralToken,
uint256 debtLiquidated,
uint256 collateralLiquidated,
uint256 collateralSentToLiquidator,
uint256 collateralLiquidationFeePaid,
bool isRedistribution
);
event Redemption(address indexed redeemer, uint256 amount, uint256 collateralSent, uint256 fee, uint256 rebate);
event BorrowingSpreadUpdated(uint256 borrowingSpread);
event RedemptionRebateUpdated(uint256 redemptionRebate);
event RedemptionSpreadUpdated(IERC20 collateralToken, uint256 redemptionSpread);
event BaseRateUpdated(IERC20 collateralToken, uint256 baseRate);
event LastFeeOpTimeUpdated(IERC20 collateralToken, uint256 lastFeeOpTime);
event SplitLiquidationCollateralChanged(
IERC20 collateralToken, ISplitLiquidationCollateral indexed newSplitLiquidationCollateral
);
error InvalidMaxFeePercentage();
error MaxFeePercentageOutOfRange();
error AmountIsZero();
error NothingToLiquidate();
error CannotLiquidateLastPosition();
error TotalDebtCannotBeLowerThanMinDebt(IERC20 collateralToken, uint256 newTotalDebt);
error TotalCollateralCannotBeLowerThanMinCollateral(
IERC20 collateralToken, uint256 newTotalCollateral, uint256 minimumCollateral
);
error FeeEatsUpAllReturnedCollateral();
error BorrowingSpreadExceedsMaximum();
error RedemptionRebateExceedsMaximum();
error RedemptionSpreadOutOfRange();
error NoCollateralOrDebtChange();
error InvalidPosition();
error NewICRLowerThanMCR(uint256 newICR);
error NetDebtBelowMinimum(uint256 netDebt);
error InvalidDelegateAddress();
error DelegateNotWhitelisted();
error FeeExceedsMaxFee(uint256 fee, uint256 amount, uint256 maxFeePercentage);
error PositionCollateralTokenMismatch();
error CollateralTokenAddressCannotBeZero();
error PriceFeedAddressCannotBeZero();
error CollateralTokenAlreadyAdded();
error CollateralTokenNotAdded();
error CollateralTokenDisabled();
error SplitLiquidationCollateralCannotBeZero();
error WrongCollateralParamsForFullRepayment();
function rToken() external view returns (IRToken);
function collateralInfo(IERC20 collateralToken)
external
view
returns (
IERC20Indexable raftCollateralToken,
IERC20Indexable raftDebtToken,
IPriceFeed priceFeed,
ISplitLiquidationCollateral splitLiquidation,
bool isEnabled,
uint256 lastFeeOperationTime,
uint256 borrowingSpread,
uint256 baseRate,
uint256 redemptionSpread,
uint256 redemptionRebate
);
function raftCollateralToken(IERC20 collateralToken) external view returns (IERC20Indexable);
function raftDebtToken(IERC20 collateralToken) external view returns (IERC20Indexable);
function priceFeed(IERC20 collateralToken) external view returns (IPriceFeed);
function splitLiquidationCollateral(IERC20 collateralToken) external view returns (ISplitLiquidationCollateral);
function collateralEnabled(IERC20 collateralToken) external view returns (bool);
function lastFeeOperationTime(IERC20 collateralToken) external view returns (uint256);
function borrowingSpread(IERC20 collateralToken) external view returns (uint256);
function baseRate(IERC20 collateralToken) external view returns (uint256 rate);
function redemptionSpread(IERC20 collateralToken) external view returns (uint256);
function redemptionRebate(IERC20 collateralToken) external view returns (uint256);
function getRedemptionRate(IERC20 collateralToken) external view returns (uint256 rate);
function collateralTokenForPosition(address position) external view returns (IERC20 collateralToken);
function addCollateralToken(
IERC20 collateralToken,
IPriceFeed priceFeed,
ISplitLiquidationCollateral newSplitLiquidationCollateral
)
external;
function setCollateralEnabled(IERC20 collateralToken, bool isEnabled) external;
function setSplitLiquidationCollateral(
IERC20 collateralToken,
ISplitLiquidationCollateral newSplitLiquidationCollateral
)
external;
function liquidate(address position) external;
function redeemCollateral(IERC20 collateralToken, uint256 debtAmount, uint256 maxFeePercentage) external;
function managePosition(
IERC20 collateralToken,
address position,
uint256 collateralChange,
bool isCollateralIncrease,
uint256 debtChange,
bool isDebtIncrease,
uint256 maxFeePercentage,
ERC20PermitSignature calldata permitSignature
)
external
returns (uint256 actualCollateralChange, uint256 actualDebtChange);
function MAX_BORROWING_SPREAD() external view returns (uint256);
function MAX_BORROWING_RATE() external view returns (uint256);
function setBorrowingSpread(IERC20 collateralToken, uint256 newBorrowingSpread) external;
function getBorrowingRate(IERC20 collateralToken) external view returns (uint256);
function getBorrowingRateWithDecay(IERC20 collateralToken) external view returns (uint256);
function getBorrowingFee(IERC20 collateralToken, uint256 debtAmount) external view returns (uint256);
function setRedemptionSpread(IERC20 collateralToken, uint256 newRedemptionSpread) external;
function setRedemptionRebate(IERC20 collateralToken, uint256 newRedemptionRebate) external;
function getRedemptionRateWithDecay(IERC20 collateralToken) external view returns (uint256);
function getRedemptionFee(
IERC20 collateralToken,
uint256 collateralAmount,
uint256 priceDeviation
)
external
view
returns (uint256);
function getRedemptionFeeWithDecay(
IERC20 collateralToken,
uint256 collateralAmount
)
external
view
returns (uint256);
function MINUTE_DECAY_FACTOR() external view returns (uint256);
function isDelegateWhitelisted(address position, address delegate) external view returns (bool isWhitelisted);
function whitelistDelegate(address delegate, bool whitelisted) external;
function BETA() external view returns (uint256);
}
interface IAMM {
error InsufficientAmountReceived(uint256 amountReceived, uint256 minReturn);
error SwapPartiallyFilled();
event Swap(
address indexed tokenIn, address indexed tokenOut, uint256 amountIn, uint256 amountOut, uint256 minReturn
);
function swap(
IERC20 tokenIn,
IERC20 tokenOut,
uint256 amountIn,
uint256 minReturn,
bytes calldata extraData
)
external
returns (uint256 amountOut);
}
interface IOneStepLeverage is IERC3156FlashBorrower, IPositionManagerDependent {
error AmmCannotBeZero();
error CollateralTokenCannotBeZero();
error UnsupportedToken();
error InvalidInitiator();
error ZeroDebtChange();
event LeveragedPositionAdjusted(
address indexed position,
uint256 principalCollateralChange,
bool principalCollateralIncrease,
uint256 debtChange,
bool isDebtIncrease,
uint256 leveragedCollateralChange
);
function MAX_LEFTOVER_R() external view returns (uint256);
function amm() external view returns (IAMM);
function collateralToken() external view returns (IERC20);
function underlyingCollateralToken() external view returns (IERC20);
function raftCollateralToken() external view returns (IERC20Indexable);
function raftDebtToken() external view returns (IERC20Indexable);
function manageLeveragedPosition(
uint256 debtChange,
bool isDebtIncrease,
uint256 principalCollateralChange,
bool principalCollateralIncrease,
bytes calldata ammData,
uint256 minReturnOrAmountToSell,
uint256 maxFeePercentage
)
external;
function rescueTokens(IERC20 token, address to) external;
}
interface IOneStepLeverageStETH is IOneStepLeverage {
event StETHLeveragedPositionChange(
address indexed position,
uint256 collateralChange,
bool isCollateralIncrease,
uint256 debtChange,
bool isDebtIncrease
);
function manageLeveragedPositionStETH(
uint256 debtChange,
bool isDebtIncrease,
uint256 stETHCollateralChange,
bool stETHCollateralIncrease,
bytes calldata ammData,
uint256 minReturnOrAmountToSell,
uint256 maxFeePercentage
)
external;
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
abstract contract Ownable2Step is Ownable {
address private _pendingOwner;
event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner);
function pendingOwner() public view virtual returns (address) {
return _pendingOwner;
}
function transferOwnership(address newOwner) public virtual override onlyOwner {
_pendingOwner = newOwner;
emit OwnershipTransferStarted(owner(), newOwner);
}
function _transferOwnership(address newOwner) internal virtual override {
delete _pendingOwner;
super._transferOwnership(newOwner);
}
function acceptOwnership() external {
address sender = _msgSender();
require(pendingOwner() == sender, "Ownable2Step: caller is not the new owner");
_transferOwnership(sender);
}
}
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 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
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");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
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");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
abstract contract PositionManagerDependent is IPositionManagerDependent {
address public immutable override positionManager;
modifier onlyPositionManager() {
if (msg.sender != positionManager) {
revert CallerIsNotPositionManager(msg.sender);
}
_;
}
constructor(address positionManager_) {
if (positionManager_ == address(0)) {
revert PositionManagerCannotBeZero();
}
positionManager = positionManager_;
}
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
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 {}
}
abstract contract ERC20Wrapper is ERC20 {
IERC20 public immutable underlying;
constructor(IERC20 underlyingToken) {
underlying = underlyingToken;
}
function decimals() public view virtual override returns (uint8) {
try IERC20Metadata(address(underlying)).decimals() returns (uint8 value) {
return value;
} catch {
return super.decimals();
}
}
function depositFor(address account, uint256 amount) public virtual returns (bool) {
SafeERC20.safeTransferFrom(underlying, _msgSender(), address(this), amount);
_mint(account, amount);
return true;
}
function withdrawTo(address account, uint256 amount) public virtual returns (bool) {
_burn(_msgSender(), amount);
SafeERC20.safeTransfer(underlying, account, amount);
return true;
}
function _recover(address account) internal virtual returns (uint256) {
uint256 value = underlying.balanceOf(address(this)) - totalSupply();
_mint(account, value);
return value;
}
}
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);
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 * 8) < value ? 1 : 0);
}
}
}
library Strings {
bytes16 private constant _SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
function toString(uint256 value) internal pure returns (string memory) {
unchecked {
uint256 length = Math.log10(value) + 1;
string memory buffer = new string(length);
uint256 ptr;
assembly {
ptr := add(buffer, add(32, length))
}
while (true) {
ptr--;
assembly {
mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
}
value /= 10;
if (value == 0) break;
}
return buffer;
}
}
function toHexString(uint256 value) internal pure returns (string memory) {
unchecked {
return toHexString(value, Math.log256(value) + 1);
}
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
}
library ECDSA {
enum RecoverError {
NoError,
InvalidSignature,
InvalidSignatureLength,
InvalidSignatureS,
InvalidSignatureV
}
function _throwError(RecoverError error) private pure {
if (error == RecoverError.NoError) {
return;
} else if (error == RecoverError.InvalidSignature) {
revert("ECDSA: invalid signature");
} else if (error == RecoverError.InvalidSignatureLength) {
revert("ECDSA: invalid signature length");
} else if (error == RecoverError.InvalidSignatureS) {
revert("ECDSA: invalid signature 's' value");
}
}
function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
if (signature.length == 65) {
bytes32 r;
bytes32 s;
uint8 v;
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return tryRecover(hash, v, r, s);
} else {
return (address(0), RecoverError.InvalidSignatureLength);
}
}
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, signature);
_throwError(error);
return recovered;
}
function tryRecover(
bytes32 hash,
bytes32 r,
bytes32 vs
) internal pure returns (address, RecoverError) {
bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
uint8 v = uint8((uint256(vs) >> 255) + 27);
return tryRecover(hash, v, r, s);
}
function recover(
bytes32 hash,
bytes32 r,
bytes32 vs
) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, r, vs);
_throwError(error);
return recovered;
}
function tryRecover(
bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s
) internal pure returns (address, RecoverError) {
if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
return (address(0), RecoverError.InvalidSignatureS);
}
address signer = ecrecover(hash, v, r, s);
if (signer == address(0)) {
return (address(0), RecoverError.InvalidSignature);
}
return (signer, RecoverError.NoError);
}
function recover(
bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s
) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, v, r, s);
_throwError(error);
return recovered;
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
}
}
abstract contract EIP712 {
bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;
uint256 private immutable _CACHED_CHAIN_ID;
address private immutable _CACHED_THIS;
bytes32 private immutable _HASHED_NAME;
bytes32 private immutable _HASHED_VERSION;
bytes32 private immutable _TYPE_HASH;
constructor(string memory name, string memory version) {
bytes32 hashedName = keccak256(bytes(name));
bytes32 hashedVersion = keccak256(bytes(version));
bytes32 typeHash = keccak256(
"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
);
_HASHED_NAME = hashedName;
_HASHED_VERSION = hashedVersion;
_CACHED_CHAIN_ID = block.chainid;
_CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(typeHash, hashedName, hashedVersion);
_CACHED_THIS = address(this);
_TYPE_HASH = typeHash;
}
function _domainSeparatorV4() internal view returns (bytes32) {
if (address(this) == _CACHED_THIS && block.chainid == _CACHED_CHAIN_ID) {
return _CACHED_DOMAIN_SEPARATOR;
} else {
return _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION);
}
}
function _buildDomainSeparator(
bytes32 typeHash,
bytes32 nameHash,
bytes32 versionHash
) private view returns (bytes32) {
return keccak256(abi.encode(typeHash, nameHash, versionHash, block.chainid, address(this)));
}
function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);
}
}
library Counters {
struct Counter {
uint256 _value;
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
unchecked {
counter._value += 1;
}
}
function decrement(Counter storage counter) internal {
uint256 value = counter._value;
require(value > 0, "Counter: decrement overflow");
unchecked {
counter._value = value - 1;
}
}
function reset(Counter storage counter) internal {
counter._value = 0;
}
}
abstract contract ERC20Permit is ERC20, IERC20Permit, EIP712 {
using Counters for Counters.Counter;
mapping(address => Counters.Counter) private _nonces;
bytes32 private constant _PERMIT_TYPEHASH =
keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 private _PERMIT_TYPEHASH_DEPRECATED_SLOT;
constructor(string memory name) EIP712(name, "1") {}
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public virtual override {
require(block.timestamp <= deadline, "ERC20Permit: expired deadline");
bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline));
bytes32 hash = _hashTypedDataV4(structHash);
address signer = ECDSA.recover(hash, v, r, s);
require(signer == owner, "ERC20Permit: invalid signature");
_approve(owner, spender, value);
}
function nonces(address owner) public view virtual override returns (uint256) {
return _nonces[owner].current();
}
function DOMAIN_SEPARATOR() external view override returns (bytes32) {
return _domainSeparatorV4();
}
function _useNonce(address owner) internal virtual returns (uint256 current) {
Counters.Counter storage nonce = _nonces[owner];
current = nonce.current();
nonce.increment();
}
}
interface IWrappedCollateralToken is IERC20, IERC20Permit {
error ExceedsMaxBalance();
error ExceedsCap();
error InvalidWhitelistAddress();
error AddressIsNotWhitelisted(address);
error Unsupported();
event MaxBalanceSet(uint256 maxBalance_);
event CapSet(uint256 cap_);
event AddressWhitelisted(address indexed addressForWhitelist, bool whitelisted);
function maxBalance() external view returns (uint256);
function cap() external view returns (uint256);
function isWhitelisted(address _addressToCheck) external view returns (bool);
function setMaxBalance(uint256 newMaxBalance) external;
function setCap(uint256 newCap) external;
function whitelistAddress(address addressForWhitelist, bool whitelisted) external;
function recover(address account) external returns (uint256);
function depositForWithAccountCheck(address to, address accountToCheck, uint256 amount) external returns (bool);
}
contract WrappedCollateralToken is
IWrappedCollateralToken,
ERC20Wrapper,
ERC20Permit,
Ownable2Step,
PositionManagerDependent
{
uint256 public override maxBalance;
uint256 public override cap;
mapping(address whitelistAddress => bool isWhitelisted) public override isWhitelisted;
constructor(
IERC20 underlying_,
string memory name_,
string memory symbol_,
uint256 maxBalance_,
uint256 cap_,
address positionManager_
)
ERC20(name_, symbol_)
ERC20Wrapper(underlying_)
ERC20Permit(name_)
PositionManagerDependent(positionManager_)
{
setMaxBalance(maxBalance_);
setCap(cap_);
}
modifier checkLimits(address accountToCheck, uint256 amount) {
if (totalSupply() + amount > cap) {
revert ExceedsCap();
}
uint256 raftColBalance = IPositionManager(positionManager).raftCollateralToken(this).balanceOf(accountToCheck);
if ((balanceOf(accountToCheck) + raftColBalance + amount) > maxBalance) {
revert ExceedsMaxBalance();
}
_;
}
modifier checkWhitelist() {
if (!isWhitelisted[msg.sender]) {
revert AddressIsNotWhitelisted(msg.sender);
}
_;
}
function setMaxBalance(uint256 newMaxBalance) public override onlyOwner {
maxBalance = newMaxBalance;
emit MaxBalanceSet(newMaxBalance);
}
function setCap(uint256 newCap) public override onlyOwner {
cap = newCap;
emit CapSet(newCap);
}
function whitelistAddress(address addressForWhitelist, bool whitelisted) external override onlyOwner {
if (addressForWhitelist == address(0)) {
revert InvalidWhitelistAddress();
}
isWhitelisted[addressForWhitelist] = whitelisted;
emit AddressWhitelisted(addressForWhitelist, whitelisted);
}
function decimals() public view virtual override(ERC20, ERC20Wrapper) returns (uint8) {
return ERC20Wrapper.decimals();
}
function recover(address account) external override onlyOwner returns (uint256) {
return _recover(account);
}
function depositFor(address, uint256) public virtual override returns (bool) {
revert Unsupported();
}
function depositForWithAccountCheck(
address to,
address accountToCheck,
uint256 amount
)
external
override
checkWhitelist
checkLimits(accountToCheck, amount)
returns (bool)
{
return super.depositFor(to, amount);
}
function _transfer(address from, address to, uint256 amount) internal override onlyPositionManager {
super._transfer(from, to, amount);
}
}
contract OneStepLeverage is IOneStepLeverage, PositionManagerDependent, Ownable2Step {
using SafeERC20 for IERC20;
IAMM public immutable override amm;
IERC20 public immutable override collateralToken;
IERC20 public immutable override underlyingCollateralToken;
IERC20Indexable public immutable override raftDebtToken;
IERC20Indexable public immutable override raftCollateralToken;
uint256 public constant override MAX_LEFTOVER_R = 1e18;
constructor(
IPositionManager positionManager_,
IAMM amm_,
IERC20 collateralToken_,
bool isWrappedCollateralToken
)
PositionManagerDependent(address(positionManager_))
{
if (address(amm_) == address(0)) {
revert AmmCannotBeZero();
}
if (address(collateralToken_) == address(0)) {
revert CollateralTokenCannotBeZero();
}
amm = amm_;
collateralToken = collateralToken_;
underlyingCollateralToken = isWrappedCollateralToken
? WrappedCollateralToken(address(collateralToken_)).underlying()
: collateralToken_;
raftCollateralToken = positionManager_.raftCollateralToken(collateralToken);
raftDebtToken = positionManager_.raftDebtToken(collateralToken);
positionManager_.rToken().approve(address(amm), type(uint256).max);
positionManager_.rToken().approve(address(positionManager_.rToken()), type(uint256).max);
underlyingCollateralToken.safeApprove(address(amm), type(uint256).max);
collateralToken_.safeApprove(address(positionManager_), type(uint256).max);
if (isWrappedCollateralToken) {
underlyingCollateralToken.safeApprove(address(collateralToken_), type(uint256).max);
}
}
function manageLeveragedPosition(
uint256 debtChange,
bool isDebtIncrease,
uint256 principalCollateralChange,
bool principalCollateralIncrease,
bytes calldata ammData,
uint256 minReturnOrAmountToSell,
uint256 maxFeePercentage
)
external
override
{
if (principalCollateralIncrease && principalCollateralChange > 0) {
underlyingCollateralToken.safeTransferFrom(msg.sender, address(this), principalCollateralChange);
}
_manageLeveragedPosition(
debtChange,
isDebtIncrease,
principalCollateralChange,
principalCollateralIncrease,
ammData,
minReturnOrAmountToSell,
maxFeePercentage,
true
);
}
function _manageLeveragedPosition(
uint256 debtChange,
bool isDebtIncrease,
uint256 principalCollateralChange,
bool principalCollateralIncrease,
bytes calldata ammData,
uint256 minReturnOrAmountToSell,
uint256 maxFeePercentage,
bool releasePrincipals
)
internal
returns (uint256 actualCollateralChange)
{
if (debtChange == 0) {
revert ZeroDebtChange();
}
bool fullRepayment;
if (!isDebtIncrease) {
uint256 positionDebt = raftDebtToken.balanceOf(msg.sender);
if (debtChange == type(uint256).max) {
debtChange = positionDebt;
}
fullRepayment = (debtChange == positionDebt);
actualCollateralChange =
fullRepayment ? raftCollateralToken.balanceOf(msg.sender) : principalCollateralChange;
} else {
actualCollateralChange = principalCollateralChange;
}
bytes memory data = abi.encode(
msg.sender,
principalCollateralChange,
principalCollateralIncrease,
isDebtIncrease,
ammData,
minReturnOrAmountToSell,
maxFeePercentage,
releasePrincipals,
fullRepayment,
actualCollateralChange
);
IRToken rToken = IPositionManager(positionManager).rToken();
rToken.flashLoan(this, address(rToken), debtChange, data);
}
function onFlashLoan(
address initiator,
address,
uint256 amount,
uint256 fee,
bytes calldata data
)
external
override
returns (bytes32)
{
IERC20 rToken = IPositionManager(positionManager).rToken();
if (msg.sender != address(rToken)) {
revert UnsupportedToken();
}
if (initiator != address(this)) {
revert InvalidInitiator();
}
(
address user,
uint256 principalCollateralChange,
bool principalCollateralIncrease,
bool isDebtIncrease,
bytes memory ammData,
uint256 minReturnOrAmountToSell,
uint256 maxFeePercentage,
bool releasePrincipals,
bool fullRepayment,
uint256 actualCollateralChange
) = abi.decode(data, (address, uint256, bool, bool, bytes, uint256, uint256, bool, bool, uint256));
uint256 leveragedCollateralChange = isDebtIncrease
? amm.swap(rToken, underlyingCollateralToken, amount, minReturnOrAmountToSell, ammData)
: minReturnOrAmountToSell;
uint256 collateralChange;
bool increaseCollateral;
if (principalCollateralIncrease != isDebtIncrease) {
collateralChange = principalCollateralChange > leveragedCollateralChange
? principalCollateralChange - leveragedCollateralChange
: leveragedCollateralChange - principalCollateralChange;
increaseCollateral = principalCollateralIncrease && !isDebtIncrease
? principalCollateralChange > leveragedCollateralChange
: leveragedCollateralChange > principalCollateralChange;
} else {
increaseCollateral = principalCollateralIncrease;
collateralChange = principalCollateralChange + (fullRepayment ? 0 : leveragedCollateralChange);
}
if (increaseCollateral) {
_wrapCollateralTokens(user, collateralChange);
}
ERC20PermitSignature memory emptySignature;
IPositionManager(positionManager).managePosition(
collateralToken,
user,
collateralChange,
increaseCollateral,
amount + (isDebtIncrease ? fee : 0),
isDebtIncrease,
maxFeePercentage,
emptySignature
);
if (releasePrincipals && !principalCollateralIncrease && actualCollateralChange > 0) {
_transferCollateralOut(user, actualCollateralChange - (fullRepayment ? minReturnOrAmountToSell : 0));
}
if (!isDebtIncrease) {
uint256 repayAmount = amount + fee;
_unwrapCollateralTokens(leveragedCollateralChange);
uint256 amountOut =
amm.swap(underlyingCollateralToken, rToken, leveragedCollateralChange, repayAmount, ammData);
if (amountOut > repayAmount + MAX_LEFTOVER_R) {
rToken.transfer(user, amountOut - repayAmount);
}
}
emit LeveragedPositionAdjusted(
user,
principalCollateralChange,
principalCollateralIncrease,
amount,
isDebtIncrease,
leveragedCollateralChange
);
return keccak256("ERC3156FlashBorrower.onFlashLoan");
}
function rescueTokens(IERC20 token, address to) external override onlyOwner {
if (token == collateralToken) {
uint256 balance = token.balanceOf(address(this));
if (balance > 0) {
_unwrapCollateralTokens(balance);
}
token = underlyingCollateralToken;
}
token.safeTransfer(to, token.balanceOf(address(this)));
}
function _wrapCollateralTokens(address user, uint256 amount) internal {
if (collateralToken != underlyingCollateralToken) {
WrappedCollateralToken(address(collateralToken)).depositForWithAccountCheck(address(this), user, amount);
}
}
function _unwrapCollateralTokens(uint256 amount) internal {
if (collateralToken != underlyingCollateralToken) {
WrappedCollateralToken(address(collateralToken)).withdrawTo(address(this), amount);
}
}
function _transferCollateralOut(address user, uint256 amount) internal {
if (collateralToken != underlyingCollateralToken) {
WrappedCollateralToken(address(collateralToken)).withdrawTo(user, amount);
} else {
collateralToken.safeTransfer(user, amount);
}
}
}
interface IStETH is IERC20 {
function getPooledEthByShares(uint256 sharesAmount) external view returns (uint256);
function getSharesByPooledEth(uint256 pooledEthAmount) external view returns (uint256);
function submit(address referral) external payable returns (uint256);
}
interface IWstETHWrapper {
error WstETHAddressCannotBeZero();
function wstETH() external view returns (IWstETH);
function stETH() external view returns (IStETH);
}
abstract contract WstETHWrapper is IWstETHWrapper {
IWstETH public immutable override wstETH;
IStETH public immutable override stETH;
constructor(IWstETH wstETH_) {
if (address(wstETH_) == address(0)) {
revert WstETHAddressCannotBeZero();
}
wstETH = wstETH_;
stETH = IStETH(address(wstETH_.stETH()));
stETH.approve(address(wstETH), type(uint256).max);
}
function wrapStETH(uint256 stETHAmount) internal returns (uint256) {
stETH.transferFrom(msg.sender, address(this), stETHAmount);
return wstETH.wrap(stETHAmount);
}
function unwrapStETH(uint256 wstETHAmount) internal {
stETH.transfer(msg.sender, wstETH.unwrap(wstETHAmount));
}
}
contract OneStepLeverageStETH is IERC3156FlashBorrower, IOneStepLeverageStETH, WstETHWrapper, OneStepLeverage {
constructor(
IPositionManager positionManager_,
IAMM amm_,
IWstETH wstETH_
)
OneStepLeverage(positionManager_, amm_, wstETH_, false)
WstETHWrapper(wstETH_)
{ }
function manageLeveragedPositionStETH(
uint256 debtChange,
bool isDebtIncrease,
uint256 stETHCollateralChange,
bool stETHCollateralIncrease,
bytes calldata ammData,
uint256 minReturnOrAmountToSell,
uint256 maxFeePercentage
)
external
override
{
uint256 wstETHCollateralChange = (stETHCollateralIncrease && stETHCollateralChange > 0)
? wrapStETH(stETHCollateralChange)
: wstETH.getWstETHByStETH(stETHCollateralChange);
wstETHCollateralChange = _manageLeveragedPosition(
debtChange,
isDebtIncrease,
wstETHCollateralChange,
stETHCollateralIncrease,
ammData,
minReturnOrAmountToSell,
maxFeePercentage,
false
);
if (!stETHCollateralIncrease && wstETHCollateralChange > 0) {
unwrapStETH(wstETH.balanceOf(address(this)));
}
emit StETHLeveragedPositionChange(
msg.sender, stETHCollateralChange, stETHCollateralIncrease, debtChange, isDebtIncrease
);
}
}
