@pendle/core-v2 6.9.0 → 6.10.0

package/contracts/pt-looping/money-market/implementations/euler/dependencies/IEthereumVaultConnector.sol

@@ -0,0 +1,432 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+pragma solidity >=0.8.0;
+
+// https://github.com/euler-xyz/ethereum-vault-connector/blob/b9d557a8ebcd3db1fbeef4aa60282aa4059a7bbf/src/interfaces/IEthereumVaultConnector.sol#L9
+
+/// @title IEVC
+/// @custom:security-contact security@euler.xyz
+/// @author Euler Labs (https://www.eulerlabs.com/)
+/// @notice This interface defines the methods for the Ethereum Vault Connector.
+interface IEVC {
+    /// @notice A struct representing a batch item.
+    /// @dev Each batch item represents a single operation to be performed within a checks deferred context.
+    struct BatchItem {
+        /// @notice The target contract to be called.
+        address targetContract;
+        /// @notice The account on behalf of which the operation is to be performed. msg.sender must be authorized to
+        /// act on behalf of this account. Must be address(0) if the target contract is the EVC itself.
+        address onBehalfOfAccount;
+        /// @notice The amount of value to be forwarded with the call. If the value is type(uint256).max, the whole
+        /// balance of the EVC contract will be forwarded. Must be 0 if the target contract is the EVC itself.
+        uint256 value;
+        /// @notice The encoded data which is called on the target contract.
+        bytes data;
+    }
+
+    /// @notice A struct representing the result of a batch item operation.
+    /// @dev Used only for simulation purposes.
+    struct BatchItemResult {
+        /// @notice A boolean indicating whether the operation was successful.
+        bool success;
+        /// @notice The result of the operation.
+        bytes result;
+    }
+
+    /// @notice A struct representing the result of the account or vault status check.
+    /// @dev Used only for simulation purposes.
+    struct StatusCheckResult {
+        /// @notice The address of the account or vault for which the check was performed.
+        address checkedAddress;
+        /// @notice A boolean indicating whether the status of the account or vault is valid.
+        bool isValid;
+        /// @notice The result of the check.
+        bytes result;
+    }
+
+    /// @notice Returns current raw execution context.
+    /// @dev When checks in progress, on behalf of account is always address(0).
+    /// @return context Current raw execution context.
+    function getRawExecutionContext() external view returns (uint256 context);
+
+    /// @notice Returns an account on behalf of which the operation is being executed at the moment and whether the
+    /// controllerToCheck is an enabled controller for that account.
+    /// @dev This function should only be used by external smart contracts if msg.sender is the EVC. Otherwise, the
+    /// account address returned must not be trusted.
+    /// @dev When checks in progress, on behalf of account is always address(0). When address is zero, the function
+    /// reverts to protect the consumer from ever relying on the on behalf of account address which is in its default
+    /// state.
+    /// @param controllerToCheck The address of the controller for which it is checked whether it is an enabled
+    /// controller for the account on behalf of which the operation is being executed at the moment.
+    /// @return onBehalfOfAccount An account that has been authenticated and on behalf of which the operation is being
+    /// executed at the moment.
+    /// @return controllerEnabled A boolean value that indicates whether controllerToCheck is an enabled controller for
+    /// the account on behalf of which the operation is being executed at the moment. Always false if controllerToCheck
+    /// is address(0).
+    function getCurrentOnBehalfOfAccount(address controllerToCheck)
+        external
+        view
+        returns (address onBehalfOfAccount, bool controllerEnabled);
+
+    /// @notice Checks if checks are deferred.
+    /// @return A boolean indicating whether checks are deferred.
+    function areChecksDeferred() external view returns (bool);
+
+    /// @notice Checks if checks are in progress.
+    /// @return A boolean indicating whether checks are in progress.
+    function areChecksInProgress() external view returns (bool);
+
+    /// @notice Checks if control collateral is in progress.
+    /// @return A boolean indicating whether control collateral is in progress.
+    function isControlCollateralInProgress() external view returns (bool);
+
+    /// @notice Checks if an operator is authenticated.
+    /// @return A boolean indicating whether an operator is authenticated.
+    function isOperatorAuthenticated() external view returns (bool);
+
+    /// @notice Checks if a simulation is in progress.
+    /// @return A boolean indicating whether a simulation is in progress.
+    function isSimulationInProgress() external view returns (bool);
+
+    /// @notice Checks whether the specified account and the other account have the same owner.
+    /// @dev The function is used to check whether one account is authorized to perform operations on behalf of the
+    /// other. Accounts are considered to have a common owner if they share the first 19 bytes of their address.
+    /// @param account The address of the account that is being checked.
+    /// @param otherAccount The address of the other account that is being checked.
+    /// @return A boolean flag that indicates whether the accounts have the same owner.
+    function haveCommonOwner(address account, address otherAccount) external pure returns (bool);
+
+    /// @notice Returns the address prefix of the specified account.
+    /// @dev The address prefix is the first 19 bytes of the account address.
+    /// @param account The address of the account whose address prefix is being retrieved.
+    /// @return A bytes19 value that represents the address prefix of the account.
+    function getAddressPrefix(address account) external pure returns (bytes19);
+
+    /// @notice Returns the owner for the specified account.
+    /// @dev The function returns address(0) if the owner is not registered. Registration of the owner happens on the
+    /// initial
+    /// interaction with the EVC that requires authentication of an owner.
+    /// @param account The address of the account whose owner is being retrieved.
+    /// @return owner The address of the account owner. An account owner is an EOA/smart contract which address matches
+    /// the first 19 bytes of the account address.
+    function getAccountOwner(address account) external view returns (address);
+
+    /// @notice Checks if lockdown mode is enabled for a given address prefix.
+    /// @param addressPrefix The address prefix to check for lockdown mode status.
+    /// @return A boolean indicating whether lockdown mode is enabled.
+    function isLockdownMode(bytes19 addressPrefix) external view returns (bool);
+
+    /// @notice Checks if permit functionality is disabled for a given address prefix.
+    /// @param addressPrefix The address prefix to check for permit functionality status.
+    /// @return A boolean indicating whether permit functionality is disabled.
+    function isPermitDisabledMode(bytes19 addressPrefix) external view returns (bool);
+
+    /// @notice Returns the current nonce for a given address prefix and nonce namespace.
+    /// @dev Each nonce namespace provides 256 bit nonce that has to be used sequentially. There's no requirement to use
+    /// all the nonces for a given nonce namespace before moving to the next one which allows to use permit messages in
+    /// a non-sequential manner.
+    /// @param addressPrefix The address prefix for which the nonce is being retrieved.
+    /// @param nonceNamespace The nonce namespace for which the nonce is being retrieved.
+    /// @return nonce The current nonce for the given address prefix and nonce namespace.
+    function getNonce(bytes19 addressPrefix, uint256 nonceNamespace) external view returns (uint256 nonce);
+
+    /// @notice Returns the bit field for a given address prefix and operator.
+    /// @dev The bit field is used to store information about authorized operators for a given address prefix. Each bit
+    /// in the bit field corresponds to one account belonging to the same owner. If the bit is set, the operator is
+    /// authorized for the account.
+    /// @param addressPrefix The address prefix for which the bit field is being retrieved.
+    /// @param operator The address of the operator for which the bit field is being retrieved.
+    /// @return operatorBitField The bit field for the given address prefix and operator. The bit field defines which
+    /// accounts the operator is authorized for. It is a 256-position binary array like 0...010...0, marking the account
+    /// positionally in a uint256. The position in the bit field corresponds to the account ID (0-255), where 0 is the
+    /// owner account's ID.
+    function getOperator(bytes19 addressPrefix, address operator) external view returns (uint256 operatorBitField);
+
+    /// @notice Returns whether a given operator has been authorized for a given account.
+    /// @param account The address of the account whose operator is being checked.
+    /// @param operator The address of the operator that is being checked.
+    /// @return authorized A boolean value that indicates whether the operator is authorized for the account.
+    function isAccountOperatorAuthorized(address account, address operator) external view returns (bool authorized);
+
+    /// @notice Enables or disables lockdown mode for a given address prefix.
+    /// @dev This function can only be called by the owner of the address prefix. To disable this mode, the EVC
+    /// must be called directly. It is not possible to disable this mode by using checks-deferrable call or
+    /// permit message.
+    /// @param addressPrefix The address prefix for which the lockdown mode is being set.
+    /// @param enabled A boolean indicating whether to enable or disable lockdown mode.
+    function setLockdownMode(bytes19 addressPrefix, bool enabled) external payable;
+
+    /// @notice Enables or disables permit functionality for a given address prefix.
+    /// @dev This function can only be called by the owner of the address prefix. To disable this mode, the EVC
+    /// must be called directly. It is not possible to disable this mode by using checks-deferrable call or (by
+    /// definition) permit message. To support permit functionality by default, note that the logic was inverted here. To
+    /// disable  the permit functionality, one must pass true as the second argument. To enable the permit
+    /// functionality, one must pass false as the second argument.
+    /// @param addressPrefix The address prefix for which the permit functionality is being set.
+    /// @param enabled A boolean indicating whether to enable or disable the disable-permit mode.
+    function setPermitDisabledMode(bytes19 addressPrefix, bool enabled) external payable;
+
+    /// @notice Sets the nonce for a given address prefix and nonce namespace.
+    /// @dev This function can only be called by the owner of the address prefix. Each nonce namespace provides a 256
+    /// bit nonce that has to be used sequentially. There's no requirement to use all the nonces for a given nonce
+    /// namespace before moving to the next one which allows the use of permit messages in a non-sequential manner. To
+    /// invalidate signed permit messages, set the nonce for a given nonce namespace accordingly. To invalidate all the
+    /// permit messages for a given nonce namespace, set the nonce to type(uint).max.
+    /// @param addressPrefix The address prefix for which the nonce is being set.
+    /// @param nonceNamespace The nonce namespace for which the nonce is being set.
+    /// @param nonce The new nonce for the given address prefix and nonce namespace.
+    function setNonce(bytes19 addressPrefix, uint256 nonceNamespace, uint256 nonce) external payable;
+
+    /// @notice Sets the bit field for a given address prefix and operator.
+    /// @dev This function can only be called by the owner of the address prefix. Each bit in the bit field corresponds
+    /// to one account belonging to the same owner. If the bit is set, the operator is authorized for the account.
+    /// @param addressPrefix The address prefix for which the bit field is being set.
+    /// @param operator The address of the operator for which the bit field is being set. Can neither be the EVC address
+    /// nor an address belonging to the same address prefix.
+    /// @param operatorBitField The new bit field for the given address prefix and operator. Reverts if the provided
+    /// value is equal to the currently stored value.
+    function setOperator(bytes19 addressPrefix, address operator, uint256 operatorBitField) external payable;
+
+    /// @notice Authorizes or deauthorizes an operator for the account.
+    /// @dev Only the owner or authorized operator of the account can call this function. An operator is an address that
+    /// can perform actions for an account on behalf of the owner. If it's an operator calling this function, it can
+    /// only deauthorize itself.
+    /// @param account The address of the account whose operator is being set or unset.
+    /// @param operator The address of the operator that is being installed or uninstalled. Can neither be the EVC
+    /// address nor an address belonging to the same owner as the account.
+    /// @param authorized A boolean value that indicates whether the operator is being authorized or deauthorized.
+    /// Reverts if the provided value is equal to the currently stored value.
+    function setAccountOperator(address account, address operator, bool authorized) external payable;
+
+    /// @notice Returns an array of collaterals enabled for an account.
+    /// @dev A collateral is a vault for which an account's balances are under the control of the currently enabled
+    /// controller vault.
+    /// @param account The address of the account whose collaterals are being queried.
+    /// @return An array of addresses that are enabled collaterals for the account.
+    function getCollaterals(address account) external view returns (address[] memory);
+
+    /// @notice Returns whether a collateral is enabled for an account.
+    /// @dev A collateral is a vault for which account's balances are under the control of the currently enabled
+    /// controller vault.
+    /// @param account The address of the account that is being checked.
+    /// @param vault The address of the collateral that is being checked.
+    /// @return A boolean value that indicates whether the vault is an enabled collateral for the account or not.
+    function isCollateralEnabled(address account, address vault) external view returns (bool);
+
+    /// @notice Enables a collateral for an account.
+    /// @dev A collaterals is a vault for which account's balances are under the control of the currently enabled
+    /// controller vault. Only the owner or an operator of the account can call this function. Unless it's a duplicate,
+    /// the collateral is added to the end of the array. There can be at most 10 unique collaterals enabled at a time.
+    /// Account status checks are performed.
+    /// @param account The account address for which the collateral is being enabled.
+    /// @param vault The address being enabled as a collateral.
+    function enableCollateral(address account, address vault) external payable;
+
+    /// @notice Disables a collateral for an account.
+    /// @dev This function does not preserve the order of collaterals in the array obtained using the getCollaterals
+    /// function; the order may change. A collateral is a vault for which account’s balances are under the control of
+    /// the currently enabled controller vault. Only the owner or an operator of the account can call this function.
+    /// Disabling a collateral might change the order of collaterals in the array obtained using getCollaterals
+    /// function. Account status checks are performed.
+    /// @param account The account address for which the collateral is being disabled.
+    /// @param vault The address of a collateral being disabled.
+    function disableCollateral(address account, address vault) external payable;
+
+    /// @notice Swaps the position of two collaterals so that they appear switched in the array of collaterals for a
+    /// given account obtained by calling getCollaterals function.
+    /// @dev A collateral is a vault for which account’s balances are under the control of the currently enabled
+    /// controller vault. Only the owner or an operator of the account can call this function. The order of collaterals
+    /// can be changed by specifying the indices of the two collaterals to be swapped. Indices are zero-based and must
+    /// be in the range of 0 to the number of collaterals minus 1. index1 must be lower than index2. Account status
+    /// checks are performed.
+    /// @param account The address of the account for which the collaterals are being reordered.
+    /// @param index1 The index of the first collateral to be swapped.
+    /// @param index2 The index of the second collateral to be swapped.
+    function reorderCollaterals(address account, uint8 index1, uint8 index2) external payable;
+
+    /// @notice Returns an array of enabled controllers for an account.
+    /// @dev A controller is a vault that has been chosen for an account to have special control over the account's
+    /// balances in enabled collaterals vaults. A user can have multiple controllers during a call execution, but at
+    /// most one can be selected when the account status check is performed.
+    /// @param account The address of the account whose controllers are being queried.
+    /// @return An array of addresses that are the enabled controllers for the account.
+    function getControllers(address account) external view returns (address[] memory);
+
+    /// @notice Returns whether a controller is enabled for an account.
+    /// @dev A controller is a vault that has been chosen for an account to have special control over account’s
+    /// balances in the enabled collaterals vaults.
+    /// @param account The address of the account that is being checked.
+    /// @param vault The address of the controller that is being checked.
+    /// @return A boolean value that indicates whether the vault is enabled controller for the account or not.
+    function isControllerEnabled(address account, address vault) external view returns (bool);
+
+    /// @notice Enables a controller for an account.
+    /// @dev A controller is a vault that has been chosen for an account to have special control over account’s
+    /// balances in the enabled collaterals vaults. Only the owner or an operator of the account can call this function.
+    /// Unless it's a duplicate, the controller is added to the end of the array. Transiently, there can be at most 10
+    /// unique controllers enabled at a time, but at most one can be enabled after the outermost checks-deferrable
+    /// call concludes. Account status checks are performed.
+    /// @param account The address for which the controller is being enabled.
+    /// @param vault The address of the controller being enabled.
+    function enableController(address account, address vault) external payable;
+
+    /// @notice Disables a controller for an account.
+    /// @dev A controller is a vault that has been chosen for an account to have special control over account’s
+    /// balances in the enabled collaterals vaults. Only the vault itself can call this function. Disabling a controller
+    /// might change the order of controllers in the array obtained using getControllers function. Account status checks
+    /// are performed.
+    /// @param account The address for which the calling controller is being disabled.
+    function disableController(address account) external payable;
+
+    /// @notice Executes signed arbitrary data by self-calling into the EVC.
+    /// @dev Low-level call function is used to execute the arbitrary data signed by the owner or the operator on the
+    /// EVC contract. During that call, EVC becomes msg.sender.
+    /// @param signer The address signing the permit message (ECDSA) or verifying the permit message signature
+    /// (ERC-1271). It's also the owner or the operator of all the accounts for which authentication will be needed
+    /// during the execution of the arbitrary data call.
+    /// @param sender The address of the msg.sender which is expected to execute the data signed by the signer. If
+    /// address(0) is passed, the msg.sender is ignored.
+    /// @param nonceNamespace The nonce namespace for which the nonce is being used.
+    /// @param nonce The nonce for the given account and nonce namespace. A valid nonce value is considered to be the
+    /// value currently stored and can take any value between 0 and type(uint256).max - 1.
+    /// @param deadline The timestamp after which the permit is considered expired.
+    /// @param value The amount of value to be forwarded with the call. If the value is type(uint256).max, the whole
+    /// balance of the EVC contract will be forwarded.
+    /// @param data The encoded data which is self-called on the EVC contract.
+    /// @param signature The signature of the data signed by the signer.
+    function permit(
+        address signer,
+        address sender,
+        uint256 nonceNamespace,
+        uint256 nonce,
+        uint256 deadline,
+        uint256 value,
+        bytes calldata data,
+        bytes calldata signature
+    ) external payable;
+
+    /// @notice Calls into a target contract as per data encoded.
+    /// @dev This function defers the account and vault status checks (it's a checks-deferrable call). If the outermost
+    /// call ends, the account and vault status checks are performed.
+    /// @dev This function can be used to interact with any contract while checks are deferred. If the target contract
+    /// is msg.sender, msg.sender is called back with the calldata provided and the context set up according to the
+    /// account provided. If the target contract is not msg.sender, only the owner or the operator of the account
+    /// provided can call this function.
+    /// @dev This function can be used to recover the remaining value from the EVC contract.
+    /// @param targetContract The address of the contract to be called.
+    /// @param onBehalfOfAccount  If the target contract is msg.sender, the address of the account which will be set
+    /// in the context. It assumes msg.sender has authenticated the account themselves. If the target contract is
+    /// not msg.sender, the address of the account for which it is checked whether msg.sender is authorized to act
+    /// on behalf of.
+    /// @param value The amount of value to be forwarded with the call. If the value is type(uint256).max, the whole
+    /// balance of the EVC contract will be forwarded.
+    /// @param data The encoded data which is called on the target contract.
+    /// @return result The result of the call.
+    function call(address targetContract, address onBehalfOfAccount, uint256 value, bytes calldata data)
+        external
+        payable
+        returns (bytes memory result);
+
+    /// @notice For a given account, calls into one of the enabled collateral vaults from the currently enabled
+    /// controller vault as per data encoded.
+    /// @dev This function defers the account and vault status checks (it's a checks-deferrable call). If the outermost
+    /// call ends, the account and vault status checks are performed.
+    /// @dev This function can be used to interact with any contract while checks are deferred as long as the contract
+    /// is enabled as a collateral of the account and the msg.sender is the only enabled controller of the account.
+    /// @param targetCollateral The collateral address to be called.
+    /// @param onBehalfOfAccount The address of the account for which it is checked whether msg.sender is authorized to
+    /// act on behalf.
+    /// @param value The amount of value to be forwarded with the call. If the value is type(uint256).max, the whole
+    /// balance of the EVC contract will be forwarded.
+    /// @param data The encoded data which is called on the target collateral.
+    /// @return result The result of the call.
+    function controlCollateral(address targetCollateral, address onBehalfOfAccount, uint256 value, bytes calldata data)
+        external
+        payable
+        returns (bytes memory result);
+
+    /// @notice Executes multiple calls into the target contracts while checks deferred as per batch items provided.
+    /// @dev This function defers the account and vault status checks (it's a checks-deferrable call). If the outermost
+    /// call ends, the account and vault status checks are performed.
+    /// @dev The authentication rules for each batch item are the same as for the call function.
+    /// @param items An array of batch items to be executed.
+    function batch(BatchItem[] calldata items) external payable;
+
+    /// @notice Executes multiple calls into the target contracts while checks deferred as per batch items provided.
+    /// @dev This function always reverts as it's only used for simulation purposes. This function cannot be called
+    /// within a checks-deferrable call.
+    /// @param items An array of batch items to be executed.
+    function batchRevert(BatchItem[] calldata items) external payable;
+
+    /// @notice Executes multiple calls into the target contracts while checks deferred as per batch items provided.
+    /// @dev This function does not modify state and should only be used for simulation purposes. This function cannot
+    /// be called within a checks-deferrable call.
+    /// @param items An array of batch items to be executed.
+    /// @return batchItemsResult An array of batch item results for each item.
+    /// @return accountsStatusCheckResult An array of account status check results for each account.
+    /// @return vaultsStatusCheckResult An array of vault status check results for each vault.
+    function batchSimulation(BatchItem[] calldata items)
+        external
+        payable
+        returns (
+            BatchItemResult[] memory batchItemsResult,
+            StatusCheckResult[] memory accountsStatusCheckResult,
+            StatusCheckResult[] memory vaultsStatusCheckResult
+        );
+
+    /// @notice Retrieves the timestamp of the last successful account status check performed for a specific account.
+    /// @dev This function reverts if the checks are in progress.
+    /// @dev The account status check is considered to be successful if it calls into the selected controller vault and
+    /// obtains expected magic value. This timestamp does not change if the account status is considered valid when no
+    /// controller enabled. When consuming, one might need to ensure that the account status check is not deferred at
+    /// the moment.
+    /// @param account The address of the account for which the last status check timestamp is being queried.
+    /// @return The timestamp of the last status check as a uint256.
+    function getLastAccountStatusCheckTimestamp(address account) external view returns (uint256);
+
+    /// @notice Checks whether the status check is deferred for a given account.
+    /// @dev This function reverts if the checks are in progress.
+    /// @param account The address of the account for which it is checked whether the status check is deferred.
+    /// @return A boolean flag that indicates whether the status check is deferred or not.
+    function isAccountStatusCheckDeferred(address account) external view returns (bool);
+
+    /// @notice Checks the status of an account and reverts if it is not valid.
+    /// @dev If checks deferred, the account is added to the set of accounts to be checked at the end of the outermost
+    /// checks-deferrable call. There can be at most 10 unique accounts added to the set at a time. Account status
+    /// check is performed by calling into the selected controller vault and passing the array of currently enabled
+    /// collaterals. If controller is not selected, the account is always considered valid.
+    /// @param account The address of the account to be checked.
+    function requireAccountStatusCheck(address account) external payable;
+
+    /// @notice Forgives previously deferred account status check.
+    /// @dev Account address is removed from the set of addresses for which status checks are deferred. This function
+    /// can only be called by the currently enabled controller of a given account. Depending on the vault
+    /// implementation, may be needed in the liquidation flow.
+    /// @param account The address of the account for which the status check is forgiven.
+    function forgiveAccountStatusCheck(address account) external payable;
+
+    /// @notice Checks whether the status check is deferred for a given vault.
+    /// @dev This function reverts if the checks are in progress.
+    /// @param vault The address of the vault for which it is checked whether the status check is deferred.
+    /// @return A boolean flag that indicates whether the status check is deferred or not.
+    function isVaultStatusCheckDeferred(address vault) external view returns (bool);
+
+    /// @notice Checks the status of a vault and reverts if it is not valid.
+    /// @dev If checks deferred, the vault is added to the set of vaults to be checked at the end of the outermost
+    /// checks-deferrable call. There can be at most 10 unique vaults added to the set at a time. This function can
+    /// only be called by the vault itself.
+    function requireVaultStatusCheck() external payable;
+
+    /// @notice Forgives previously deferred vault status check.
+    /// @dev Vault address is removed from the set of addresses for which status checks are deferred. This function can
+    /// only be called by the vault itself.
+    function forgiveVaultStatusCheck() external payable;
+
+    /// @notice Checks the status of an account and a vault and reverts if it is not valid.
+    /// @dev If checks deferred, the account and the vault are added to the respective sets of accounts and vaults to be
+    /// checked at the end of the outermost checks-deferrable call. Account status check is performed by calling into
+    /// selected controller vault and passing the array of currently enabled collaterals. If controller is not selected,
+    /// the account is always considered valid. This function can only be called by the vault itself.
+    /// @param account The address of the account to be checked.
+    function requireAccountAndVaultStatusCheck(address account) external payable;
+}

