编译器
0.8.17+commit.8df45f5f
文件 1 的 97：ActionBaseMintRedeem.sol
pragma solidity 0.8.17;
import "../../core/libraries/TokenHelper.sol";
import "../../interfaces/IStandardizedYield.sol";
import "../../interfaces/IPYieldToken.sol";
import "../../interfaces/IPBulkSeller.sol";
import "../../core/libraries/Errors.sol";
import "../swap-aggregator/IPSwapAggregator.sol";
struct TokenInput {
address tokenIn;
uint256 netTokenIn;
address tokenMintSy;
address bulk;
address pendleSwap;
SwapData swapData;
}
struct TokenOutput {
address tokenOut;
uint256 minTokenOut;
address tokenRedeemSy;
address bulk;
address pendleSwap;
SwapData swapData;
}
abstract contract ActionBaseMintRedeem is TokenHelper {
bytes internal constant EMPTY_BYTES = abi.encode();
function _mintSyFromToken(
address receiver,
address SY,
uint256 minSyOut,
TokenInput calldata inp
) internal returns (uint256 netSyOut) {
SwapType swapType = inp.swapData.swapType;
uint256 netTokenMintSy;
if (swapType == SwapType.NONE) {
_transferIn(inp.tokenIn, msg.sender, inp.netTokenIn);
netTokenMintSy = inp.netTokenIn;
} else if (swapType == SwapType.ETH_WETH) {
_transferIn(inp.tokenIn, msg.sender, inp.netTokenIn);
_wrap_unwrap_ETH(inp.tokenIn, inp.tokenMintSy, inp.netTokenIn);
netTokenMintSy = inp.netTokenIn;
} else {
if (inp.tokenIn == NATIVE) _transferIn(NATIVE, msg.sender, inp.netTokenIn);
else _transferFrom(IERC20(inp.tokenIn), msg.sender, inp.pendleSwap, inp.netTokenIn);
IPSwapAggregator(inp.pendleSwap).swap{
value: inp.tokenIn == NATIVE ? inp.netTokenIn : 0
}(inp.tokenIn, inp.netTokenIn, inp.swapData);
netTokenMintSy = _selfBalance(inp.tokenMintSy);
}
netSyOut = __mintSy(receiver, SY, netTokenMintSy, minSyOut, inp);
}
function __mintSy(
address receiver,
address SY,
uint256 netTokenMintSy,
uint256 minSyOut,
TokenInput calldata inp
) private returns (uint256 netSyOut) {
uint256 netNative = inp.tokenMintSy == NATIVE ? netTokenMintSy : 0;
if (inp.bulk != address(0)) {
netSyOut = IPBulkSeller(inp.bulk).swapExactTokenForSy{ value: netNative }(
receiver,
netTokenMintSy,
minSyOut
);
} else {
netSyOut = IStandardizedYield(SY).deposit{ value: netNative }(
receiver,
inp.tokenMintSy,
netTokenMintSy,
minSyOut
);
}
}
function _redeemSyToToken(
address receiver,
address SY,
uint256 netSyIn,
TokenOutput calldata out,
bool doPull
) internal returns (uint256 netTokenOut) {
SwapType swapType = out.swapData.swapType;
if (swapType == SwapType.NONE) {
netTokenOut = __redeemSy(receiver, SY, netSyIn, out, doPull);
} else if (swapType == SwapType.ETH_WETH) {
netTokenOut = __redeemSy(address(this), SY, netSyIn, out, doPull);
_wrap_unwrap_ETH(out.tokenRedeemSy, out.tokenOut, netTokenOut);
_transferOut(out.tokenOut, receiver, netTokenOut);
} else {
uint256 netTokenRedeemed = __redeemSy(out.pendleSwap, SY, netSyIn, out, doPull);
IPSwapAggregator(out.pendleSwap).swap(
out.tokenRedeemSy,
netTokenRedeemed,
out.swapData
);
netTokenOut = _selfBalance(out.tokenOut);
_transferOut(out.tokenOut, receiver, netTokenOut);
}
if (netTokenOut < out.minTokenOut) {
revert Errors.RouterInsufficientTokenOut(netTokenOut, out.minTokenOut);
}
}
function __redeemSy(
address receiver,
address SY,
uint256 netSyIn,
TokenOutput calldata out,
bool doPull
) private returns (uint256 netTokenRedeemed) {
if (doPull) {
_transferFrom(IERC20(SY), msg.sender, _syOrBulk(SY, out), netSyIn);
}
if (out.bulk != address(0)) {
netTokenRedeemed = IPBulkSeller(out.bulk).swapExactSyForToken(
receiver,
netSyIn,
0,
true
);
} else {
netTokenRedeemed = IStandardizedYield(SY).redeem(
receiver,
netSyIn,
out.tokenRedeemSy,
0,
true
);
}
}
function _mintPyFromSy(
address receiver,
address SY,
address YT,
uint256 netSyIn,
uint256 minPyOut,
bool doPull
) internal returns (uint256 netPyOut) {
if (doPull) {
_transferFrom(IERC20(SY), msg.sender, YT, netSyIn);
}
netPyOut = IPYieldToken(YT).mintPY(receiver, receiver);
if (netPyOut < minPyOut) revert Errors.RouterInsufficientPYOut(netPyOut, minPyOut);
}
function _redeemPyToSy(
address receiver,
address YT,
uint256 netPyIn,
uint256 minSyOut
) internal returns (uint256 netSyOut) {
address PT = IPYieldToken(YT).PT();
_transferFrom(IERC20(PT), msg.sender, YT, netPyIn);
bool needToBurnYt = (!IPYieldToken(YT).isExpired());
if (needToBurnYt) _transferFrom(IERC20(YT), msg.sender, YT, netPyIn);
netSyOut = IPYieldToken(YT).redeemPY(receiver);
if (netSyOut < minSyOut) revert Errors.RouterInsufficientSyOut(netSyOut, minSyOut);
}
function _syOrBulk(address SY, TokenOutput calldata output)
internal
pure
returns (address addr)
{
return output.bulk != address(0) ? output.bulk : SY;
}
}
文件 2 的 97：Address.sol
pragma solidity ^0.8.1;
library Address {
function isContract(address account) internal view returns (bool) {
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "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");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(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) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(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) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
文件 3 的 97：AddressUpgradeable.sol
pragma solidity ^0.8.1;
library AddressUpgradeable {
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 functionCall(target, data, "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");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(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) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
文件 4 的 97：ArrayLib.sol
pragma solidity ^0.8.0;
library ArrayLib {
function sum(uint256[] memory input) internal pure returns (uint256) {
uint256 value = 0;
for (uint256 i = 0; i < input.length; ) {
value += input[i];
unchecked {
i++;
}
}
return value;
}
function find(address[] memory array, address element) internal pure returns (uint256 index) {
uint256 length = array.length;
for (uint256 i = 0; i < length; ) {
if (array[i] == element) return i;
unchecked {
i++;
}
}
return type(uint256).max;
}
function append(
address[] memory inp,
address element
) internal pure returns (address[] memory out) {
uint256 length = inp.length;
out = new address[](length + 1);
for (uint256 i = 0; i < length; ) {
out[i] = inp[i];
unchecked {
i++;
}
}
out[length] = element;
}
function merge(
address[] memory a,
address[] memory b
) internal pure returns (address[] memory out) {
unchecked {
uint256 countUnidenticalB = 0;
bool[] memory isUnidentical = new bool[](b.length);
for (uint256 i = 0; i < b.length; ++i) {
if (!contains(a, b[i])) {
countUnidenticalB++;
isUnidentical[i] = true;
}
}
out = new address[](a.length + countUnidenticalB);
for (uint256 i = 0; i < a.length; ++i) {
out[i] = a[i];
}
uint256 id = a.length;
for (uint256 i = 0; i < b.length; ++i) {
if (isUnidentical[i]) {
out[id++] = b[i];
}
}
}
}
function contains(address[] memory array, address element) internal pure returns (bool) {
uint256 length = array.length;
for (uint256 i = 0; i < length; ) {
if (array[i] == element) return true;
unchecked {
i++;
}
}
return false;
}
function contains(bytes4[] memory array, bytes4 element) internal pure returns (bool) {
uint256 length = array.length;
for (uint256 i = 0; i < length; ) {
if (array[i] == element) return true;
unchecked {
i++;
}
}
return false;
}
function create(address a) internal pure returns (address[] memory res) {
res = new address[](1);
res[0] = a;
}
function create(address a, address b) internal pure returns (address[] memory res) {
res = new address[](2);
res[0] = a;
res[1] = b;
}
}
文件 5 的 97：AuraEthxBbAWethSY.sol
pragma solidity 0.8.17;
import "@pendle/core-v2/contracts/core/StandardizedYield/implementations/BalancerStable/base/PendleAuraBalancerStableLPSYV2.sol";
import "@pendle/core-v2/contracts/core/StandardizedYield/implementations/BalancerStable/base/ComposableStable/ComposableStablePreview.sol";
import "@pendle/core-v2/contracts/core/StandardizedYield/implementations/BalancerStable/base/Linear/BbAPoolHelper.sol";
contract AuraEthxBbAWethSY is PendleAuraBalancerStableLPSYV2, BbAWethHelper {
uint256 internal constant AURA_PID = 134;
address internal constant LP = 0x4CbdE5C4B4B53EBE4aF4adB85404725985406163;
address internal constant ETHx = 0xA35b1B31Ce002FBF2058D22F30f95D405200A15b;
address internal constant LINEAR_PREVIEW = 0x73187e5b27F2aadD5fFee023d6a9E179365F2ad6;
address internal constant COMPOSABLE_PREVIEW = 0x4239Ddd3c50463383670E86c119220849BFaF64a;
address internal constant _BB_A_WETH = 0xbB6881874825E60e1160416D6C426eae65f2459E;
address internal constant _WA_WETH = 0x03928473f25bb2da6Bc880b07eCBaDC636822264;
bytes32 internal constant _BB_A_WETH_POOL_ID =
0xbb6881874825e60e1160416d6c426eae65f2459e000000000000000000000592;
bool internal constant NO_TOKENS_EXEMPT = true;
bool internal constant ALL_TOKENS_EXEMPT = false;
constructor(
string memory _name,
string memory _symbol
)
BbAWethHelper(LinearPreview(LINEAR_PREVIEW), _BB_A_WETH, _BB_A_WETH_POOL_ID, _WA_WETH)
PendleAuraBalancerStableLPSYV2(
_name,
_symbol,
LP,
AURA_PID,
ComposableStablePreview(COMPOSABLE_PREVIEW)
)
{
}
function _deposit(
address tokenIn,
uint256 amount
) internal override returns (uint256 amountSharesOut) {
if (tokenIn == NATIVE || tokenIn == WETH || tokenIn == WA_WETH) {
uint256 amountBbAWeth = _depositBbAWeth(tokenIn, amount);
amountSharesOut = super._deposit(BB_A_WETH, amountBbAWeth);
} else {
amountSharesOut = super._deposit(tokenIn, amount);
}
}
function _redeem(
address receiver,
address tokenOut,
uint256 amountSharesToRedeem
) internal override returns (uint256 amountTokenOut) {
if (tokenOut == NATIVE || tokenOut == WETH || tokenOut == WA_WETH) {
uint256 amountBbAWeth = super._redeem(address(this), BB_A_WETH, amountSharesToRedeem);
amountTokenOut = _redeemBbAWeth(receiver, tokenOut, amountBbAWeth);
} else {
return super._redeem(receiver, tokenOut, amountSharesToRedeem);
}
}
function _previewDeposit(
address tokenIn,
uint256 amountTokenToDeposit
) internal view override returns (uint256 amountSharesOut) {
if (tokenIn == NATIVE || tokenIn == WETH || tokenIn == WA_WETH) {
uint256 amountBbAWeth = _previewDepositBbAWeth(tokenIn, amountTokenToDeposit);
amountSharesOut = super._previewDeposit(BB_A_WETH, amountBbAWeth);
} else {
amountSharesOut = super._previewDeposit(tokenIn, amountTokenToDeposit);
}
}
function _previewRedeem(
address tokenOut,
uint256 amountSharesToRedeem
) internal view override returns (uint256 amountTokenOut) {
if (tokenOut == NATIVE || tokenOut == WETH || tokenOut == WA_WETH) {
uint256 amountBbAWeth = super._previewRedeem(BB_A_WETH, amountSharesToRedeem);
amountTokenOut = _previewRedeemBbAWeth(tokenOut, amountBbAWeth);
} else {
return super._previewRedeem(tokenOut, amountSharesToRedeem);
}
}
function _getImmutablePoolData() internal pure override returns (bytes memory ret) {
ComposableStablePreview.ImmutableData memory res;
res.poolTokens = _getPoolTokenAddresses();
res.rateProviders = _getRateProviders();
res.rawScalingFactors = _getRawScalingFactors();
res.isExemptFromYieldProtocolFee = _getExemption();
res.LP = LP;
res.noTokensExempt = NO_TOKENS_EXEMPT;
res.allTokensExempt = ALL_TOKENS_EXEMPT;
res.bptIndex = _getBPTIndex();
res.totalTokens = res.poolTokens.length;
return abi.encode(res);
}
function _getPoolTokenAddresses() internal pure override returns (address[] memory res) {
res = new address[](3);
res[0] = LP;
res[1] = ETHx;
res[2] = _BB_A_WETH;
}
function _getBPTIndex() internal pure override returns (uint256) {
return 0;
}
function _getRateProviders() internal pure returns (address[] memory res) {
res = new address[](3);
res[0] = 0x0000000000000000000000000000000000000000;
res[1] = 0xAAE054B9b822554dd1D9d1F48f892B4585D3bbf0;
res[2] = 0xbB6881874825E60e1160416D6C426eae65f2459E;
}
function _getRawScalingFactors() internal pure returns (uint256[] memory res) {
res = new uint256[](3);
res[0] = res[1] = res[2] = 1e18;
}
function _getExemption() internal pure returns (bool[] memory res) {
res = new bool[](3);
res[0] = res[1] = res[2] = false;
}
function getTokensIn() public view override returns (address[] memory res) {
res = new address[](6);
res[0] = NATIVE;
res[1] = WETH;
res[2] = WA_WETH;
res[3] = BB_A_WETH;
res[4] = ETHx;
res[5] = LP;
}
function getTokensOut() public view override returns (address[] memory res) {
return getTokensIn();
}
function isValidTokenIn(address token) public view override returns (bool) {
return (token == NATIVE ||
token == WETH ||
token == WA_WETH ||
token == BB_A_WETH ||
token == ETHx ||
token == LP);
}
function isValidTokenOut(address token) public view override returns (bool) {
return isValidTokenIn(token);
}
}
文件 6 的 97：AuraSwEthBbAWethSYV2.sol
pragma solidity 0.8.17;
import "@pendle/core-v2/contracts/core/StandardizedYield/implementations/BalancerStable/base/PendleAuraBalancerStableLPSYV2.sol";
import "@pendle/core-v2/contracts/core/StandardizedYield/implementations/BalancerStable/base/ComposableStable/ComposableStablePreview.sol";
import "@pendle/core-v2/contracts/core/StandardizedYield/implementations/BalancerStable/base/Linear/BbAPoolHelper.sol";
contract AuraSwEthBbAWethSYV2 is PendleAuraBalancerStableLPSYV2, BbAWethHelper {
uint256 internal constant AURA_PID = 143;
address internal constant LP = 0xaE8535c23afeDdA9304B03c68a3563B75fc8f92b;
address internal constant SWETH = 0xf951E335afb289353dc249e82926178EaC7DEd78;
address internal constant LINEAR_PREVIEW = 0x73187e5b27F2aadD5fFee023d6a9E179365F2ad6;
address internal constant COMPOSABLE_PREVIEW = 0x4239Ddd3c50463383670E86c119220849BFaF64a;
address internal constant _BB_A_WETH = 0xbB6881874825E60e1160416D6C426eae65f2459E;
address internal constant _WA_WETH = 0x03928473f25bb2da6Bc880b07eCBaDC636822264;
bytes32 internal constant _BB_A_WETH_POOL_ID =
0xbb6881874825e60e1160416d6c426eae65f2459e000000000000000000000592;
bool internal constant NO_TOKENS_EXEMPT = true;
bool internal constant ALL_TOKENS_EXEMPT = false;
constructor(
string memory _name,
string memory _symbol
)
BbAWethHelper(LinearPreview(LINEAR_PREVIEW), _BB_A_WETH, _BB_A_WETH_POOL_ID, _WA_WETH)
PendleAuraBalancerStableLPSYV2(
_name,
_symbol,
LP,
AURA_PID,
ComposableStablePreview(COMPOSABLE_PREVIEW)
)
{
}
function _deposit(
address tokenIn,
uint256 amount
) internal override returns (uint256 amountSharesOut) {
if (tokenIn == NATIVE || tokenIn == WETH || tokenIn == WA_WETH) {
uint256 amountBbAWeth = _depositBbAWeth(tokenIn, amount);
amountSharesOut = super._deposit(BB_A_WETH, amountBbAWeth);
} else {
amountSharesOut = super._deposit(tokenIn, amount);
}
}
function _redeem(
address receiver,
address tokenOut,
uint256 amountSharesToRedeem
) internal override returns (uint256 amountTokenOut) {
if (tokenOut == NATIVE || tokenOut == WETH || tokenOut == WA_WETH) {
uint256 amountBbAWeth = super._redeem(address(this), BB_A_WETH, amountSharesToRedeem);
amountTokenOut = _redeemBbAWeth(receiver, tokenOut, amountBbAWeth);
} else {
return super._redeem(receiver, tokenOut, amountSharesToRedeem);
}
}
function _previewDeposit(
address tokenIn,
uint256 amountTokenToDeposit
) internal view override returns (uint256 amountSharesOut) {
if (tokenIn == NATIVE || tokenIn == WETH || tokenIn == WA_WETH) {
uint256 amountBbAWeth = _previewDepositBbAWeth(tokenIn, amountTokenToDeposit);
amountSharesOut = super._previewDeposit(BB_A_WETH, amountBbAWeth);
} else {
amountSharesOut = super._previewDeposit(tokenIn, amountTokenToDeposit);
}
}
function _previewRedeem(
address tokenOut,
uint256 amountSharesToRedeem
) internal view override returns (uint256 amountTokenOut) {
if (tokenOut == NATIVE || tokenOut == WETH || tokenOut == WA_WETH) {
uint256 amountBbAWeth = super._previewRedeem(BB_A_WETH, amountSharesToRedeem);
amountTokenOut = _previewRedeemBbAWeth(tokenOut, amountBbAWeth);
} else {
return super._previewRedeem(tokenOut, amountSharesToRedeem);
}
}
function _getImmutablePoolData() internal pure override returns (bytes memory ret) {
ComposableStablePreview.ImmutableData memory res;
res.poolTokens = _getPoolTokenAddresses();
res.rateProviders = _getRateProviders();
res.rawScalingFactors = _getRawScalingFactors();
res.isExemptFromYieldProtocolFee = _getExemption();
res.LP = LP;
res.noTokensExempt = NO_TOKENS_EXEMPT;
res.allTokensExempt = ALL_TOKENS_EXEMPT;
res.bptIndex = _getBPTIndex();
res.totalTokens = res.poolTokens.length;
return abi.encode(res);
}
function _getPoolTokenAddresses() internal pure override returns (address[] memory res) {
res = new address[](3);
res[0] = LP;
res[1] = _BB_A_WETH;
res[2] = SWETH;
}
function _getBPTIndex() internal pure override returns (uint256) {
return 0;
}
function _getRateProviders() internal pure returns (address[] memory res) {
res = new address[](3);
res[0] = 0x0000000000000000000000000000000000000000;
res[1] = 0xbB6881874825E60e1160416D6C426eae65f2459E;
res[2] = 0xf951E335afb289353dc249e82926178EaC7DEd78;
}
function _getRawScalingFactors() internal pure returns (uint256[] memory res) {
res = new uint256[](3);
res[0] = res[1] = res[2] = 1e18;
}
function _getExemption() internal pure returns (bool[] memory res) {
res = new bool[](3);
res[0] = res[1] = res[2] = false;
}
function getTokensIn() public view override returns (address[] memory res) {
res = new address[](6);
res[0] = NATIVE;
res[1] = WETH;
res[2] = WA_WETH;
res[3] = BB_A_WETH;
res[4] = SWETH;
res[5] = LP;
}
function getTokensOut() public view override returns (address[] memory res) {
return getTokensIn();
}
function isValidTokenIn(address token) public view override returns (bool) {
return (token == NATIVE ||
token == WETH ||
token == WA_WETH ||
token == BB_A_WETH ||
token == SWETH ||
token == LP);
}
function isValidTokenOut(address token) public view override returns (bool) {
return isValidTokenIn(token);
}
}
文件 7 的 97：AuraVethWethSY.sol
pragma solidity 0.8.17;
import "@pendle/core-v2/contracts/core/StandardizedYield/implementations/BalancerStable/base/PendleAuraBalancerStableLPSYV2.sol";
import "@pendle/core-v2/contracts/core/StandardizedYield/implementations/BalancerStable/base/ComposableStable/ComposableStablePreview.sol";
contract AuraWethVethSY is PendleAuraBalancerStableLPSYV2 {
address internal constant VETH = 0x4Bc3263Eb5bb2Ef7Ad9aB6FB68be80E43b43801F;
address internal constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
uint256 internal constant AURA_PID = 147;
address internal constant LP = 0xB54E6AADBF1ac1a3EF2A56E358706F0f8E320a03;
address internal constant COMPOSABLE_PREVIEW = 0x4239Ddd3c50463383670E86c119220849BFaF64a;
bool internal constant NO_TOKENS_EXEMPT = true;
bool internal constant ALL_TOKENS_EXEMPT = false;
constructor(
string memory _name,
string memory _symbol
)
PendleAuraBalancerStableLPSYV2(
_name,
_symbol,
LP,
AURA_PID,
ComposableStablePreview(COMPOSABLE_PREVIEW)
)
{
}
function _deposit(
address tokenIn,
uint256 amount
) internal virtual override returns (uint256 amountSharesOut) {
if (tokenIn == NATIVE) {
IWETH(WETH).deposit{ value: amount }();
amountSharesOut = super._deposit(WETH, amount);
} else {
amountSharesOut = super._deposit(tokenIn, amount);
}
}
function _redeem(
address receiver,
address tokenOut,
uint256 amountSharesToRedeem
) internal virtual override returns (uint256) {
if (tokenOut == NATIVE) {
uint256 amountTokenOut = super._redeem(address(this), WETH, amountSharesToRedeem);
IWETH(WETH).withdraw(amountTokenOut);
_transferOut(NATIVE, receiver, amountTokenOut);
return amountTokenOut;
} else {
return super._redeem(receiver, tokenOut, amountSharesToRedeem);
}
}
function _previewDeposit(
address tokenIn,
uint256 amountTokenToDeposit
) internal view virtual override returns (uint256 amountSharesOut) {
if (tokenIn == NATIVE) {
amountSharesOut = super._previewDeposit(WETH, amountTokenToDeposit);
} else {
amountSharesOut = super._previewDeposit(tokenIn, amountTokenToDeposit);
}
}
function _previewRedeem(
address tokenOut,
uint256 amountSharesToRedeem
) internal view virtual override returns (uint256 amountTokenOut) {
if (tokenOut == NATIVE) {
amountTokenOut = super._previewRedeem(WETH, amountSharesToRedeem);
} else {
amountTokenOut = super._previewRedeem(tokenOut, amountSharesToRedeem);
}
}
function _getImmutablePoolData() internal pure override returns (bytes memory ret) {
ComposableStablePreview.ImmutableData memory res;
res.poolTokens = _getPoolTokenAddresses();
res.rateProviders = _getRateProviders();
res.rawScalingFactors = _getRawScalingFactors();
res.isExemptFromYieldProtocolFee = _getExemption();
res.LP = LP;
res.noTokensExempt = NO_TOKENS_EXEMPT;
res.allTokensExempt = ALL_TOKENS_EXEMPT;
res.bptIndex = _getBPTIndex();
res.totalTokens = res.poolTokens.length;
return abi.encode(res);
}
function _getPoolTokenAddresses() internal pure override returns (address[] memory res) {
res = new address[](3);
res[0] = VETH;
res[1] = LP;
res[2] = WETH;
}
function _getBPTIndex() internal pure override returns (uint256) {
return 1;
}
function _getRateProviders() internal pure returns (address[] memory res) {
res = new address[](3);
res[0] = 0x12589A727aeFAc3fbE5025F890f1CB97c269BEc2;
res[1] = 0x0000000000000000000000000000000000000000;
res[2] = 0x0000000000000000000000000000000000000000;
}
function _getRawScalingFactors() internal pure returns (uint256[] memory res) {
res = new uint256[](3);
res[0] = res[1] = res[2] = 1e18;
}
function _getExemption() internal pure returns (bool[] memory res) {
res = new bool[](3);
res[0] = res[1] = res[2] = false;
}
function getTokensIn() public view virtual override returns (address[] memory res) {
res = new address[](4);
res[0] = LP;
res[1] = WETH;
res[2] = VETH;
res[3] = NATIVE;
}
function getTokensOut() public view virtual override returns (address[] memory res) {
return getTokensIn();
}
function isValidTokenIn(address token) public view virtual override returns (bool) {
return (token == LP || token == WETH || token == VETH || token == NATIVE);
}
function isValidTokenOut(address token) public view virtual override returns (bool) {
return isValidTokenIn(token);
}
}文件 8 的 97：BaseSplitCodeFactory.sol
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/Create2.sol";
library CodeDeployer {
bytes32 private constant _DEPLOYER_CREATION_CODE =
0x602038038060206000396000f3fefefefefefefefefefefefefefefefefefefe;
function deploy(bytes memory code) internal returns (address destination) {
bytes32 deployerCreationCode = _DEPLOYER_CREATION_CODE;
assembly {
let codeLength := mload(code)
mstore(code, deployerCreationCode)
destination := create(0, code, add(codeLength, 32))
mstore(code, codeLength)
}
require(destination != address(0), "DEPLOYMENT_FAILED_BALANCER");
}
}
library BaseSplitCodeFactory {
function setCreationCode(
bytes memory creationCode
)
internal
returns (
address creationCodeContractA,
uint256 creationCodeSizeA,
address creationCodeContractB,
uint256 creationCodeSizeB
)
{
unchecked {
require(creationCode.length > 0, "zero length");
uint256 creationCodeSize = creationCode.length;
creationCodeSizeA = creationCodeSize / 2;
creationCodeSizeB = creationCodeSize - creationCodeSizeA;
bytes memory creationCodeA;
assembly {
creationCodeA := creationCode
mstore(creationCodeA, creationCodeSizeA)
}
creationCodeContractA = CodeDeployer.deploy(creationCodeA);
bytes memory creationCodeB;
bytes32 lastByteA;
assembly {
creationCodeB := add(creationCode, creationCodeSizeA)
lastByteA := mload(creationCodeB)
mstore(creationCodeB, creationCodeSizeB)
}
creationCodeContractB = CodeDeployer.deploy(creationCodeB);
assembly {
mstore(creationCodeA, creationCodeSize)
mstore(creationCodeB, lastByteA)
}
}
}
function getCreationCode(
address creationCodeContractA,
uint256 creationCodeSizeA,
address creationCodeContractB,
uint256 creationCodeSizeB
) internal view returns (bytes memory) {
return
_getCreationCodeWithArgs(
"",
creationCodeContractA,
creationCodeSizeA,
creationCodeContractB,
creationCodeSizeB
);
}
function _getCreationCodeWithArgs(
bytes memory constructorArgs,
address creationCodeContractA,
uint256 creationCodeSizeA,
address creationCodeContractB,
uint256 creationCodeSizeB
) private view returns (bytes memory code) {
unchecked {
uint256 creationCodeSize = creationCodeSizeA + creationCodeSizeB;
uint256 constructorArgsSize = constructorArgs.length;
uint256 codeSize = creationCodeSize + constructorArgsSize;
assembly {
code := mload(0x40)
mstore(0x40, add(code, add(codeSize, 32)))
mstore(code, codeSize)
let dataStart := add(code, 32)
extcodecopy(creationCodeContractA, dataStart, 0, creationCodeSizeA)
extcodecopy(
creationCodeContractB,
add(dataStart, creationCodeSizeA),
0,
creationCodeSizeB
)
}
uint256 constructorArgsDataPtr;
uint256 constructorArgsCodeDataPtr;
assembly {
constructorArgsDataPtr := add(constructorArgs, 32)
constructorArgsCodeDataPtr := add(add(code, 32), creationCodeSize)
}
_memcpy(constructorArgsCodeDataPtr, constructorArgsDataPtr, constructorArgsSize);
}
}
function _create2(
uint256 amount,
bytes32 salt,
bytes memory constructorArgs,
address creationCodeContractA,
uint256 creationCodeSizeA,
address creationCodeContractB,
uint256 creationCodeSizeB
) internal returns (address) {
unchecked {
bytes memory creationCode = _getCreationCodeWithArgs(
constructorArgs,
creationCodeContractA,
creationCodeSizeA,
creationCodeContractB,
creationCodeSizeB
);
return Create2.deploy(amount, salt, creationCode);
}
}
function _memcpy(uint256 dest, uint256 src, uint256 len) private pure {
unchecked {
for (; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
}
dest += 32;
src += 32;
}
uint256 mask = 256 ** (32 - len) - 1;
assembly {
let srcpart := and(mload(src), not(mask))
let destpart := and(mload(dest), mask)
mstore(dest, or(destpart, srcpart))
}
}
}
}
文件 9 的 97：BbAPoolHelper.sol
pragma solidity ^0.8.0;
import "../../../../../libraries/TokenHelper.sol";
import "../../../../../../interfaces/Balancer/IVault.sol";
import "./LinearPreview.sol";
abstract contract BbAPoolHelper is TokenHelper {
address private constant BALANCER_VAULT = 0xBA12222222228d8Ba445958a75a0704d566BF2C8;
bytes private constant EMPTY_BYTES = abi.encode();
LinearPreview public immutable linearPreviewHelper;
constructor(LinearPreview _linearPreviewHelper) {
linearPreviewHelper = _linearPreviewHelper;
}
function _safeApproveInfVault(address token) internal {
_safeApproveInf(token, BALANCER_VAULT);
}
function joinExitPool(
address receiver,
bytes32 poolId,
address tokenIn,
address tokenOut,
uint256 amountIn
) internal returns (uint256 amountOut) {
return
IVault(BALANCER_VAULT).swap{ value: (tokenIn == NATIVE ? amountIn : 0) }(
IVault.SingleSwap({
poolId: poolId,
kind: IVault.SwapKind.GIVEN_IN,
assetIn: IAsset(tokenIn),
assetOut: IAsset(tokenOut),
amount: amountIn,
userData: EMPTY_BYTES
}),
IVault.FundManagement({
sender: address(this),
fromInternalBalance: false,
recipient: payable(receiver),
toInternalBalance: false
}),
0,
block.timestamp
);
}
}
abstract contract BbAWethHelper is BbAPoolHelper {
address internal constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address internal immutable BB_A_WETH;
bytes32 internal immutable BB_A_WETH_POOL_ID;
address internal immutable WA_WETH;
constructor(
LinearPreview _linearPreviewHelper,
address _bbAWeth,
bytes32 _bbAWethPoolId,
address _waWeth
) BbAPoolHelper(_linearPreviewHelper) {
BB_A_WETH = _bbAWeth;
BB_A_WETH_POOL_ID = _bbAWethPoolId;
WA_WETH = _waWeth;
_safeApproveInfVault(WETH);
_safeApproveInfVault(WA_WETH);
}
function _depositBbAWeth(
address tokenIn,
uint256 amountDep
) internal virtual returns (uint256 amountOut) {
amountOut = joinExitPool(address(this), BB_A_WETH_POOL_ID, tokenIn, BB_A_WETH, amountDep);
}
function _redeemBbAWeth(
address receiver,
address tokenOut,
uint256 amountRedeem
) internal virtual returns (uint256 amountTokenOut) {
amountTokenOut = joinExitPool(
receiver,
BB_A_WETH_POOL_ID,
BB_A_WETH,
tokenOut,
amountRedeem
);
}
function _previewDepositBbAWeth(
address tokenIn,
uint256 amountDep
) internal view virtual returns (uint256 amountOut) {
return
linearPreviewHelper.joinExitPoolPreview(
BB_A_WETH_POOL_ID,
tokenIn == NATIVE ? WETH : tokenIn,
BB_A_WETH,
amountDep
);
}
function _previewRedeemBbAWeth(
address tokenOut,
uint256 amountRedeem
) internal view returns (uint256 amountOut) {
return
linearPreviewHelper.joinExitPoolPreview(
BB_A_WETH_POOL_ID,
BB_A_WETH,
tokenOut == NATIVE ? WETH : tokenOut,
amountRedeem
);
}
}
文件 10 的 97：BoringOwnableUpgradeable.sol
pragma solidity ^0.8.0;
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
contract BoringOwnableUpgradeableData {
address public owner;
address public pendingOwner;
}
abstract contract BoringOwnableUpgradeable is BoringOwnableUpgradeableData, Initializable {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function __BoringOwnable_init() internal onlyInitializing {
owner = msg.sender;
}
function transferOwnership(address newOwner, bool direct, bool renounce) public onlyOwner {
if (direct) {
require(newOwner != address(0) || renounce, "Ownable: zero address");
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
pendingOwner = address(0);
} else {
pendingOwner = newOwner;
}
}
function claimOwnership() public {
address _pendingOwner = pendingOwner;
require(msg.sender == _pendingOwner, "Ownable: caller != pending owner");
emit OwnershipTransferred(owner, _pendingOwner);
owner = _pendingOwner;
pendingOwner = address(0);
}
modifier onlyOwner() {
require(msg.sender == owner, "Ownable: caller is not the owner");
_;
}
uint256[48] private __gap;
}
文件 11 的 97：BulkSellerMathCore.sol
pragma solidity ^0.8.0;
import "../libraries/TokenHelper.sol";
import "../libraries/math/PMath.sol";
import "../libraries/Errors.sol";
struct BulkSellerState {
uint256 rateTokenToSy;
uint256 rateSyToToken;
uint256 totalToken;
uint256 totalSy;
uint256 feeRate;
}
library BulkSellerMathCore {
using PMath for uint256;
function swapExactTokenForSy(
BulkSellerState memory state,
uint256 netTokenIn
) internal pure returns (uint256 netSyOut) {
netSyOut = calcSwapExactTokenForSy(state, netTokenIn);
state.totalToken += netTokenIn;
state.totalSy -= netSyOut;
}
function swapExactSyForToken(
BulkSellerState memory state,
uint256 netSyIn
) internal pure returns (uint256 netTokenOut) {
netTokenOut = calcSwapExactSyForToken(state, netSyIn);
state.totalSy += netSyIn;
state.totalToken -= netTokenOut;
}
function calcSwapExactTokenForSy(
BulkSellerState memory state,
uint256 netTokenIn
) internal pure returns (uint256 netSyOut) {
uint256 postFeeRate = state.rateTokenToSy.mulDown(PMath.ONE - state.feeRate);
assert(postFeeRate != 0);
netSyOut = netTokenIn.mulDown(postFeeRate);
if (netSyOut > state.totalSy)
revert Errors.BulkInsufficientSyForTrade(state.totalSy, netSyOut);
}
function calcSwapExactSyForToken(
BulkSellerState memory state,
uint256 netSyIn
) internal pure returns (uint256 netTokenOut) {
uint256 postFeeRate = state.rateSyToToken.mulDown(PMath.ONE - state.feeRate);
assert(postFeeRate != 0);
netTokenOut = netSyIn.mulDown(postFeeRate);
if (netTokenOut > state.totalToken)
revert Errors.BulkInsufficientTokenForTrade(state.totalToken, netTokenOut);
}
function getTokenProp(BulkSellerState memory state) internal pure returns (uint256) {
uint256 totalToken = state.totalToken;
uint256 totalTokenFromSy = state.totalSy.mulDown(state.rateSyToToken);
return totalToken.divDown(totalToken + totalTokenFromSy);
}
function getReBalanceParams(
BulkSellerState memory state,
uint256 targetTokenProp
) internal pure returns (uint256 netTokenToDeposit, uint256 netSyToRedeem) {
uint256 currentTokenProp = getTokenProp(state);
if (currentTokenProp > targetTokenProp) {
netTokenToDeposit = state
.totalToken
.mulDown(currentTokenProp - targetTokenProp)
.divDown(currentTokenProp);
} else {
uint256 currentSyProp = PMath.ONE - currentTokenProp;
netSyToRedeem = state.totalSy.mulDown(targetTokenProp - currentTokenProp).divDown(
currentSyProp
);
}
}
function reBalanceTokenToSy(
BulkSellerState memory state,
uint256 netTokenToDeposit,
uint256 netSyFromToken,
uint256 maxDiff
) internal pure {
uint256 rate = netSyFromToken.divDown(netTokenToDeposit);
if (!PMath.isAApproxB(rate, state.rateTokenToSy, maxDiff))
revert Errors.BulkBadRateTokenToSy(rate, state.rateTokenToSy, maxDiff);
state.totalToken -= netTokenToDeposit;
state.totalSy += netSyFromToken;
}
function reBalanceSyToToken(
BulkSellerState memory state,
uint256 netSyToRedeem,
uint256 netTokenFromSy,
uint256 maxDiff
) internal pure {
uint256 rate = netTokenFromSy.divDown(netSyToRedeem);
if (!PMath.isAApproxB(rate, state.rateSyToToken, maxDiff))
revert Errors.BulkBadRateSyToToken(rate, state.rateSyToToken, maxDiff);
state.totalToken += netTokenFromSy;
state.totalSy -= netSyToRedeem;
}
function setRate(
BulkSellerState memory state,
uint256 rateSyToToken,
uint256 rateTokenToSy,
uint256 maxDiff
) internal pure {
if (
state.rateTokenToSy != 0 &&
!PMath.isAApproxB(rateTokenToSy, state.rateTokenToSy, maxDiff)
) {
revert Errors.BulkBadRateTokenToSy(rateTokenToSy, state.rateTokenToSy, maxDiff);
}
if (
state.rateSyToToken != 0 &&
!PMath.isAApproxB(rateSyToToken, state.rateSyToToken, maxDiff)
) {
revert Errors.BulkBadRateSyToToken(rateSyToToken, state.rateSyToToken, maxDiff);
}
state.rateTokenToSy = rateTokenToSy;
state.rateSyToToken = rateSyToToken;
}
}
文件 12 的 97：ComposableStablePreview.sol
pragma solidity ^0.8.0;
import "../StablePreviewBase.sol";
abstract contract ComposableStablePreview is StablePreviewBase {
struct ImmutableData {
address[] poolTokens;
address[] rateProviders;
uint256[] rawScalingFactors;
bool[] isExemptFromYieldProtocolFee;
address LP;
bool noTokensExempt;
bool allTokensExempt;
uint256 bptIndex;
uint256 totalTokens;
}
struct TokenRateCache {
uint256 currentRate;
uint256 oldRate;
}
}
文件 13 的 97：Counters.sol
pragma solidity ^0.8.0;
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;
}
}
文件 14 的 97：Create2.sol
pragma solidity ^0.8.0;
library Create2 {
function deploy(
uint256 amount,
bytes32 salt,
bytes memory bytecode
) internal returns (address) {
address addr;
require(address(this).balance >= amount, "Create2: insufficient balance");
require(bytecode.length != 0, "Create2: bytecode length is zero");
assembly {
addr := create2(amount, add(bytecode, 0x20), mload(bytecode), salt)
}
require(addr != address(0), "Create2: Failed on deploy");
return addr;
}
function computeAddress(bytes32 salt, bytes32 bytecodeHash) internal view returns (address) {
return computeAddress(salt, bytecodeHash, address(this));
}
function computeAddress(
bytes32 salt,
bytes32 bytecodeHash,
address deployer
) internal pure returns (address) {
bytes32 _data = keccak256(abi.encodePacked(bytes1(0xff), deployer, salt, bytecodeHash));
return address(uint160(uint256(_data)));
}
}
文件 15 的 97：ECDSA.sol
pragma solidity ^0.8.0;
import "../Strings.sol";
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");
} else if (error == RecoverError.InvalidSignatureV) {
revert("ECDSA: invalid signature 'v' 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);
}
if (v != 27 && v != 28) {
return (address(0), RecoverError.InvalidSignatureV);
}
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));
}
}
文件 16 的 97：EPendleSY.sol
pragma solidity 0.8.17;
import "@pendle/core-v2/contracts/core/StandardizedYield/SYBaseWithRewards.sol";
import "./interfaces/IWNative.sol";
import "./interfaces/ISmartConvertor.sol";
import "./interfaces/IBaseRewardPool.sol";
import "./interfaces/IBalancerVault.sol";
contract EPendleSY is SYBaseWithRewards {
using SafeERC20 for IERC20;
address public immutable pendle;
address public immutable ePendle;
address public immutable eqb;
address public immutable xEqb;
address public immutable weth;
IBaseRewardPool public immutable ePendleRewardPool;
address public immutable balancerVault;
bytes32 public immutable balancerWethPendlePoolId;
ISmartConvertor public immutable smartConvertor;
constructor(
string memory _name,
string memory _symbol,
address _ePendle,
address _pendle,
address _eqb,
address _xEqb,
address _weth,
address _ePendleRewardPool,
address _smartConvertor,
address _balancerVault,
bytes32 _balancerWethPendlePoolId
) SYBaseWithRewards(_name, _symbol, _ePendle) {
pendle = _pendle;
ePendle = _ePendle;
eqb = _eqb;
xEqb = _xEqb;
weth = _weth;
ePendleRewardPool = IBaseRewardPool(_ePendleRewardPool);
smartConvertor = ISmartConvertor(_smartConvertor);
balancerVault = _balancerVault;
balancerWethPendlePoolId = _balancerWethPendlePoolId;
_safeApproveInf(ePendle, _ePendleRewardPool);
_safeApproveInf(pendle, _smartConvertor);
_safeApproveInf(ePendle, _smartConvertor);
}
function _deposit(
address tokenIn,
uint256 amountToDeposit
) internal virtual override returns (uint256 amountSharesOut) {
_harvest();
uint256 pendleTotalBalance = _selfBalance(pendle);
uint256 ePendleReceived = 0;
if (tokenIn == pendle) {
uint256 ePendleConverted = smartConvertor.deposit(
pendleTotalBalance
);
ePendleReceived =
(ePendleConverted * amountToDeposit) /
pendleTotalBalance;
} else if (tokenIn == ePendle) {
ePendleReceived = amountToDeposit;
if (pendleTotalBalance > 0) {
smartConvertor.deposit(pendleTotalBalance);
}
}
ePendleRewardPool.stake(_selfBalance(ePendle));
amountSharesOut = _calcSharesOut(
ePendleReceived,
totalSupply(),
getTotalAssetOwned() - ePendleReceived
);
}
function _redeem(
address receiver,
address tokenOut,
uint256 amountSharesToRedeem
) internal virtual override returns (uint256 amountTokenOut) {
_harvestAndCompound();
uint256 totalAsset = getTotalAssetOwned();
uint256 priorTotalSupply = totalSupply() + amountSharesToRedeem;
amountTokenOut = (amountSharesToRedeem * totalAsset) / priorTotalSupply;
ePendleRewardPool.withdraw(amountTokenOut);
if (tokenOut == ePendle) {
_transferOut(tokenOut, receiver, amountTokenOut);
} else if (tokenOut == pendle) {
amountTokenOut = smartConvertor.swapEPendleForPendle(
amountTokenOut,
0,
receiver
);
}
}
function exchangeRate() public view virtual override returns (uint256) {
return (getTotalAssetOwned() * 1e18) / totalSupply();
}
function getTotalAssetOwned()
public
view
returns (uint256 totalAssetOwned)
{
totalAssetOwned =
ePendleRewardPool.balanceOf(address(this)) +
_selfBalance(ePendle);
}
function _swapWETH2Pendle(uint256 _amount) internal returns (uint256) {
if (_amount == 0) {
return _amount;
}
IBalancerVault.SingleSwap memory singleSwap;
singleSwap.poolId = balancerWethPendlePoolId;
singleSwap.kind = IBalancerVault.SwapKind.GIVEN_IN;
singleSwap.assetIn = IAsset(weth);
singleSwap.assetOut = IAsset(pendle);
singleSwap.amount = _amount;
IBalancerVault.FundManagement memory funds;
funds.sender = address(this);
funds.fromInternalBalance = false;
funds.recipient = payable(address(this));
funds.toInternalBalance = false;
IERC20(weth).safeApprove(balancerVault, _amount);
return
IBalancerVault(balancerVault).swap(
singleSwap,
funds,
0,
block.timestamp
);
}
function _harvestAndCompound() internal {
_harvest();
uint256 pendleAmount = _selfBalance(pendle);
if (pendleAmount > 0) {
smartConvertor.deposit(pendleAmount);
ePendleRewardPool.stake(_selfBalance(ePendle));
}
}
function _harvest() internal {
ePendleRewardPool.getReward(address(this));
uint256 ethBalance = address(this).balance;
if (ethBalance > 0) {
IWNative(weth).deposit{value: ethBalance}();
}
_swapWETH2Pendle(_selfBalance(weth));
}
function _getRewardTokens()
internal
view
override
returns (address[] memory res)
{
res = new address[](2);
res[0] = eqb;
res[1] = xEqb;
}
function _redeemExternalReward() internal override {
_harvestAndCompound();
}
function _previewDeposit(
address tokenIn,
uint256 amountTokenToDeposit
) internal view override returns (uint256 amountSharesOut) {
if (amountTokenToDeposit == 0) {
return 0;
}
uint256 totalAsset = getTotalAssetOwned();
if (tokenIn == ePendle) {
amountSharesOut = _calcSharesOut(
amountTokenToDeposit,
totalSupply(),
totalAsset
);
} else if (tokenIn == pendle) {
amountSharesOut = _calcSharesOut(
smartConvertor.previewAmountOut(pendle, amountTokenToDeposit),
totalSupply(),
totalAsset
);
}
}
function _previewRedeem(
address tokenOut,
uint256 amountSharesToRedeem
) internal view override returns (uint256 amountTokenOut) {
if (amountSharesToRedeem == 0) {
return 0;
}
uint256 totalAsset = getTotalAssetOwned();
uint256 ePendleOut = (amountSharesToRedeem * totalAsset) /
totalSupply();
if (tokenOut == ePendle) {
amountTokenOut = ePendleOut;
} else if (tokenOut == pendle) {
amountTokenOut = smartConvertor.previewAmountOut(
ePendle,
ePendleOut
);
}
}
function _calcSharesOut(
uint256 _ePendleReceived,
uint256 _totalSupply,
uint256 _totalAssetPrior
) internal view virtual returns (uint256) {
if (_totalAssetPrior == 0 || _totalSupply == 0) {
return _ePendleReceived;
} else {
return (_ePendleReceived * _totalSupply) / _totalAssetPrior;
}
}
function assetInfo()
external
view
returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
{
return (AssetType.TOKEN, ePendle, IERC20Metadata(ePendle).decimals());
}
function getTokensIn()
public
view
virtual
override
returns (address[] memory res)
{
res = new address[](2);
res[0] = pendle;
res[1] = ePendle;
}
function getTokensOut()
public
view
virtual
override
returns (address[] memory res)
{
res = getTokensIn();
}
function isValidTokenIn(
address token
) public view virtual override returns (bool) {
return token == ePendle || token == pendle;
}
function isValidTokenOut(
address token
) public view virtual override returns (bool) {
return token == ePendle || token == pendle;
}
}
文件 17 的 97：ERC1967Upgrade.sol
pragma solidity ^0.8.2;
import "../beacon/IBeacon.sol";
import "../../interfaces/draft-IERC1822.sol";
import "../../utils/Address.sol";
import "../../utils/StorageSlot.sol";
abstract contract ERC1967Upgrade {
bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;
bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
event Upgraded(address indexed implementation);
function _getImplementation() internal view returns (address) {
return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
}
function _setImplementation(address newImplementation) private {
require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
}
function _upgradeTo(address newImplementation) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
}
function _upgradeToAndCall(
address newImplementation,
bytes memory data,
bool forceCall
) internal {
_upgradeTo(newImplementation);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(newImplementation, data);
}
}
function _upgradeToAndCallUUPS(
address newImplementation,
bytes memory data,
bool forceCall
) internal {
if (StorageSlot.getBooleanSlot(_ROLLBACK_SLOT).value) {
_setImplementation(newImplementation);
} else {
try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {
require(slot == _IMPLEMENTATION_SLOT, "ERC1967Upgrade: unsupported proxiableUUID");
} catch {
revert("ERC1967Upgrade: new implementation is not UUPS");
}
_upgradeToAndCall(newImplementation, data, forceCall);
}
}
bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
event AdminChanged(address previousAdmin, address newAdmin);
function _getAdmin() internal view returns (address) {
return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;
}
function _setAdmin(address newAdmin) private {
require(newAdmin != address(0), "ERC1967: new admin is the zero address");
StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
}
function _changeAdmin(address newAdmin) internal {
emit AdminChanged(_getAdmin(), newAdmin);
_setAdmin(newAdmin);
}
bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;
event BeaconUpgraded(address indexed beacon);
function _getBeacon() internal view returns (address) {
return StorageSlot.getAddressSlot(_BEACON_SLOT).value;
}
function _setBeacon(address newBeacon) private {
require(Address.isContract(newBeacon), "ERC1967: new beacon is not a contract");
require(
Address.isContract(IBeacon(newBeacon).implementation()),
"ERC1967: beacon implementation is not a contract"
);
StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;
}
function _upgradeBeaconToAndCall(
address newBeacon,
bytes memory data,
bool forceCall
) internal {
_setBeacon(newBeacon);
emit BeaconUpgraded(newBeacon);
if (data.length > 0 || forceCall) {
Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);
}
}
}
文件 18 的 97：ERC20.sol
pragma solidity ^0.8.0;
import "./IERC20.sol";
import "./extensions/IERC20Metadata.sol";
import "../../utils/Context.sol";
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
}
_balances[to] += amount;
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
_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 {}
}
文件 19 的 97：ETHXSY.sol
pragma solidity 0.8.17;
import "@pendle/core-v2/contracts/core/StandardizedYield/SYBase.sol";
import "@pendle/core-v2/contracts/core/libraries/ArrayLib.sol";
interface IStaderStakeManager {
function deposit(address _receiver) external payable returns (uint256);
function previewDeposit(uint256 _assets) external view returns (uint256);
function previewWithdraw(uint256 _shares) external view returns (uint256);
function getExchangeRate() external view returns (uint256);
function maxDeposit() external view returns (uint256);
function minDeposit() external view returns (uint256);
}
contract ETHXSY is SYBase {
using PMath for uint256;
error StaderMaxDepositExceed(uint256 amountToDeposit, uint256 maxDeposit);
error StaderMinDepositUnreached(uint256 amountToDeposit, uint256 minDeposit);
address public immutable stakeManager;
address public immutable ethx;
constructor(
address _stakeManager,
address _ethx
) SYBase("SY Stader Staking ETHx", "SY-ETHx", _ethx) {
stakeManager = _stakeManager;
ethx = _ethx;
}
function _deposit(
address tokenIn,
uint256 amountDeposited
) internal virtual override returns (uint256 ) {
if (tokenIn == NATIVE) {
return
IStaderStakeManager(stakeManager).deposit{ value: amountDeposited }(address(this));
} else {
return amountDeposited;
}
}
function _redeem(
address receiver,
address ,
uint256 amountSharesToRedeem
) internal virtual override returns (uint256 ) {
_transferOut(ethx, receiver, amountSharesToRedeem);
return amountSharesToRedeem;
}
function exchangeRate() public view virtual override returns (uint256) {
return IStaderStakeManager(stakeManager).getExchangeRate();
}
function _previewDeposit(
address tokenIn,
uint256 amountTokenToDeposit
) internal view override returns (uint256 ) {
if (tokenIn == NATIVE) {
uint256 maxDeposit = IStaderStakeManager(stakeManager).maxDeposit();
uint256 minDeposit = IStaderStakeManager(stakeManager).minDeposit();
if (amountTokenToDeposit > maxDeposit) {
revert StaderMaxDepositExceed(amountTokenToDeposit, maxDeposit);
}
if (amountTokenToDeposit < minDeposit) {
revert StaderMinDepositUnreached(amountTokenToDeposit, minDeposit);
}
return IStaderStakeManager(stakeManager).previewDeposit(amountTokenToDeposit);
} else {
return amountTokenToDeposit;
}
}
function _previewRedeem(
address ,
uint256 amountSharesToRedeem
) internal pure override returns (uint256 ) {
return amountSharesToRedeem;
}
function getTokensIn() public view virtual override returns (address[] memory) {
return ArrayLib.create(NATIVE, ethx);
}
function getTokensOut() public view virtual override returns (address[] memory) {
return ArrayLib.create(ethx);
}
function isValidTokenIn(address token) public view virtual override returns (bool) {
return token == ethx || token == NATIVE;
}
function isValidTokenOut(address token) public view virtual override returns (bool) {
return token == ethx;
}
function assetInfo()
external
pure
returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
{
return (AssetType.TOKEN, NATIVE, 18);
}
}
文件 20 的 97：EnumerableSet.sol
pragma solidity ^0.8.0;
library EnumerableSet {
struct Set {
bytes32[] _values;
mapping(bytes32 => uint256) _indexes;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
set._indexes[value] = set._values.length;
return true;
} else {
return false;
}
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
uint256 valueIndex = set._indexes[value];
if (valueIndex != 0) {
uint256 toDeleteIndex = valueIndex - 1;
uint256 lastIndex = set._values.length - 1;
if (lastIndex != toDeleteIndex) {
bytes32 lastValue = set._values[lastIndex];
set._values[toDeleteIndex] = lastValue;
set._indexes[lastValue] = valueIndex;
}
set._values.pop();
delete set._indexes[value];
return true;
} else {
return false;
}
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._indexes[value] != 0;
}
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
return set._values[index];
}
function _values(Set storage set) private view returns (bytes32[] memory) {
return set._values;
}
struct Bytes32Set {
Set _inner;
}
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
return _values(set._inner);
}
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(uint160(value))));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(uint160(value))));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(uint160(value))));
}
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint160(uint256(_at(set._inner, index))));
}
function values(AddressSet storage set) internal view returns (address[] memory) {
bytes32[] memory store = _values(set._inner);
address[] memory result;
assembly {
result := store
}
return result;
}
struct UintSet {
Set _inner;
}
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
function values(UintSet storage set) internal view returns (uint256[] memory) {
bytes32[] memory store = _values(set._inner);
uint256[] memory result;
assembly {
result := store
}
return result;
}
}
文件 21 的 97：Errors.sol
pragma solidity ^0.8.0;
library Errors {
error BulkInsufficientSyForTrade(uint256 currentAmount, uint256 requiredAmount);
error BulkInsufficientTokenForTrade(uint256 currentAmount, uint256 requiredAmount);
error BulkInSufficientSyOut(uint256 actualSyOut, uint256 requiredSyOut);
error BulkInSufficientTokenOut(uint256 actualTokenOut, uint256 requiredTokenOut);
error BulkInsufficientSyReceived(uint256 actualBalance, uint256 requiredBalance);
error BulkNotMaintainer();
error BulkNotAdmin();
error BulkSellerAlreadyExisted(address token, address SY, address bulk);
error BulkSellerInvalidToken(address token, address SY);
error BulkBadRateTokenToSy(uint256 actualRate, uint256 currentRate, uint256 eps);
error BulkBadRateSyToToken(uint256 actualRate, uint256 currentRate, uint256 eps);
error ApproxFail();
error ApproxParamsInvalid(uint256 guessMin, uint256 guessMax, uint256 eps);
error ApproxBinarySearchInputInvalid(
uint256 approxGuessMin,
uint256 approxGuessMax,
uint256 minGuessMin,
uint256 maxGuessMax
);
error MarketExpired();
error MarketZeroAmountsInput();
error MarketZeroAmountsOutput();
error MarketZeroLnImpliedRate();
error MarketInsufficientPtForTrade(int256 currentAmount, int256 requiredAmount);
error MarketInsufficientPtReceived(uint256 actualBalance, uint256 requiredBalance);
error MarketInsufficientSyReceived(uint256 actualBalance, uint256 requiredBalance);
error MarketZeroTotalPtOrTotalAsset(int256 totalPt, int256 totalAsset);
error MarketExchangeRateBelowOne(int256 exchangeRate);
error MarketProportionMustNotEqualOne();
error MarketRateScalarBelowZero(int256 rateScalar);
error MarketScalarRootBelowZero(int256 scalarRoot);
error MarketProportionTooHigh(int256 proportion, int256 maxProportion);
error OracleUninitialized();
error OracleTargetTooOld(uint32 target, uint32 oldest);
error OracleZeroCardinality();
error MarketFactoryExpiredPt();
error MarketFactoryInvalidPt();
error MarketFactoryMarketExists();
error MarketFactoryLnFeeRateRootTooHigh(uint80 lnFeeRateRoot, uint256 maxLnFeeRateRoot);
error MarketFactoryReserveFeePercentTooHigh(
uint8 reserveFeePercent,
uint8 maxReserveFeePercent
);
error MarketFactoryZeroTreasury();
error MarketFactoryInitialAnchorTooLow(int256 initialAnchor, int256 minInitialAnchor);
error RouterInsufficientLpOut(uint256 actualLpOut, uint256 requiredLpOut);
error RouterInsufficientSyOut(uint256 actualSyOut, uint256 requiredSyOut);
error RouterInsufficientPtOut(uint256 actualPtOut, uint256 requiredPtOut);
error RouterInsufficientYtOut(uint256 actualYtOut, uint256 requiredYtOut);
error RouterInsufficientPYOut(uint256 actualPYOut, uint256 requiredPYOut);
error RouterInsufficientTokenOut(uint256 actualTokenOut, uint256 requiredTokenOut);
error RouterExceededLimitSyIn(uint256 actualSyIn, uint256 limitSyIn);
error RouterExceededLimitPtIn(uint256 actualPtIn, uint256 limitPtIn);
error RouterExceededLimitYtIn(uint256 actualYtIn, uint256 limitYtIn);
error RouterInsufficientSyRepay(uint256 actualSyRepay, uint256 requiredSyRepay);
error RouterInsufficientPtRepay(uint256 actualPtRepay, uint256 requiredPtRepay);
error RouterNotAllSyUsed(uint256 netSyDesired, uint256 netSyUsed);
error RouterTimeRangeZero();
error RouterCallbackNotPendleMarket(address caller);
error RouterInvalidAction(bytes4 selector);
error RouterInvalidFacet(address facet);
error RouterKyberSwapDataZero();
error YCExpired();
error YCNotExpired();
error YieldContractInsufficientSy(uint256 actualSy, uint256 requiredSy);
error YCNothingToRedeem();
error YCPostExpiryDataNotSet();
error YCNoFloatingSy();
error YCFactoryInvalidExpiry();
error YCFactoryYieldContractExisted();
error YCFactoryZeroExpiryDivisor();
error YCFactoryZeroTreasury();
error YCFactoryInterestFeeRateTooHigh(uint256 interestFeeRate, uint256 maxInterestFeeRate);
error YCFactoryRewardFeeRateTooHigh(uint256 newRewardFeeRate, uint256 maxRewardFeeRate);
error SYInvalidTokenIn(address token);
error SYInvalidTokenOut(address token);
error SYZeroDeposit();
error SYZeroRedeem();
error SYInsufficientSharesOut(uint256 actualSharesOut, uint256 requiredSharesOut);
error SYInsufficientTokenOut(uint256 actualTokenOut, uint256 requiredTokenOut);
error SYQiTokenMintFailed(uint256 errCode);
error SYQiTokenRedeemFailed(uint256 errCode);
error SYQiTokenRedeemRewardsFailed(uint256 rewardAccruedType0, uint256 rewardAccruedType1);
error SYQiTokenBorrowRateTooHigh(uint256 borrowRate, uint256 borrowRateMax);
error SYCurveInvalidPid();
error SYCurve3crvPoolNotFound();
error SYApeDepositAmountTooSmall(uint256 amountDeposited);
error SYBalancerInvalidPid();
error SYInvalidRewardToken(address token);
error SYStargateRedeemCapExceeded(uint256 amountLpDesired, uint256 amountLpRedeemable);
error SYBalancerReentrancy();
error NotFromTrustedRemote(uint16 srcChainId, bytes path);
error VCInactivePool(address pool);
error VCPoolAlreadyActive(address pool);
error VCZeroVePendle(address user);
error VCExceededMaxWeight(uint256 totalWeight, uint256 maxWeight);
error VCEpochNotFinalized(uint256 wTime);
error VCPoolAlreadyAddAndRemoved(address pool);
error VEInvalidNewExpiry(uint256 newExpiry);
error VEExceededMaxLockTime();
error VEInsufficientLockTime();
error VENotAllowedReduceExpiry();
error VEZeroAmountLocked();
error VEPositionNotExpired();
error VEZeroPosition();
error VEZeroSlope(uint128 bias, uint128 slope);
error VEReceiveOldSupply(uint256 msgTime);
error GCNotPendleMarket(address caller);
error GCNotVotingController(address caller);
error InvalidWTime(uint256 wTime);
error ExpiryInThePast(uint256 expiry);
error ChainNotSupported(uint256 chainId);
error FDTotalAmountFundedNotMatch(uint256 actualTotalAmount, uint256 expectedTotalAmount);
error FDEpochLengthMismatch();
error FDInvalidPool(address pool);
error FDPoolAlreadyExists(address pool);
error FDInvalidNewFinishedEpoch(uint256 oldFinishedEpoch, uint256 newFinishedEpoch);
error FDInvalidStartEpoch(uint256 startEpoch);
error FDInvalidWTimeFund(uint256 lastFunded, uint256 wTime);
error FDFutureFunding(uint256 lastFunded, uint256 currentWTime);
error BDInvalidEpoch(uint256 epoch, uint256 startTime);
error MsgNotFromSendEndpoint(uint16 srcChainId, bytes path);
error MsgNotFromReceiveEndpoint(address sender);
error InsufficientFeeToSendMsg(uint256 currentFee, uint256 requiredFee);
error ApproxDstExecutionGasNotSet();
error InvalidRetryData();
error ArrayLengthMismatch();
error ArrayEmpty();
error ArrayOutOfBounds();
error ZeroAddress();
error FailedToSendEther();
error InvalidMerkleProof();
error OnlyLayerZeroEndpoint();
error OnlyYT();
error OnlyYCFactory();
error OnlyWhitelisted();
error SAInsufficientTokenIn(address tokenIn, uint256 amountExpected, uint256 amountActual);
error UnsupportedSelector(uint256 aggregatorType, bytes4 selector);
}
文件 22 的 97：ExpiryUtilsLib.sol
pragma solidity ^0.8.0;
library ExpiryUtils {
struct Date {
uint16 year;
uint8 month;
uint8 day;
}
uint256 private constant DAY_IN_SECONDS = 86400;
uint256 private constant YEAR_IN_SECONDS = 31536000;
uint256 private constant LEAP_YEAR_IN_SECONDS = 31622400;
uint16 private constant ORIGIN_YEAR = 1970;
function concat(
string memory _bt,
string memory _yt,
uint256 _expiry,
string memory _delimiter
) internal pure returns (string memory result) {
result = string(
abi.encodePacked(_bt, _delimiter, _yt, _delimiter, toRFC2822String(_expiry))
);
}
function toRFC2822String(uint256 _timestamp) internal pure returns (string memory s) {
Date memory d = parseTimestamp(_timestamp);
string memory day = uintToString(d.day);
string memory month = monthName(d);
string memory year = uintToString(d.year);
s = string(abi.encodePacked(day, month, year));
}
function getDaysInMonth(uint8 _month, uint16 _year) private pure returns (uint8) {
if (
_month == 1 ||
_month == 3 ||
_month == 5 ||
_month == 7 ||
_month == 8 ||
_month == 10 ||
_month == 12
) {
return 31;
} else if (_month == 4 || _month == 6 || _month == 9 || _month == 11) {
return 30;
} else if (isLeapYear(_year)) {
return 29;
} else {
return 28;
}
}
function getYear(uint256 _timestamp) private pure returns (uint16) {
uint256 secondsAccountedFor = 0;
uint16 year;
uint256 numLeapYears;
year = uint16(ORIGIN_YEAR + _timestamp / YEAR_IN_SECONDS);
numLeapYears = leapYearsBefore(year) - leapYearsBefore(ORIGIN_YEAR);
secondsAccountedFor += LEAP_YEAR_IN_SECONDS * numLeapYears;
secondsAccountedFor += YEAR_IN_SECONDS * (year - ORIGIN_YEAR - numLeapYears);
while (secondsAccountedFor > _timestamp) {
if (isLeapYear(uint16(year - 1))) {
secondsAccountedFor -= LEAP_YEAR_IN_SECONDS;
} else {
secondsAccountedFor -= YEAR_IN_SECONDS;
}
year -= 1;
}
return year;
}
function isLeapYear(uint16 _year) private pure returns (bool) {
return ((_year % 4 == 0) && (_year % 100 != 0)) || (_year % 400 == 0);
}
function leapYearsBefore(uint256 _year) private pure returns (uint256) {
_year -= 1;
return _year / 4 - _year / 100 + _year / 400;
}
function monthName(Date memory d) private pure returns (string memory) {
string[12] memory months = [
"JAN",
"FEB",
"MAR",
"APR",
"MAY",
"JUN",
"JUL",
"AUG",
"SEP",
"OCT",
"NOV",
"DEC"
];
return months[d.month - 1];
}
function parseTimestamp(uint256 _timestamp) private pure returns (Date memory d) {
uint256 secondsAccountedFor = 0;
uint256 buf;
uint8 i;
d.year = getYear(_timestamp);
buf = leapYearsBefore(d.year) - leapYearsBefore(ORIGIN_YEAR);
secondsAccountedFor += LEAP_YEAR_IN_SECONDS * buf;
secondsAccountedFor += YEAR_IN_SECONDS * (d.year - ORIGIN_YEAR - buf);
uint256 secondsInMonth;
for (i = 1; i <= 12; i++) {
secondsInMonth = DAY_IN_SECONDS * getDaysInMonth(i, d.year);
if (secondsInMonth + secondsAccountedFor > _timestamp) {
d.month = i;
break;
}
secondsAccountedFor += secondsInMonth;
}
for (i = 1; i <= getDaysInMonth(d.month, d.year); i++) {
if (DAY_IN_SECONDS + secondsAccountedFor > _timestamp) {
d.day = i;
break;
}
secondsAccountedFor += DAY_IN_SECONDS;
}
}
function uintToString(uint256 _i) private pure returns (string memory) {
if (_i == 0) {
return "0";
}
uint256 j = _i;
uint256 len;
while (j != 0) {
len++;
j /= 10;
}
bytes memory bstr = new bytes(len);
uint256 k = len - 1;
while (_i != 0) {
bstr[k] = bytes1(uint8(48 + (_i % 10)));
if (k != 0) k--;
_i /= 10;
}
return string(bstr);
}
}
文件 23 的 97：FixedPoint.sol
pragma solidity ^0.8.0;
library FixedPoint {
uint256 internal constant ONE = 1e18;
uint256 internal constant TWO = 2 * ONE;
uint256 internal constant FOUR = 4 * ONE;
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mulDown(uint256 a, uint256 b) internal pure returns (uint256) {
return (a * b) / ONE;
}
function mulUp(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 product = a * b;
if (product == 0) {
return 0;
} else {
unchecked {
return ((product - 1) / ONE) + 1;
}
}
}
function divDown(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "Zero division");
if (a == 0) {
return 0;
} else {
uint256 aInflated = a * ONE;
return aInflated / b;
}
}
function divUp(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0, "Zero division");
if (a == 0) {
return 0;
} else {
uint256 aInflated = a * ONE;
unchecked {
return ((aInflated - 1) / b) + 1;
}
}
}
function complement(uint256 x) internal pure returns (uint256) {
unchecked {
return (x < ONE) ? (ONE - x) : 0;
}
}
function max(uint256 x, uint256 y) internal pure returns (uint256) {
return (x > y ? x : y);
}
function min(uint256 x, uint256 y) internal pure returns (uint256) {
return (x < y ? x : y);
}
}
文件 24 的 97：IAsset.sol
pragma solidity ^0.8.0;
interface IAsset {}
文件 25 的 97：IBalancerFees.sol
pragma solidity ^0.8.0;
interface IBalancerFees {
function getSwapFeePercentage() external view returns (uint256);
}
文件 26 的 97：IBalancerStablePreview.sol
pragma solidity ^0.8.0;
import "./IVault.sol";
interface IBalancerStablePreview {
function joinPoolPreview(
bytes32 poolId,
address sender,
address recipient,
IVault.JoinPoolRequest memory request,
bytes memory data
) external view returns (uint256 amountBptOut);
function exitPoolPreview(
bytes32 poolId,
address sender,
address recipient,
IVault.ExitPoolRequest memory request,
bytes memory data
) external view returns (uint256 amountTokenOut);
}
文件 27 的 97：IBalancerVault.sol
pragma solidity 0.8.17;
import "./IAsset.sol";
interface IBalancerVault {
enum SwapKind {
GIVEN_IN,
GIVEN_OUT
}
struct SingleSwap {
bytes32 poolId;
SwapKind kind;
IAsset assetIn;
IAsset assetOut;
uint256 amount;
bytes userData;
}
struct FundManagement {
address sender;
bool fromInternalBalance;
address payable recipient;
bool toInternalBalance;
}
struct BatchSwapStep {
bytes32 poolId;
uint256 assetInIndex;
uint256 assetOutIndex;
uint256 amount;
bytes userData;
}
function swap(
SingleSwap memory singleSwap,
FundManagement memory funds,
uint256 limit,
uint256 deadline
) external payable returns (uint256 amountCalculated);
function batchSwap(
SwapKind kind,
BatchSwapStep[] memory swaps,
IAsset[] memory assets,
FundManagement memory funds,
int256[] memory limits,
uint256 deadline
) external payable returns (int256[] memory assetDeltas);
}
文件 28 的 97：IBasePool.sol
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface IBasePool is IERC20 {
function onJoinPool(
bytes32 poolId,
address sender,
address recipient,
uint256[] memory balances,
uint256 lastChangeBlock,
uint256 protocolSwapFeePercentage,
bytes memory userData
) external returns (uint256[] memory amountsIn, uint256[] memory dueProtocolFeeAmounts);
function onExitPool(
bytes32 poolId,
address sender,
address recipient,
uint256[] memory balances,
uint256 lastChangeBlock,
uint256 protocolSwapFeePercentage,
bytes memory userData
) external returns (uint256[] memory amountsOut, uint256[] memory dueProtocolFeeAmounts);
function getPoolId() external view returns (bytes32);
function getSwapFeePercentage() external view returns (uint256);
}
文件 29 的 97：IBaseRewardPool.sol
pragma solidity 0.8.17;
import "./IRewards.sol";
interface IBaseRewardPool is IRewards {
function setParams(
uint256 _pid,
address _stakingToken,
address _rewardToken
) external;
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function stake(uint256) external;
function stakeAll() external;
function stakeFor(address, uint256) external;
function withdraw(uint256) external;
function withdrawAll() external;
function donate(address, uint256) external payable;
function earned(address, address) external view returns (uint256);
function getUserAmountTime(address) external view returns (uint256);
function getRewardTokens() external view returns (address[] memory);
function getRewardTokensLength() external view returns (uint256);
function getReward(address) external;
function withdrawFor(address _account, uint256 _amount) external;
event BoosterUpdated(address _booster);
event RewardTokenAdded(address indexed _rewardToken);
event Staked(address indexed _user, uint256 _amount);
event Withdrawn(address indexed _user, uint256 _amount);
event EmergencyWithdrawn(address indexed _user, uint256 _amount);
event RewardPaid(
address indexed _user,
address indexed _rewardToken,
uint256 _reward
);
}
文件 30 的 97：IBeacon.sol
pragma solidity ^0.8.0;
interface IBeacon {
function implementation() external view returns (address);
}
文件 31 的 97：IBooster.sol
pragma solidity ^0.8.0;
interface IBooster {
function crv() external view returns (address);
function poolLength() external view returns (uint256);
function poolInfo(
uint256
) external view returns (address lpToken, address, address, address, address, bool);
function deposit(uint256 _pid, uint256 _amount, bool _stake) external returns (bool);
function depositAll(uint256 _pid, bool _stake) external returns (bool);
function withdraw(uint256 _pid, uint256 _amount) external returns (bool);
function withdrawAll(uint256 _pid) external returns (bool);
}
文件 32 的 97：IDiamondLoupe.sol
pragma solidity ^0.8.0;
interface IDiamondLoupe {
struct Facet {
address facetAddress;
bytes4[] functionSelectors;
}
function facets() external view returns (Facet[] memory facets_);
function facetFunctionSelectors(
address _facet
) external view returns (bytes4[] memory facetFunctionSelectors_);
function facetAddresses() external view returns (address[] memory facetAddresses_);
function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);
}
文件 33 的 97：IERC20.sol
pragma solidity ^0.8.0;
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
文件 34 的 97：IERC20Metadata.sol
pragma solidity ^0.8.0;
import "../IERC20.sol";
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
文件 35 的 97：IERC4626LinearPool.sol
pragma solidity ^0.8.0;
interface IERC4626LinearPool {
event Approval(address indexed owner, address indexed spender, uint256 value);
event PausedStateChanged(bool paused);
event RecoveryModeStateChanged(bool enabled);
event SwapFeePercentageChanged(uint256 swapFeePercentage);
event TargetsSet(address indexed token, uint256 lowerTarget, uint256 upperTarget);
event Transfer(address indexed from, address indexed to, uint256 value);
struct SwapRequest {
uint8 kind;
address tokenIn;
address tokenOut;
uint256 amount;
bytes32 poolId;
uint256 lastChangeBlock;
address from;
address to;
bytes userData;
}
function DOMAIN_SEPARATOR() external view returns (bytes32);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
function decimals() external view returns (uint8);
function decreaseAllowance(address spender, uint256 amount) external returns (bool);
function disableRecoveryMode() external;
function enableRecoveryMode() external;
function getActionId(bytes4 selector) external view returns (bytes32);
function getAuthorizer() external view returns (address);
function getBptIndex() external pure returns (uint256);
function getDomainSeparator() external view returns (bytes32);
function getMainIndex() external view returns (uint256);
function getMainToken() external view returns (address);
function getNextNonce(address account) external view returns (uint256);
function getOwner() external view returns (address);
function getPausedState()
external
view
returns (
bool paused,
uint256 pauseWindowEndTime,
uint256 bufferPeriodEndTime
);
function getPoolId() external view returns (bytes32);
function getProtocolFeesCollector() external view returns (address);
function getRate() external view returns (uint256);
function getScalingFactors() external view returns (uint256[] memory);
function getSwapFeePercentage() external view returns (uint256);
function getTargets() external view returns (uint256 lowerTarget, uint256 upperTarget);
function getVault() external view returns (address);
function getVirtualSupply() external view returns (uint256);
function getWrappedIndex() external view returns (uint256);
function getWrappedToken() external view returns (address);
function getWrappedTokenRate() external view returns (uint256);
function inRecoveryMode() external view returns (bool);
function increaseAllowance(address spender, uint256 addedValue) external returns (bool);
function initialize() external;
function name() external view returns (string memory);
function nonces(address owner) external view returns (uint256);
function onExitPool(
bytes32 poolId,
address sender,
address,
uint256[] memory balances,
uint256,
uint256,
bytes memory userData
) external returns (uint256[] memory amountsOut, uint256[] memory dueProtocolFees);
function onJoinPool(
bytes32 poolId,
address sender,
address recipient,
uint256[] memory balances,
uint256,
uint256,
bytes memory userData
) external returns (uint256[] memory amountsIn, uint256[] memory dueProtocolFees);
function onSwap(
SwapRequest memory request,
uint256[] memory balances,
uint256 indexIn,
uint256 indexOut
) external returns (uint256);
function onSwap(
SwapRequest memory request,
uint256 balanceTokenIn,
uint256 balanceTokenOut
) external returns (uint256);
function pause() external;
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
function queryExit(
bytes32,
address sender,
address,
uint256[] memory balances,
uint256,
uint256,
bytes memory userData
) external returns (uint256 bptIn, uint256[] memory amountsOut);
function queryJoin(
bytes32,
address sender,
address,
uint256[] memory balances,
uint256,
uint256,
bytes memory userData
) external returns (uint256 bptOut, uint256[] memory amountsIn);
function setSwapFeePercentage(uint256 swapFeePercentage) external;
function setTargets(uint256 newLowerTarget, uint256 newUpperTarget) external;
function symbol() external view returns (string memory);
function totalSupply() external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
function unpause() external;
function version() external view returns (string memory);
}
文件 36 的 97：IPActionAddRemoveLiq.sol
pragma solidity ^0.8.0;
import "../router/base/MarketApproxLib.sol";
import "../router/base/ActionBaseMintRedeem.sol";
interface IPActionAddRemoveLiq {
event AddLiquidityDualSyAndPt(
address indexed caller,
address indexed market,
address indexed receiver,
uint256 netSyUsed,
uint256 netPtUsed,
uint256 netLpOut
);
event AddLiquidityDualTokenAndPt(
address indexed caller,
address indexed market,
address indexed tokenIn,
address receiver,
uint256 netTokenUsed,
uint256 netPtUsed,
uint256 netLpOut
);
event AddLiquiditySinglePt(
address indexed caller,
address indexed market,
address indexed receiver,
uint256 netPtIn,
uint256 netLpOut
);
event AddLiquiditySingleSy(
address indexed caller,
address indexed market,
address indexed receiver,
uint256 netSyIn,
uint256 netLpOut
);
event AddLiquiditySingleToken(
address indexed caller,
address indexed market,
address indexed token,
address receiver,
uint256 netTokenIn,
uint256 netLpOut
);
event AddLiquiditySingleSyKeepYt(
address indexed caller,
address indexed market,
address indexed receiver,
uint256 netSyIn,
uint256 netLpOut,
uint256 netYtOut
);
event AddLiquiditySingleTokenKeepYt(
address indexed caller,
address indexed market,
address indexed token,
address receiver,
uint256 netTokenIn,
uint256 netLpOut,
uint256 netYtOut
);
event RemoveLiquidityDualSyAndPt(
address indexed caller,
address indexed market,
address indexed receiver,
uint256 netLpToRemove,
uint256 netPtOut,
uint256 netSyOut
);
event RemoveLiquidityDualTokenAndPt(
address indexed caller,
address indexed market,
address indexed tokenOut,
address receiver,
uint256 netLpToRemove,
uint256 netPtOut,
uint256 netTokenOut
);
event RemoveLiquiditySinglePt(
address indexed caller,
address indexed market,
address indexed receiver,
uint256 netLpToRemove,
uint256 netPtOut
);
event RemoveLiquiditySingleSy(
address indexed caller,
address indexed market,
address indexed receiver,
uint256 netLpToRemove,
uint256 netSyOut
);
event RemoveLiquiditySingleToken(
address indexed caller,
address indexed market,
address indexed token,
address receiver,
uint256 netLpToRemove,
uint256 netTokenOut
);
function addLiquidityDualSyAndPt(
address receiver,
address market,
uint256 netSyDesired,
uint256 netPtDesired,
uint256 minLpOut
) external returns (uint256 netLpOut, uint256 netSyUsed, uint256 netPtUsed);
function addLiquidityDualTokenAndPt(
address receiver,
address market,
TokenInput calldata input,
uint256 netPtDesired,
uint256 minLpOut
) external payable returns (uint256 netLpOut, uint256 netTokenUsed, uint256 netPtUsed);
function addLiquiditySinglePt(
address receiver,
address market,
uint256 netPtIn,
uint256 minLpOut,
ApproxParams calldata guessPtSwapToSy
) external returns (uint256 netLpOut, uint256 netSyFee);
function addLiquiditySingleSy(
address receiver,
address market,
uint256 netSyIn,
uint256 minLpOut,
ApproxParams calldata guessPtReceivedFromSy
) external returns (uint256 netLpOut, uint256 netSyFee);
function addLiquiditySingleToken(
address receiver,
address market,
uint256 minLpOut,
ApproxParams calldata guessPtReceivedFromSy,
TokenInput calldata input
) external payable returns (uint256 netLpOut, uint256 netSyFee);
function addLiquiditySingleSyKeepYt(
address receiver,
address market,
uint256 netSyIn,
uint256 minLpOut,
uint256 minYtOut
) external returns (uint256 netLpOut, uint256 netYtOut);
function addLiquiditySingleTokenKeepYt(
address receiver,
address market,
uint256 minLpOut,
uint256 minYtOut,
TokenInput calldata input
) external returns (uint256 netLpOut, uint256 netYtOut);
function removeLiquidityDualSyAndPt(
address receiver,
address market,
uint256 netLpToRemove,
uint256 minSyOut,
uint256 minPtOut
) external returns (uint256 netSyOut, uint256 netPtOut);
function removeLiquidityDualTokenAndPt(
address receiver,
address market,
uint256 netLpToRemove,
TokenOutput calldata output,
uint256 minPtOut
) external returns (uint256 netTokenOut, uint256 netPtOut);
function removeLiquiditySinglePt(
address receiver,
address market,
uint256 netLpToRemove,
uint256 minPtOut,
ApproxParams calldata guessPtOut
) external returns (uint256 netPtOut, uint256 netSyFee);
function removeLiquiditySingleSy(
address receiver,
address market,
uint256 netLpToRemove,
uint256 minSyOut
) external returns (uint256 netSyOut, uint256 netSyFee);
function removeLiquiditySingleToken(
address receiver,
address market,
uint256 netLpToRemove,
TokenOutput calldata output
) external returns (uint256 netTokenOut, uint256 netSyFee);
}
文件 37 的 97：IPActionMintRedeem.sol
pragma solidity ^0.8.0;
import "../router/base/MarketApproxLib.sol";
import "../router/base/ActionBaseMintRedeem.sol";
interface IPActionMintRedeem {
event MintSyFromToken(
address indexed caller,
address indexed tokenIn,
address indexed SY,
address receiver,
uint256 netTokenIn,
uint256 netSyOut
);
event RedeemSyToToken(
address indexed caller,
address indexed tokenOut,
address indexed SY,
address receiver,
uint256 netSyIn,
uint256 netTokenOut
);
event MintPyFromSy(
address indexed caller,
address indexed receiver,
address indexed YT,
uint256 netSyIn,
uint256 netPyOut
);
event RedeemPyToSy(
address indexed caller,
address indexed receiver,
address indexed YT,
uint256 netPyIn,
uint256 netSyOut
);
event MintPyFromToken(
address indexed caller,
address indexed tokenIn,
address indexed YT,
address receiver,
uint256 netTokenIn,
uint256 netPyOut
);
event RedeemPyToToken(
address indexed caller,
address indexed tokenOut,
address indexed YT,
address receiver,
uint256 netPyIn,
uint256 netTokenOut
);
function mintSyFromToken(
address receiver,
address SY,
uint256 minSyOut,
TokenInput calldata input
) external payable returns (uint256 netSyOut);
function redeemSyToToken(
address receiver,
address SY,
uint256 netSyIn,
TokenOutput calldata output
) external returns (uint256 netTokenOut);
function mintPyFromToken(
address receiver,
address YT,
uint256 minPyOut,
TokenInput calldata input
) external payable returns (uint256 netPyOut);
function redeemPyToToken(
address receiver,
address YT,
uint256 netPyIn,
TokenOutput calldata output
) external returns (uint256 netTokenOut);
function mintPyFromSy(
address receiver,
address YT,
uint256 netSyIn,
uint256 minPyOut
) external returns (uint256 netPyOut);
function redeemPyToSy(
address receiver,
address YT,
uint256 netPyIn,
uint256 minSyOut
) external returns (uint256 netSyOut);
function redeemDueInterestAndRewards(
address user,
address[] calldata sys,
address[] calldata yts,
address[] calldata markets
) external;
}
文件 38 的 97：IPActionMisc.sol
pragma solidity ^0.8.0;
interface IPActionMisc {
struct MultiApproval {
address[] tokens;
address spender;
}
struct Call3 {
bool allowFailure;
bytes callData;
}
struct Result {
bool success;
bytes returnData;
}
function approveInf(MultiApproval[] calldata) external;
function batchExec(Call3[] calldata calls) external returns (Result[] memory returnData);
}
文件 39 的 97：IPActionSwapPT.sol
pragma solidity ^0.8.0;
import "../router/base/MarketApproxLib.sol";
import "../router/base/ActionBaseMintRedeem.sol";
interface IPActionSwapPT {
event SwapPtAndSy(
address indexed caller,
address indexed market,
address indexed receiver,
int256 netPtToAccount,
int256 netSyToAccount
);
event SwapPtAndToken(
address indexed caller,
address indexed market,
address indexed token,
address receiver,
int256 netPtToAccount,
int256 netTokenToAccount
);
function swapExactPtForSy(
address receiver,
address market,
uint256 exactPtIn,
uint256 minSyOut
) external returns (uint256 netSyOut, uint256 netSyFee);
function swapPtForExactSy(
address receiver,
address market,
uint256 exactSyOut,
uint256 maxPtIn,
ApproxParams calldata guessPtIn
) external returns (uint256 netPtIn, uint256 netSyFee);
function swapSyForExactPt(
address receiver,
address market,
uint256 exactPtOut,
uint256 maxSyIn
) external returns (uint256 netSyIn, uint256 netSyFee);
function swapExactSyForPt(
address receiver,
address market,
uint256 exactSyIn,
uint256 minPtOut,
ApproxParams calldata guessPtOut
) external returns (uint256 netPtOut, uint256 netSyFee);
function swapExactTokenForPt(
address receiver,
address market,
uint256 minPtOut,
ApproxParams calldata guessPtOut,
TokenInput calldata input
) external payable returns (uint256 netPtOut, uint256 netSyFee);
function swapExactPtForToken(
address receiver,
address market,
uint256 exactPtIn,
TokenOutput calldata output
) external returns (uint256 netTokenOut, uint256 netSyFee);
}
文件 40 的 97：IPActionSwapYT.sol
pragma solidity ^0.8.0;
import "../router/base/MarketApproxLib.sol";
import "../router/base/ActionBaseMintRedeem.sol";
interface IPActionSwapYT {
event SwapYtAndSy(
address indexed caller,
address indexed market,
address indexed receiver,
int256 netYtToAccount,
int256 netSyToAccount
);
event SwapYtAndToken(
address indexed caller,
address indexed market,
address indexed token,
address receiver,
int256 netYtToAccount,
int256 netTokenToAccount
);
event SwapPtAndYt(
address indexed caller,
address indexed market,
address indexed receiver,
int256 netPtToAccount,
int256 netYtToAccount
);
function swapExactSyForYt(
address receiver,
address market,
uint256 exactSyIn,
uint256 minYtOut,
ApproxParams calldata guessYtOut
) external returns (uint256 netYtOut, uint256 netSyFee);
function swapExactYtForSy(
address receiver,
address market,
uint256 exactYtIn,
uint256 minSyOut
) external returns (uint256 netSyOut, uint256 netSyFee);
function swapSyForExactYt(
address receiver,
address market,
uint256 exactYtOut,
uint256 maxSyIn
) external returns (uint256 netSyIn, uint256 netSyFee);
function swapYtForExactSy(
address receiver,
address market,
uint256 exactSyOut,
uint256 maxYtIn,
ApproxParams calldata guessYtIn
) external returns (uint256 netYtIn, uint256 netSyFee);
function swapExactTokenForYt(
address receiver,
address market,
uint256 minYtOut,
ApproxParams calldata guessYtOut,
TokenInput calldata input
) external payable returns (uint256 netYtOut, uint256 netSyFee);
function swapExactYtForToken(
address receiver,
address market,
uint256 netYtIn,
TokenOutput calldata output
) external returns (uint256 netTokenOut, uint256 netSyFee);
function swapExactPtForYt(
address receiver,
address market,
uint256 exactPtIn,
uint256 minYtOut,
ApproxParams calldata guessTotalPtToSwap
) external returns (uint256 netYtOut, uint256 netSyFee);
function swapExactYtForPt(
address receiver,
address market,
uint256 exactYtIn,
uint256 minPtOut,
ApproxParams calldata guessTotalPtSwapped
) external returns (uint256 netPtOut, uint256 netSyFee);
}
文件 41 的 97：IPAllAction.sol
pragma solidity ^0.8.0;
import "./IPActionAddRemoveLiq.sol";
import "./IPActionSwapPT.sol";
import "./IPActionSwapYT.sol";
import "./IPActionMintRedeem.sol";
import "./IPActionMisc.sol";
import "./IPMarketSwapCallback.sol";
import "./IDiamondLoupe.sol";
interface IPAllAction is
IPActionAddRemoveLiq,
IPActionSwapPT,
IPActionSwapYT,
IPActionMintRedeem,
IPActionMisc,
IPMarketSwapCallback,
IDiamondLoupe
{}
文件 42 的 97：IPBulkSeller.sol
pragma solidity ^0.8.0;
import "../core/BulkSeller/BulkSellerMathCore.sol";
interface IPBulkSeller {
event SwapExactTokenForSy(address receiver, uint256 netTokenIn, uint256 netSyOut);
event SwapExactSyForToken(address receiver, uint256 netSyIn, uint256 netTokenOut);
event RateUpdated(
uint256 newRateTokenToSy,
uint256 newRateSyToToken,
uint256 oldRateTokenToSy,
uint256 oldRateSyToToken
);
event ReBalanceTokenToSy(
uint256 netTokenDeposit,
uint256 netSyFromToken,
uint256 newTokenProp,
uint256 oldTokenProp
);
event ReBalanceSyToToken(
uint256 netSyRedeem,
uint256 netTokenFromSy,
uint256 newTokenProp,
uint256 oldTokenProp
);
event ReserveUpdated(uint256 totalToken, uint256 totalSy);
event FeeRateUpdated(uint256 newFeeRate, uint256 oldFeeRate);
function swapExactTokenForSy(
address receiver,
uint256 netTokenIn,
uint256 minSyOut
) external payable returns (uint256 netSyOut);
function swapExactSyForToken(
address receiver,
uint256 exactSyIn,
uint256 minTokenOut,
bool swapFromInternalBalance
) external returns (uint256 netTokenOut);
function SY() external view returns (address);
function token() external view returns (address);
function readState() external view returns (BulkSellerState memory);
}
文件 43 的 97：IPGauge.sol
pragma solidity ^0.8.0;
interface IPGauge {
function totalActiveSupply() external view returns (uint256);
function activeBalance(address user) external view returns (uint256);
event RedeemRewards(address indexed user, uint256[] rewardsOut);
}
文件 44 的 97：IPInterestManagerYT.sol
pragma solidity ^0.8.0;
interface IPInterestManagerYT {
function userInterest(
address user
) external view returns (uint128 lastPYIndex, uint128 accruedInterest);
}
文件 45 的 97：IPInterfaces.sol
pragma solidity 0.8.17;
import "@pendle/core-v2/contracts/interfaces/IPAllAction.sol";
import "@pendle/core-v2/contracts/core/Market/PendleMarketFactory.sol";
import "@pendle/core-v2/contracts/core/YieldContracts/PendleYieldContractFactory.sol";
文件 46 的 97：IPMarket.sol
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "./IPPrincipalToken.sol";
import "./IPYieldToken.sol";
import "./IStandardizedYield.sol";
import "./IPGauge.sol";
import "../core/Market/MarketMathCore.sol";
interface IPMarket is IERC20Metadata, IPGauge {
event Mint(
address indexed receiver,
uint256 netLpMinted,
uint256 netSyUsed,
uint256 netPtUsed
);
event Burn(
address indexed receiverSy,
address indexed receiverPt,
uint256 netLpBurned,
uint256 netSyOut,
uint256 netPtOut
);
event Swap(
address indexed caller,
address indexed receiver,
int256 netPtOut,
int256 netSyOut,
uint256 netSyFee,
uint256 netSyToReserve
);
event UpdateImpliedRate(uint256 indexed timestamp, uint256 lnLastImpliedRate);
event IncreaseObservationCardinalityNext(
uint16 observationCardinalityNextOld,
uint16 observationCardinalityNextNew
);
function mint(
address receiver,
uint256 netSyDesired,
uint256 netPtDesired
) external returns (uint256 netLpOut, uint256 netSyUsed, uint256 netPtUsed);
function burn(
address receiverSy,
address receiverPt,
uint256 netLpToBurn
) external returns (uint256 netSyOut, uint256 netPtOut);
function swapExactPtForSy(
address receiver,
uint256 exactPtIn,
bytes calldata data
) external returns (uint256 netSyOut, uint256 netSyFee);
function swapSyForExactPt(
address receiver,
uint256 exactPtOut,
bytes calldata data
) external returns (uint256 netSyIn, uint256 netSyFee);
function redeemRewards(address user) external returns (uint256[] memory);
function readState(address router) external view returns (MarketState memory market);
function observe(
uint32[] memory secondsAgos
) external view returns (uint216[] memory lnImpliedRateCumulative);
function increaseObservationsCardinalityNext(uint16 cardinalityNext) external;
function readTokens()
external
view
returns (IStandardizedYield _SY, IPPrincipalToken _PT, IPYieldToken _YT);
function getRewardTokens() external view returns (address[] memory);
function isExpired() external view returns (bool);
function expiry() external view returns (uint256);
function observations(
uint256 index
)
external
view
returns (uint32 blockTimestamp, uint216 lnImpliedRateCumulative, bool initialized);
function _storage()
external
view
returns (
int128 totalPt,
int128 totalSy,
uint96 lastLnImpliedRate,
uint16 observationIndex,
uint16 observationCardinality,
uint16 observationCardinalityNext
);
}
文件 47 的 97：IPMarketFactory.sol
pragma solidity ^0.8.0;
interface IPMarketFactory {
struct FeeConfig {
uint80 lnFeeRateRoot;
uint8 reserveFeePercent;
bool active;
}
event NewMarketConfig(
address indexed treasury,
uint80 defaultLnFeeRateRoot,
uint8 reserveFeePercent
);
event SetOverriddenFee(address indexed router, uint80 lnFeeRateRoot, uint8 reserveFeePercent);
event UnsetOverriddenFee(address indexed router);
event CreateNewMarket(
address indexed market,
address indexed PT,
int256 scalarRoot,
int256 initialAnchor
);
function isValidMarket(address market) external view returns (bool);
function getMarketConfig(
address router
) external view returns (address treasury, uint80 lnFeeRateRoot, uint8 reserveFeePercent);
}
文件 48 的 97：IPMarketSwapCallback.sol
pragma solidity ^0.8.0;
interface IPMarketSwapCallback {
function swapCallback(int256 ptToAccount, int256 syToAccount, bytes calldata data) external;
}
文件 49 的 97：IPPrincipalToken.sol
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
interface IPPrincipalToken is IERC20Metadata {
function burnByYT(address user, uint256 amount) external;
function mintByYT(address user, uint256 amount) external;
function initialize(address _YT) external;
function SY() external view returns (address);
function YT() external view returns (address);
function factory() external view returns (address);
function expiry() external view returns (uint256);
function isExpired() external view returns (bool);
}
文件 50 的 97：IPSwapAggregator.sol
pragma solidity ^0.8.0;
struct SwapData {
SwapType swapType;
address extRouter;
bytes extCalldata;
bool needScale;
}
enum SwapType {
NONE,
KYBERSWAP,
ONE_INCH,
ETH_WETH
}
interface IPSwapAggregator {
function swap(address tokenIn, uint256 amountIn, SwapData calldata swapData) external payable;
}
文件 51 的 97：IPYieldContractFactory.sol
pragma solidity ^0.8.0;
interface IPYieldContractFactory {
event CreateYieldContract(address indexed SY, uint256 indexed expiry, address PT, address YT);
event SetExpiryDivisor(uint256 newExpiryDivisor);
event SetInterestFeeRate(uint256 newInterestFeeRate);
event SetRewardFeeRate(uint256 newRewardFeeRate);
event SetTreasury(address indexed treasury);
function getPT(address SY, uint256 expiry) external view returns (address);
function getYT(address SY, uint256 expiry) external view returns (address);
function expiryDivisor() external view returns (uint96);
function interestFeeRate() external view returns (uint128);
function rewardFeeRate() external view returns (uint128);
function treasury() external view returns (address);
function isPT(address) external view returns (bool);
function isYT(address) external view returns (bool);
}
文件 52 的 97：IPYieldToken.sol
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "./IRewardManager.sol";
import "./IPInterestManagerYT.sol";
interface IPYieldToken is IERC20Metadata, IRewardManager, IPInterestManagerYT {
event NewInterestIndex(uint256 indexed newIndex);
event Mint(
address indexed caller,
address indexed receiverPT,
address indexed receiverYT,
uint256 amountSyToMint,
uint256 amountPYOut
);
event Burn(
address indexed caller,
address indexed receiver,
uint256 amountPYToRedeem,
uint256 amountSyOut
);
event RedeemRewards(address indexed user, uint256[] amountRewardsOut);
event RedeemInterest(address indexed user, uint256 interestOut);
event WithdrawFeeToTreasury(uint256[] amountRewardsOut, uint256 syOut);
function mintPY(address receiverPT, address receiverYT) external returns (uint256 amountPYOut);
function redeemPY(address receiver) external returns (uint256 amountSyOut);
function redeemPYMulti(
address[] calldata receivers,
uint256[] calldata amountPYToRedeems
) external returns (uint256[] memory amountSyOuts);
function redeemDueInterestAndRewards(
address user,
bool redeemInterest,
bool redeemRewards
) external returns (uint256 interestOut, uint256[] memory rewardsOut);
function rewardIndexesCurrent() external returns (uint256[] memory);
function pyIndexCurrent() external returns (uint256);
function pyIndexStored() external view returns (uint256);
function getRewardTokens() external view returns (address[] memory);
function SY() external view returns (address);
function PT() external view returns (address);
function factory() external view returns (address);
function expiry() external view returns (uint256);
function isExpired() external view returns (bool);
function doCacheIndexSameBlock() external view returns (bool);
function pyIndexLastUpdatedBlock() external view returns (uint128);
}
文件 53 的 97：IPendleLiquiditySeedingHelper.sol
pragma solidity 0.8.17;
interface IPLiquiditySeedingHelper {
function seedLiquidity(address market, address token, uint256 amount) external payable;
}
文件 54 的 97：IRateProvider.sol
pragma solidity ^0.8.0;
interface IRateProvider {
function getRate() external view returns (uint256);
}
文件 55 的 97：IRewardManager.sol
pragma solidity ^0.8.0;
interface IRewardManager {
function userReward(
address token,
address user
) external view returns (uint128 index, uint128 accrued);
}
文件 56 的 97：IRewards copy.sol
pragma solidity 0.8.17;
interface IRewards {
function queueNewRewards(address, uint256) external payable;
event RewardAdded(address indexed _rewardToken, uint256 _reward);
}
文件 57 的 97：IRewards.sol
pragma solidity ^0.8.0;
interface IRewards {
function operator() external view returns (address);
function stake(address, uint256) external;
function stakeFor(address, uint256) external;
function withdraw(uint256, bool) external returns (bool);
function withdrawAndUnwrap(uint256, bool) external returns (bool);
function exit(address) external;
function getReward(address , bool ) external;
function getReward() external;
function queueNewRewards(uint256) external;
function notifyRewardAmount(uint256) external;
function addExtraReward(address) external;
function rewardToken() external returns (address);
function rewardPerToken() external returns (uint256);
function rewardPerTokenStored() external view returns (uint256);
function extraRewardsLength() external view returns (uint256);
function extraRewards(uint256) external returns (address);
function stakingToken() external returns (address);
function lastTimeRewardApplicable() external view returns (uint256);
}
文件 58 的 97：ISmartConvertor.sol
pragma solidity 0.8.17;
interface ISmartConvertor {
function estimateTotalConversion(
uint256 _amount
) external returns (uint256 amountOut);
function previewAmountOut(
address _tokenIn,
uint256 _amount
) external view returns (uint256);
function deposit(uint256 _amount) external returns (uint256 obtainedAmount);
function depositFor(
uint256 _amount,
address _for
) external returns (uint256 obtainedAmount);
function swapEPendleForPendle(
uint256 _amount,
uint256 _amountOutMinimum,
address _receiver
) external returns (uint256 pendleReceived);
event EPendleObtained(
address indexed _user,
uint256 _depositedPendle,
uint256 _obtainedFromDexAmount,
uint256 _obtainedFromDepositAmount
);
event TokenSwapped(
address indexed _tokenIn,
address indexed _tokenOut,
uint256 _amountIn,
uint256 _amountOutMinimum,
address indexed _receiver,
uint256 _amountOut
);
event SwapThresholdChanged(uint256 _swapThreshold);
event MaxSwapAmountChanged(uint256 _maxSwapAmount);
event MaverickPendleEpendlePoolChanged(address _maverickPendleEpendlePool);
}
文件 59 的 97：IStandardizedYield.sol
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
interface IStandardizedYield is IERC20Metadata {
event Deposit(
address indexed caller,
address indexed receiver,
address indexed tokenIn,
uint256 amountDeposited,
uint256 amountSyOut
);
event Redeem(
address indexed caller,
address indexed receiver,
address indexed tokenOut,
uint256 amountSyToRedeem,
uint256 amountTokenOut
);
enum AssetType {
TOKEN,
LIQUIDITY
}
event ClaimRewards(address indexed user, address[] rewardTokens, uint256[] rewardAmounts);
function deposit(
address receiver,
address tokenIn,
uint256 amountTokenToDeposit,
uint256 minSharesOut
) external payable returns (uint256 amountSharesOut);
function redeem(
address receiver,
uint256 amountSharesToRedeem,
address tokenOut,
uint256 minTokenOut,
bool burnFromInternalBalance
) external returns (uint256 amountTokenOut);
function exchangeRate() external view returns (uint256 res);
function claimRewards(address user) external returns (uint256[] memory rewardAmounts);
function accruedRewards(address user) external view returns (uint256[] memory rewardAmounts);
function rewardIndexesCurrent() external returns (uint256[] memory indexes);
function rewardIndexesStored() external view returns (uint256[] memory indexes);
function getRewardTokens() external view returns (address[] memory);
function yieldToken() external view returns (address);
function getTokensIn() external view returns (address[] memory res);
function getTokensOut() external view returns (address[] memory res);
function isValidTokenIn(address token) external view returns (bool);
function isValidTokenOut(address token) external view returns (bool);
function previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
external
view
returns (uint256 amountSharesOut);
function previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
external
view
returns (uint256 amountTokenOut);
function assetInfo()
external
view
returns (
AssetType assetType,
address assetAddress,
uint8 assetDecimals
);
}
文件 60 的 97：ISwETH.sol
pragma solidity 0.8.17;
interface ISwETH {
function deposit() external payable;
function getRate() external view returns (uint256);
function ethToSwETHRate() external view returns (uint256);
}
文件 61 的 97：IVault.sol
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./IAsset.sol";
interface IVault {
enum UserBalanceOpKind {
DEPOSIT_INTERNAL,
WITHDRAW_INTERNAL,
TRANSFER_INTERNAL,
TRANSFER_EXTERNAL
}
struct UserBalanceOp {
UserBalanceOpKind kind;
IAsset asset;
uint256 amount;
address sender;
address payable recipient;
}
struct JoinPoolRequest {
address[] assets;
uint256[] maxAmountsIn;
bytes userData;
bool fromInternalBalance;
}
struct SwapRequest {
IVault.SwapKind kind;
IERC20 tokenIn;
IERC20 tokenOut;
uint256 amount;
bytes32 poolId;
uint256 lastChangeBlock;
address from;
address to;
bytes userData;
}
function joinPool(
bytes32 poolId,
address sender,
address recipient,
JoinPoolRequest memory request
) external payable;
struct ExitPoolRequest {
address[] assets;
uint256[] minAmountsOut;
bytes userData;
bool toInternalBalance;
}
function exitPool(
bytes32 poolId,
address sender,
address payable recipient,
ExitPoolRequest memory request
) external;
enum SwapKind {
GIVEN_IN,
GIVEN_OUT
}
struct SingleSwap {
bytes32 poolId;
SwapKind kind;
IAsset assetIn;
IAsset assetOut;
uint256 amount;
bytes userData;
}
struct FundManagement {
address sender;
bool fromInternalBalance;
address payable recipient;
bool toInternalBalance;
}
function swap(
SingleSwap memory singleSwap,
FundManagement memory funds,
uint256 limit,
uint256 deadline
) external payable returns (uint256);
function getPoolTokens(bytes32 poolId)
external
view
returns (
IERC20[] memory tokens,
uint256[] memory balances,
uint256 lastChangeBlock
);
function WETH() external view returns (IERC20);
function getPool(bytes32 poolId) external view returns (address, uint8);
function getProtocolFeesCollector() external view returns (address);
}
文件 62 的 97：IWETH.sol
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface IWETH is IERC20 {
event Deposit(address indexed dst, uint256 wad);
event Withdrawal(address indexed src, uint256 wad);
function deposit() external payable;
function withdraw(uint256 wad) external;
}
文件 63 的 97：IWNative.sol
pragma solidity 0.8.17;
interface IWNative {
function deposit() external payable;
function withdraw(uint256) external;
}
文件 64 的 97：Initializable.sol
pragma solidity ^0.8.2;
import "../../utils/AddressUpgradeable.sol";
abstract contract Initializable {
uint8 private _initialized;
bool private _initializing;
event Initialized(uint8 version);
modifier initializer() {
bool isTopLevelCall = !_initializing;
require(
(isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
"Initializable: contract is already initialized"
);
_initialized = 1;
if (isTopLevelCall) {
_initializing = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
emit Initialized(1);
}
}
modifier reinitializer(uint8 version) {
require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
_initialized = version;
_initializing = true;
_;
_initializing = false;
emit Initialized(version);
}
modifier onlyInitializing() {
require(_initializing, "Initializable: contract is not initializing");
_;
}
function _disableInitializers() internal virtual {
require(!_initializing, "Initializable: contract is initializing");
if (_initialized < type(uint8).max) {
_initialized = type(uint8).max;
emit Initialized(type(uint8).max);
}
}
}
文件 65 的 97：InterestManagerYT.sol
pragma solidity 0.8.17;
import "../../interfaces/IPYieldToken.sol";
import "../../interfaces/IPPrincipalToken.sol";
import "../../interfaces/IPInterestManagerYT.sol";
import "../../interfaces/IPYieldContractFactory.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "../libraries/math/PMath.sol";
import "../libraries/TokenHelper.sol";
import "../StandardizedYield/SYUtils.sol";
abstract contract InterestManagerYT is TokenHelper, IPInterestManagerYT {
using PMath for uint256;
struct UserInterest {
uint128 index;
uint128 accrued;
}
mapping(address => UserInterest) public userInterest;
function _distributeInterest(address user) internal {
_distributeInterestForTwo(user, address(0));
}
function _distributeInterestForTwo(address user1, address user2) internal {
uint256 index = _getInterestIndex();
if (user1 != address(0) && user1 != address(this))
_distributeInterestPrivate(user1, index);
if (user2 != address(0) && user2 != address(this))
_distributeInterestPrivate(user2, index);
}
function _doTransferOutInterest(
address user,
address SY,
address factory
) internal returns (uint256 interestAmount) {
address treasury = IPYieldContractFactory(factory).treasury();
uint256 feeRate = IPYieldContractFactory(factory).interestFeeRate();
uint256 interestPreFee = userInterest[user].accrued;
userInterest[user].accrued = 0;
uint256 feeAmount = interestPreFee.mulDown(feeRate);
interestAmount = interestPreFee - feeAmount;
_transferOut(SY, treasury, feeAmount);
_transferOut(SY, user, interestAmount);
}
function _distributeInterestPrivate(address user, uint256 currentIndex) private {
assert(user != address(0) && user != address(this));
uint256 prevIndex = userInterest[user].index;
if (prevIndex == currentIndex) return;
if (prevIndex == 0) {
userInterest[user].index = currentIndex.Uint128();
return;
}
uint256 principal = _YTbalance(user);
uint256 interestFromYT = (principal * (currentIndex - prevIndex)).divDown(
prevIndex * currentIndex
);
userInterest[user].accrued += interestFromYT.Uint128();
userInterest[user].index = currentIndex.Uint128();
}
function _getInterestIndex() internal virtual returns (uint256 index);
function _YTbalance(address user) internal view virtual returns (uint256);
}
文件 66 的 97：LinearMath.sol
pragma solidity ^0.8.0;
import "../FixedPoint.sol";
library LinearMath {
using FixedPoint for uint256;
struct Params {
uint256 fee;
uint256 lowerTarget;
uint256 upperTarget;
}
function _calcBptOutPerMainIn(
uint256 mainIn,
uint256 mainBalance,
uint256 wrappedBalance,
uint256 bptSupply,
Params memory params
) internal pure returns (uint256) {
if (bptSupply == 0) {
return _toNominal(mainIn, params);
}
uint256 previousNominalMain = _toNominal(mainBalance, params);
uint256 afterNominalMain = _toNominal(mainBalance.add(mainIn), params);
uint256 deltaNominalMain = afterNominalMain.sub(previousNominalMain);
uint256 invariant = _calcInvariant(previousNominalMain, wrappedBalance);
return divDown(mul(bptSupply, deltaNominalMain), invariant);
}
function _calcBptInPerMainOut(
uint256 mainOut,
uint256 mainBalance,
uint256 wrappedBalance,
uint256 bptSupply,
Params memory params
) internal pure returns (uint256) {
uint256 previousNominalMain = _toNominal(mainBalance, params);
uint256 afterNominalMain = _toNominal(mainBalance.sub(mainOut), params);
uint256 deltaNominalMain = previousNominalMain.sub(afterNominalMain);
uint256 invariant = _calcInvariant(previousNominalMain, wrappedBalance);
return divUp(mul(bptSupply, deltaNominalMain), invariant);
}
function _calcWrappedOutPerMainIn(
uint256 mainIn,
uint256 mainBalance,
Params memory params
) internal pure returns (uint256) {
uint256 previousNominalMain = _toNominal(mainBalance, params);
uint256 afterNominalMain = _toNominal(mainBalance.add(mainIn), params);
return afterNominalMain.sub(previousNominalMain);
}
function _calcWrappedInPerMainOut(
uint256 mainOut,
uint256 mainBalance,
Params memory params
) internal pure returns (uint256) {
uint256 previousNominalMain = _toNominal(mainBalance, params);
uint256 afterNominalMain = _toNominal(mainBalance.sub(mainOut), params);
return previousNominalMain.sub(afterNominalMain);
}
function _calcMainInPerBptOut(
uint256 bptOut,
uint256 mainBalance,
uint256 wrappedBalance,
uint256 bptSupply,
Params memory params
) internal pure returns (uint256) {
if (bptSupply == 0) {
return _fromNominal(bptOut, params);
}
uint256 previousNominalMain = _toNominal(mainBalance, params);
uint256 invariant = _calcInvariant(previousNominalMain, wrappedBalance);
uint256 deltaNominalMain = divUp(mul(invariant, bptOut), bptSupply);
uint256 afterNominalMain = previousNominalMain.add(deltaNominalMain);
uint256 newMainBalance = _fromNominal(afterNominalMain, params);
return newMainBalance.sub(mainBalance);
}
function _calcMainOutPerBptIn(
uint256 bptIn,
uint256 mainBalance,
uint256 wrappedBalance,
uint256 bptSupply,
Params memory params
) internal pure returns (uint256) {
uint256 previousNominalMain = _toNominal(mainBalance, params);
uint256 invariant = _calcInvariant(previousNominalMain, wrappedBalance);
uint256 deltaNominalMain = divDown(mul(invariant, bptIn), bptSupply);
uint256 afterNominalMain = previousNominalMain.sub(deltaNominalMain);
uint256 newMainBalance = _fromNominal(afterNominalMain, params);
return mainBalance.sub(newMainBalance);
}
function _calcMainOutPerWrappedIn(
uint256 wrappedIn,
uint256 mainBalance,
Params memory params
) internal pure returns (uint256) {
uint256 previousNominalMain = _toNominal(mainBalance, params);
uint256 afterNominalMain = previousNominalMain.sub(wrappedIn);
uint256 newMainBalance = _fromNominal(afterNominalMain, params);
return mainBalance.sub(newMainBalance);
}
function _calcMainInPerWrappedOut(
uint256 wrappedOut,
uint256 mainBalance,
Params memory params
) internal pure returns (uint256) {
uint256 previousNominalMain = _toNominal(mainBalance, params);
uint256 afterNominalMain = previousNominalMain.add(wrappedOut);
uint256 newMainBalance = _fromNominal(afterNominalMain, params);
return newMainBalance.sub(mainBalance);
}
function _calcBptOutPerWrappedIn(
uint256 wrappedIn,
uint256 mainBalance,
uint256 wrappedBalance,
uint256 bptSupply,
Params memory params
) internal pure returns (uint256) {
if (bptSupply == 0) {
return wrappedIn;
}
uint256 nominalMain = _toNominal(mainBalance, params);
uint256 previousInvariant = _calcInvariant(nominalMain, wrappedBalance);
uint256 newWrappedBalance = wrappedBalance.add(wrappedIn);
uint256 newInvariant = _calcInvariant(nominalMain, newWrappedBalance);
uint256 newBptBalance = divDown(mul(bptSupply, newInvariant), previousInvariant);
return newBptBalance.sub(bptSupply);
}
function _calcBptInPerWrappedOut(
uint256 wrappedOut,
uint256 mainBalance,
uint256 wrappedBalance,
uint256 bptSupply,
Params memory params
) internal pure returns (uint256) {
uint256 nominalMain = _toNominal(mainBalance, params);
uint256 previousInvariant = _calcInvariant(nominalMain, wrappedBalance);
uint256 newWrappedBalance = wrappedBalance.sub(wrappedOut);
uint256 newInvariant = _calcInvariant(nominalMain, newWrappedBalance);
uint256 newBptBalance = divDown(mul(bptSupply, newInvariant), previousInvariant);
return bptSupply.sub(newBptBalance);
}
function _calcWrappedInPerBptOut(
uint256 bptOut,
uint256 mainBalance,
uint256 wrappedBalance,
uint256 bptSupply,
Params memory params
) internal pure returns (uint256) {
if (bptSupply == 0) {
return bptOut;
}
uint256 nominalMain = _toNominal(mainBalance, params);
uint256 previousInvariant = _calcInvariant(nominalMain, wrappedBalance);
uint256 newBptBalance = bptSupply.add(bptOut);
uint256 newWrappedBalance = divUp(mul(newBptBalance, previousInvariant), bptSupply).sub(
nominalMain
);
return newWrappedBalance.sub(wrappedBalance);
}
function _calcWrappedOutPerBptIn(
uint256 bptIn,
uint256 mainBalance,
uint256 wrappedBalance,
uint256 bptSupply,
Params memory params
) internal pure returns (uint256) {
uint256 nominalMain = _toNominal(mainBalance, params);
uint256 previousInvariant = _calcInvariant(nominalMain, wrappedBalance);
uint256 newBptBalance = bptSupply.sub(bptIn);
uint256 newWrappedBalance = divUp(mul(newBptBalance, previousInvariant), bptSupply).sub(
nominalMain
);
return wrappedBalance.sub(newWrappedBalance);
}
function _calcInvariant(uint256 nominalMainBalance, uint256 wrappedBalance)
internal
pure
returns (uint256)
{
return nominalMainBalance.add(wrappedBalance);
}
function _toNominal(uint256 real, Params memory params) internal pure returns (uint256) {
unchecked {
if (real < params.lowerTarget) {
uint256 fees = (params.lowerTarget - real).mulDown(params.fee);
return real.sub(fees);
} else if (real <= params.upperTarget) {
return real;
} else {
uint256 fees = (real - params.upperTarget).mulDown(params.fee);
return real.sub(fees);
}
}
}
function _fromNominal(uint256 nominal, Params memory params) internal pure returns (uint256) {
unchecked {
if (nominal < params.lowerTarget) {
return
(nominal.add(params.fee.mulDown(params.lowerTarget))).divDown(
FixedPoint.ONE.add(params.fee)
);
} else if (nominal <= params.upperTarget) {
return nominal;
} else {
return (
nominal.sub(params.fee.mulDown(params.upperTarget)).divDown(
FixedPoint.ONE.sub(params.fee)
)
);
}
}
}
function _calcTokensOutGivenExactBptIn(
uint256[] memory balances,
uint256 bptAmountIn,
uint256 bptTotalSupply,
uint256 bptIndex
) internal pure returns (uint256[] memory) {
unchecked {
uint256 bptRatio = bptAmountIn.divDown(bptTotalSupply);
uint256[] memory amountsOut = new uint256[](balances.length);
for (uint256 i = 0; i < balances.length; i++) {
if (i != bptIndex) {
amountsOut[i] = balances[i].mulDown(bptRatio);
}
}
return amountsOut;
}
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
unchecked {
uint256 c = a * b;
require(a == 0 || c / a == b);
return c;
}
}
function div(
uint256 a,
uint256 b,
bool roundUp
) internal pure returns (uint256) {
return roundUp ? divUp(a, b) : divDown(a, b);
}
function divDown(uint256 a, uint256 b) internal pure returns (uint256) {
unchecked {
require(b != 0);
return a / b;
}
}
function divUp(uint256 a, uint256 b) internal pure returns (uint256) {
unchecked {
require(b != 0);
if (a == 0) {
return 0;
} else {
return 1 + (a - 1) / b;
}
}
}
}
文件 67 的 97：LinearPreview.sol
pragma solidity ^0.8.0;
import "../../../../../../interfaces/Balancer/IVault.sol";
import "../../../../../../interfaces/Balancer/IERC4626LinearPool.sol";
import "../../../../../libraries/BoringOwnableUpgradeable.sol";
import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
import "./LinearMath.sol";
contract LinearPreview is BoringOwnableUpgradeable, UUPSUpgradeable {
using FixedPoint for uint256;
struct ImmutableData {
address pool;
uint256 _BPT_INDEX;
IERC20 _mainToken;
uint256 _mainIndex;
IERC20 _wrappedToken;
uint256 _wrappedIndex;
}
address internal constant BALANCER_VAULT = 0xBA12222222228d8Ba445958a75a0704d566BF2C8;
bytes internal constant EMPTY_BYTES = abi.encode();
constructor() initializer {}
function initialize() external initializer {
__BoringOwnable_init();
}
function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
function joinExitPoolPreview(bytes32 poolId, address tokenIn, address tokenOut, uint256 amountIn)
external
view
returns (uint256 amountOut)
{
IVault.SwapRequest memory request = IVault.SwapRequest({
kind: IVault.SwapKind.GIVEN_IN,
tokenIn: IERC20(tokenIn),
tokenOut: IERC20(tokenOut),
amount: amountIn,
poolId: bytes32(0),
lastChangeBlock: 0,
from: address(0),
to: address(0),
userData: EMPTY_BYTES
});
(IERC20[] memory tokens, uint256[] memory balances,) = IVault(BALANCER_VAULT).getPoolTokens(poolId);
address pool = address(uint160(uint256(poolId) >> (12 * 8)));
IERC20 mainToken = IERC20(IERC4626LinearPool(pool).getMainToken());
uint256 indexIn;
uint256 indexOut;
ImmutableData memory imd;
for (uint256 i = 0; i < tokens.length;) {
if (tokens[i] == mainToken) {
imd._mainToken = mainToken;
imd._mainIndex = i;
} else if (tokens[i] == IERC20(pool)) {
imd.pool = pool;
imd._BPT_INDEX = i;
} else {
imd._wrappedToken = tokens[i];
imd._wrappedIndex = i;
}
if (tokens[i] == IERC20(tokenIn)) {
indexIn = i;
} else if (tokens[i] == IERC20(tokenOut)) {
indexOut = i;
}
unchecked {
i++;
}
}
return _onSwapGeneral(request, balances, indexIn, indexOut, imd);
}
function _onSwapGeneral(
IVault.SwapRequest memory request,
uint256[] memory balances,
uint256 indexIn,
uint256 indexOut,
ImmutableData memory imd
) internal view returns (uint256) {
uint256[] memory scalingFactors = IERC4626LinearPool(imd.pool).getScalingFactors();
_upscaleArray(balances, scalingFactors);
(uint256 lowerTarget, uint256 upperTarget) = IERC4626LinearPool(imd.pool).getTargets();
LinearMath.Params memory params = LinearMath.Params({
fee: IERC4626LinearPool(imd.pool).getSwapFeePercentage(),
lowerTarget: lowerTarget,
upperTarget: upperTarget
});
assert(request.kind == IVault.SwapKind.GIVEN_IN);
request.amount = _upscale(request.amount, scalingFactors[indexIn]);
uint256 amountOut = _onSwapGivenIn(request, balances, params, imd);
return _downscaleDown(amountOut, scalingFactors[indexOut]);
}
function _onSwapGivenIn(
IVault.SwapRequest memory request,
uint256[] memory balances,
LinearMath.Params memory params,
ImmutableData memory imd
) internal view returns (uint256) {
if (request.tokenIn == IERC20(imd.pool)) {
return _swapGivenBptIn(request, balances, params, imd);
} else if (request.tokenIn == imd._mainToken) {
return _swapGivenMainIn(request, balances, params, imd);
} else if (request.tokenIn == imd._wrappedToken) {
return _swapGivenWrappedIn(request, balances, params, imd);
} else {
assert(false);
}
}
function _swapGivenBptIn(
IVault.SwapRequest memory request,
uint256[] memory balances,
LinearMath.Params memory params,
ImmutableData memory imd
) internal view returns (uint256) {
return (
request.tokenOut == imd._mainToken ? LinearMath._calcMainOutPerBptIn : LinearMath._calcWrappedOutPerBptIn
)(
request.amount,
balances[imd._mainIndex],
balances[imd._wrappedIndex],
_getVirtualSupply(balances[imd._BPT_INDEX], imd.pool),
params
);
}
function _swapGivenMainIn(
IVault.SwapRequest memory request,
uint256[] memory balances,
LinearMath.Params memory params,
ImmutableData memory imd
) internal view returns (uint256) {
return request.tokenOut == IERC20(imd.pool)
? LinearMath._calcBptOutPerMainIn(
request.amount,
balances[imd._mainIndex],
balances[imd._wrappedIndex],
_getVirtualSupply(balances[imd._BPT_INDEX], imd.pool),
params
)
: LinearMath._calcWrappedOutPerMainIn(request.amount, balances[imd._mainIndex], params);
}
function _swapGivenWrappedIn(
IVault.SwapRequest memory request,
uint256[] memory balances,
LinearMath.Params memory params,
ImmutableData memory imd
) internal view returns (uint256) {
return request.tokenOut == IERC20(imd.pool)
? LinearMath._calcBptOutPerWrappedIn(
request.amount,
balances[imd._mainIndex],
balances[imd._wrappedIndex],
_getVirtualSupply(balances[imd._BPT_INDEX], imd.pool),
params
)
: LinearMath._calcMainOutPerWrappedIn(request.amount, balances[imd._mainIndex], params);
}
function _getVirtualSupply(uint256 bptBalance, address pool) internal view returns (uint256) {
return (IERC20(pool).totalSupply()).sub(bptBalance);
}
function _upscale(uint256 amount, uint256 scalingFactor) internal pure returns (uint256) {
return FixedPoint.mulDown(amount, scalingFactor);
}
function _downscaleDown(uint256 amount, uint256 scalingFactor) internal pure returns (uint256) {
return FixedPoint.divDown(amount, scalingFactor);
}
function _upscaleArray(uint256[] memory amounts, uint256[] memory scalingFactors) internal pure {
uint256 length = amounts.length;
for (uint256 i = 0; i < length; ++i) {
amounts[i] = FixedPoint.mulDown(amounts[i], scalingFactors[i]);
}
}
}
文件 68 的 97：LogExpMath.sol
pragma solidity ^0.8.0;
library LogExpMath {
int256 constant ONE_18 = 1e18;
int256 constant ONE_20 = 1e20;
int256 constant ONE_36 = 1e36;
int256 constant MAX_NATURAL_EXPONENT = 130e18;
int256 constant MIN_NATURAL_EXPONENT = -41e18;
int256 constant LN_36_LOWER_BOUND = ONE_18 - 1e17;
int256 constant LN_36_UPPER_BOUND = ONE_18 + 1e17;
uint256 constant MILD_EXPONENT_BOUND = 2 ** 254 / uint256(ONE_20);
int256 constant x0 = 128000000000000000000;
int256 constant a0 = 38877084059945950922200000000000000000000000000000000000;
int256 constant x1 = 64000000000000000000;
int256 constant a1 = 6235149080811616882910000000;
int256 constant x2 = 3200000000000000000000;
int256 constant a2 = 7896296018268069516100000000000000;
int256 constant x3 = 1600000000000000000000;
int256 constant a3 = 888611052050787263676000000;
int256 constant x4 = 800000000000000000000;
int256 constant a4 = 298095798704172827474000;
int256 constant x5 = 400000000000000000000;
int256 constant a5 = 5459815003314423907810;
int256 constant x6 = 200000000000000000000;
int256 constant a6 = 738905609893065022723;
int256 constant x7 = 100000000000000000000;
int256 constant a7 = 271828182845904523536;
int256 constant x8 = 50000000000000000000;
int256 constant a8 = 164872127070012814685;
int256 constant x9 = 25000000000000000000;
int256 constant a9 = 128402541668774148407;
int256 constant x10 = 12500000000000000000;
int256 constant a10 = 113314845306682631683;
int256 constant x11 = 6250000000000000000;
int256 constant a11 = 106449445891785942956;
function exp(int256 x) internal pure returns (int256) {
unchecked {
require(x >= MIN_NATURAL_EXPONENT && x <= MAX_NATURAL_EXPONENT, "Invalid exponent");
if (x < 0) {
return ((ONE_18 * ONE_18) / exp(-x));
}
int256 firstAN;
if (x >= x0) {
x -= x0;
firstAN = a0;
} else if (x >= x1) {
x -= x1;
firstAN = a1;
} else {
firstAN = 1;
}
x *= 100;
int256 product = ONE_20;
if (x >= x2) {
x -= x2;
product = (product * a2) / ONE_20;
}
if (x >= x3) {
x -= x3;
product = (product * a3) / ONE_20;
}
if (x >= x4) {
x -= x4;
product = (product * a4) / ONE_20;
}
if (x >= x5) {
x -= x5;
product = (product * a5) / ONE_20;
}
if (x >= x6) {
x -= x6;
product = (product * a6) / ONE_20;
}
if (x >= x7) {
x -= x7;
product = (product * a7) / ONE_20;
}
if (x >= x8) {
x -= x8;
product = (product * a8) / ONE_20;
}
if (x >= x9) {
x -= x9;
product = (product * a9) / ONE_20;
}
int256 seriesSum = ONE_20;
int256 term;
term = x;
seriesSum += term;
term = ((term * x) / ONE_20) / 2;
seriesSum += term;
term = ((term * x) / ONE_20) / 3;
seriesSum += term;
term = ((term * x) / ONE_20) / 4;
seriesSum += term;
term = ((term * x) / ONE_20) / 5;
seriesSum += term;
term = ((term * x) / ONE_20) / 6;
seriesSum += term;
term = ((term * x) / ONE_20) / 7;
seriesSum += term;
term = ((term * x) / ONE_20) / 8;
seriesSum += term;
term = ((term * x) / ONE_20) / 9;
seriesSum += term;
term = ((term * x) / ONE_20) / 10;
seriesSum += term;
term = ((term * x) / ONE_20) / 11;
seriesSum += term;
term = ((term * x) / ONE_20) / 12;
seriesSum += term;
return (((product * seriesSum) / ONE_20) * firstAN) / 100;
}
}
function ln(int256 a) internal pure returns (int256) {
unchecked {
require(a > 0, "out of bounds");
if (LN_36_LOWER_BOUND < a && a < LN_36_UPPER_BOUND) {
return _ln_36(a) / ONE_18;
} else {
return _ln(a);
}
}
}
function pow(uint256 x, uint256 y) internal pure returns (uint256) {
unchecked {
if (y == 0) {
return uint256(ONE_18);
}
if (x == 0) {
return 0;
}
require(x < 2 ** 255, "x out of bounds");
int256 x_int256 = int256(x);
require(y < MILD_EXPONENT_BOUND, "y out of bounds");
int256 y_int256 = int256(y);
int256 logx_times_y;
if (LN_36_LOWER_BOUND < x_int256 && x_int256 < LN_36_UPPER_BOUND) {
int256 ln_36_x = _ln_36(x_int256);
logx_times_y = ((ln_36_x / ONE_18) *
y_int256 +
((ln_36_x % ONE_18) * y_int256) /
ONE_18);
} else {
logx_times_y = _ln(x_int256) * y_int256;
}
logx_times_y /= ONE_18;
require(
MIN_NATURAL_EXPONENT <= logx_times_y && logx_times_y <= MAX_NATURAL_EXPONENT,
"product out of bounds"
);
return uint256(exp(logx_times_y));
}
}
function _ln(int256 a) private pure returns (int256) {
unchecked {
if (a < ONE_18) {
return (-_ln((ONE_18 * ONE_18) / a));
}
int256 sum = 0;
if (a >= a0 * ONE_18) {
a /= a0;
sum += x0;
}
if (a >= a1 * ONE_18) {
a /= a1;
sum += x1;
}
sum *= 100;
a *= 100;
if (a >= a2) {
a = (a * ONE_20) / a2;
sum += x2;
}
if (a >= a3) {
a = (a * ONE_20) / a3;
sum += x3;
}
if (a >= a4) {
a = (a * ONE_20) / a4;
sum += x4;
}
if (a >= a5) {
a = (a * ONE_20) / a5;
sum += x5;
}
if (a >= a6) {
a = (a * ONE_20) / a6;
sum += x6;
}
if (a >= a7) {
a = (a * ONE_20) / a7;
sum += x7;
}
if (a >= a8) {
a = (a * ONE_20) / a8;
sum += x8;
}
if (a >= a9) {
a = (a * ONE_20) / a9;
sum += x9;
}
if (a >= a10) {
a = (a * ONE_20) / a10;
sum += x10;
}
if (a >= a11) {
a = (a * ONE_20) / a11;
sum += x11;
}
int256 z = ((a - ONE_20) * ONE_20) / (a + ONE_20);
int256 z_squared = (z * z) / ONE_20;
int256 num = z;
int256 seriesSum = num;
num = (num * z_squared) / ONE_20;
seriesSum += num / 3;
num = (num * z_squared) / ONE_20;
seriesSum += num / 5;
num = (num * z_squared) / ONE_20;
seriesSum += num / 7;
num = (num * z_squared) / ONE_20;
seriesSum += num / 9;
num = (num * z_squared) / ONE_20;
seriesSum += num / 11;
seriesSum *= 2;
return (sum + seriesSum) / 100;
}
}
function _ln_36(int256 x) private pure returns (int256) {
unchecked {
x *= ONE_18;
int256 z = ((x - ONE_36) * ONE_36) / (x + ONE_36);
int256 z_squared = (z * z) / ONE_36;
int256 num = z;
int256 seriesSum = num;
num = (num * z_squared) / ONE_36;
seriesSum += num / 3;
num = (num * z_squared) / ONE_36;
seriesSum += num / 5;
num = (num * z_squared) / ONE_36;
seriesSum += num / 7;
num = (num * z_squared) / ONE_36;
seriesSum += num / 9;
num = (num * z_squared) / ONE_36;
seriesSum += num / 11;
num = (num * z_squared) / ONE_36;
seriesSum += num / 13;
num = (num * z_squared) / ONE_36;
seriesSum += num / 15;
return seriesSum * 2;
}
}
}
文件 69 的 97：MarketApproxLib.sol
pragma solidity ^0.8.0;
import "../../core/libraries/math/PMath.sol";
import "../../core/Market/MarketMathCore.sol";
struct ApproxParams {
uint256 guessMin;
uint256 guessMax;
uint256 guessOffchain;
uint256 maxIteration;
uint256 eps;
}
library MarketApproxPtInLib {
using MarketMathCore for MarketState;
using PYIndexLib for PYIndex;
using PMath for uint256;
using PMath for int256;
using LogExpMath for int256;
function approxSwapPtForExactSy(
MarketState memory market,
PYIndex index,
uint256 minSyOut,
uint256 blockTime,
ApproxParams memory approx
) internal pure returns (uint256 , uint256 , uint256 ) {
MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
if (approx.guessOffchain == 0) {
approx.guessMax = PMath.min(approx.guessMax, calcMaxPtIn(market, comp));
validateApprox(approx);
}
for (uint256 iter = 0; iter < approx.maxIteration; ++iter) {
uint256 guess = nextGuess(approx, iter);
(uint256 netSyOut, uint256 netSyFee, ) = calcSyOut(market, comp, index, guess);
if (netSyOut >= minSyOut) {
if (PMath.isAGreaterApproxB(netSyOut, minSyOut, approx.eps))
return (guess, netSyOut, netSyFee);
approx.guessMax = guess;
} else {
approx.guessMin = guess;
}
}
revert Errors.ApproxFail();
}
function approxSwapExactSyForYt(
MarketState memory market,
PYIndex index,
uint256 exactSyIn,
uint256 blockTime,
ApproxParams memory approx
) internal pure returns (uint256 , uint256 ) {
MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
if (approx.guessOffchain == 0) {
approx.guessMin = PMath.max(approx.guessMin, index.syToAsset(exactSyIn));
approx.guessMax = PMath.min(approx.guessMax, calcMaxPtIn(market, comp));
validateApprox(approx);
}
for (uint256 iter = 0; iter < approx.maxIteration; ++iter) {
uint256 guess = nextGuess(approx, iter);
(uint256 netSyOut, uint256 netSyFee, ) = calcSyOut(market, comp, index, guess);
uint256 netSyToTokenizePt = index.assetToSyUp(guess);
uint256 netSyToPull = netSyToTokenizePt - netSyOut;
if (netSyToPull <= exactSyIn) {
if (PMath.isASmallerApproxB(netSyToPull, exactSyIn, approx.eps))
return (guess, netSyFee);
approx.guessMin = guess;
} else {
approx.guessMax = guess - 1;
}
}
revert Errors.ApproxFail();
}
function approxSwapPtToAddLiquidity(
MarketState memory market,
PYIndex index,
uint256 totalPtIn,
uint256 blockTime,
ApproxParams memory approx
)
internal
pure
returns (uint256 , uint256 , uint256 )
{
MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
if (approx.guessOffchain == 0) {
approx.guessMax = PMath.min(approx.guessMax, calcMaxPtIn(market, comp));
approx.guessMax = PMath.min(approx.guessMax, totalPtIn);
validateApprox(approx);
require(market.totalLp != 0, "no existing lp");
}
for (uint256 iter = 0; iter < approx.maxIteration; ++iter) {
uint256 guess = nextGuess(approx, iter);
(
uint256 syNumerator,
uint256 ptNumerator,
uint256 netSyOut,
uint256 netSyFee,
) = calcNumerators(market, index, totalPtIn, comp, guess);
if (PMath.isAApproxB(syNumerator, ptNumerator, approx.eps))
return (guess, netSyOut, netSyFee);
if (syNumerator <= ptNumerator) {
approx.guessMin = guess + 1;
} else {
approx.guessMax = guess - 1;
}
}
revert Errors.ApproxFail();
}
function calcNumerators(
MarketState memory market,
PYIndex index,
uint256 totalPtIn,
MarketPreCompute memory comp,
uint256 guess
)
internal
pure
returns (
uint256 syNumerator,
uint256 ptNumerator,
uint256 netSyOut,
uint256 netSyFee,
uint256 netSyToReserve
)
{
(netSyOut, netSyFee, netSyToReserve) = calcSyOut(market, comp, index, guess);
uint256 newTotalPt = uint256(market.totalPt) + guess;
uint256 newTotalSy = (uint256(market.totalSy) - netSyOut - netSyToReserve);
syNumerator = netSyOut * newTotalPt;
ptNumerator = (totalPtIn - guess) * newTotalSy;
}
struct Args7 {
MarketState market;
PYIndex index;
uint256 exactPtIn;
uint256 blockTime;
}
function approxSwapExactPtForYt(
MarketState memory market,
PYIndex index,
uint256 exactPtIn,
uint256 blockTime,
ApproxParams memory approx
)
internal
pure
returns (uint256 , uint256 , uint256 )
{
MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
if (approx.guessOffchain == 0) {
approx.guessMin = PMath.max(approx.guessMin, exactPtIn);
approx.guessMax = PMath.min(approx.guessMax, calcMaxPtIn(market, comp));
validateApprox(approx);
}
for (uint256 iter = 0; iter < approx.maxIteration; ++iter) {
uint256 guess = nextGuess(approx, iter);
(uint256 netSyOut, uint256 netSyFee, ) = calcSyOut(market, comp, index, guess);
uint256 netAssetOut = index.syToAsset(netSyOut);
uint256 netPtToPull = guess - netAssetOut;
if (netPtToPull <= exactPtIn) {
if (PMath.isASmallerApproxB(netPtToPull, exactPtIn, approx.eps))
return (netAssetOut, guess, netSyFee);
approx.guessMin = guess;
} else {
approx.guessMax = guess - 1;
}
}
revert Errors.ApproxFail();
}
function calcSyOut(
MarketState memory market,
MarketPreCompute memory comp,
PYIndex index,
uint256 netPtIn
) internal pure returns (uint256 netSyOut, uint256 netSyFee, uint256 netSyToReserve) {
(int256 _netSyOut, int256 _netSyFee, int256 _netSyToReserve) = market.calcTrade(
comp,
index,
-int256(netPtIn)
);
netSyOut = uint256(_netSyOut);
netSyFee = uint256(_netSyFee);
netSyToReserve = uint256(_netSyToReserve);
}
function nextGuess(ApproxParams memory approx, uint256 iter) internal pure returns (uint256) {
if (iter == 0 && approx.guessOffchain != 0) return approx.guessOffchain;
if (approx.guessMin <= approx.guessMax) return (approx.guessMin + approx.guessMax) / 2;
revert Errors.ApproxFail();
}
function validateApprox(ApproxParams memory approx) internal pure {
if (approx.guessMin > approx.guessMax || approx.eps > PMath.ONE)
revert Errors.ApproxParamsInvalid(approx.guessMin, approx.guessMax, approx.eps);
}
function calcMaxPtIn(
MarketState memory market,
MarketPreCompute memory comp
) internal pure returns (uint256) {
uint256 low = 0;
uint256 hi = uint256(comp.totalAsset) - 1;
while (low != hi) {
uint256 mid = (low + hi + 1) / 2;
if (calcSlope(comp, market.totalPt, int256(mid)) < 0) hi = mid - 1;
else low = mid;
}
return low;
}
function calcSlope(
MarketPreCompute memory comp,
int256 totalPt,
int256 ptToMarket
) internal pure returns (int256) {
int256 diffAssetPtToMarket = comp.totalAsset - ptToMarket;
int256 sumPt = ptToMarket + totalPt;
require(diffAssetPtToMarket > 0 && sumPt > 0, "invalid ptToMarket");
int256 part1 = (ptToMarket * (totalPt + comp.totalAsset)).divDown(
sumPt * diffAssetPtToMarket
);
int256 part2 = sumPt.divDown(diffAssetPtToMarket).ln();
int256 part3 = PMath.IONE.divDown(comp.rateScalar);
return comp.rateAnchor - (part1 - part2).mulDown(part3);
}
}
library MarketApproxPtOutLib {
using MarketMathCore for MarketState;
using PYIndexLib for PYIndex;
using PMath for uint256;
using PMath for int256;
using LogExpMath for int256;
function approxSwapExactSyForPt(
MarketState memory market,
PYIndex index,
uint256 exactSyIn,
uint256 blockTime,
ApproxParams memory approx
) internal pure returns (uint256 , uint256 ) {
MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
if (approx.guessOffchain == 0) {
approx.guessMax = PMath.min(approx.guessMax, calcMaxPtOut(comp, market.totalPt));
validateApprox(approx);
}
for (uint256 iter = 0; iter < approx.maxIteration; ++iter) {
uint256 guess = nextGuess(approx, iter);
(uint256 netSyIn, uint256 netSyFee, ) = calcSyIn(market, comp, index, guess);
if (netSyIn <= exactSyIn) {
if (PMath.isASmallerApproxB(netSyIn, exactSyIn, approx.eps))
return (guess, netSyFee);
approx.guessMin = guess;
} else {
approx.guessMax = guess - 1;
}
}
revert Errors.ApproxFail();
}
function approxSwapYtForExactSy(
MarketState memory market,
PYIndex index,
uint256 minSyOut,
uint256 blockTime,
ApproxParams memory approx
) internal pure returns (uint256 , uint256 , uint256 ) {
MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
if (approx.guessOffchain == 0) {
approx.guessMax = PMath.min(approx.guessMax, calcMaxPtOut(comp, market.totalPt));
validateApprox(approx);
}
for (uint256 iter = 0; iter < approx.maxIteration; ++iter) {
uint256 guess = nextGuess(approx, iter);
(uint256 netSyOwed, uint256 netSyFee, ) = calcSyIn(market, comp, index, guess);
uint256 netAssetToRepay = index.syToAssetUp(netSyOwed);
uint256 netSyOut = index.assetToSy(guess - netAssetToRepay);
if (netSyOut >= minSyOut) {
if (PMath.isAGreaterApproxB(netSyOut, minSyOut, approx.eps))
return (guess, netSyOut, netSyFee);
approx.guessMax = guess;
} else {
approx.guessMin = guess + 1;
}
}
revert Errors.ApproxFail();
}
struct Args6 {
MarketState market;
PYIndex index;
uint256 totalSyIn;
uint256 blockTime;
ApproxParams approx;
}
function approxSwapSyToAddLiquidity(
MarketState memory _market,
PYIndex _index,
uint256 _totalSyIn,
uint256 _blockTime,
ApproxParams memory _approx
)
internal
pure
returns (uint256 , uint256 , uint256 )
{
Args6 memory a = Args6(_market, _index, _totalSyIn, _blockTime, _approx);
MarketPreCompute memory comp = a.market.getMarketPreCompute(a.index, a.blockTime);
if (a.approx.guessOffchain == 0) {
a.approx.guessMax = PMath.min(a.approx.guessMax, calcMaxPtOut(comp, a.market.totalPt));
validateApprox(a.approx);
require(a.market.totalLp != 0, "no existing lp");
}
for (uint256 iter = 0; iter < a.approx.maxIteration; ++iter) {
uint256 guess = nextGuess(a.approx, iter);
(uint256 netSyIn, uint256 netSyFee, uint256 netSyToReserve) = calcSyIn(
a.market,
comp,
a.index,
guess
);
if (netSyIn > a.totalSyIn) {
a.approx.guessMax = guess - 1;
continue;
}
uint256 syNumerator;
uint256 ptNumerator;
{
uint256 newTotalPt = uint256(a.market.totalPt) - guess;
uint256 netTotalSy = uint256(a.market.totalSy) + netSyIn - netSyToReserve;
ptNumerator = guess * netTotalSy;
syNumerator = (a.totalSyIn - netSyIn) * newTotalPt;
}
if (PMath.isAApproxB(ptNumerator, syNumerator, a.approx.eps))
return (guess, netSyIn, netSyFee);
if (ptNumerator <= syNumerator) {
a.approx.guessMin = guess + 1;
} else {
a.approx.guessMax = guess - 1;
}
}
revert Errors.ApproxFail();
}
function approxSwapExactYtForPt(
MarketState memory market,
PYIndex index,
uint256 exactYtIn,
uint256 blockTime,
ApproxParams memory approx
)
internal
pure
returns (uint256 , uint256 , uint256 )
{
MarketPreCompute memory comp = market.getMarketPreCompute(index, blockTime);
if (approx.guessOffchain == 0) {
approx.guessMin = PMath.max(approx.guessMin, exactYtIn);
approx.guessMax = PMath.min(approx.guessMax, calcMaxPtOut(comp, market.totalPt));
validateApprox(approx);
}
for (uint256 iter = 0; iter < approx.maxIteration; ++iter) {
uint256 guess = nextGuess(approx, iter);
(uint256 netSyOwed, uint256 netSyFee, ) = calcSyIn(market, comp, index, guess);
uint256 netYtToPull = index.syToAssetUp(netSyOwed);
if (netYtToPull <= exactYtIn) {
if (PMath.isASmallerApproxB(netYtToPull, exactYtIn, approx.eps))
return (guess - netYtToPull, guess, netSyFee);
approx.guessMin = guess;
} else {
approx.guessMax = guess - 1;
}
}
revert Errors.ApproxFail();
}
function calcSyIn(
MarketState memory market,
MarketPreCompute memory comp,
PYIndex index,
uint256 netPtOut
) internal pure returns (uint256 netSyIn, uint256 netSyFee, uint256 netSyToReserve) {
(int256 _netSyIn, int256 _netSyFee, int256 _netSyToReserve) = market.calcTrade(
comp,
index,
int256(netPtOut)
);
netSyIn = uint256(-_netSyIn);
netSyFee = uint256(_netSyFee);
netSyToReserve = uint256(_netSyToReserve);
}
function calcMaxPtOut(
MarketPreCompute memory comp,
int256 totalPt
) internal pure returns (uint256) {
int256 logitP = (comp.feeRate - comp.rateAnchor).mulDown(comp.rateScalar).exp();
int256 proportion = logitP.divDown(logitP + PMath.IONE);
int256 numerator = proportion.mulDown(totalPt + comp.totalAsset);
int256 maxPtOut = totalPt - numerator;
return (uint256(maxPtOut) * 999) / 1000;
}
function nextGuess(ApproxParams memory approx, uint256 iter) internal pure returns (uint256) {
if (iter == 0 && approx.guessOffchain != 0) return approx.guessOffchain;
if (approx.guessMin <= approx.guessMax) return (approx.guessMin + approx.guessMax) / 2;
revert Errors.ApproxFail();
}
function validateApprox(ApproxParams memory approx) internal pure {
if (approx.guessMin > approx.guessMax || approx.eps > PMath.ONE)
revert Errors.ApproxParamsInvalid(approx.guessMin, approx.guessMax, approx.eps);
}
}
文件 70 的 97：MiniHelpers.sol
pragma solidity ^0.8.0;
library MiniHelpers {
function isCurrentlyExpired(uint256 expiry) internal view returns (bool) {
return (expiry <= block.timestamp);
}
function isExpired(uint256 expiry, uint256 blockTime) internal pure returns (bool) {
return (expiry <= blockTime);
}
function isTimeInThePast(uint256 timestamp) internal view returns (bool) {
return (timestamp <= block.timestamp);
}
}
文件 71 的 97：PMath.sol
pragma solidity ^0.8.0;
library PMath {
uint256 internal constant ONE = 1e18;
int256 internal constant IONE = 1e18;
function subMax0(uint256 a, uint256 b) internal pure returns (uint256) {
unchecked {
return (a >= b ? a - b : 0);
}
}
function subNoNeg(int256 a, int256 b) internal pure returns (int256) {
require(a >= b, "negative");
return a - b;
}
function mulDown(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 product = a * b;
unchecked {
return product / ONE;
}
}
function mulDown(int256 a, int256 b) internal pure returns (int256) {
int256 product = a * b;
unchecked {
return product / IONE;
}
}
function divDown(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 aInflated = a * ONE;
unchecked {
return aInflated / b;
}
}
function divDown(int256 a, int256 b) internal pure returns (int256) {
int256 aInflated = a * IONE;
unchecked {
return aInflated / b;
}
}
function rawDivUp(uint256 a, uint256 b) internal pure returns (uint256) {
return (a + b - 1) / b;
}
function sqrt(uint256 y) internal pure returns (uint256 z) {
if (y > 3) {
z = y;
uint256 x = y / 2 + 1;
while (x < z) {
z = x;
x = (y / x + x) / 2;
}
} else if (y != 0) {
z = 1;
}
}
function square(uint256 x) internal pure returns (uint256) {
return x * x;
}
function squareDown(uint256 x) internal pure returns (uint256) {
return mulDown(x, x);
}
function abs(int256 x) internal pure returns (uint256) {
return uint256(x > 0 ? x : -x);
}
function neg(int256 x) internal pure returns (int256) {
return x * (-1);
}
function neg(uint256 x) internal pure returns (int256) {
return Int(x) * (-1);
}
function max(uint256 x, uint256 y) internal pure returns (uint256) {
return (x > y ? x : y);
}
function max(int256 x, int256 y) internal pure returns (int256) {
return (x > y ? x : y);
}
function min(uint256 x, uint256 y) internal pure returns (uint256) {
return (x < y ? x : y);
}
function min(int256 x, int256 y) internal pure returns (int256) {
return (x < y ? x : y);
}
function Int(uint256 x) internal pure returns (int256) {
require(x <= uint256(type(int256).max));
return int256(x);
}
function Int128(int256 x) internal pure returns (int128) {
require(type(int128).min <= x && x <= type(int128).max);
return int128(x);
}
function Int128(uint256 x) internal pure returns (int128) {
return Int128(Int(x));
}
function Uint(int256 x) internal pure returns (uint256) {
require(x >= 0);
return uint256(x);
}
function Uint32(uint256 x) internal pure returns (uint32) {
require(x <= type(uint32).max);
return uint32(x);
}
function Uint112(uint256 x) internal pure returns (uint112) {
require(x <= type(uint112).max);
return uint112(x);
}
function Uint96(uint256 x) internal pure returns (uint96) {
require(x <= type(uint96).max);
return uint96(x);
}
function Uint128(uint256 x) internal pure returns (uint128) {
require(x <= type(uint128).max);
return uint128(x);
}
function isAApproxB(
uint256 a,
uint256 b,
uint256 eps
) internal pure returns (bool) {
return mulDown(b, ONE - eps) <= a && a <= mulDown(b, ONE + eps);
}
function isAGreaterApproxB(
uint256 a,
uint256 b,
uint256 eps
) internal pure returns (bool) {
return a >= b && a <= mulDown(b, ONE + eps);
}
function isASmallerApproxB(
uint256 a,
uint256 b,
uint256 eps
) internal pure returns (bool) {
return a <= b && a >= mulDown(b, ONE - eps);
}
}
文件 72 的 97：PYIndex.sol
pragma solidity ^0.8.0;
import "../../interfaces/IPYieldToken.sol";
import "../../interfaces/IPPrincipalToken.sol";
import "./SYUtils.sol";
import "../libraries/math/PMath.sol";
type PYIndex is uint256;
library PYIndexLib {
using PMath for uint256;
using PMath for int256;
function newIndex(IPYieldToken YT) internal returns (PYIndex) {
return PYIndex.wrap(YT.pyIndexCurrent());
}
function syToAsset(PYIndex index, uint256 syAmount) internal pure returns (uint256) {
return SYUtils.syToAsset(PYIndex.unwrap(index), syAmount);
}
function assetToSy(PYIndex index, uint256 assetAmount) internal pure returns (uint256) {
return SYUtils.assetToSy(PYIndex.unwrap(index), assetAmount);
}
function assetToSyUp(PYIndex index, uint256 assetAmount) internal pure returns (uint256) {
return SYUtils.assetToSyUp(PYIndex.unwrap(index), assetAmount);
}
function syToAssetUp(PYIndex index, uint256 syAmount) internal pure returns (uint256) {
uint256 _index = PYIndex.unwrap(index);
return SYUtils.syToAssetUp(_index, syAmount);
}
function syToAsset(PYIndex index, int256 syAmount) internal pure returns (int256) {
int256 sign = syAmount < 0 ? int256(-1) : int256(1);
return sign * (SYUtils.syToAsset(PYIndex.unwrap(index), syAmount.abs())).Int();
}
function assetToSy(PYIndex index, int256 assetAmount) internal pure returns (int256) {
int256 sign = assetAmount < 0 ? int256(-1) : int256(1);
return sign * (SYUtils.assetToSy(PYIndex.unwrap(index), assetAmount.abs())).Int();
}
function assetToSyUp(PYIndex index, int256 assetAmount) internal pure returns (int256) {
int256 sign = assetAmount < 0 ? int256(-1) : int256(1);
return sign * (SYUtils.assetToSyUp(PYIndex.unwrap(index), assetAmount.abs())).Int();
}
}
文件 73 的 97：Pausable.sol
pragma solidity ^0.8.0;
import "../utils/Context.sol";
abstract contract Pausable is Context {
event Paused(address account);
event Unpaused(address account);
bool private _paused;
constructor() {
_paused = false;
}
modifier whenNotPaused() {
_requireNotPaused();
_;
}
modifier whenPaused() {
_requirePaused();
_;
}
function paused() public view virtual returns (bool) {
return _paused;
}
function _requireNotPaused() internal view virtual {
require(!paused(), "Pausable: paused");
}
function _requirePaused() internal view virtual {
require(paused(), "Pausable: not paused");
}
function _pause() internal virtual whenNotPaused {
_paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
_paused = false;
emit Unpaused(_msgSender());
}
}
文件 74 的 97：PendleAuraBalancerStableLPSYV2.sol
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "../../../../../interfaces/Balancer/IVault.sol";
import "../../../../../interfaces/Balancer/IRateProvider.sol";
import "../../../../../interfaces/Balancer/IBasePool.sol";
import "../../../../../interfaces/Balancer/IBalancerStablePreview.sol";
import "../../../../../interfaces/ConvexCurve/IBooster.sol";
import "../../../../../interfaces/ConvexCurve/IRewards.sol";
import "./StablePoolUserData.sol";
import "../../../../libraries/ArrayLib.sol";
import "../../../SYBaseWithRewards.sol";
abstract contract PendleAuraBalancerStableLPSYV2 is SYBaseWithRewards {
using ArrayLib for address[];
address internal constant BAL_TOKEN = 0xba100000625a3754423978a60c9317c58a424e3D;
address internal constant AURA_TOKEN = 0xC0c293ce456fF0ED870ADd98a0828Dd4d2903DBF;
address internal constant AURA_BOOSTER = 0xA57b8d98dAE62B26Ec3bcC4a365338157060B234;
address internal constant BALANCER_VAULT = 0xBA12222222228d8Ba445958a75a0704d566BF2C8;
uint256 internal constant DEFAULT_GAS_REENTRANCY_CHECK = 7000;
address public immutable balLp;
bytes32 public immutable balPoolId;
uint256 public immutable auraPid;
address public immutable auraRewardManager;
IBalancerStablePreview public immutable previewHelper;
uint256 public gasForReentrancyCheck;
address[] public extraRewards;
constructor(
string memory _name,
string memory _symbol,
address _balLp,
uint256 _auraPid,
IBalancerStablePreview _previewHelper
) SYBaseWithRewards(_name, _symbol, _balLp) {
balPoolId = IBasePool(_balLp).getPoolId();
auraPid = _auraPid;
(balLp, auraRewardManager) = _getPoolInfo(_auraPid);
if (balLp != _balLp) revert Errors.SYBalancerInvalidPid();
_safeApproveInf(_balLp, AURA_BOOSTER);
address[] memory tokens = _getPoolTokenAddresses();
for (uint256 i = 0; i < tokens.length; ++i) {
_safeApproveInf(tokens[i], BALANCER_VAULT);
}
previewHelper = _previewHelper;
gasForReentrancyCheck = DEFAULT_GAS_REENTRANCY_CHECK;
}
function _getPoolInfo(uint256 _auraPid)
internal
view
returns (address _auraLp, address _auraRewardManager)
{
if (_auraPid > IBooster(AURA_BOOSTER).poolLength()) revert Errors.SYBalancerInvalidPid();
(_auraLp, , , _auraRewardManager, , ) = IBooster(AURA_BOOSTER).poolInfo(_auraPid);
}
function _deposit(address tokenIn, uint256 amount)
internal
virtual
override
returns (uint256 amountSharesOut)
{
if (tokenIn == balLp) {
amountSharesOut = amount;
} else {
amountSharesOut = _depositToBalancer(tokenIn, amount);
}
IBooster(AURA_BOOSTER).deposit(auraPid, amountSharesOut, true);
}
function _redeem(
address receiver,
address tokenOut,
uint256 amountSharesToRedeem
) internal virtual override returns (uint256 amountTokenOut) {
IRewards(auraRewardManager).withdrawAndUnwrap(amountSharesToRedeem, false);
if (tokenOut == balLp) {
amountTokenOut = amountSharesToRedeem;
_transferOut(tokenOut, receiver, amountTokenOut);
} else {
amountTokenOut = _redeemFromBalancer(receiver, tokenOut, amountSharesToRedeem);
}
}
function exchangeRate() external view override returns (uint256) {
_checkBalancerReadOnlyReentrancy();
return IRateProvider(balLp).getRate();
}
function _checkBalancerReadOnlyReentrancy() internal view {
IVault.UserBalanceOp[] memory noop = new IVault.UserBalanceOp[](0);
(bool isSuccess, bytes memory response) = BALANCER_VAULT.staticcall{
gas: gasForReentrancyCheck
}(
abi.encodeWithSignature(
"manageUserBalance((uint8,address,uint256,address,address)[])",
noop
)
);
assert(!isSuccess);
if (response.length != 0) revert Errors.SYBalancerReentrancy();
}
function setGasForReentrancyCheck(uint256 newGas) external onlyOwner {
require(newGas >= DEFAULT_GAS_REENTRANCY_CHECK, "lower than default");
gasForReentrancyCheck = newGas;
}
function _depositToBalancer(address tokenIn, uint256 amountTokenToDeposit)
internal
virtual
returns (uint256)
{
IVault.JoinPoolRequest memory request = _assembleJoinRequest(
tokenIn,
amountTokenToDeposit
);
IVault(BALANCER_VAULT).joinPool(balPoolId, address(this), address(this), request);
return _selfBalance(balLp);
}
function _assembleJoinRequest(address tokenIn, uint256 amountTokenToDeposit)
internal
view
virtual
returns (IVault.JoinPoolRequest memory request)
{
address[] memory assets = _getPoolTokenAddresses();
uint256 amountsLength = _getBPTIndex() < type(uint256).max
? assets.length - 1
: assets.length;
uint256[] memory amountsIn = new uint256[](amountsLength);
uint256[] memory maxAmountsIn = new uint256[](assets.length);
uint256 index = assets.find(tokenIn);
uint256 indexSkipBPT = index > _getBPTIndex() ? index - 1 : index;
maxAmountsIn[index] = amountsIn[indexSkipBPT] = amountTokenToDeposit;
StablePoolUserData.JoinKind joinKind = StablePoolUserData
.JoinKind
.EXACT_TOKENS_IN_FOR_BPT_OUT;
uint256 minimumBPT = 0;
bytes memory userData = abi.encode(joinKind, amountsIn, minimumBPT);
request = IVault.JoinPoolRequest(assets, maxAmountsIn, userData, false);
}
function _redeemFromBalancer(
address receiver,
address tokenOut,
uint256 amountLpToRedeem
) internal virtual returns (uint256) {
uint256 balanceBefore = IERC20(tokenOut).balanceOf(receiver);
IVault.ExitPoolRequest memory request = _assembleExitRequest(tokenOut, amountLpToRedeem);
IVault(BALANCER_VAULT).exitPool(balPoolId, address(this), payable(receiver), request);
uint256 balanceAfter = IERC20(tokenOut).balanceOf(receiver);
return balanceAfter - balanceBefore;
}
function _assembleExitRequest(address tokenOut, uint256 amountLpToRedeem)
internal
view
virtual
returns (IVault.ExitPoolRequest memory request)
{
address[] memory assets = _getPoolTokenAddresses();
uint256[] memory minAmountsOut = new uint256[](assets.length);
StablePoolUserData.ExitKind exitKind = StablePoolUserData
.ExitKind
.EXACT_BPT_IN_FOR_ONE_TOKEN_OUT;
uint256 bptAmountIn = amountLpToRedeem;
uint256 exitTokenIndex = assets.find(tokenOut);
exitTokenIndex = _getBPTIndex() < exitTokenIndex ? exitTokenIndex - 1 : exitTokenIndex;
bytes memory userData = abi.encode(exitKind, bptAmountIn, exitTokenIndex);
request = IVault.ExitPoolRequest(assets, minAmountsOut, userData, false);
}
function _getPoolTokenAddresses() internal view virtual returns (address[] memory res);
function _getBPTIndex() internal view virtual returns (uint256) {
return type(uint256).max;
}
function _previewDeposit(address tokenIn, uint256 amountTokenToDeposit)
internal
view
virtual
override
returns (uint256 amountSharesOut)
{
if (tokenIn == balLp) {
amountSharesOut = amountTokenToDeposit;
} else {
IVault.JoinPoolRequest memory request = _assembleJoinRequest(
tokenIn,
amountTokenToDeposit
);
amountSharesOut = previewHelper.joinPoolPreview(
balPoolId,
address(this),
address(this),
request,
_getImmutablePoolData()
);
}
}
function _previewRedeem(address tokenOut, uint256 amountSharesToRedeem)
internal
view
virtual
override
returns (uint256 amountTokenOut)
{
if (tokenOut == balLp) {
amountTokenOut = amountSharesToRedeem;
} else {
IVault.ExitPoolRequest memory request = _assembleExitRequest(
tokenOut,
amountSharesToRedeem
);
amountTokenOut = previewHelper.exitPoolPreview(
balPoolId,
address(this),
address(this),
request,
_getImmutablePoolData()
);
}
}
function _getImmutablePoolData() internal view virtual returns (bytes memory);
function addRewardTokens(address token) external virtual onlyOwner {
if (token == BAL_TOKEN || token == AURA_TOKEN || extraRewards.contains(token))
revert Errors.SYInvalidRewardToken(token);
uint256 nRewardsAura = IRewards(auraRewardManager).extraRewardsLength();
for (uint256 i = 0; i < nRewardsAura; i++) {
if (token == IRewards(IRewards(auraRewardManager).extraRewards(i)).rewardToken()) {
extraRewards.push(token);
return;
}
}
revert Errors.SYInvalidRewardToken(token);
}
function extraRewardsLength() external view virtual returns (uint256) {
return extraRewards.length;
}
function _getRewardTokens() internal view virtual override returns (address[] memory res) {
uint256 extraRewardsLen = extraRewards.length;
res = new address[](2 + extraRewardsLen);
res[0] = BAL_TOKEN;
res[1] = AURA_TOKEN;
for (uint256 i = 0; i < extraRewardsLen; i++) {
res[2 + i] = extraRewards[i];
}
}
function _redeemExternalReward() internal virtual override {
uint256 extraRewardsLen = extraRewards.length;
if (extraRewardsLen == 0) IRewards(auraRewardManager).getReward(address(this), false);
else IRewards(auraRewardManager).getReward(address(this), true);
}
function getTokensIn() public view virtual override returns (address[] memory res);
function getTokensOut() public view virtual override returns (address[] memory res);
function isValidTokenIn(address token) public view virtual override returns (bool);
function isValidTokenOut(address token) public view virtual override returns (bool);
function assetInfo()
external
view
returns (
AssetType assetType,
address assetAddress,
uint8 assetDecimals
)
{
return (AssetType.LIQUIDITY, balLp, IERC20Metadata(balLp).decimals());
}
}
文件 75 的 97：PendleERC20Permit.sol
pragma solidity ^0.8.0;
import "./PendleERC20.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/draft-ERC20Permit.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
contract PendleERC20Permit is PendleERC20, 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)"
);
constructor(
string memory name_,
string memory symbol_,
uint8 decimals_
) PendleERC20(name_, symbol_, decimals_) 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();
}
}
文件 76 的 97：PendleMarketFactory.sol
pragma solidity 0.8.17;
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "../../interfaces/IPMarket.sol";
import "../../interfaces/IPYieldContractFactory.sol";
import "../../interfaces/IPMarketFactory.sol";
import "../libraries/BaseSplitCodeFactory.sol";
import "../libraries/Errors.sol";
import "../libraries/BoringOwnableUpgradeable.sol";
contract PendleMarketFactory is BoringOwnableUpgradeable, IPMarketFactory {
using EnumerableSet for EnumerableSet.AddressSet;
address public immutable marketCreationCodeContractA;
uint256 public immutable marketCreationCodeSizeA;
address public immutable marketCreationCodeContractB;
uint256 public immutable marketCreationCodeSizeB;
address public immutable yieldContractFactory;
uint256 public immutable maxLnFeeRateRoot;
uint8 public constant maxReserveFeePercent = 100;
int256 public constant minInitialAnchor = PMath.IONE;
address public treasury;
FeeConfig public defaultFee;
mapping(address => FeeConfig) public overriddenFee;
mapping(address => mapping(int256 => mapping(int256 => address))) internal markets;
EnumerableSet.AddressSet internal allMarkets;
address public vePendle;
address public gaugeController;
constructor(
address _yieldContractFactory,
address _marketCreationCodeContractA,
uint256 _marketCreationCodeSizeA,
address _marketCreationCodeContractB,
uint256 _marketCreationCodeSizeB
) {
yieldContractFactory = _yieldContractFactory;
maxLnFeeRateRoot = uint256(LogExpMath.ln(int256((105 * PMath.IONE) / 100)));
marketCreationCodeContractA = _marketCreationCodeContractA;
marketCreationCodeSizeA = _marketCreationCodeSizeA;
marketCreationCodeContractB = _marketCreationCodeContractB;
marketCreationCodeSizeB = _marketCreationCodeSizeB;
}
function initialize(
address _treasury,
uint80 _defaultLnFeeRateRoot,
uint8 _defaultReserveFeePercent,
address newVePendle,
address newGaugeController
) external initializer {
__BoringOwnable_init();
setTreasury(_treasury);
setDefaultFee(_defaultLnFeeRateRoot, _defaultReserveFeePercent);
vePendle = newVePendle;
gaugeController = newGaugeController;
}
function createNewMarket(
address PT,
int256 scalarRoot,
int256 initialAnchor
) external returns (address market) {
if (!IPYieldContractFactory(yieldContractFactory).isPT(PT))
revert Errors.MarketFactoryInvalidPt();
if (IPPrincipalToken(PT).isExpired()) revert Errors.MarketFactoryExpiredPt();
if (markets[PT][scalarRoot][initialAnchor] != address(0))
revert Errors.MarketFactoryMarketExists();
if (initialAnchor < minInitialAnchor)
revert Errors.MarketFactoryInitialAnchorTooLow(initialAnchor, minInitialAnchor);
market = BaseSplitCodeFactory._create2(
0,
bytes32(block.chainid),
abi.encode(PT, scalarRoot, initialAnchor, vePendle, gaugeController),
marketCreationCodeContractA,
marketCreationCodeSizeA,
marketCreationCodeContractB,
marketCreationCodeSizeB
);
markets[PT][scalarRoot][initialAnchor] = market;
if (!allMarkets.add(market)) assert(false);
emit CreateNewMarket(market, PT, scalarRoot, initialAnchor);
}
function getMarketConfig(
address router
) external view returns (address _treasury, uint80 _lnFeeRateRoot, uint8 _reserveFeePercent) {
(_treasury, _lnFeeRateRoot, _reserveFeePercent) = (
treasury,
defaultFee.lnFeeRateRoot,
defaultFee.reserveFeePercent
);
FeeConfig memory over = overriddenFee[router];
if (over.active) {
(_lnFeeRateRoot, _reserveFeePercent) = (over.lnFeeRateRoot, over.reserveFeePercent);
}
}
function isValidMarket(address market) external view returns (bool) {
return allMarkets.contains(market);
}
function setTreasury(address newTreasury) public onlyOwner {
if (newTreasury == address(0)) revert Errors.MarketFactoryZeroTreasury();
treasury = newTreasury;
_emitNewMarketConfigEvent();
}
function setDefaultFee(uint80 newLnFeeRateRoot, uint8 newReserveFeePercent) public onlyOwner {
_verifyFeeConfig(newLnFeeRateRoot, newReserveFeePercent);
defaultFee = FeeConfig(newLnFeeRateRoot, newReserveFeePercent, true);
_emitNewMarketConfigEvent();
}
function setOverriddenFee(
address router,
uint80 newLnFeeRateRoot,
uint8 newReserveFeePercent
) public onlyOwner {
_verifyFeeConfig(newLnFeeRateRoot, newReserveFeePercent);
overriddenFee[router] = FeeConfig(newLnFeeRateRoot, newReserveFeePercent, true);
emit SetOverriddenFee(router, newLnFeeRateRoot, newReserveFeePercent);
}
function unsetOverriddenFee(address router) external onlyOwner {
delete overriddenFee[router];
emit UnsetOverriddenFee(router);
}
function _verifyFeeConfig(uint80 newLnFeeRateRoot, uint8 newReserveFeePercent) internal view {
if (newLnFeeRateRoot > maxLnFeeRateRoot)
revert Errors.MarketFactoryLnFeeRateRootTooHigh(newLnFeeRateRoot, maxLnFeeRateRoot);
if (newReserveFeePercent > maxReserveFeePercent)
revert Errors.MarketFactoryReserveFeePercentTooHigh(
newReserveFeePercent,
maxReserveFeePercent
);
}
function _emitNewMarketConfigEvent() internal {
emit NewMarketConfig(treasury, defaultFee.lnFeeRateRoot, defaultFee.reserveFeePercent);
}
}
文件 77 的 97：PendlePrincipalToken.sol
pragma solidity 0.8.17;
import "../../interfaces/IPPrincipalToken.sol";
import "../../interfaces/IPYieldToken.sol";
import "../libraries/MiniHelpers.sol";
import "../libraries/Errors.sol";
import "../erc20/PendleERC20Permit.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
contract PendlePrincipalToken is PendleERC20Permit, Initializable, IPPrincipalToken {
address public immutable SY;
address public immutable factory;
uint256 public immutable expiry;
address public YT;
modifier onlyYT() {
if (msg.sender != YT) revert Errors.OnlyYT();
_;
}
modifier onlyYieldFactory() {
if (msg.sender != factory) revert Errors.OnlyYCFactory();
_;
}
constructor(
address _SY,
string memory _name,
string memory _symbol,
uint8 __decimals,
uint256 _expiry
) PendleERC20Permit(_name, _symbol, __decimals) {
SY = _SY;
expiry = _expiry;
factory = msg.sender;
}
function initialize(address _YT) external initializer onlyYieldFactory {
YT = _YT;
}
function burnByYT(address user, uint256 amount) external onlyYT {
_burn(user, amount);
}
function mintByYT(address user, uint256 amount) external onlyYT {
_mint(user, amount);
}
function isExpired() public view returns (bool) {
return MiniHelpers.isCurrentlyExpired(expiry);
}
}
文件 78 的 97：PendleYieldContractFactory.sol
pragma solidity 0.8.17;
import "../../interfaces/IPYieldContractFactory.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import "../libraries/ExpiryUtilsLib.sol";
import "../libraries/BaseSplitCodeFactory.sol";
import "../libraries/MiniHelpers.sol";
import "../libraries/Errors.sol";
import "../libraries/BoringOwnableUpgradeable.sol";
import "../libraries/StringLib.sol";
import "./PendlePrincipalToken.sol";
import "./PendleYieldToken.sol";
contract PendleYieldContractFactory is BoringOwnableUpgradeable, IPYieldContractFactory {
using ExpiryUtils for string;
using StringLib for string;
using StringLib for StringLib.slice;
string private constant PT_PREFIX = "PT";
string private constant YT_PREFIX = "YT";
string private constant SY_SYMBOL_PREF = "SY-";
string private constant SY_NAME_PREF = "SY ";
address public immutable ytCreationCodeContractA;
uint256 public immutable ytCreationCodeSizeA;
address public immutable ytCreationCodeContractB;
uint256 public immutable ytCreationCodeSizeB;
uint128 public interestFeeRate;
uint128 public rewardFeeRate;
address public treasury;
uint96 public expiryDivisor;
mapping(address => mapping(uint256 => address)) public getPT;
mapping(address => mapping(uint256 => address)) public getYT;
mapping(address => bool) public isPT;
mapping(address => bool) public isYT;
uint256 public constant maxInterestFeeRate = 2e17;
uint256 public constant maxRewardFeeRate = 2e17;
constructor(
address _ytCreationCodeContractA,
uint256 _ytCreationCodeSizeA,
address _ytCreationCodeContractB,
uint256 _ytCreationCodeSizeB
) {
ytCreationCodeContractA = _ytCreationCodeContractA;
ytCreationCodeSizeA = _ytCreationCodeSizeA;
ytCreationCodeContractB = _ytCreationCodeContractB;
ytCreationCodeSizeB = _ytCreationCodeSizeB;
}
function initialize(
uint96 _expiryDivisor,
uint128 _interestFeeRate,
uint128 _rewardFeeRate,
address _treasury
) external initializer {
__BoringOwnable_init();
setExpiryDivisor(_expiryDivisor);
setInterestFeeRate(_interestFeeRate);
setRewardFeeRate(_rewardFeeRate);
setTreasury(_treasury);
}
function createYieldContract(
address SY,
uint32 expiry,
bool doCacheIndexSameBlock
) external returns (address PT, address YT) {
if (MiniHelpers.isTimeInThePast(expiry) || expiry % expiryDivisor != 0)
revert Errors.YCFactoryInvalidExpiry();
if (getPT[SY][expiry] != address(0)) revert Errors.YCFactoryYieldContractExisted();
IStandardizedYield _SY = IStandardizedYield(SY);
(, , uint8 assetDecimals) = _SY.assetInfo();
string memory syCoreName = _stripSYPrefix(_SY.name());
string memory syCoreSymbol = _stripSYPrefix(_SY.symbol());
PT = Create2.deploy(
0,
bytes32(block.chainid),
abi.encodePacked(
type(PendlePrincipalToken).creationCode,
abi.encode(
SY,
PT_PREFIX.concat(syCoreName, expiry, " "),
PT_PREFIX.concat(syCoreSymbol, expiry, "-"),
assetDecimals,
expiry
)
)
);
YT = BaseSplitCodeFactory._create2(
0,
bytes32(block.chainid),
abi.encode(
SY,
PT,
YT_PREFIX.concat(syCoreName, expiry, " "),
YT_PREFIX.concat(syCoreSymbol, expiry, "-"),
assetDecimals,
expiry,
doCacheIndexSameBlock
),
ytCreationCodeContractA,
ytCreationCodeSizeA,
ytCreationCodeContractB,
ytCreationCodeSizeB
);
IPPrincipalToken(PT).initialize(YT);
getPT[SY][expiry] = PT;
getYT[SY][expiry] = YT;
isPT[PT] = true;
isYT[YT] = true;
emit CreateYieldContract(SY, expiry, PT, YT);
}
function setExpiryDivisor(uint96 newExpiryDivisor) public onlyOwner {
if (newExpiryDivisor == 0) revert Errors.YCFactoryZeroExpiryDivisor();
expiryDivisor = newExpiryDivisor;
emit SetExpiryDivisor(newExpiryDivisor);
}
function setInterestFeeRate(uint128 newInterestFeeRate) public onlyOwner {
if (newInterestFeeRate > maxInterestFeeRate)
revert Errors.YCFactoryInterestFeeRateTooHigh(newInterestFeeRate, maxInterestFeeRate);
interestFeeRate = newInterestFeeRate;
emit SetInterestFeeRate(newInterestFeeRate);
}
function setRewardFeeRate(uint128 newRewardFeeRate) public onlyOwner {
if (newRewardFeeRate > maxRewardFeeRate)
revert Errors.YCFactoryRewardFeeRateTooHigh(newRewardFeeRate, maxRewardFeeRate);
rewardFeeRate = newRewardFeeRate;
emit SetRewardFeeRate(newRewardFeeRate);
}
function setTreasury(address newTreasury) public onlyOwner {
if (newTreasury == address(0)) revert Errors.YCFactoryZeroTreasury();
treasury = newTreasury;
emit SetTreasury(newTreasury);
}
function _stripSYPrefix(string memory _str) internal pure returns (string memory) {
StringLib.slice memory str = _str.toSlice();
StringLib.slice memory delim_name = SY_NAME_PREF.toSlice();
StringLib.slice memory delim_symbol = SY_SYMBOL_PREF.toSlice();
return str.beyond(delim_name).beyond(delim_symbol).toString();
}
}
文件 79 的 97：PendleYieldToken.sol
pragma solidity 0.8.17;
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "../../interfaces/IStandardizedYield.sol";
import "../../interfaces/IPYieldToken.sol";
import "../../interfaces/IPPrincipalToken.sol";
import "../libraries/math/PMath.sol";
import "../libraries/ArrayLib.sol";
import "../../interfaces/IPYieldContractFactory.sol";
import "../StandardizedYield/SYUtils.sol";
import "../libraries/Errors.sol";
import "../libraries/MiniHelpers.sol";
import "../RewardManager/RewardManagerAbstract.sol";
import "../erc20/PendleERC20Permit.sol";
import "./InterestManagerYT.sol";
contract PendleYieldToken is
IPYieldToken,
PendleERC20Permit,
RewardManagerAbstract,
InterestManagerYT
{
using PMath for uint256;
using SafeERC20 for IERC20;
using ArrayLib for uint256[];
struct PostExpiryData {
uint128 firstPYIndex;
uint128 totalSyInterestForTreasury;
mapping(address => uint256) firstRewardIndex;
mapping(address => uint256) userRewardOwed;
}
address public immutable SY;
address public immutable PT;
address public immutable factory;
uint256 public immutable expiry;
bool public immutable doCacheIndexSameBlock;
uint256 public syReserve;
uint128 public pyIndexLastUpdatedBlock;
uint128 internal _pyIndexStored;
PostExpiryData public postExpiry;
modifier updateData() {
if (isExpired()) _setPostExpiryData();
_;
_updateSyReserve();
}
modifier notExpired() {
if (isExpired()) revert Errors.YCExpired();
_;
}
constructor(
address _SY,
address _PT,
string memory _name,
string memory _symbol,
uint8 __decimals,
uint256 _expiry,
bool _doCacheIndexSameBlock
) PendleERC20Permit(_name, _symbol, __decimals) {
SY = _SY;
PT = _PT;
expiry = _expiry;
factory = msg.sender;
doCacheIndexSameBlock = _doCacheIndexSameBlock;
}
function mintPY(
address receiverPT,
address receiverYT
) external nonReentrant notExpired updateData returns (uint256 amountPYOut) {
address[] memory receiverPTs = new address[](1);
address[] memory receiverYTs = new address[](1);
uint256[] memory amountSyToMints = new uint256[](1);
(receiverPTs[0], receiverYTs[0], amountSyToMints[0]) = (
receiverPT,
receiverYT,
_getFloatingSyAmount()
);
uint256[] memory amountPYOuts = _mintPY(receiverPTs, receiverYTs, amountSyToMints);
amountPYOut = amountPYOuts[0];
}
function mintPYMulti(
address[] calldata receiverPTs,
address[] calldata receiverYTs,
uint256[] calldata amountSyToMints
) external nonReentrant notExpired updateData returns (uint256[] memory amountPYOuts) {
uint256 length = receiverPTs.length;
if (length == 0) revert Errors.ArrayEmpty();
if (receiverYTs.length != length || amountSyToMints.length != length)
revert Errors.ArrayLengthMismatch();
uint256 totalSyToMint = amountSyToMints.sum();
if (totalSyToMint > _getFloatingSyAmount())
revert Errors.YieldContractInsufficientSy(totalSyToMint, _getFloatingSyAmount());
amountPYOuts = _mintPY(receiverPTs, receiverYTs, amountSyToMints);
}
function redeemPY(
address receiver
) external nonReentrant updateData returns (uint256 amountSyOut) {
address[] memory receivers = new address[](1);
uint256[] memory amounts = new uint256[](1);
(receivers[0], amounts[0]) = (receiver, _getAmountPYToRedeem());
uint256[] memory amountSyOuts;
amountSyOuts = _redeemPY(receivers, amounts);
amountSyOut = amountSyOuts[0];
}
function redeemPYMulti(
address[] calldata receivers,
uint256[] calldata amountPYToRedeems
) external nonReentrant updateData returns (uint256[] memory amountSyOuts) {
if (receivers.length != amountPYToRedeems.length) revert Errors.ArrayLengthMismatch();
if (receivers.length == 0) revert Errors.ArrayEmpty();
amountSyOuts = _redeemPY(receivers, amountPYToRedeems);
}
function redeemDueInterestAndRewards(
address user,
bool redeemInterest,
bool redeemRewards
) external nonReentrant updateData returns (uint256 interestOut, uint256[] memory rewardsOut) {
if (!redeemInterest && !redeemRewards) revert Errors.YCNothingToRedeem();
_updateAndDistributeRewards(user);
if (redeemRewards) {
rewardsOut = _doTransferOutRewards(user, user);
emit RedeemRewards(user, rewardsOut);
} else {
address[] memory tokens = getRewardTokens();
rewardsOut = new uint256[](tokens.length);
}
if (redeemInterest) {
_distributeInterest(user);
interestOut = _doTransferOutInterest(user, SY, factory);
emit RedeemInterest(user, interestOut);
} else {
interestOut = 0;
}
}
function redeemInterestAndRewardsPostExpiryForTreasury()
external
nonReentrant
updateData
returns (uint256 interestOut, uint256[] memory rewardsOut)
{
if (!isExpired()) revert Errors.YCNotExpired();
address treasury = IPYieldContractFactory(factory).treasury();
address[] memory tokens = getRewardTokens();
rewardsOut = new uint256[](tokens.length);
_redeemExternalReward();
for (uint256 i = 0; i < tokens.length; i++) {
rewardsOut[i] = _selfBalance(tokens[i]) - postExpiry.userRewardOwed[tokens[i]];
}
_transferOut(tokens, treasury, rewardsOut);
interestOut = postExpiry.totalSyInterestForTreasury;
postExpiry.totalSyInterestForTreasury = 0;
_transferOut(SY, treasury, interestOut);
}
function rewardIndexesCurrent() external override nonReentrant returns (uint256[] memory) {
return IStandardizedYield(SY).rewardIndexesCurrent();
}
function pyIndexCurrent() public nonReentrant returns (uint256 currentIndex) {
currentIndex = _pyIndexCurrent();
}
function pyIndexStored() public view returns (uint256) {
return _pyIndexStored;
}
function setPostExpiryData() external nonReentrant {
if (isExpired()) {
_setPostExpiryData();
}
}
function getPostExpiryData()
external
view
returns (
uint256 firstPYIndex,
uint256 totalSyInterestForTreasury,
uint256[] memory firstRewardIndexes,
uint256[] memory userRewardOwed
)
{
if (postExpiry.firstPYIndex == 0) revert Errors.YCPostExpiryDataNotSet();
firstPYIndex = postExpiry.firstPYIndex;
totalSyInterestForTreasury = postExpiry.totalSyInterestForTreasury;
address[] memory tokens = getRewardTokens();
firstRewardIndexes = new uint256[](tokens.length);
userRewardOwed = new uint256[](tokens.length);
for (uint256 i = 0; i < tokens.length; ++i) {
firstRewardIndexes[i] = postExpiry.firstRewardIndex[tokens[i]];
userRewardOwed[i] = postExpiry.userRewardOwed[tokens[i]];
}
}
function _mintPY(
address[] memory receiverPTs,
address[] memory receiverYTs,
uint256[] memory amountSyToMints
) internal returns (uint256[] memory amountPYOuts) {
amountPYOuts = new uint256[](amountSyToMints.length);
uint256 index = _pyIndexCurrent();
for (uint256 i = 0; i < amountSyToMints.length; i++) {
amountPYOuts[i] = _calcPYToMint(amountSyToMints[i], index);
_mint(receiverYTs[i], amountPYOuts[i]);
IPPrincipalToken(PT).mintByYT(receiverPTs[i], amountPYOuts[i]);
emit Mint(
msg.sender,
receiverPTs[i],
receiverYTs[i],
amountSyToMints[i],
amountPYOuts[i]
);
}
}
function isExpired() public view returns (bool) {
return MiniHelpers.isCurrentlyExpired(expiry);
}
function _redeemPY(
address[] memory receivers,
uint256[] memory amountPYToRedeems
) internal returns (uint256[] memory amountSyOuts) {
uint256 totalAmountPYToRedeem = amountPYToRedeems.sum();
IPPrincipalToken(PT).burnByYT(address(this), totalAmountPYToRedeem);
if (!isExpired()) _burn(address(this), totalAmountPYToRedeem);
uint256 index = _pyIndexCurrent();
uint256 totalSyInterestPostExpiry;
amountSyOuts = new uint256[](receivers.length);
for (uint256 i = 0; i < receivers.length; i++) {
uint256 syInterestPostExpiry;
(amountSyOuts[i], syInterestPostExpiry) = _calcSyRedeemableFromPY(
amountPYToRedeems[i],
index
);
_transferOut(SY, receivers[i], amountSyOuts[i]);
totalSyInterestPostExpiry += syInterestPostExpiry;
emit Burn(msg.sender, receivers[i], amountPYToRedeems[i], amountSyOuts[i]);
}
if (totalSyInterestPostExpiry != 0) {
postExpiry.totalSyInterestForTreasury += totalSyInterestPostExpiry.Uint128();
}
}
function _calcPYToMint(
uint256 amountSy,
uint256 indexCurrent
) internal pure returns (uint256 amountPY) {
return SYUtils.syToAsset(indexCurrent, amountSy);
}
function _calcSyRedeemableFromPY(
uint256 amountPY,
uint256 indexCurrent
) internal view returns (uint256 syToUser, uint256 syInterestPostExpiry) {
syToUser = SYUtils.assetToSy(indexCurrent, amountPY);
if (isExpired()) {
uint256 totalSyRedeemable = SYUtils.assetToSy(postExpiry.firstPYIndex, amountPY);
syInterestPostExpiry = totalSyRedeemable - syToUser;
}
}
function _getAmountPYToRedeem() internal view returns (uint256) {
if (!isExpired()) return PMath.min(_selfBalance(PT), balanceOf(address(this)));
else return _selfBalance(PT);
}
function _updateSyReserve() internal virtual {
syReserve = _selfBalance(SY);
}
function _getFloatingSyAmount() internal view returns (uint256 amount) {
amount = _selfBalance(SY) - syReserve;
if (amount == 0) revert Errors.YCNoFloatingSy();
}
function _setPostExpiryData() internal {
PostExpiryData storage local = postExpiry;
if (local.firstPYIndex != 0) return;
_redeemExternalReward();
local.firstPYIndex = _pyIndexCurrent().Uint128();
address[] memory rewardTokens = IStandardizedYield(SY).getRewardTokens();
uint256[] memory rewardIndexes = IStandardizedYield(SY).rewardIndexesCurrent();
for (uint256 i = 0; i < rewardTokens.length; i++) {
local.firstRewardIndex[rewardTokens[i]] = rewardIndexes[i];
local.userRewardOwed[rewardTokens[i]] = _selfBalance(rewardTokens[i]);
}
}
function _getInterestIndex() internal virtual override returns (uint256 index) {
if (isExpired()) index = postExpiry.firstPYIndex;
else index = _pyIndexCurrent();
}
function _pyIndexCurrent() internal returns (uint256 currentIndex) {
if (doCacheIndexSameBlock && pyIndexLastUpdatedBlock == block.number)
return _pyIndexStored;
uint128 index128 = PMath
.max(IStandardizedYield(SY).exchangeRate(), _pyIndexStored)
.Uint128();
currentIndex = index128;
_pyIndexStored = index128;
pyIndexLastUpdatedBlock = uint128(block.number);
emit NewInterestIndex(currentIndex);
}
function _YTbalance(address user) internal view override returns (uint256) {
return balanceOf(user);
}
function getRewardTokens() public view returns (address[] memory) {
return IStandardizedYield(SY).getRewardTokens();
}
function _doTransferOutRewards(
address user,
address receiver
) internal virtual override returns (uint256[] memory rewardAmounts) {
address[] memory tokens = getRewardTokens();
if (isExpired()) {
for (uint256 i = 0; i < tokens.length; i++)
postExpiry.userRewardOwed[tokens[i]] -= userReward[tokens[i]][user].accrued;
rewardAmounts = __doTransferOutRewardsLocal(tokens, user, receiver, false);
} else {
rewardAmounts = __doTransferOutRewardsLocal(tokens, user, receiver, true);
}
}
function __doTransferOutRewardsLocal(
address[] memory tokens,
address user,
address receiver,
bool allowedToRedeemExternalReward
) internal returns (uint256[] memory rewardAmounts) {
address treasury = IPYieldContractFactory(factory).treasury();
uint256 feeRate = IPYieldContractFactory(factory).rewardFeeRate();
bool redeemExternalThisRound;
rewardAmounts = new uint256[](tokens.length);
for (uint256 i = 0; i < tokens.length; i++) {
uint256 rewardPreFee = userReward[tokens[i]][user].accrued;
userReward[tokens[i]][user].accrued = 0;
uint256 feeAmount = rewardPreFee.mulDown(feeRate);
rewardAmounts[i] = rewardPreFee - feeAmount;
if (!redeemExternalThisRound && allowedToRedeemExternalReward) {
if (_selfBalance(tokens[i]) < rewardPreFee) {
_redeemExternalReward();
redeemExternalThisRound = true;
}
}
_transferOut(tokens[i], treasury, feeAmount);
_transferOut(tokens[i], receiver, rewardAmounts[i]);
}
}
function _redeemExternalReward() internal virtual override {
IStandardizedYield(SY).claimRewards(address(this));
}
function _rewardSharesUser(address user) internal view virtual override returns (uint256) {
uint256 index = userInterest[user].index;
if (index == 0) return 0;
return SYUtils.assetToSy(index, balanceOf(user)) + userInterest[user].accrued;
}
function _updateRewardIndex()
internal
override
returns (address[] memory tokens, uint256[] memory indexes)
{
tokens = getRewardTokens();
if (isExpired()) {
indexes = new uint256[](tokens.length);
for (uint256 i = 0; i < tokens.length; i++)
indexes[i] = postExpiry.firstRewardIndex[tokens[i]];
} else {
indexes = IStandardizedYield(SY).rewardIndexesCurrent();
}
}
function _beforeTokenTransfer(address from, address to, uint256) internal override {
if (isExpired()) _setPostExpiryData();
_updateAndDistributeRewardsForTwo(from, to);
_distributeInterestForTwo(from, to);
}
}
文件 80 的 97：RewardManager.sol
pragma solidity ^0.8.0;
import "./RewardManagerAbstract.sol";
abstract contract RewardManager is RewardManagerAbstract {
using PMath for uint256;
using ArrayLib for uint256[];
uint256 public lastRewardBlock;
mapping(address => RewardState) public rewardState;
function _updateRewardIndex()
internal
virtual
override
returns (address[] memory tokens, uint256[] memory indexes)
{
tokens = _getRewardTokens();
indexes = new uint256[](tokens.length);
if (tokens.length == 0) return (tokens, indexes);
if (lastRewardBlock != block.number) {
lastRewardBlock = block.number;
uint256 totalShares = _rewardSharesTotal();
_redeemExternalReward();
for (uint256 i = 0; i < tokens.length; ++i) {
address token = tokens[i];
uint256 accrued = _selfBalance(tokens[i]) - rewardState[token].lastBalance;
uint256 index = rewardState[token].index;
if (index == 0) index = INITIAL_REWARD_INDEX;
if (totalShares != 0) index += accrued.divDown(totalShares);
rewardState[token].index = index.Uint128();
rewardState[token].lastBalance += accrued.Uint128();
}
}
for (uint256 i = 0; i < tokens.length; i++) indexes[i] = rewardState[tokens[i]].index;
}
function _doTransferOutRewards(
address user,
address receiver
) internal virtual override returns (uint256[] memory rewardAmounts) {
address[] memory tokens = _getRewardTokens();
rewardAmounts = new uint256[](tokens.length);
for (uint256 i = 0; i < tokens.length; i++) {
rewardAmounts[i] = userReward[tokens[i]][user].accrued;
if (rewardAmounts[i] != 0) {
userReward[tokens[i]][user].accrued = 0;
rewardState[tokens[i]].lastBalance -= rewardAmounts[i].Uint128();
_transferOut(tokens[i], receiver, rewardAmounts[i]);
}
}
}
function _getRewardTokens() internal view virtual returns (address[] memory);
function _rewardSharesTotal() internal view virtual returns (uint256);
}
文件 81 的 97：RewardManagerAbstract.sol
pragma solidity ^0.8.0;
import "../../interfaces/IRewardManager.sol";
import "../libraries/ArrayLib.sol";
import "../libraries/TokenHelper.sol";
import "../libraries/math/PMath.sol";
import "./RewardManagerAbstract.sol";
abstract contract RewardManagerAbstract is IRewardManager, TokenHelper {
using PMath for uint256;
uint256 internal constant INITIAL_REWARD_INDEX = 1;
struct RewardState {
uint128 index;
uint128 lastBalance;
}
struct UserReward {
uint128 index;
uint128 accrued;
}
mapping(address => mapping(address => UserReward)) public userReward;
function _updateAndDistributeRewards(address user) internal virtual {
_updateAndDistributeRewardsForTwo(user, address(0));
}
function _updateAndDistributeRewardsForTwo(address user1, address user2) internal virtual {
(address[] memory tokens, uint256[] memory indexes) = _updateRewardIndex();
if (tokens.length == 0) return;
if (user1 != address(0) && user1 != address(this))
_distributeRewardsPrivate(user1, tokens, indexes);
if (user2 != address(0) && user2 != address(this))
_distributeRewardsPrivate(user2, tokens, indexes);
}
function _distributeRewardsPrivate(
address user,
address[] memory tokens,
uint256[] memory indexes
) private {
assert(user != address(0) && user != address(this));
uint256 userShares = _rewardSharesUser(user);
for (uint256 i = 0; i < tokens.length; ++i) {
address token = tokens[i];
uint256 index = indexes[i];
uint256 userIndex = userReward[token][user].index;
if (userIndex == 0) {
userIndex = INITIAL_REWARD_INDEX.Uint128();
}
if (userIndex == index) continue;
uint256 deltaIndex = index - userIndex;
uint256 rewardDelta = userShares.mulDown(deltaIndex);
uint256 rewardAccrued = userReward[token][user].accrued + rewardDelta;
userReward[token][user] = UserReward({
index: index.Uint128(),
accrued: rewardAccrued.Uint128()
});
}
}
function _updateRewardIndex()
internal
virtual
returns (address[] memory tokens, uint256[] memory indexes);
function _redeemExternalReward() internal virtual;
function _doTransferOutRewards(
address user,
address receiver
) internal virtual returns (uint256[] memory rewardAmounts);
function _rewardSharesUser(address user) internal view virtual returns (uint256);
}
文件 82 的 97：SYBase.sol
pragma solidity ^0.8.0;
import "../../interfaces/IStandardizedYield.sol";
import "../erc20/PendleERC20Permit.sol";
import "../libraries/math/PMath.sol";
import "../libraries/TokenHelper.sol";
import "../libraries/Errors.sol";
import "../libraries/BoringOwnableUpgradeable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
abstract contract SYBase is
IStandardizedYield,
PendleERC20Permit,
TokenHelper,
BoringOwnableUpgradeable,
Pausable
{
using PMath for uint256;
address public immutable yieldToken;
constructor(
string memory _name,
string memory _symbol,
address _yieldToken
) PendleERC20Permit(_name, _symbol, IERC20Metadata(_yieldToken).decimals()) initializer {
yieldToken = _yieldToken;
__BoringOwnable_init();
}
receive() external payable {}
function deposit(
address receiver,
address tokenIn,
uint256 amountTokenToDeposit,
uint256 minSharesOut
) external payable nonReentrant returns (uint256 amountSharesOut) {
if (!isValidTokenIn(tokenIn)) revert Errors.SYInvalidTokenIn(tokenIn);
if (amountTokenToDeposit == 0) revert Errors.SYZeroDeposit();
_transferIn(tokenIn, msg.sender, amountTokenToDeposit);
amountSharesOut = _deposit(tokenIn, amountTokenToDeposit);
if (amountSharesOut < minSharesOut)
revert Errors.SYInsufficientSharesOut(amountSharesOut, minSharesOut);
_mint(receiver, amountSharesOut);
emit Deposit(msg.sender, receiver, tokenIn, amountTokenToDeposit, amountSharesOut);
}
function redeem(
address receiver,
uint256 amountSharesToRedeem,
address tokenOut,
uint256 minTokenOut,
bool burnFromInternalBalance
) external nonReentrant returns (uint256 amountTokenOut) {
if (!isValidTokenOut(tokenOut)) revert Errors.SYInvalidTokenOut(tokenOut);
if (amountSharesToRedeem == 0) revert Errors.SYZeroRedeem();
if (burnFromInternalBalance) {
_burn(address(this), amountSharesToRedeem);
} else {
_burn(msg.sender, amountSharesToRedeem);
}
amountTokenOut = _redeem(receiver, tokenOut, amountSharesToRedeem);
if (amountTokenOut < minTokenOut)
revert Errors.SYInsufficientTokenOut(amountTokenOut, minTokenOut);
emit Redeem(msg.sender, receiver, tokenOut, amountSharesToRedeem, amountTokenOut);
}
function _deposit(
address tokenIn,
uint256 amountDeposited
) internal virtual returns (uint256 amountSharesOut);
function _redeem(
address receiver,
address tokenOut,
uint256 amountSharesToRedeem
) internal virtual returns (uint256 amountTokenOut);
function exchangeRate() external view virtual override returns (uint256 res);
function claimRewards(
address
) external virtual override returns (uint256[] memory rewardAmounts) {
rewardAmounts = new uint256[](0);
}
function getRewardTokens()
external
view
virtual
override
returns (address[] memory rewardTokens)
{
rewardTokens = new address[](0);
}
function accruedRewards(
address
) external view virtual override returns (uint256[] memory rewardAmounts) {
rewardAmounts = new uint256[](0);
}
function rewardIndexesCurrent() external virtual override returns (uint256[] memory indexes) {
indexes = new uint256[](0);
}
function rewardIndexesStored()
external
view
virtual
override
returns (uint256[] memory indexes)
{
indexes = new uint256[](0);
}
function previewDeposit(
address tokenIn,
uint256 amountTokenToDeposit
) external view virtual returns (uint256 amountSharesOut) {
if (!isValidTokenIn(tokenIn)) revert Errors.SYInvalidTokenIn(tokenIn);
return _previewDeposit(tokenIn, amountTokenToDeposit);
}
function previewRedeem(
address tokenOut,
uint256 amountSharesToRedeem
) external view virtual returns (uint256 amountTokenOut) {
if (!isValidTokenOut(tokenOut)) revert Errors.SYInvalidTokenOut(tokenOut);
return _previewRedeem(tokenOut, amountSharesToRedeem);
}
function pause() external onlyOwner {
_pause();
}
function unpause() external onlyOwner {
_unpause();
}
function _beforeTokenTransfer(
address,
address,
uint256
) internal virtual override whenNotPaused {}
function _previewDeposit(
address tokenIn,
uint256 amountTokenToDeposit
) internal view virtual returns (uint256 amountSharesOut);
function _previewRedeem(
address tokenOut,
uint256 amountSharesToRedeem
) internal view virtual returns (uint256 amountTokenOut);
function getTokensIn() public view virtual returns (address[] memory res);
function getTokensOut() public view virtual returns (address[] memory res);
function isValidTokenIn(address token) public view virtual returns (bool);
function isValidTokenOut(address token) public view virtual returns (bool);
}
文件 83 的 97：SYBaseWithRewards.sol
pragma solidity ^0.8.0;
import "../RewardManager/RewardManager.sol";
import "./SYBase.sol";
abstract contract SYBaseWithRewards is SYBase, RewardManager {
using PMath for uint256;
using ArrayLib for address[];
constructor(
string memory _name,
string memory _symbol,
address _yieldToken
)
SYBase(_name, _symbol, _yieldToken)
{}
function claimRewards(address user)
external
virtual
override
nonReentrant
returns (uint256[] memory rewardAmounts)
{
_updateAndDistributeRewards(user);
rewardAmounts = _doTransferOutRewards(user, user);
emit ClaimRewards(user, _getRewardTokens(), rewardAmounts);
}
function getRewardTokens()
external
view
virtual
override
returns (address[] memory rewardTokens)
{
rewardTokens = _getRewardTokens();
}
function accruedRewards(address user)
external
view
virtual
override
returns (uint256[] memory rewardAmounts)
{
address[] memory rewardTokens = _getRewardTokens();
rewardAmounts = new uint256[](rewardTokens.length);
for (uint256 i = 0; i < rewardTokens.length; ) {
rewardAmounts[i] = userReward[rewardTokens[i]][user].accrued;
unchecked {
i++;
}
}
}
function rewardIndexesCurrent()
external
override
nonReentrant
returns (uint256[] memory indexes)
{
_updateRewardIndex();
return rewardIndexesStored();
}
function rewardIndexesStored()
public
view
virtual
override
returns (uint256[] memory indexes)
{
address[] memory rewardTokens = _getRewardTokens();
indexes = new uint256[](rewardTokens.length);
for (uint256 i = 0; i < rewardTokens.length; ) {
indexes[i] = rewardState[rewardTokens[i]].index;
unchecked {
i++;
}
}
}
function _rewardSharesTotal() internal view virtual override returns (uint256) {
return totalSupply();
}
function _rewardSharesUser(address user) internal view virtual override returns (uint256) {
return balanceOf(user);
}
function _beforeTokenTransfer(
address from,
address to,
uint256
) internal virtual override whenNotPaused {
_updateAndDistributeRewardsForTwo(from, to);
}
}
文件 84 的 97：SYUtils.sol
pragma solidity ^0.8.0;
library SYUtils {
uint256 internal constant ONE = 1e18;
function syToAsset(uint256 exchangeRate, uint256 syAmount) internal pure returns (uint256) {
return (syAmount * exchangeRate) / ONE;
}
function syToAssetUp(uint256 exchangeRate, uint256 syAmount) internal pure returns (uint256) {
return (syAmount * exchangeRate + ONE - 1) / ONE;
}
function assetToSy(uint256 exchangeRate, uint256 assetAmount) internal pure returns (uint256) {
return (assetAmount * ONE) / exchangeRate;
}
function assetToSyUp(
uint256 exchangeRate,
uint256 assetAmount
) internal pure returns (uint256) {
return (assetAmount * ONE + exchangeRate - 1) / exchangeRate;
}
}
文件 85 的 97：SafeERC20.sol
pragma solidity ^0.8.0;
import "../IERC20.sol";
import "../extensions/draft-IERC20Permit.sol";
import "../../../utils/Address.sol";
library SafeERC20 {
using Address for address;
function safeTransfer(
IERC20 token,
address to,
uint256 value
) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(
IERC20 token,
address from,
address to,
uint256 value
) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(
IERC20 token,
address spender,
uint256 value
) internal {
require(
(value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
uint256 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");
}
}
}
文件 86 的 97：StablePoolUserData.sol
pragma solidity ^0.8.0;
library StablePoolUserData {
enum JoinKind {
INIT,
EXACT_TOKENS_IN_FOR_BPT_OUT,
TOKEN_IN_FOR_EXACT_BPT_OUT
}
enum ExitKind {
EXACT_BPT_IN_FOR_ONE_TOKEN_OUT,
BPT_IN_FOR_EXACT_TOKENS_OUT
}
function exactTokensInForBptOut(
bytes memory self
) internal pure returns (uint256[] memory amountsIn, uint256 minBPTAmountOut) {
(, amountsIn, minBPTAmountOut) = abi.decode(self, (JoinKind, uint256[], uint256));
}
function exactBptInForTokenOut(
bytes memory self
) internal pure returns (uint256 bptAmountIn, uint256 tokenIndex) {
(, bptAmountIn, tokenIndex) = abi.decode(self, (ExitKind, uint256, uint256));
}
}
文件 87 的 97：StablePreviewBase.sol
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "../../../../../interfaces/Balancer/IVault.sol";
import "../../../../../interfaces/Balancer/IBalancerFees.sol";
import "../../../../../interfaces/Balancer/IBalancerStablePreview.sol";
abstract contract StablePreviewBase is IBalancerStablePreview {
address internal constant BALANCER_VAULT = 0xBA12222222228d8Ba445958a75a0704d566BF2C8;
address internal constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address internal constant FEE_COLLECTOR = 0xce88686553686DA562CE7Cea497CE749DA109f9F;
enum PoolBalanceChangeKind {
JOIN,
EXIT
}
struct PoolBalanceChange {
IAsset[] assets;
uint256[] limits;
bytes userData;
bool useInternalBalance;
}
function joinPoolPreview(
bytes32 poolId,
address sender,
address recipient,
IVault.JoinPoolRequest memory request,
bytes memory data
) external view returns (uint256 amountBptOut) {
amountBptOut = _joinOrExit(
PoolBalanceChangeKind.JOIN,
poolId,
sender,
payable(recipient),
_toPoolBalanceChange(request),
data
);
}
function exitPoolPreview(
bytes32 poolId,
address sender,
address recipient,
IVault.ExitPoolRequest memory request,
bytes memory data
) external view returns (uint256 amountTokenOut) {
amountTokenOut = _joinOrExit(
PoolBalanceChangeKind.EXIT,
poolId,
sender,
recipient,
_toPoolBalanceChange(request),
data
);
}
function _joinOrExit(
PoolBalanceChangeKind kind,
bytes32 poolId,
address sender,
address recipient,
PoolBalanceChange memory change,
bytes memory data
) private view returns (uint256 amountBptOrTokensOut) {
IERC20[] memory tokens = _translateToIERC20(change.assets);
(uint256[] memory balances, uint256 lastChangeBlock) = _validateTokensAndGetBalances(
poolId,
tokens
);
amountBptOrTokensOut = _callPoolBalanceChange(
kind,
poolId,
sender,
recipient,
change,
balances,
lastChangeBlock,
data
);
}
function _callPoolBalanceChange(
PoolBalanceChangeKind kind,
bytes32 poolId,
address sender,
address recipient,
PoolBalanceChange memory change,
uint256[] memory balances,
uint256 lastChangeBlock,
bytes memory data
) private view returns (uint256 amountsChanged) {
if (kind == PoolBalanceChangeKind.JOIN) {
amountsChanged = onJoinPool(
poolId,
sender,
recipient,
balances,
lastChangeBlock,
_getProtocolSwapFeePercentage(),
change.userData,
data
);
} else {
amountsChanged = onExitPool(
poolId,
sender,
recipient,
balances,
lastChangeBlock,
_getProtocolSwapFeePercentage(),
change.userData,
data
);
}
}
function _getProtocolSwapFeePercentage() private view returns (uint256) {
return IBalancerFees(FEE_COLLECTOR).getSwapFeePercentage();
}
function _validateTokensAndGetBalances(
bytes32 poolId,
IERC20[] memory
) private view returns (uint256[] memory, uint256) {
(, uint256[] memory balances, uint256 lastChangeBlock) = IVault(BALANCER_VAULT)
.getPoolTokens(poolId);
return (balances, lastChangeBlock);
}
function _translateToIERC20(IAsset[] memory assets) internal pure returns (IERC20[] memory) {
IERC20[] memory tokens = new IERC20[](assets.length);
for (uint256 i = 0; i < assets.length; ++i) {
tokens[i] = _translateToIERC20(assets[i]);
}
return tokens;
}
function _translateToIERC20(IAsset asset) internal pure returns (IERC20) {
return address(asset) == address(0) ? IERC20(WETH) : IERC20(address(asset));
}
function _toPoolBalanceChange(
IVault.JoinPoolRequest memory request
) private pure returns (PoolBalanceChange memory change) {
assembly {
change := request
}
}
function _toPoolBalanceChange(
IVault.ExitPoolRequest memory request
) private pure returns (PoolBalanceChange memory change) {
assembly {
change := request
}
}
function onJoinPool(
bytes32 poolId,
address sender,
address recipient,
uint256[] memory balances,
uint256 lastChangeBlock,
uint256 protocolSwapFeePercentage,
bytes memory userData,
bytes memory data
) internal view virtual returns (uint256 bptAmountOut);
function onExitPool(
bytes32 poolId,
address sender,
address recipient,
uint256[] memory balances,
uint256 lastChangeBlock,
uint256 protocolSwapFeePercentage,
bytes memory userData,
bytes memory data
) internal view virtual returns (uint256 amountTokenOut);
}
文件 88 的 97：StorageSlot.sol
pragma solidity ^0.8.0;
library StorageSlot {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
assembly {
r.slot := slot
}
}
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
assembly {
r.slot := slot
}
}
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
assembly {
r.slot := slot
}
}
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
assembly {
r.slot := slot
}
}
}
文件 89 的 97：StringLib.sol
pragma solidity ^0.8.0;
library StringLib {
struct slice {
uint256 _len;
uint256 _ptr;
}
function memcpy(uint256 dest, uint256 src, uint256 len) private pure {
for (; len >= 32; len -= 32) {
assembly {
mstore(dest, mload(src))
}
dest += 32;
src += 32;
}
uint256 mask = type(uint256).max;
if (len > 0) {
mask = 256 ** (32 - len) - 1;
}
assembly {
let srcpart := and(mload(src), not(mask))
let destpart := and(mload(dest), mask)
mstore(dest, or(destpart, srcpart))
}
}
function toSlice(string memory self) internal pure returns (slice memory) {
uint256 ptr;
assembly {
ptr := add(self, 0x20)
}
return slice(bytes(self).length, ptr);
}
function len(bytes32 self) internal pure returns (uint256) {
uint256 ret;
if (self == 0) return 0;
if (uint256(self) & type(uint128).max == 0) {
ret += 16;
self = bytes32(uint256(self) / 0x100000000000000000000000000000000);
}
if (uint256(self) & type(uint64).max == 0) {
ret += 8;
self = bytes32(uint256(self) / 0x10000000000000000);
}
if (uint256(self) & type(uint32).max == 0) {
ret += 4;
self = bytes32(uint256(self) / 0x100000000);
}
if (uint256(self) & type(uint16).max == 0) {
ret += 2;
self = bytes32(uint256(self) / 0x10000);
}
if (uint256(self) & type(uint8).max == 0) {
ret += 1;
}
return 32 - ret;
}
function toSliceB32(bytes32 self) internal pure returns (slice memory ret) {
assembly {
let ptr := mload(0x40)
mstore(0x40, add(ptr, 0x20))
mstore(ptr, self)
mstore(add(ret, 0x20), ptr)
}
ret._len = len(self);
}
function copy(slice memory self) internal pure returns (slice memory) {
return slice(self._len, self._ptr);
}
function toString(slice memory self) internal pure returns (string memory) {
string memory ret = new string(self._len);
uint256 retptr;
assembly {
retptr := add(ret, 32)
}
memcpy(retptr, self._ptr, self._len);
return ret;
}
function len(slice memory self) internal pure returns (uint256 l) {
uint256 ptr = self._ptr - 31;
uint256 end = ptr + self._len;
for (l = 0; ptr < end; l++) {
uint8 b;
assembly {
b := and(mload(ptr), 0xFF)
}
if (b < 0x80) {
ptr += 1;
} else if (b < 0xE0) {
ptr += 2;
} else if (b < 0xF0) {
ptr += 3;
} else if (b < 0xF8) {
ptr += 4;
} else if (b < 0xFC) {
ptr += 5;
} else {
ptr += 6;
}
}
}
function empty(slice memory self) internal pure returns (bool) {
return self._len == 0;
}
function compare(slice memory self, slice memory other) internal pure returns (int256) {
uint256 shortest = self._len;
if (other._len < self._len) shortest = other._len;
uint256 selfptr = self._ptr;
uint256 otherptr = other._ptr;
for (uint256 idx = 0; idx < shortest; idx += 32) {
uint256 a;
uint256 b;
assembly {
a := mload(selfptr)
b := mload(otherptr)
}
if (a != b) {
uint256 mask = type(uint256).max;
if (shortest < 32) {
mask = ~(2 ** (8 * (32 - shortest + idx)) - 1);
}
unchecked {
uint256 diff = (a & mask) - (b & mask);
if (diff != 0) return int256(diff);
}
}
selfptr += 32;
otherptr += 32;
}
return int256(self._len) - int256(other._len);
}
function equals(slice memory self, slice memory other) internal pure returns (bool) {
return compare(self, other) == 0;
}
function nextRune(slice memory self, slice memory rune) internal pure returns (slice memory) {
rune._ptr = self._ptr;
if (self._len == 0) {
rune._len = 0;
return rune;
}
uint256 l;
uint256 b;
assembly {
b := and(mload(sub(mload(add(self, 32)), 31)), 0xFF)
}
if (b < 0x80) {
l = 1;
} else if (b < 0xE0) {
l = 2;
} else if (b < 0xF0) {
l = 3;
} else {
l = 4;
}
if (l > self._len) {
rune._len = self._len;
self._ptr += self._len;
self._len = 0;
return rune;
}
self._ptr += l;
self._len -= l;
rune._len = l;
return rune;
}
function nextRune(slice memory self) internal pure returns (slice memory ret) {
nextRune(self, ret);
}
function ord(slice memory self) internal pure returns (uint256 ret) {
if (self._len == 0) {
return 0;
}
uint256 word;
uint256 length;
uint256 divisor = 2 ** 248;
assembly {
word := mload(mload(add(self, 32)))
}
uint256 b = word / divisor;
if (b < 0x80) {
ret = b;
length = 1;
} else if (b < 0xE0) {
ret = b & 0x1F;
length = 2;
} else if (b < 0xF0) {
ret = b & 0x0F;
length = 3;
} else {
ret = b & 0x07;
length = 4;
}
if (length > self._len) {
return 0;
}
for (uint256 i = 1; i < length; i++) {
divisor = divisor / 256;
b = (word / divisor) & 0xFF;
if (b & 0xC0 != 0x80) {
return 0;
}
ret = (ret * 64) | (b & 0x3F);
}
return ret;
}
function keccak(slice memory self) internal pure returns (bytes32 ret) {
assembly {
ret := keccak256(mload(add(self, 32)), mload(self))
}
}
function startsWith(slice memory self, slice memory needle) internal pure returns (bool) {
if (self._len < needle._len) {
return false;
}
if (self._ptr == needle._ptr) {
return true;
}
bool equal;
assembly {
let length := mload(needle)
let selfptr := mload(add(self, 0x20))
let needleptr := mload(add(needle, 0x20))
equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
}
return equal;
}
function beyond(slice memory self, slice memory needle) internal pure returns (slice memory) {
if (self._len < needle._len) {
return self;
}
bool equal = true;
if (self._ptr != needle._ptr) {
assembly {
let length := mload(needle)
let selfptr := mload(add(self, 0x20))
let needleptr := mload(add(needle, 0x20))
equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
}
}
if (equal) {
self._len -= needle._len;
self._ptr += needle._len;
}
return self;
}
function endsWith(slice memory self, slice memory needle) internal pure returns (bool) {
if (self._len < needle._len) {
return false;
}
uint256 selfptr = self._ptr + self._len - needle._len;
if (selfptr == needle._ptr) {
return true;
}
bool equal;
assembly {
let length := mload(needle)
let needleptr := mload(add(needle, 0x20))
equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
}
return equal;
}
function until(slice memory self, slice memory needle) internal pure returns (slice memory) {
if (self._len < needle._len) {
return self;
}
uint256 selfptr = self._ptr + self._len - needle._len;
bool equal = true;
if (selfptr != needle._ptr) {
assembly {
let length := mload(needle)
let needleptr := mload(add(needle, 0x20))
equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
}
}
if (equal) {
self._len -= needle._len;
}
return self;
}
function findPtr(
uint256 selflen,
uint256 selfptr,
uint256 needlelen,
uint256 needleptr
) private pure returns (uint256) {
uint256 ptr = selfptr;
uint256 idx;
if (needlelen <= selflen) {
if (needlelen <= 32) {
bytes32 mask;
if (needlelen > 0) {
mask = bytes32(~(2 ** (8 * (32 - needlelen)) - 1));
}
bytes32 needledata;
assembly {
needledata := and(mload(needleptr), mask)
}
uint256 end = selfptr + selflen - needlelen;
bytes32 ptrdata;
assembly {
ptrdata := and(mload(ptr), mask)
}
while (ptrdata != needledata) {
if (ptr >= end) return selfptr + selflen;
ptr++;
assembly {
ptrdata := and(mload(ptr), mask)
}
}
return ptr;
} else {
bytes32 hash;
assembly {
hash := keccak256(needleptr, needlelen)
}
for (idx = 0; idx <= selflen - needlelen; idx++) {
bytes32 testHash;
assembly {
testHash := keccak256(ptr, needlelen)
}
if (hash == testHash) return ptr;
ptr += 1;
}
}
}
return selfptr + selflen;
}
function rfindPtr(
uint256 selflen,
uint256 selfptr,
uint256 needlelen,
uint256 needleptr
) private pure returns (uint256) {
uint256 ptr;
if (needlelen <= selflen) {
if (needlelen <= 32) {
bytes32 mask;
if (needlelen > 0) {
mask = bytes32(~(2 ** (8 * (32 - needlelen)) - 1));
}
bytes32 needledata;
assembly {
needledata := and(mload(needleptr), mask)
}
ptr = selfptr + selflen - needlelen;
bytes32 ptrdata;
assembly {
ptrdata := and(mload(ptr), mask)
}
while (ptrdata != needledata) {
if (ptr <= selfptr) return selfptr;
ptr--;
assembly {
ptrdata := and(mload(ptr), mask)
}
}
return ptr + needlelen;
} else {
bytes32 hash;
assembly {
hash := keccak256(needleptr, needlelen)
}
ptr = selfptr + (selflen - needlelen);
while (ptr >= selfptr) {
bytes32 testHash;
assembly {
testHash := keccak256(ptr, needlelen)
}
if (hash == testHash) return ptr + needlelen;
ptr -= 1;
}
}
}
return selfptr;
}
function find(slice memory self, slice memory needle) internal pure returns (slice memory) {
uint256 ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr);
self._len -= ptr - self._ptr;
self._ptr = ptr;
return self;
}
function rfind(slice memory self, slice memory needle) internal pure returns (slice memory) {
uint256 ptr = rfindPtr(self._len, self._ptr, needle._len, needle._ptr);
self._len = ptr - self._ptr;
return self;
}
function split(
slice memory self,
slice memory needle,
slice memory token
) internal pure returns (slice memory) {
uint256 ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr);
token._ptr = self._ptr;
token._len = ptr - self._ptr;
if (ptr == self._ptr + self._len) {
self._len = 0;
} else {
self._len -= token._len + needle._len;
self._ptr = ptr + needle._len;
}
return token;
}
function split(
slice memory self,
slice memory needle
) internal pure returns (slice memory token) {
split(self, needle, token);
}
function rsplit(
slice memory self,
slice memory needle,
slice memory token
) internal pure returns (slice memory) {
uint256 ptr = rfindPtr(self._len, self._ptr, needle._len, needle._ptr);
token._ptr = ptr;
token._len = self._len - (ptr - self._ptr);
if (ptr == self._ptr) {
self._len = 0;
} else {
self._len -= token._len + needle._len;
}
return token;
}
function rsplit(
slice memory self,
slice memory needle
) internal pure returns (slice memory token) {
rsplit(self, needle, token);
}
function count(slice memory self, slice memory needle) internal pure returns (uint256 cnt) {
uint256 ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr) + needle._len;
while (ptr <= self._ptr + self._len) {
cnt++;
ptr =
findPtr(self._len - (ptr - self._ptr), ptr, needle._len, needle._ptr) +
needle._len;
}
}
function contains(slice memory self, slice memory needle) internal pure returns (bool) {
return rfindPtr(self._len, self._ptr, needle._len, needle._ptr) != self._ptr;
}
function concat(slice memory self, slice memory other) internal pure returns (string memory) {
string memory ret = new string(self._len + other._len);
uint256 retptr;
assembly {
retptr := add(ret, 32)
}
memcpy(retptr, self._ptr, self._len);
memcpy(retptr + self._len, other._ptr, other._len);
return ret;
}
function join(slice memory self, slice[] memory parts) internal pure returns (string memory) {
if (parts.length == 0) return "";
uint256 length = self._len * (parts.length - 1);
for (uint256 i = 0; i < parts.length; i++) length += parts[i]._len;
string memory ret = new string(length);
uint256 retptr;
assembly {
retptr := add(ret, 32)
}
for (uint256 i = 0; i < parts.length; i++) {
memcpy(retptr, parts[i]._ptr, parts[i]._len);
retptr += parts[i]._len;
if (i < parts.length - 1) {
memcpy(retptr, self._ptr, self._len);
retptr += self._len;
}
}
return ret;
}
}
文件 90 的 97：Strings.sol
pragma solidity ^0.8.0;
library Strings {
bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
function toString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0";
}
uint256 temp = value;
uint256 digits;
while (temp != 0) {
digits++;
temp /= 10;
}
bytes memory buffer = new bytes(digits);
while (value != 0) {
digits -= 1;
buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
value /= 10;
}
return string(buffer);
}
function toHexString(uint256 value) internal pure returns (string memory) {
if (value == 0) {
return "0x00";
}
uint256 temp = value;
uint256 length = 0;
while (temp != 0) {
length++;
temp >>= 8;
}
return toHexString(value, length);
}
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] = _HEX_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);
}
}
文件 91 的 97：SwETHSY.sol
pragma solidity 0.8.17;
import "@pendle/core-v2/contracts/core/StandardizedYield/SYBase.sol";
import "./interfaces/ISwETH.sol";
contract SwETHSY is SYBase {
using PMath for uint256;
address public immutable swETH;
constructor(
string memory _name,
string memory _symbol,
address _swETH
) SYBase(_name, _symbol, _swETH) {
swETH = _swETH;
}
function _deposit(
address tokenIn,
uint256 amountDeposited
) internal virtual override returns (uint256 ) {
if (tokenIn == NATIVE) {
uint256 preBalance = _selfBalance(swETH);
ISwETH(swETH).deposit{ value: amountDeposited }();
return _selfBalance(swETH) - preBalance;
} else {
return amountDeposited;
}
}
function _redeem(
address receiver,
address ,
uint256 amountSharesToRedeem
) internal virtual override returns (uint256 ) {
_transferOut(swETH, receiver, amountSharesToRedeem);
return amountSharesToRedeem;
}
function exchangeRate() public view virtual override returns (uint256) {
return ISwETH(swETH).getRate();
}
function _previewDeposit(
address tokenIn,
uint256 amountTokenToDeposit
) internal view override returns (uint256 ) {
if (tokenIn == NATIVE) {
return amountTokenToDeposit.divDown(ISwETH(swETH).getRate());
} else {
return amountTokenToDeposit;
}
}
function _previewRedeem(
address ,
uint256 amountSharesToRedeem
) internal pure override returns (uint256 ) {
return amountSharesToRedeem;
}
function getTokensIn() public view virtual override returns (address[] memory res) {
res = new address[](2);
res[0] = swETH;
res[1] = NATIVE;
}
function getTokensOut() public view virtual override returns (address[] memory res) {
res = new address[](1);
res[0] = swETH;
}
function isValidTokenIn(address token) public view virtual override returns (bool) {
return token == NATIVE || token == swETH;
}
function isValidTokenOut(address token) public view virtual override returns (bool) {
return token == swETH;
}
function assetInfo()
external
pure
returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
{
return (AssetType.TOKEN, NATIVE, 18);
}
}
文件 92 的 97：TokenHelper.sol
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "../../interfaces/IWETH.sol";
abstract contract TokenHelper {
using SafeERC20 for IERC20;
address internal constant NATIVE = address(0);
uint256 internal constant LOWER_BOUND_APPROVAL = type(uint96).max / 2;
function _transferIn(address token, address from, uint256 amount) internal {
if (token == NATIVE) require(msg.value == amount, "eth mismatch");
else if (amount != 0) IERC20(token).safeTransferFrom(from, address(this), amount);
}
function _transferFrom(IERC20 token, address from, address to, uint256 amount) internal {
if (amount != 0) token.safeTransferFrom(from, to, amount);
}
function _transferOut(address token, address to, uint256 amount) internal {
if (amount == 0) return;
if (token == NATIVE) {
(bool success, ) = to.call{ value: amount }("");
require(success, "eth send failed");
} else {
IERC20(token).safeTransfer(to, amount);
}
}
function _transferOut(address[] memory tokens, address to, uint256[] memory amounts) internal {
uint256 numTokens = tokens.length;
require(numTokens == amounts.length, "length mismatch");
for (uint256 i = 0; i < numTokens; ) {
_transferOut(tokens[i], to, amounts[i]);
unchecked {
i++;
}
}
}
function _selfBalance(address token) internal view returns (uint256) {
return (token == NATIVE) ? address(this).balance : IERC20(token).balanceOf(address(this));
}
function _selfBalance(IERC20 token) internal view returns (uint256) {
return token.balanceOf(address(this));
}
function _safeApprove(address token, address to, uint256 value) internal {
(bool success, bytes memory data) = token.call(
abi.encodeWithSelector(IERC20.approve.selector, to, value)
);
require(success && (data.length == 0 || abi.decode(data, (bool))), "Safe Approve");
}
function _safeApproveInf(address token, address to) internal {
if (token == NATIVE) return;
if (IERC20(token).allowance(address(this), to) < LOWER_BOUND_APPROVAL) {
_safeApprove(token, to, 0);
_safeApprove(token, to, type(uint256).max);
}
}
function _wrap_unwrap_ETH(address tokenIn, address tokenOut, uint256 netTokenIn) internal {
if (tokenIn == NATIVE) IWETH(tokenOut).deposit{ value: netTokenIn }();
else IWETH(tokenIn).withdraw(netTokenIn);
}
}
文件 93 的 97：UUPSUpgradeable.sol
pragma solidity ^0.8.0;
import "../../interfaces/draft-IERC1822.sol";
import "../ERC1967/ERC1967Upgrade.sol";
abstract contract UUPSUpgradeable is IERC1822Proxiable, ERC1967Upgrade {
address private immutable __self = address(this);
modifier onlyProxy() {
require(address(this) != __self, "Function must be called through delegatecall");
require(_getImplementation() == __self, "Function must be called through active proxy");
_;
}
modifier notDelegated() {
require(address(this) == __self, "UUPSUpgradeable: must not be called through delegatecall");
_;
}
function proxiableUUID() external view virtual override notDelegated returns (bytes32) {
return _IMPLEMENTATION_SLOT;
}
function upgradeTo(address newImplementation) external virtual onlyProxy {
_authorizeUpgrade(newImplementation);
_upgradeToAndCallUUPS(newImplementation, new bytes(0), false);
}
function upgradeToAndCall(address newImplementation, bytes memory data) external payable virtual onlyProxy {
_authorizeUpgrade(newImplementation);
_upgradeToAndCallUUPS(newImplementation, data, true);
}
function _authorizeUpgrade(address newImplementation) internal virtual;
}
文件 94 的 97：draft-EIP712.sol
pragma solidity ^0.8.0;
import "./ECDSA.sol";
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);
}
}
文件 95 的 97：draft-ERC20Permit.sol
pragma solidity ^0.8.0;
import "./draft-IERC20Permit.sol";
import "../ERC20.sol";
import "../../../utils/cryptography/draft-EIP712.sol";
import "../../../utils/cryptography/ECDSA.sol";
import "../../../utils/Counters.sol";
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();
}
}
文件 96 的 97：draft-IERC1822.sol
pragma solidity ^0.8.0;
interface IERC1822Proxiable {
function proxiableUUID() external view returns (bytes32);
}
文件 97 的 97：draft-IERC20Permit.sol
pragma solidity ^0.8.0;
interface IERC20Permit {
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
function nonces(address owner) external view returns (uint256);
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
{
"compilationTarget": {
"contracts/EPendleSY.sol": "EPendleSY"
},
"evmVersion": "london",
"libraries": {},
"metadata": {
"bytecodeHash": "ipfs"
},
"optimizer": {
"enabled": true,
"runs": 1000000
},
"remappings": [],
"viaIR": true
}[{"inputs":[{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"},{"internalType":"address","name":"_ePendle","type":"address"},{"internalType":"address","name":"_pendle","type":"address"},{"internalType":"address","name":"_eqb","type":"address"},{"internalType":"address","name":"_xEqb","type":"address"},{"internalType":"address","name":"_weth","type":"address"},{"internalType":"address","name":"_ePendleRewardPool","type":"address"},{"internalType":"address","name":"_smartConvertor","type":"address"},{"internalType":"address","name":"_balancerVault","type":"address"},{"internalType":"bytes32","name":"_balancerWethPendlePoolId","type":"bytes32"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"uint256","name":"actualSharesOut","type":"uint256"},{"internalType":"uint256","name":"requiredSharesOut","type":"uint256"}],"name":"SYInsufficientSharesOut","type":"error"},{"inputs":[{"internalType":"uint256","name":"actualTokenOut","type":"uint256"},{"internalType":"uint256","name":"requiredTokenOut","type":"uint256"}],"name":"SYInsufficientTokenOut","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SYInvalidTokenIn","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SYInvalidTokenOut","type":"error"},{"inputs":[],"name":"SYZeroDeposit","type":"error"},{"inputs":[],"name":"SYZeroRedeem","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"address[]","name":"rewardTokens","type":"address[]"},{"indexed":false,"internalType":"uint256[]","name":"rewardAmounts","type":"uint256[]"}],"name":"ClaimRewards","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"caller","type":"address"},{"indexed":true,"internalType":"address","name":"receiver","type":"address"},{"indexed":true,"internalType":"address","name":"tokenIn","type":"address"},{"indexed":false,"internalType":"uint256","name":"amountDeposited","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amountSyOut","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint8","name":"version","type":"uint8"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"caller","type":"address"},{"indexed":true,"internalType":"address","name":"receiver","type":"address"},{"indexed":true,"internalType":"address","name":"tokenOut","type":"address"},{"indexed":false,"internalType":"uint256","name":"amountSyToRedeem","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amountTokenOut","type":"uint256"}],"name":"Redeem","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"accruedRewards","outputs":[{"internalType":"uint256[]","name":"rewardAmounts","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"assetInfo","outputs":[{"internalType":"enum IStandardizedYield.AssetType","name":"assetType","type":"uint8"},{"internalType":"address","name":"assetAddress","type":"address"},{"internalType":"uint8","name":"assetDecimals","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"balancerVault","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"balancerWethPendlePoolId","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"claimOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"claimRewards","outputs":[{"internalType":"uint256[]","name":"rewardAmounts","type":"uint256[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"tokenIn","type":"address"},{"internalType":"uint256","name":"amountTokenToDeposit","type":"uint256"},{"internalType":"uint256","name":"minSharesOut","type":"uint256"}],"name":"deposit","outputs":[{"internalType":"uint256","name":"amountSharesOut","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"ePendle","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ePendleRewardPool","outputs":[{"internalType":"contract IBaseRewardPool","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"eqb","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"exchangeRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getRewardTokens","outputs":[{"internalType":"address[]","name":"rewardTokens","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTokensIn","outputs":[{"internalType":"address[]","name":"res","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTokensOut","outputs":[{"internalType":"address[]","name":"res","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTotalAssetOwned","outputs":[{"internalType":"uint256","name":"totalAssetOwned","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"isValidTokenIn","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"isValidTokenOut","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastRewardBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendle","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"tokenIn","type":"address"},{"internalType":"uint256","name":"amountTokenToDeposit","type":"uint256"}],"name":"previewDeposit","outputs":[{"internalType":"uint256","name":"amountSharesOut","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"tokenOut","type":"address"},{"internalType":"uint256","name":"amountSharesToRedeem","type":"uint256"}],"name":"previewRedeem","outputs":[{"internalType":"uint256","name":"amountTokenOut","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint256","name":"amountSharesToRedeem","type":"uint256"},{"internalType":"address","name":"tokenOut","type":"address"},{"internalType":"uint256","name":"minTokenOut","type":"uint256"},{"internalType":"bool","name":"burnFromInternalBalance","type":"bool"}],"name":"redeem","outputs":[{"internalType":"uint256","name":"amountTokenOut","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rewardIndexesCurrent","outputs":[{"internalType":"uint256[]","name":"indexes","type":"uint256[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rewardIndexesStored","outputs":[{"internalType":"uint256[]","name":"indexes","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"rewardState","outputs":[{"internalType":"uint128","name":"index","type":"uint128"},{"internalType":"uint128","name":"lastBalance","type":"uint128"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"smartConvertor","outputs":[{"internalType":"contract ISmartConvertor","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"},{"internalType":"bool","name":"direct","type":"bool"},{"internalType":"bool","name":"renounce","type":"bool"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"userReward","outputs":[{"internalType":"uint128","name":"index","type":"uint128"},{"internalType":"uint128","name":"accrued","type":"uint128"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"weth","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"xEqb","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"yieldToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]
