Description:
Proxy contract enabling upgradeable smart contract patterns. Delegates calls to an implementation contract.
Blockchain: Ethereum
Source Code: View Code On The Blockchain
Solidity Source Code:
{{
"language": "Solidity",
"sources": {
"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol": {
"content": "// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (proxy/utils/Initializable.sol)
pragma solidity ^0.8.20;
/**
* @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
* behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
* external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
* function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
*
* The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
* reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
* case an upgrade adds a module that needs to be initialized.
*
* For example:
*
* [.hljs-theme-light.nopadding]
* ```solidity
* contract MyToken is ERC20Upgradeable {
* function initialize() initializer public {
* __ERC20_init("MyToken", "MTK");
* }
* }
*
* contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
* function initializeV2() reinitializer(2) public {
* __ERC20Permit_init("MyToken");
* }
* }
* ```
*
* TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
* possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
*
* CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
* that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
*
* [CAUTION]
* ====
* Avoid leaving a contract uninitialized.
*
* An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
* contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
* the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
*
* [.hljs-theme-light.nopadding]
* ```
* /// @custom:oz-upgrades-unsafe-allow constructor
* constructor() {
* _disableInitializers();
* }
* ```
* ====
*/
abstract contract Initializable {
/**
* @dev Storage of the initializable contract.
*
* It's implemented on a custom ERC-7201 namespace to reduce the risk of storage collisions
* when using with upgradeable contracts.
*
* @custom:storage-location erc7201:openzeppelin.storage.Initializable
*/
struct InitializableStorage {
/**
* @dev Indicates that the contract has been initialized.
*/
uint64 _initialized;
/**
* @dev Indicates that the contract is in the process of being initialized.
*/
bool _initializing;
}
// keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.Initializable")) - 1)) & ~bytes32(uint256(0xff))
bytes32 private constant INITIALIZABLE_STORAGE = 0xf0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a00;
/**
* @dev The contract is already initialized.
*/
error InvalidInitialization();
/**
* @dev The contract is not initializing.
*/
error NotInitializing();
/**
* @dev Triggered when the contract has been initialized or reinitialized.
*/
event Initialized(uint64 version);
/**
* @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
* `onlyInitializing` functions can be used to initialize parent contracts.
*
* Similar to `reinitializer(1)`, except that in the context of a constructor an `initializer` may be invoked any
* number of times. This behavior in the constructor can be useful during testing and is not expected to be used in
* production.
*
* Emits an {Initialized} event.
*/
modifier initializer() {
// solhint-disable-next-line var-name-mixedcase
InitializableStorage storage $ = _getInitializableStorage();
// Cache values to avoid duplicated sloads
bool isTopLevelCall = !$._initializing;
uint64 initialized = $._initialized;
// Allowed calls:
// - initialSetup: the contract is not in the initializing state and no previous version was
// initialized
// - construction: the contract is initialized at version 1 (no reininitialization) and the
// current contract is just being deployed
bool initialSetup = initialized == 0 && isTopLevelCall;
bool construction = initialized == 1 && address(this).code.length == 0;
if (!initialSetup && !construction) {
revert InvalidInitialization();
}
$._initialized = 1;
if (isTopLevelCall) {
$._initializing = true;
}
_;
if (isTopLevelCall) {
$._initializing = false;
emit Initialized(1);
}
}
/**
* @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
* contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
* used to initialize parent contracts.
*
* A reinitializer may be used after the original initialization step. This is essential to configure modules that
* are added through upgrades and that require initialization.
*
* When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`
* cannot be nested. If one is invoked in the context of another, execution will revert.
*
* Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
* a contract, executing them in the right order is up to the developer or operator.
*
* WARNING: Setting the version to 2**64 - 1 will prevent any future reinitialization.
*
* Emits an {Initialized} event.
*/
modifier reinitializer(uint64 version) {
// solhint-disable-next-line var-name-mixedcase
InitializableStorage storage $ = _getInitializableStorage();
if ($._initializing || $._initialized >= version) {
revert InvalidInitialization();
}
$._initialized = version;
$._initializing = true;
_;
$._initializing = false;
emit Initialized(version);
}
/**
* @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
* {initializer} and {reinitializer} modifiers, directly or indirectly.
*/
modifier onlyInitializing() {
_checkInitializing();
_;
}
/**
* @dev Reverts if the contract is not in an initializing state. See {onlyInitializing}.
*/
function _checkInitializing() internal view virtual {
if (!_isInitializing()) {
revert NotInitializing();
}
}
/**
* @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
* Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
* to any version. It is recommended to use this to lock implementation contracts that are designed to be called
* through proxies.
*
* Emits an {Initialized} event the first time it is successfully executed.
*/
function _disableInitializers() internal virtual {
// solhint-disable-next-line var-name-mixedcase
InitializableStorage storage $ = _getInitializableStorage();
if ($._initializing) {
revert InvalidInitialization();
}
if ($._initialized != type(uint64).max) {
$._initialized = type(uint64).max;
emit Initialized(type(uint64).max);
}
}
/**
* @dev Returns the highest version that has been initialized. See {reinitializer}.
*/
function _getInitializedVersion() internal view returns (uint64) {
return _getInitializableStorage()._initialized;
}
/**
* @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.
*/
function _isInitializing() internal view returns (bool) {
return _getInitializableStorage()._initializing;
}
/**
* @dev Returns a pointer to the storage namespace.
*/
// solhint-disable-next-line var-name-mixedcase
function _getInitializableStorage() private pure returns (InitializableStorage storage $) {
assembly {
$.slot := INITIALIZABLE_STORAGE
}
}
}
"
},
"@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol": {
"content": "// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/ERC165.sol)
pragma solidity ^0.8.20;
import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import {Initializable} from "../../proxy/utils/Initializable.sol";
/**
* @dev Implementation of the {IERC165} interface.
*
* Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
* for the additional interface id that will be supported. For example:
*
* ```solidity
* function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
* return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
* }
* ```
*/
abstract contract ERC165Upgradeable is Initializable, IERC165 {
function __ERC165_init() internal onlyInitializing {
}
function __ERC165_init_unchained() internal onlyInitializing {
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
"
},
"@openzeppelin/contracts/token/ERC20/IERC20.sol": {
"content": "// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)
pragma solidity ^0.8.20;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Returns the value of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the value of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves a `value` amount of tokens from the caller's account to `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address to, uint256 value) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets a `value` amount of tokens as the allowance of `spender` over the
* caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 value) external returns (bool);
/**
* @dev Moves a `value` amount of tokens from `from` to `to` using the
* allowance mechanism. `value` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address from, address to, uint256 value) external returns (bool);
}
"
},
"@openzeppelin/contracts/utils/Address.sol": {
"content": "// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)
pragma solidity ^0.8.20;
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev The ETH balance of the account is not enough to perform the operation.
*/
error AddressInsufficientBalance(address account);
/**
* @dev There's no code at `target` (it is not a contract).
*/
error AddressEmptyCode(address target);
/**
* @dev A call to an address target failed. The target may have reverted.
*/
error FailedInnerCall();
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
if (address(this).balance < amount) {
revert AddressInsufficientBalance(address(this));
}
(bool success, ) = recipient.call{value: amount}("");
if (!success) {
revert FailedInnerCall();
}
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason or custom error, it is bubbled
* up by this function (like regular Solidity function calls). However, if
* the call reverted with no returned reason, this function reverts with a
* {FailedInnerCall} error.
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*/
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*/
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
if (address(this).balance < value) {
revert AddressInsufficientBalance(address(this));
}
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*/
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*/
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata);
}
/**
* @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
* was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an
* unsuccessful call.
*/
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata
) internal view returns (bytes memory) {
if (!success) {
_revert(returndata);
} else {
// only check if target is a contract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
if (returndata.length == 0 && target.code.length == 0) {
revert AddressEmptyCode(target);
}
return returndata;
}
}
/**
* @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
* revert reason or with a default {FailedInnerCall} error.
*/
function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
if (!success) {
_revert(returndata);
} else {
return returndata;
}
}
/**
* @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.
*/
function _revert(bytes memory returndata) private pure {
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert FailedInnerCall();
}
}
}
"
},
"@openzeppelin/contracts/utils/introspection/IERC165.sol": {
"content": "// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/IERC165.sol)
pragma solidity ^0.8.20;
/**
* @dev Interface of the ERC165 standard, as defined in the
* https://eips.ethereum.org/EIPS/eip-165[EIP].
*
* Implementers can declare support of contract interfaces, which can then be
* queried by others ({ERC165Checker}).
*
* For an implementation, see {ERC165}.
*/
interface IERC165 {
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
"
},
"contracts/compiler/base/LiquidityPoolsRepository.sol": {
"content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;
import {
AlreadyUpToDate,
ILiquidityPoolsRepository,
PoolIdNotFound,
PoolIsNotSupported,
Status
} from "contracts/interfaces/compiler/adapters/index.sol";
abstract contract LiquidityPoolsRepository is ILiquidityPoolsRepository {
modifier getPoolGuard(uint256 _poolId) {
Status status = getPoolStatus(_poolId);
if (status == Status.Undefined) revert PoolIsNotSupported(_poolId);
_;
}
// Interface implementation
function updatePoolSupport(
bytes calldata _encodedParams,
bool _supported
) external override returns (uint256 poolId_) {
poolId_ = getPoolIdFromParams(_encodedParams);
Status status = getPoolStatus(poolId_);
if (_supported && status == Status.Undefined) {
return initializePool(_encodedParams);
}
if (_supported && status == Status.Suspended) {
setPoolStatus(poolId_, Status.Supported);
return poolId_;
}
if (!_supported && status == Status.Supported) {
setPoolStatus(poolId_, Status.Suspended);
return poolId_;
}
revert AlreadyUpToDate();
}
function getPoolId(
bytes calldata _encodedTokens
) external view override returns (uint256 poolId_) {
if (getPoolStatus(poolId_ = getPoolIdFromTokens(_encodedTokens)) == Status.Undefined) {
revert PoolIdNotFound(_encodedTokens);
}
}
function getPoolStatus(uint256 _poolId) public view virtual override returns (Status);
// Internal fixture
function initializePool(
bytes calldata _encodedParams
) internal virtual returns (uint256 poolId_);
function setPoolStatus(uint256 _poolId, Status _status) internal virtual;
function getPoolIdFromParams(
bytes calldata _encodedParams
) internal view virtual returns (uint256 poolId_);
function getPoolIdFromTokens(
bytes calldata _encodedTokens
) internal view virtual returns (uint256 poolId_);
}
"
},
"contracts/compiler/libraries/Path.sol": {
"content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;
library Path {
using Path for bytes;
uint256 internal constant ADDRESS_LEN = 20;
uint256 internal constant POOL_ID_LEN = 4;
uint256 internal constant NEXT_OFFSET = ADDRESS_LEN + POOL_ID_LEN;
error InvalidPathLength(uint256);
function extractTokenIn(bytes calldata _path) internal pure returns (address tokenIn_) {
_path.ensureValid();
tokenIn_ = _path.extractTokenInUnsafe();
}
function extractTokenInUnsafe(bytes calldata _path) internal pure returns (address tokenIn_) {
tokenIn_ = address(bytes20(_path[0:ADDRESS_LEN]));
}
function extractTokenOut(bytes calldata _path) internal pure returns (address tokenOut_) {
_path.ensureValid();
tokenOut_ = _path.extractTokenOutUnsafe();
}
function extractTokenOutUnsafe(bytes calldata _path) internal pure returns (address tokenOut_) {
uint256 len = _path.length;
tokenOut_ = address(bytes20(_path[len - ADDRESS_LEN:len]));
}
/* solhint-disable var-name-mixedcase */
function extractPool(
bytes calldata _path,
uint256 _poolNumber
) internal pure returns (address tokenIn__, address tokenOut_, uint32 poolId_____) {
/* solhint-enable var-name-mixedcase */
_path.ensureValid();
uint256 ptr = _poolNumber * NEXT_OFFSET;
tokenIn__ = address(bytes20(_path[ptr:(ptr = ptr + ADDRESS_LEN)]));
poolId_____ = uint32(bytes4(_path[ptr:(ptr = ptr + POOL_ID_LEN)]));
tokenOut_ = address(bytes20(_path[ptr:(ptr = ptr + ADDRESS_LEN)]));
}
function getNumberOfPools(bytes calldata _path) internal pure returns (uint256) {
_path.ensureValid();
return (_path.length - ADDRESS_LEN) / NEXT_OFFSET;
}
function ensureValid(bytes calldata _path) internal pure {
if (!isValid(_path)) revert InvalidPathLength(_path.length);
}
function isValid(bytes calldata _path) private pure returns (bool) {
if (_path.length < ADDRESS_LEN) return false;
return (_path.length - ADDRESS_LEN) % NEXT_OFFSET == 0;
}
}
"
},
"contracts/compiler/pendle/actions/PendleRouter.sol": {
"content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;
import {IPActionMiscV3} from "contracts/interfaces/compliance/internal/pendle/IPActionMiscV3.sol";
import {
IPActionSwapPTV3,
LimitOrderData,
TokenOutput
} from "contracts/interfaces/compliance/internal/pendle/IPActionSwapPTV3.sol";
import {PendleImmutableState} from "../base/PendleImmutableState.sol";
abstract contract PendleRouter is PendleImmutableState {
function constructSwapExactPtForToken(
address receiver,
address market,
uint256 exactPtIn,
TokenOutput memory output,
LimitOrderData memory limit
) internal pure returns (address target, bytes memory data) {
target = ROUTER;
data = abi.encodeCall(
IPActionSwapPTV3.swapExactPtForToken,
(receiver, market, exactPtIn, output, limit)
);
}
function constructExitPostExpToToken(
address receiver,
address market,
uint256 netPtIn,
uint256 netLpIn,
TokenOutput memory output
) internal pure returns (address target, bytes memory data) {
target = ROUTER;
data = abi.encodeCall(
IPActionMiscV3.exitPostExpToToken,
(receiver, market, netPtIn, netLpIn, output)
);
}
}
"
},
"contracts/compiler/pendle/base/PendleHub.sol": {
"content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;
import {IPMarket} from "contracts/interfaces/compliance/internal/pendle/IPMarket.sol";
import {
IPActionMiscV3,
IPActionSwapPTV3,
LimitOrderData,
PendleRouter,
TokenOutput
} from "../actions/PendleRouter.sol";
abstract contract PendleHub is PendleRouter {
struct SwitchResult {
address tokenIn;
address tokenOut;
address target;
bytes data;
}
struct SwapResult {
address receiver;
address market;
uint256 netLpIn;
TokenOutput output;
LimitOrderData limit;
}
error UnsupportedPendleRouterFunction(bytes4 selector);
function switchBySelector(
bytes calldata extraData,
uint256 amountIn,
uint256 minAmountOut,
address recipient
) internal view returns (SwitchResult memory result) {
bytes4 selector = bytes4(extraData[:4]);
bytes calldata payload = extraData[4:];
SwapResult memory swapResult = decodePayload(selector, payload);
if (selector == IPActionSwapPTV3.swapExactPtForToken.selector) {
result = swapExactPtForToken(swapResult, amountIn, minAmountOut, recipient);
} else if (selector == IPActionMiscV3.exitPostExpToToken.selector) {
result = exitPostExpToToken(swapResult, amountIn, minAmountOut, recipient);
} else {
revert UnsupportedPendleRouterFunction(selector);
}
}
function swapExactPtForToken(
SwapResult memory swapResult,
uint256 amountIn,
uint256 minAmountOut,
address recipient
) internal view virtual returns (SwitchResult memory result) {
IPMarket market = IPMarket(swapResult.market);
(, address tokenPt, ) = market.readTokens();
result.tokenIn = tokenPt;
result.tokenOut = swapResult.output.tokenOut;
swapResult.output.minTokenOut = minAmountOut;
(result.target, result.data) = constructSwapExactPtForToken(
recipient,
swapResult.market,
amountIn,
swapResult.output,
swapResult.limit
);
}
function exitPostExpToToken(
SwapResult memory swapResult,
uint256 amountIn,
uint256 minAmountOut,
address recipient
) internal view virtual returns (SwitchResult memory result) {
IPMarket market = IPMarket(swapResult.market);
(, address tokenPt, ) = market.readTokens();
result.tokenIn = tokenPt;
result.tokenOut = swapResult.output.tokenOut;
swapResult.output.minTokenOut = minAmountOut;
(result.target, result.data) = constructExitPostExpToToken(
recipient,
swapResult.market,
amountIn,
swapResult.netLpIn,
swapResult.output
);
}
function decodePayload(
bytes4 selector,
bytes calldata payload
) private pure returns (SwapResult memory result) {
if (selector == IPActionSwapPTV3.swapExactPtForToken.selector) {
(result.receiver, result.market, , result.output, result.limit) = abi.decode(
payload,
(address, address, uint256, TokenOutput, LimitOrderData)
);
} else if (selector == IPActionMiscV3.exitPostExpToToken.selector) {
(result.receiver, result.market, , result.netLpIn, result.output) = abi.decode(
payload,
(address, address, uint256, uint256, TokenOutput)
);
} else {
revert UnsupportedPendleRouterFunction(selector);
}
}
}
"
},
"contracts/compiler/pendle/base/PendleImmutableState.sol": {
"content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;
contract PendleImmutableState {
address internal constant ROUTER = 0x888888888889758F76e7103c6CbF23ABbF58F946;
}
"
},
"contracts/compiler/pendle/PendleEvaluator.sol": {
"content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;
import {
IDecreasePositionEvaluator,
IExchangeEvaluator
} from "contracts/interfaces/compiler/adapters/index.sol";
import {
IPActionAddRemoveLiqV3,
LimitOrderData,
TokenOutput
} from "contracts/interfaces/compliance/internal/pendle/IPActionAddRemoveLiqV3.sol";
import {IPMarket} from "contracts/interfaces/compliance/internal/pendle/IPMarket.sol";
import {IPYieldToken} from "contracts/interfaces/compliance/internal/pendle/IPYieldToken.sol";
import {
IStandardizedYield
} from "contracts/interfaces/compliance/internal/pendle/IStandardizedYield.sol";
import {Command, CommandLibrary} from "contracts/libraries/CommandLibrary.sol";
import {Path} from "../libraries/Path.sol";
import {PendleHub} from "./base/PendleHub.sol";
import {PendleLiquidityPoolsRepository} from "./PendleLiquidityPoolsRepository.sol";
contract PendleEvaluator is
IDecreasePositionEvaluator,
IExchangeEvaluator,
PendleLiquidityPoolsRepository,
PendleHub
{
using CommandLibrary for Command[];
using Path for bytes;
error UnexpectedTokenDuringExchangeRequest(address tokenProvided, address tokenExpected);
error UnexpectedTokenDuringDecreasePositionRequest(uint256 poolId, address token);
function evaluate(
address,
ExchangeRequest calldata request
) external view override returns (Command[] memory cmds) {
SwitchResult memory result = switchBySelector(
request.extraData,
request.amountIn,
request.minAmountOut,
request.recipient
);
address tokenIn = request.path.extractTokenIn();
if (tokenIn != result.tokenIn)
revert UnexpectedTokenDuringExchangeRequest(tokenIn, result.tokenIn);
cmds = Command({target: result.target, value: 0, payload: result.data}).populateWithApprove(
result.tokenIn,
request.amountIn
);
}
function evaluate(
address operator,
DecreasePositionRequest calldata request
) external view override returns (Command[] memory cmds) {
(address token, address market, ) = getPool(request.descriptor.poolId);
if (token != request.minOutput[0].token)
revert UnexpectedTokenDuringDecreasePositionRequest(
request.descriptor.poolId,
request.minOutput[0].token
);
(address syToken, , address ytToken) = IPMarket(market).readTokens();
bytes memory payload = abi.encodeCall(IStandardizedYield.claimRewards, (operator));
cmds = (Command({target: syToken, value: 0, payload: payload})).asArray();
payload = abi.encodeCall(IPYieldToken.redeemDueInterestAndRewards, (operator, true, true));
cmds = cmds.push(Command({target: ytToken, value: 0, payload: payload}));
payload = abi.encodeCall(IPMarket.redeemRewards, (operator));
cmds = cmds.push(Command({target: market, value: 0, payload: payload}));
TokenOutput memory output;
LimitOrderData memory limit;
output.tokenOut = token;
output.minTokenOut = request.minOutput[0].amount;
output.tokenRedeemSy = token;
payload = abi.encodeCall(
IPActionAddRemoveLiqV3.removeLiquiditySingleToken,
(operator, market, request.liquidity, output, limit)
);
cmds = cmds.append(
Command({target: ROUTER, value: 0, payload: payload}).populateWithApprove(
market,
request.liquidity
)
);
}
}
"
},
"contracts/compiler/pendle/PendleLiquidityPoolsRepository.sol": {
"content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;
import {Address} from "contracts/libraries/Address.sol";
import {LiquidityPoolsRepository, Status} from "../base/LiquidityPoolsRepository.sol";
abstract contract PendleLiquidityPoolsRepository is LiquidityPoolsRepository {
using Address for address;
enum PositionType {
LP,
PT,
YT
}
struct Pool {
address token;
address market;
PositionType pType;
Status status;
}
struct Storage {
uint256 currentPoolId;
mapping(bytes32 poolTokensHash => uint256 poolId) ids;
mapping(uint256 poolId => Pool) pools;
}
// keccak256("Pendle Liquidity Pools State V1")
bytes32 internal constant STORAGE_SLOT =
0xdb30d141cb14f7793ef507f58c70af081a451bad8a68a642aa3dfbd48964a803;
function getPoolStatus(uint256 poolId) public view override returns (Status) {
return _storage().pools[poolId].status;
}
function initializePool(
bytes calldata encodedParams
) internal override returns (uint256 poolId) {
(address token, address market, uint8 pType) = abi.decode(
encodedParams,
(address, address, uint8)
);
Storage storage $ = _storage();
$.ids[hashDecode(encodedParams)] = ++$.currentPoolId;
$.pools[poolId = $.currentPoolId] = Pool({
token: token,
market: market,
pType: PositionType(pType),
status: Status.Supported
});
}
function setPoolStatus(uint256 poolId, Status status) internal override {
_storage().pools[poolId].status = status;
}
function getPool(
uint256 poolId
) internal view getPoolGuard(poolId) returns (address, address, PositionType) {
Pool storage pool = _storage().pools[poolId];
return (pool.token, pool.market, pool.pType);
}
function getPoolIdFromParams(
bytes calldata encodedParams
) internal view override returns (uint256) {
return getPoolIdFromTokens(encodedParams);
}
function getPoolIdFromTokens(
bytes calldata encodedTokens
) internal view override returns (uint256) {
return _storage().ids[hashDecode(encodedTokens)];
}
function hashDecode(bytes calldata encoded) internal pure returns (bytes32) {
(address token, address market, uint8 pType) = abi.decode(
encoded,
(address, address, uint8)
);
return keccak256(abi.encodePacked(token, market, pType));
}
function _storage() private pure returns (Storage storage $) {
assembly {
$.slot := STORAGE_SLOT
}
}
}
"
},
"contracts/interfaces/base/CommonErrors.sol": {
"content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;
/**
* @notice An error indicating that the amount for the specified token is zero.
* @param token The address of the token with a zero amount.
*/
error AmountMustNotBeZero(address token);
/**
* @notice An error indicating that an address must not be zero.
*/
error AddressMustNotBeZero();
/**
* @notice An error indicating that an array must not be empty.
*/
error ArrayMustNotBeEmpty();
/**
* @notice An error indicating that an string must not be empty.
*/
error StringMustNotBeEmpty();
/**
* @notice An error indicating storage is already up to date and doesn't need further processing.
* @dev This error is thrown when attempting to update an entity(s) that is(are) already up to date.
*/
error AlreadyUpToDate();
/**
* @notice An error indicating that an action is unauthorized for the specified account.
* @param account The address of the unauthorized account.
*/
error UnauthorizedAccount(address account);
/**
* @notice An error indicating that the min amount out must not be zero.
*/
error MinAmountOutMustNotBeZero();
"
},
"contracts/interfaces/base/IERC165Extended.sol": {
"content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;
/* solhint-disable no-unused-import */
import {
IERC165
} from "@openzeppelin/contracts-upgradeable/utils/introspection/ERC165Upgradeable.sol";
/* solhint-enable no-unused-import */
/**
* @notice An error indicating that an address does not support the expected interface
* @param implementation The address that does not implement the required interface
*/
error UnsupportedInterface(address implementation);
/**
* @dev Extended interface of the ERC165 standard to ensure compatibility
* with Diamond facets as defined in EIP-2535.
*
* This interface extends the basic ERC165 mechanism to provide additional
* flexibility for querying supported interfaces, which can then be
* dynamically resolved by one of facets in a Diamond.
*/
interface IERC165Extended {
/**
* @notice Checks if the given interface ID is supported by the contract.
* @param interfaceId The ID of the interface to query.
* @return isSupported Boolean value indicating whether the interface is supported.
*/
function supportsInterfaceExtended(bytes4 interfaceId) external pure returns (bool isSupported);
}
"
},
"contracts/interfaces/compiler/adapters/IDecreasePositionEvaluator.sol": {
"content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;
import {Asset} from "contracts/libraries/AssetLibrary.sol";
import {Command} from "../Command.sol";
import {PositionDescriptor} from "./PositionDescriptor.sol";
interface IDecreasePositionEvaluator {
/**
* @notice Request structure for decreasing a position.
* @dev `descriptor`: The [`PositionDescriptor`](/interfaces/compiler/adapters/PositionDescriptor.sol/struct.PositionDescriptor.html)
* struct.
* @dev `liquidity`: Abstract amount that can be interpreted differently in different protocols (e.g., amount of LP tokens to burn).
* @dev `minOutput`: [`Asset`](/interfaces/compliance/Asset.sol/struct.Asset.html) array with minimum amounts that must be retrieved from the position.
*/
struct DecreasePositionRequest {
PositionDescriptor descriptor;
uint256 liquidity;
Asset[] minOutput;
}
/**
* @notice Evaluate a decrease position request.
* @param _operator Address which initiated the request
* @param _request The [`DecreasePositionRequest`](#decreasepositionrequest) struct containing decrease position details.
* @return cmds_ An array of [`Command`](../../Command.sol/struct.Command.html) to execute the request.
*/
function evaluate(
address _operator,
DecreasePositionRequest calldata _request
) external returns (Command[] memory cmds_);
}
"
},
"contracts/interfaces/compiler/adapters/IExchangeEvaluator.sol": {
"content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;
import {Command} from "../Command.sol";
/**
* @title IExchangeEvaluator
* @notice Interface for compiling commands for token exchanges for different protocols.
*/
interface IExchangeEvaluator {
/**
* @notice Structure for an exchange token request.
* @dev `path`: Encoded path of tokens to follow in the exchange, including pool identifiers.
* 20 bytes(tokenA) + 4 byte(poolId_A_B) + 20 bytes(tokenB) + ...
* ... + 4 byte(poolId_N-1_N) + 20 bytes(tokenN).
* @dev `extraData`: Additional data specific to a particular protocol, such as the response from a 1Inch Exchange API.
* @dev `amountIn`: The amount of tokenA to spend.
* @dev `minAmountOut`: The minimum amount of tokenN to receive.
* @dev `recipient`: The recipient of tokenN.
*/
struct ExchangeRequest {
bytes path;
bytes extraData;
uint256 amountIn;
uint256 minAmountOut;
address recipient;
}
/**
* @notice Constructs an exchange token request.
* @param _operator Address which initiated the request
* @param _request The [`ExchangeRequest`](#exchangerequest) struct containing exchange token details.
* @return cmds_ An array of [`Command`](../../Command.sol/struct.Command.html) to execute the request.
*/
function evaluate(
address _operator,
ExchangeRequest calldata _request
) external view returns (Command[] memory cmds_);
}
"
},
"contracts/interfaces/compiler/adapters/IIncreasePositionEvaluator.sol": {
"content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;
import {Asset} from "contracts/libraries/AssetLibrary.sol";
import {Command} from "../Command.sol";
import {PositionDescriptor} from "./PositionDescriptor.sol";
interface IIncreasePositionEvaluator {
/**
* @notice Structure for an increase position request.
* @dev `descriptor`: The [`PositionDescriptor`](/interfaces/compiler/adapters/PositionDescriptor.sol/struct.PositionDescriptor.html)
* struct.
* @dev `input`: An array of [`Asset`](/interfaces/compliance/Asset.sol/struct.Asset.html) representing the token-amounts that will be added to the position.
* @dev `minLiquidityOut`: An abstract amount that can be interpreted differently in different protocols (e.g., minimum amount of LP tokens to receive).
*/
struct IncreasePositionRequest {
PositionDescriptor descriptor;
Asset[] input;
uint256 minLiquidityOut;
}
/**
* @notice Evaluate a increase position request.
* @param _operator Address which initiated the request
* @param _request The [`IncreasePositionRequest`](#increasepositionrequest) struct containing increase position details.
* @return cmds_ An array of [`Command`](../../Command.sol/struct.Command.html) to execute the request.
*/
function evaluate(
address _operator,
IncreasePositionRequest calldata _request
) external returns (Command[] memory cmds_);
}
"
},
"contracts/interfaces/compiler/adapters/ILiquidityPoolsRepository.sol": {
"content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;
/* solhint-disable no-unused-import */
import {AlreadyUpToDate} from "contracts/interfaces/base/CommonErrors.sol";
import {
Status,
TokenIsNotSupported
} from "contracts/interfaces/compliance/IWhitelistingController.sol";
/* solhint-enable no-unused-import */
/**
* @notice Error indicating that the pool ID was not found.
* @param encodedPool The encoded pool data that was searched for.
*/
error PoolIdNotFound(bytes encodedPool);
/**
* @notice Error indicating that the pool does not exist.
* @param poolId The unique identifier of the pool that was searched for.
*/
error PoolIsNotSupported(uint256 poolId);
/**
* @notice Error indicating that the pool is suspended.
* @param poolId The unique identifier of the pool that is suspended.
*/
error PoolIsSuspended(uint256 poolId);
/**
* @title ILiquidityPoolsRepository
* @notice Interface for managing liquidity pools and their support status.
*/
interface ILiquidityPoolsRepository {
/**
* @notice Update the support status of a liquidity pool.
* @param _encodedPool The encoded pool data.
* @param _supported Whether the pool is supported or not.
* @return poolId_ The unique identifier of the pool.
* @dev Reverts with a [`PoolIdNotFound()`](/interfaces/compiler/adapters/ILiquidityPoolsRepository.sol/error.PoolIdNotFound.html)
* error if the pool does not exist.
*/
function updatePoolSupport(
bytes calldata _encodedPool,
bool _supported
) external returns (uint256 poolId_);
/**
* @notice Get the status of a specific pool.
* @param _poolId The unique identifier of the pool.
* @return status The status of the pool.
* @dev Reverts with a [`PoolIsNotSupported()`](/interfaces/compiler/adapters/ILiquidityPoolsRepository.sol/error.PoolIsNotSupported.html)
* error if the pool does not exist.
*/
function getPoolStatus(uint256 _poolId) external returns (Status status);
/**
* @notice Get the unique identifier (pool ID) of a specific pool.
* @param _encodedPool The encoded pool data.
* @return poolId_ The unique identifier of the pool.
* @dev Reverts with a [`PoolIsNotSupported()`](/interfaces/compiler/adapters/ILiquidityPoolsRepository.sol/error.PoolIsNotSupported.html)
* error if the pool does not exist.
*/
function getPoolId(bytes calldata _encodedPool) external view returns (uint256 poolId_);
}
"
},
"contracts/interfaces/compiler/adapters/index.sol": {
"content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;
import {
IDecreasePositionEvaluator
} from "contracts/interfaces/compiler/adapters/IDecreasePositionEvaluator.sol";
import {IExchangeEvaluator} from "contracts/interfaces/compiler/adapters/IExchangeEvaluator.sol";
import {
IIncreasePositionEvaluator
} from "contracts/interfaces/compiler/adapters/IIncreasePositionEvaluator.sol";
import {
AlreadyUpToDate,
ILiquidityPoolsRepository,
PoolIdNotFound,
PoolIsNotSupported,
PoolIsSuspended,
Status,
TokenIsNotSupported
} from "contracts/interfaces/compiler/adapters/ILiquidityPoolsRepository.sol";
import {PositionDescriptor} from "contracts/interfaces/compiler/adapters/PositionDescriptor.sol";
"
},
"contracts/interfaces/compiler/adapters/PositionDescriptor.sol": {
"content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;
// TODO CRYPTO-145: Possibly move into appropriate interface?
/**
* @notice Used to determine the required position for an operation.
* @dev `poolId`: An identifier that is unique within a single protocol.
* @dev `extraData`: Additional data used to specify the position, for example
* this is used in OneInchV5Evaluator to pass swap tx generated via 1inch API.
*/
struct PositionDescriptor {
uint256 poolId;
bytes extraData;
}
"
},
"contracts/interfaces/compiler/Command.sol": {
"content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;
import {CommandLibrary} from "contracts/libraries/CommandLibrary.sol";
/**
* @title Command
* @notice Contains arguments for a low-level call.
* @dev This struct allows deferring the call's execution, suspending it by passing it to another function or contract.
* @dev `target` The address to be called.
* @dev `value` Value to send in the call.
* @dev `payload` Encoded call with function selector and arguments.
*/
struct Command {
address target;
uint256 value;
bytes payload;
}
using CommandLibrary for Command global;
"
},
"contracts/interfaces/compliance/Asset.sol": {
"content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;
import {AssetLibrary} from "contracts/libraries/AssetLibrary.sol";
/**
* @title Asset
* @dev Represents an asset with its token address and the amount.
* @param token The address of the asset's token.
* @param amount The amount of the asset.
*/
struct Asset {
address token;
uint256 amount;
}
using AssetLibrary for Asset global;
"
},
"contracts/interfaces/compliance/internal/pendle/IPActionAddRemoveLiqV3.sol": {
"content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;
import {ApproxParams, LimitOrderData, TokenInput, TokenOutput} from "./IPAllActionTypeV3.sol";
/// Refer to IPAllActionTypeV3.sol for details on the parameters
interface IPActionAddRemoveLiqV3 {
function addLiquiditySingleToken(
address receiver,
address market,
uint256 minLpOut,
ApproxParams calldata guessPtReceivedFromSy,
TokenInput calldata input,
LimitOrderData calldata limit
) external payable returns (uint256 netLpOut, uint256 netSyFee, uint256 netSyInterm);
function removeLiquiditySingleToken(
address receiver,
address market,
uint256 netLpToRemove,
TokenOutput calldata output,
LimitOrderData calldata limit
) external returns (uint256 netTokenOut, uint256 netSyFee, uint256 netSyInterm);
}
"
},
"contracts/interfaces/compliance/internal/pendle/IPActionMiscV3.sol": {
"content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;
import {
SwapDataExtra
} from "contracts/interfaces/compliance/internal/pendle/router/swap-aggregator/IPSwapAggregator.sol";
import {
ExitPostExpReturnParams,
RedeemYtIncomeToTokenStruct,
TokenOutput
} from "./IPAllActionTypeV3.sol";
/// Refer to IPAllActionTypeV3.sol for details on the parameters
interface IPActionMiscV3 {
struct Call3 {
bool allowFailure;
bytes callData;
}
struct Result {
bool success;
bytes returnData;
}
function redeemPyToToken(
address receiver,
address YT,
uint256 netPyIn,
TokenOutput calldata output
) external returns (uint256 netTokenOut, uint256 netSyInterm);
function redeemDueInterestAndRewards(
address user,
address[] calldata sys,
address[] calldata yts,
address[] calldata markets
) external;
function redeemDueInterestAndRewardsV2(
address[] calldata SYs,
RedeemYtIncomeToTokenStruct[] calldata YTs,
address[] calldata markets,
address pendleSwap,
SwapDataExtra[] calldata swaps
) external returns (uint256[] memory netOutFromSwaps, uint256[] memory netInterests);
function exitPostExpToToken(
address receiver,
address market,
uint256 netPtIn,
uint256 netLpIn,
TokenOutput calldata output
) external returns (uint256 netTokenOut, ExitPostExpReturnParams memory params);
function callAndReflect(
address payable reflector,
bytes calldata selfCall1,
bytes calldata selfCall2,
bytes calldata reflectCall
)
external
payable
returns (bytes memory selfRes1, bytes memory selfRes2, bytes memory reflectRes);
function multicall(Call3[] calldata calls) external payable returns (Result[] memory res);
}
"
},
"contracts/interfaces/compliance/internal/pendle/IPActionSwapPTV3.sol": {
"content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;
import {ApproxParams, LimitOrderData, TokenInput, TokenOutput} from "./IPAllActionTypeV3.sol";
/// Refer to IPAllActionTypeV3.sol for details on the parameters
interface IPActionSwapPTV3 {
function swapExactTokenForPt(
address receiver,
address market,
uint256 minPtOut,
ApproxParams calldata guessPtOut,
TokenInput calldata input,
LimitOrderData calldata limit
) external payable returns (uint256 netPtOut, uint256 netSyFee, uint256 netSyInterm);
function swapExactPtForToken(
address receiver,
address market,
uint256 exactPtIn,
TokenOutput calldata output,
LimitOrderData calldata limit
) external returns (uint256 netTokenOut, uint256 netSyFee, uint256 netSyInterm);
}
"
},
"contracts/interfaces/compliance/internal/pendle/IPAllActionTypeV3.sol": {
"content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;
import {FillOrderParams} from "./IPLimitRouter.sol";
import {SwapData} from "./router/swap-aggregator/IPSwapAggregator.sol";
struct TokenInput {
address tokenIn;
uint256 netTokenIn;
address tokenMintSy;
address pendleSwap;
SwapData swapData;
}
struct TokenOutput {
address tokenOut;
uint256 minTokenOut;
address tokenRedeemSy;
address pendleSwap;
SwapData swapData;
}
struct LimitOrderData {
address limitRouter;
uint256 epsSkipMarket;
FillOrderParams[] normalFills;
FillOrderParams[] flashFills;
bytes optData;
}
struct ApproxParams {
uint256 guessMin;
uint256 guessMax;
uint256 guessOffchain;
uint256 maxIteration;
uint256 eps;
}
struct ExitPostExpReturnParams {
uint256 netPtFromRemove;
uint256 netSyFromRemove;
uint256 netPtRedeem;
uint256 netSyFromRedeem;
uint256 totalSyOut;
}
struct RedeemYtIncomeToTokenStruct {
address yt;
bool doRedeemInterest;
bool doRedeemRewards;
address tokenRedeemSy;
uint256 minTokenRedeemOut;
}
"
},
"contracts/interfaces/compliance/internal/pendle/IPLimitRouter.sol": {
"content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;
interface IPLimitOrderType {
enum OrderType {
SY_FOR_PT,
PT_FOR_SY,
SY_FOR_YT,
YT_FOR_SY
}
}
struct Order {
uint256 salt;
uint256 expiry;
uint256 nonce;
IPLimitOrderType.OrderType orderType;
address token;
address YT;
address maker;
address receiver;
uint256 makingAmount;
uint256 lnImpliedRate;
uint256 failSafeRate;
bytes permit;
}
struct FillOrderParams {
Order order;
bytes signature;
uint256 makingAmount;
}
"
},
"contracts/interfaces/compliance/internal/pendle/IPMarket.sol": {
"content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;
interface IPMarket {
function redeemRewards(address user) external returns (uint256[] memory);
function readTokens() external view returns (address _SY, address _PT, address _YT);
function isExpired() external view returns (bool);
function expiry() external view returns (uint256);
}
"
},
"contracts/interfaces/compliance/internal/pendle/IPYieldToken.sol": {
"content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;
interface IPYieldToken {
function redeemDueInterestAndRewards(
address user,
bool redeemInterest,
bool redeemRewards
) external returns (uint256 interestOut, uint256[] memory rewardsOut);
function expiry() external view returns (uint256);
}
"
},
"contracts/interfaces/compliance/internal/pendle/IStandardizedYield.sol": {
"content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;
interface IStandardizedYield {
function claimRewards(address user) external returns (uint256[] memory rewardAmounts);
}
"
},
"contracts/interfaces/compliance/internal/pendle/router/swap-aggregator/IPSwapAggregator.sol": {
"content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;
struct SwapData {
SwapType swapType;
address extRouter;
bytes extCalldata;
bool needScale;
}
struct SwapDataExtra {
address tokenIn;
address tokenOut;
uint256 minOut;
SwapData swapData;
}
enum SwapType {
NONE,
KYBERSWAP,
ODOS,
// ETH_WETH not used in Aggregator
ETH_WETH,
OKX,
ONE_INCH,
RESERVE_1,
RESERVE_2,
RESERVE_3,
RESERVE_4,
RESERVE_5
}
"
},
"contracts/interfaces/compliance/IWhitelistingController.sol": {
"content": "// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.22;
import {IERC165Extended} from "../base/IERC165Extended.sol";
import {IWhitelistingControllerAgreement} from "./IWhitelistingControllerAgreement.sol";
/**
* @title Status
* @notice Enum representing status of a record (e.g., token, protocol, operator)
* used for operation validation.
* @notice Validators must adhere to the following rules for different operations and contexts:
* 1) For exchanges: `operator`, `pool`, and `input token` *MAY* be either supported or suspended, but the `output token` *MUST* be supported.
* 2) For deposits: `operator`, `pool`, and every `token` in the `pool` *MUST* be supported.
* 3) For withdrawals: `operator`, `pool`, and each `token` *MAY* be either supported or suspended.
*
* @dev **Note** that deposit denotes **all** ways of acquiring liquidity such
* as token deposit, LP tokens stake, NFT mint etc.
*/
enum Status {
Undefined,
Supported,
Suspended
}
/**
* @title WhitelistingAddressRecord
* @notice A struct to store an address and its support status.
* @dev This struct stores an address and its support status.
* @dev `source`: The address to be stored.
* @dev `supported`: Indicates whether the address is supported or not.
*/
struct WhitelistingAddressRecord {
address source;
bool supported;
}
/**
* @title WhitelistingTokenRecord
* @notice This struct stores an address and its support status for whitelisting, collateral and leverage.
* @dev `source`: The address of the token.
* @dev `supported`: Whether the token can be received from a protocol trades.
*/
struct WhitelistingTokenRecord {
address source;
bool supported;
}
/**
* @notice An error indicating that a token is not supported by the whitelisting controller.
* @dev This error is thrown when an unsupported token is used.
* @dev `token`: The address of the unsupported token.
*/
error TokenIsNotSupported(address token);
/**
* @notice An error indicating that a token is suspended by the whitelisting controller.
* @dev This error is thrown when a suspended token is used.
* @dev `token`: The address of the suspended token.
*/
error TokenIsSuspended(address token);
/**
* @notice An error indicating that an operator is not supported by the whitelisting controller.
* @dev This error is thrown when an unsupported operator is used.
* @dev `operator`: The address of the unsupported operator.
*/
error OperatorIsNotSupported(address operator);
/**
* @notice An error indicating that an operator is suspended by the whitelisting controller.
* @dev This error is thrown when a suspended operator is used.
* @dev `operator`: The address of the suspended operator.
*/
error OperatorIsSuspended(address operator);
/**
* @notice An error indicating that a protocol is not supported by the whitelisting controller.
* @dev This error is thrown when an unsupported protocol is used.
* @dev `protocol`: The identification string of the unsupported protocol.
*/
error ProtocolIsNotSupported(bytes31 protocolNameHash);
/**
* @notice An error indicating that a protocol is suspended by the whitelisting controller.
* @dev This error is thrown when a suspended protocol is used.
* @dev `protocol`: The identification string of the unsupported protocol.
*/
error ProtocolIsSuspended(bytes31 protocolNameHash);
interface ITenant {
function factory() external view returns (address);
}
/**
* @title IWhitelistingController
* @notice Interface for managing whitelisting of tokens, protocols, and operators.
*/
interface IWhitelistingController is IWhitelistingControllerAgreement, IERC165Extended {
/**
* @dev Emitted when the support status of a protocol changes.
* @dev `protocol`: The identification string of the protocol.
* @dev `supported`: Whether the protocol is supported or not.
*/
event ProtocolSupportChanged(string indexed protocol, bool supported);
/**
* @dev Emitted when the support status of a token changes.
* @dev `token`: The address of the token.
* @dev `supported`: Whether the token is supported or not.
*/
event TokenSupportChanged(address indexed token, bool supported);
/**
* @dev Emitted when the support status of an operator changes for a specific protocol.
* @dev `protocol`: The identification string of the protocol.
* @dev `operator`: The address of the operator.
* @dev `supported`: Whether the operator is supported or not.
*/
event OperatorSupportChanged(string indexed protocol, address indexed operator, bool supported);
/**
* @notice Reverts when the agreement was deployed by a different factory version.
* @dev This error is used by the `onlyAgreementFactory` modifier to prevent
* `addTokens` and `addOperators` calls from wrong factory.
* @param factory The address of the factory attempting to interact.
* @param agreement The agreement contract whose associated factory version did not match the caller.
*/
error AgreementFactoryVersionMismatch(address factory, address agreement);
/**
* @notice Reverts when the caller contract supports a prohibited interface.
* @dev This error is used by the `notMarginAccount` modifier to prevent
* function calls from contracts that implement the `IAccount` interface.
* @param caller The address of the caller contract
*/
error CallerSupportsForbiddenInterface(address caller);
/**
* @notice An error indicating that the provided address is not a valid token address.
* @dev This error is thrown when the address does not conform to the expected token interface.
* @param token The address that failed the token validation check.
*/
error InvalidTokenAddress(address token);
/**
* @notice Update the support status of multiple tokens.
* @dev Emits a [`TokenSupportChanged()`](#tokensupportchanged) event for each token whose status changed.
* @dev Reverts with an [`AlreadyUpToDate()`](/interfaces/base/CommonErrors.sol/error.AlreadyUpToDate.html)
* error if no token status changed.
* @param _tokens An array of [`WhitelistingTokenRecord`](./struct.WhitelistingTokenRecord.html)
* structs containing token addresses and support.
*/
function updateTokensSupport(WhitelistingTokenRecord[] calldata _tokens) external;
/**
* @notice Update the support status of a protocol.
* @dev Emits a [`ProtocolSupportChanged()`](#protocolsupportchanged) event.
* @dev Reverts with an [`AlreadyUpToDate()`](/interfaces/base/CommonErrors.sol/error.AlreadyUpToDate.html)
Submitted on: 2025-10-14 12:21:10
Comments
Log in to comment.
No comments yet.