package/contracts/pt-looping/money-market/implementations/euler/dependencies/IEulerFactory.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.4;
+
+/// @notice Minimal interface for Euler's `GenericFactory` (the EVault factory), as a mapping
+/// of vault index to the corresponding vault address.
+/// https://github.com/euler-xyz/euler-vault-kit/blob/master/src/GenericFactory/GenericFactory.sol
+
+interface IEulerFactory {
+    function proxyList(uint256 index) external view returns (address);
+}

package/contracts/pt-looping/money-market/implementations/euler/dependencies/IEulerPriceOracle.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+pragma solidity >=0.8.0;
+
+/// https://github.com/euler-xyz/euler-vault-kit/blob/5b98b42048ba11ae82fb62dfec06d1010c8e41e6/src/interfaces/IPriceOracle.sol#L4
+/// Modifications:
+/// - Rename `IPriceOracle` to `IEulerPriceOracle`
+/// - Remove `getQuotes` method
+
+/// @title IPriceOracle
+/// @custom:security-contact security@euler.xyz
+/// @author Euler Labs (https://www.eulerlabs.com/)
+/// @notice Common PriceOracle interface.
+interface IEulerPriceOracle {
+    /// @notice Get the name of the oracle.
+    /// @return The name of the oracle.
+    function name() external view returns (string memory);
+
+    /// @notice One-sided price: How much quote token you would get for inAmount of base token, assuming no price
+    /// spread.
+    /// @param inAmount The amount of `base` to convert.
+    /// @param base The token that is being priced.
+    /// @param quote The token that is the unit of account.
+    /// @return outAmount The amount of `quote` that is equivalent to `inAmount` of `base`.
+    function getQuote(uint256 inAmount, address base, address quote) external view returns (uint256 outAmount);
+}

package/contracts/pt-looping/money-market/implementations/euler/dependencies/IEulerVault.sol

@@ -0,0 +1,149 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.4;
+
+/// https://github.com/euler-xyz/euler-vault-kit/blob/master/src/EVault/IEVault.sol
+/// Modifications:
+/// - Include `AmountCap` library in.
+/// - Combine all interfaces into `IEulerVault`, and remove unused fucntions.
+/// - Make the return values of `caps` function `AmountCap` for type safety.
+
+import {IERC4626} from "@openzeppelin/contracts/interfaces/IERC4626.sol";
+import {IEulerPriceOracle} from "./IEulerPriceOracle.sol";
+
+type AmountCap is uint16;
+
+uint256 constant NO_CAP = type(uint256).max;
+
+/// @title AmountCapLib
+/// @custom:security-contact security@euler.xyz
+/// @author Euler Labs (https://www.eulerlabs.com/)
+/// @notice Library for `AmountCap` custom type
+/// @dev AmountCaps are 16-bit decimal floating point values:
+/// * The least significant 6 bits are the exponent
+/// * The most significant 10 bits are the mantissa, scaled by 100
+/// * The special value of 0 means limit is not set
+///   * This is so that uninitialized storage implies no limit
+///   * For an actual cap value of 0, use a zero mantissa and non-zero exponent
+library AmountCapLib {
+    function resolve(AmountCap self) internal pure returns (uint256) {
+        uint256 amountCap = AmountCap.unwrap(self);
+
+        if (amountCap == 0) return type(uint256).max;
+
+        unchecked {
+            // Cannot overflow because this is less than 2**256:
+            //   10**(2**6 - 1) * (2**10 - 1) = 1.023e+66
+            return 10 ** (amountCap & 63) * (amountCap >> 6) / 100;
+        }
+    }
+
+    function toRawUint16(AmountCap self) internal pure returns (uint16) {
+        return AmountCap.unwrap(self);
+    }
+}
+
+using AmountCapLib for AmountCap global;
+
+interface IEulerVault is IERC4626 {
+    /// @notice Debt owed by a particular account, in underlying units
+    /// @param account Address to query
+    /// @return The debt of the account in asset units
+    function debtOf(address account) external view returns (uint256);
+
+    /// @notice Transfer underlying tokens from the vault to the sender, and increase sender's debt
+    /// @param amount Amount of assets to borrow (use max uint256 for all available tokens)
+    /// @param receiver Account receiving the borrowed tokens
+    /// @return Amount of assets borrowed
+    function borrow(uint256 amount, address receiver) external returns (uint256);
+
+    /// @notice Transfer underlying tokens from the sender to the vault, and decrease receiver's debt
+    /// @param amount Amount of debt to repay in assets (use max uint256 for full debt)
+    /// @param receiver Account holding the debt to be repaid
+    /// @return Amount of assets repaid
+    function repay(uint256 amount, address receiver) external returns (uint256);
+
+    /// @notice Enables balance forwarding for the authenticated account
+    /// @dev Only the authenticated account can enable balance forwarding for itself
+    /// @dev Should call the IBalanceTracker hook with the current account's balance
+    function enableBalanceForwarder() external;
+
+    // View
+
+    /// @notice Balance of vault assets as tracked by deposits/withdrawals and borrows/repays
+    /// @return The amount of assets the vault tracks as current direct holdings
+    function cash() external view returns (uint256);
+
+    /// @notice Retrieves supply and borrow caps
+    /// @return supplyCap The supply cap
+    /// @return borrowCap The borrow cap
+    function caps() external view returns (AmountCap supplyCap, AmountCap borrowCap);
+
+    /// @notice Retrieves LTV configuration for the collateral
+    /// @param collateral Collateral asset
+    /// @return borrowLTV The current value of borrow LTV for originating positions
+    /// @return liquidationLTV The value of fully converged liquidation LTV
+    /// @return initialLiquidationLTV The initial value of the liquidation LTV, when the ramp began
+    /// @return targetTimestamp The timestamp when the liquidation LTV is considered fully converged
+    /// @return rampDuration The time it takes for the liquidation LTV to converge from the initial value to the fully
+    /// converged value
+    function LTVFull(IEulerVault collateral)
+        external
+        view
+        returns (
+            uint256 borrowLTV,
+            uint256 liquidationLTV,
+            uint256 initialLiquidationLTV,
+            uint256 targetTimestamp,
+            uint256 rampDuration
+        );
+
+    function LTVList() external view returns (IEulerVault[] memory);
+
+    /// @notice Retrieves the address of the oracle contract
+    /// @return The address of the oracle
+    function oracle() external view returns (IEulerPriceOracle);
+
+    /// @notice Retrieves the current interest rate for an asset
+    /// @return The interest rate in yield-per-second, scaled by 10**27
+    function interestRate() external view returns (uint256);
+    /// @notice Sum of all outstanding debts, in underlying units (increases as interest is accrued)
+    /// @return The total borrows in asset units
+    function totalBorrows() external view returns (uint256);
+    /// @notice Retrieves the interest fee in effect for the vault
+    /// @return Amount of interest that is redirected as a fee, as a fraction scaled by 1e4
+    function interestFee() external view returns (uint16);
+
+    /// @notice Retrieves a reference asset used for liquidity calculations
+    /// @return The address of the reference asset
+    function unitOfAccount() external view returns (address);
+
+    /// @notice Looks up an asset's currently configured interest rate model
+    /// @return Address of the interest rate contract or address zero to indicate 0% interest
+    function interestRateModel() external view returns (address);
+
+    /// @notice Checks to see if a liquidation would be profitable, without actually doing anything
+    /// @param liquidator Address that will initiate the liquidation
+    /// @param violator Address that may be in collateral violation
+    /// @param collateral Collateral which is to be seized
+    /// @return maxRepay Max amount of debt that can be repaid, in asset units
+    /// @return maxYield Yield in collateral corresponding to max allowed amount of debt to be repaid, in collateral
+    /// balance (shares for vaults)
+    function checkLiquidation(address liquidator, address violator, IEulerVault collateral)
+        external
+        view
+        returns (uint256 maxRepay, uint256 maxYield);
+
+    /// @notice Attempts to perform a liquidation
+    /// @param violator Address that may be in collateral violation
+    /// @param collateral Collateral which is to be seized
+    /// @param repayAssets The amount of underlying debt to be transferred from violator to sender, in asset units (use
+    /// max uint256 to repay the maximum possible amount).
+    /// @param minYieldBalance The minimum acceptable amount of collateral to be transferred from violator to sender, in
+    /// collateral balance units (shares for vaults)
+    function liquidate(address violator, IEulerVault collateral, uint256 repayAssets, uint256 minYieldBalance) external;
+
+    /// @notice Retrieves liquidation cool-off time, which must elapse after successful account status check before
+    /// account can be liquidated
+    /// @return The liquidation cool off time in seconds
+    function liquidationCoolOffTime() external view returns (uint16);
+}

package/contracts/router/swap-aggregator/OKXScaleHelper.sol

@@ -57,6 +57,9 @@ abstract contract OKXScaleHelper {
         if (chainid == 196) {
             return 0x8b773D83bc66Be128c60e07E17C8901f7a64F000;
         }
+        if (chainid == 4663) {
+            return 0x42170295F1173c9e5874ea9d00c6d137E1a4f53d;
+        }
         return address(0);
     }
 

package/deployments/143-core.json

@@ -55,5 +55,8 @@
     "merkleDepositor": "0x3dAe3d1734cA3C7B3089D4DD03C9876e0A0102b4",
     "crossChainSwapHub": "0xd41c99760f4A7e27E736ED25cd6915110948Ea8a",
     "depositBoxFactory": "0x15Ff9D268ef3300a3fcCe5DE4bc4326316c5dD6D",
-    "oftPtSwapper": "0x8ef78aD230887E05fa3324277A5225fE93889b08"
+    "oftPtSwapper": "0x8ef78aD230887E05fa3324277A5225fE93889b08",
+    "pendlePtLooper": "0xF82Ef4080A53b71093f9c470676Fc80E2ADC4263",
+    "pendlePtLooperView": "0x887b00B5F584f1cC015e8f68C29d6Feb6bf95b02",
+    "loopPositionBoxFactory": "0xe5125dfE3Fc232723E7Ae17cFa66034b3BCAC696"
 }