@pendle/core-v2 5.2.0-beta-4 → 5.2.0

package/contracts/core/StandardizedYield/implementations/AaveV3/{PendleAaveV3WithRewardsSY.sol → PendleAaveV3WithRewardsSYUpg.sol}

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity ^0.8.23;
 
-import "../../SYBaseWithRewards.sol";
+import "../../SYBaseWithRewardsUpg.sol";
 import "./libraries/AaveAdapterLib.sol";
 import "../../../../interfaces/AaveV3/IAaveV3AToken.sol";
 import "../../../../interfaces/AaveV3/IAaveV3Pool.sol";
@@ -11,7 +11,7 @@ import "../../../../interfaces/AaveV3/IAaveV3IncentiveController.sol";
 
 // [NEW] @NOTE: As for the getRewardTokens function, it will check for different incentive controller
 // so this implementation should only be used in L2s. L1 would require more gas optimization
-contract PendleAaveV3WithRewardsSY is SYBaseWithRewards {
+contract PendleAaveV3WithRewardsSYUpg is SYBaseWithRewardsUpg {
     using PMath for uint256;
 
     event NewIncentiveController(address incentiveController);
@@ -22,25 +22,27 @@ contract PendleAaveV3WithRewardsSY is SYBaseWithRewards {
     address public immutable aToken;
     address public immutable aavePool;
     address public immutable underlying;
+    address public immutable incentiveController;
+    address public immutable defaultRewardToken;
 
-    address public incentiveController;
-    address[] public rewardTokens;
+    uint256[100] private __gap;
 
     constructor(
-        string memory _name,
-        string memory _symbol,
         address _aavePool,
         address _aToken,
-        address _incentiveController
-    ) SYBaseWithRewards(_name, _symbol, _aToken) {
+        address _initialIncentiveController,
+        address _defaultRewardToken
+    ) SYBaseUpg(_aToken) {
         aToken = _aToken;
         aavePool = _aavePool;
         underlying = IAaveV3AToken(aToken).UNDERLYING_ASSET_ADDRESS();
+        incentiveController = _initialIncentiveController;
+        defaultRewardToken = _defaultRewardToken;
+    }
 
-        if (_incentiveController != address(0)) {
-            _updateIncentiveController(_incentiveController);
-        }
-        _safeApproveInf(underlying, _aavePool);
+    function initialize(string memory _name, string memory _symbol) external initializer {
+        __SYBaseUpg_init(_name, _symbol);
+        _safeApproveInf(underlying, aavePool);
     }
 
     function _deposit(
@@ -73,14 +75,14 @@ contract PendleAaveV3WithRewardsSY is SYBaseWithRewards {
     function _previewDeposit(
         address,
         uint256 amountTokenToDeposit
-    ) internal view override returns (uint256 /*amountSharesOut*/) {
+    ) internal view virtual override returns (uint256 /*amountSharesOut*/) {
         return AaveAdapterLib.calcSharesFromAssetUp(amountTokenToDeposit, _getNormalizedIncome());
     }
 
     function _previewRedeem(
         address,
         uint256 amountSharesToRedeem
-    ) internal view override returns (uint256 /*amountTokenOut*/) {
+    ) internal view virtual override returns (uint256 /*amountTokenOut*/) {
         return AaveAdapterLib.calcSharesToAssetDown(amountSharesToRedeem, _getNormalizedIncome());
     }
 
@@ -88,23 +90,28 @@ contract PendleAaveV3WithRewardsSY is SYBaseWithRewards {
         return IAaveV3Pool(aavePool).getReserveNormalizedIncome(underlying);
     }
 
-    function getTokensIn() public view override returns (address[] memory res) {
+    function getTokensIn() public view virtual override returns (address[] memory res) {
         return ArrayLib.create(underlying, aToken);
     }
 
-    function getTokensOut() public view override returns (address[] memory res) {
+    function getTokensOut() public view virtual override returns (address[] memory res) {
         return ArrayLib.create(underlying, aToken);
     }
 
-    function isValidTokenIn(address token) public view override returns (bool) {
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
         return token == aToken || token == underlying;
     }
 
-    function isValidTokenOut(address token) public view override returns (bool) {
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
         return token == aToken || token == underlying;
     }
 
-    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+    function assetInfo()
+        external
+        view
+        virtual
+        returns (AssetType assetType, address assetAddress, uint8 assetDecimals)
+    {
         return (AssetType.TOKEN, underlying, IERC20Metadata(underlying).decimals());
     }
 
@@ -112,19 +119,11 @@ contract PendleAaveV3WithRewardsSY is SYBaseWithRewards {
                             REWARDS-RELATED
     //////////////////////////////////////////////////////////////*/
 
-    function updateIncentiveController(address _incentiveController) external onlyOwner {
-        _updateIncentiveController(_incentiveController);
-    }
-
-    function updateRewardTokenList() external onlyOwner {
-        _updateRewardTokenList();
-    }
-
     /**
      * @dev See {IStandardizedYield-getRewardTokens}
      */
     function _getRewardTokens() internal view override returns (address[] memory res) {
-        return rewardTokens;
+        return ArrayLib.create(defaultRewardToken);
     }
 
     function _redeemExternalReward() internal override {
@@ -132,21 +131,4 @@ contract PendleAaveV3WithRewardsSY is SYBaseWithRewards {
             IAaveV3IncentiveController(incentiveController).claimAllRewardsToSelf(ArrayLib.create(aToken));
         }
     }
-
-    function _updateIncentiveController(address _incentiveController) internal {
-        if (_incentiveController == incentiveController) {
-            revert SameIncentiveController();
-        }
-        _redeemExternalReward();
-
-        incentiveController = _incentiveController;
-        if (_incentiveController != address(0)) {
-            _updateRewardTokenList();
-        }
-        emit NewIncentiveController(_incentiveController);
-    }
-
-    function _updateRewardTokenList() internal {
-        rewardTokens = ArrayLib.merge(rewardTokens, IAaveV3IncentiveController(incentiveController).getRewardsList());
-    }
 }

package/contracts/core/StandardizedYield/implementations/AaveV3/PendleStkGHOSY.sol

@@ -0,0 +1,130 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../SYBaseWithRewardsUpg.sol";
+import "../../../../interfaces/AaveV3/IAaveStkGHO.sol";
+import "../../../../interfaces/Angle/IAngleDistributor.sol";
+
+contract PendleStkGHOSY is SYBaseWithRewardsUpg {
+    using PMath for uint256;
+
+    event ClaimedOffchainGHO(uint256 amountClaimed);
+
+    address public constant ANGLE_DISTRIBUTOR = 0x3Ef3D8bA38EBe18DB133cEc108f4D14CE00Dd9Ae;
+    address public constant STKGHO = 0x1a88Df1cFe15Af22B3c4c783D4e6F7F9e0C1885d;
+    address public constant GHO = 0x40D16FC0246aD3160Ccc09B8D0D3A2cD28aE6C2f;
+    address public constant AAVE = 0x7Fc66500c84A76Ad7e9c93437bFc5Ac33E2DDaE9;
+    bytes32 public constant ZERO_REWARD_ERROR = 0x33d2eb294587ef7b32eb48e48695ebfec45a9c8922ec7d1c444cfad1fb208e8d;
+
+    constructor() SYBaseUpg(STKGHO) {}
+
+    function initialize() external initializer {
+        __SYBaseUpg_init("SY stk GHO", "SY-stkGHO");
+        _safeApproveInf(GHO, STKGHO);
+    }
+
+    function _deposit(address tokenIn, uint256 amountDeposited) internal virtual override returns (uint256) {
+        if (tokenIn == STKGHO) {
+            return amountDeposited;
+        }
+
+        uint256 preBalance = _selfBalance(STKGHO);
+        IAaveStkGHO(STKGHO).stake(address(this), amountDeposited);
+        return _selfBalance(STKGHO) - preBalance;
+    }
+
+    function _redeem(
+        address receiver,
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256) {
+        _transferOut(STKGHO, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        return PMath.ONE.divDown(IAaveStkGHO(STKGHO).getExchangeRate());
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               REWARDS-RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev See {IStandardizedYield-getRewardTokens}
+     */
+    function _getRewardTokens() internal pure override returns (address[] memory) {
+        return ArrayLib.create(AAVE);
+    }
+
+    function _redeemExternalReward() internal override {
+        try IAaveStkGHO(STKGHO).claimRewards(address(this), type(uint256).max) {} catch Error(
+            string memory errorString
+        ) {
+            // StkGHO claim reverts when claimable amount = 0, meaning two sy transfers in diff block/same timestamp would revert.
+            // This is expected to not happen at all on ETH mainnet but just to be sure.
+            if (keccak256(abi.encodePacked(errorString)) != ZERO_REWARD_ERROR) {
+                revert(errorString);
+            }
+        }
+    }
+
+    function claimOffchainGHORewards(
+        address[] calldata users,
+        address[] calldata tokens,
+        uint256[] calldata amounts,
+        bytes32[][] calldata proofs
+    ) external onlyOwner {
+        uint256 preBalance = _selfBalance(GHO);
+        IAngleDistributor(ANGLE_DISTRIBUTOR).claim(users, tokens, amounts, proofs);
+        uint256 amountClaimed = _selfBalance(GHO) - preBalance;
+
+        if (amountClaimed > 0) {
+            _transferOut(GHO, msg.sender, amountClaimed);
+            emit ClaimedOffchainGHO(amountClaimed);
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256 amountSharesOut) {
+        if (tokenIn == STKGHO) return amountTokenToDeposit;
+        return IAaveStkGHO(STKGHO).previewStake(amountTokenToDeposit);
+    }
+
+    function _previewRedeem(
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal view override returns (uint256 amountTokenOut) {
+        return amountSharesToRedeem;
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory) {
+        return ArrayLib.create(GHO, STKGHO);
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory) {
+        return ArrayLib.create(STKGHO);
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == GHO || token == STKGHO;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == STKGHO;
+    }
+
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.TOKEN, GHO, IERC20Metadata(GHO).decimals());
+    }
+}

package/contracts/core/StandardizedYield/implementations/GLP/PendleGlpSY.sol

@@ -15,7 +15,7 @@ contract PendleGlpSY is SYBaseWithRewardsUpg, GLPPreviewHelper {
     address public immutable stakedGlp;
     address public immutable rewardRouter;
     address public immutable glpRouter;
-    address public immutable glpManager;
+    address public immutable glpManager = 0x3963FfC9dff443c2A94f21b129D429891E32ec18;
     address public immutable weth;
 
     constructor(
@@ -31,7 +31,6 @@ contract PendleGlpSY is SYBaseWithRewardsUpg, GLPPreviewHelper {
         stakedGlp = _stakedGlp;
         rewardRouter = _rewardRouter;
         glpRouter = _glpRouter;
-        glpManager = IRewardRouterV2(glpRouter).glpManager();
         weth = IRewardRouterV2(glpRouter).weth();
     }
 

package/contracts/core/StandardizedYield/implementations/Mantle/PendleCMETHSY.sol

@@ -0,0 +1,82 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../SYBase.sol";
+import "../../../../interfaces/IPExchangeRateOracle.sol";
+
+contract PendleCMETHSY is SYBase {
+    using PMath for int256;
+
+    address public exchangeRateOracle = 0x1E2Ad9764cfAc60876486A7c714bc71f5b55f5C2;
+    address public constant CMETH = 0xE6829d9a7eE3040e1276Fa75293Bde931859e8fA;
+    address public constant WETH = 0xdEAddEaDdeadDEadDEADDEAddEADDEAddead1111;
+
+    constructor() SYBase("SY cmETH", "SY-cmETH", CMETH) {}
+
+    function setExchangeRateOracle(address newOracle) external onlyOwner {
+        exchangeRateOracle = newOracle;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(address, uint256 amountDeposited) internal pure override returns (uint256 /*amountSharesOut*/) {
+        return amountDeposited;
+    }
+
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal override returns (uint256 /*amountTokenOut*/) {
+        _transferOut(tokenOut, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view override returns (uint256) {
+        return IPExchangeRateOracle(exchangeRateOracle).getExchangeRate();
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(
+        address,
+        uint256 amountTokenToDeposit
+    ) internal pure override returns (uint256 /*amountSharesOut*/) {
+        return amountTokenToDeposit;
+    }
+
+    function _previewRedeem(
+        address,
+        uint256 amountSharesToRedeem
+    ) internal pure override returns (uint256 /*amountTokenOut*/) {
+        return amountSharesToRedeem;
+    }
+
+    function getTokensIn() public view override returns (address[] memory res) {
+        return ArrayLib.create(yieldToken);
+    }
+
+    function getTokensOut() public view override returns (address[] memory res) {
+        return ArrayLib.create(yieldToken);
+    }
+
+    function isValidTokenIn(address token) public view override returns (bool) {
+        return token == yieldToken;
+    }
+
+    function isValidTokenOut(address token) public view override returns (bool) {
+        return token == yieldToken;
+    }
+
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.TOKEN, WETH, 18);
+    }
+}

package/contracts/core/StandardizedYield/implementations/Silo/PendleSiloWithIncentiveNonBorrowableSY.sol

@@ -0,0 +1,154 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity ^0.8.17;
+
+import "../../SYBaseWithRewards.sol";
+import "../../../../interfaces/Silo/ISiloIncentiveController.sol";
+import "../../../../interfaces/Silo/ISilo.sol";
+import "../../../../interfaces/Silo/ISiloLens.sol";
+import "../../../libraries/ArrayLib.sol";
+import "../../../libraries/math/PMath.sol";
+
+contract PendleSiloWithIncentiveNonBorrowableSY is SYBaseWithRewards {
+    using PMath for uint256;
+    using ArrayLib for address[];
+
+    event SetNewIncentiveController(address indexed newController);
+
+    address public immutable asset;
+    address public immutable collateralToken;
+    address public immutable silo;
+    address public immutable siloLens;
+
+    address public incentiveController;
+    address[] public additionalRewardTokens;
+    address public immutable defaultRewardToken;
+
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _asset,
+        address _collateralToken,
+        address _silo,
+        address _siloLens,
+        address _incentiveController
+    ) SYBaseWithRewards(_name, _symbol, _collateralToken) {
+        asset = _asset;
+        collateralToken = _collateralToken;
+        silo = _silo;
+        siloLens = _siloLens;
+
+        incentiveController = _incentiveController;
+        defaultRewardToken = ISiloIncentiveController(incentiveController).REWARD_TOKEN();
+
+        _safeApproveInf(asset, silo);
+    }
+
+    function _deposit(
+        address tokenIn,
+        uint256 amountDeposited
+    ) internal virtual override returns (uint256 amountSharesOut) {
+        if (tokenIn == collateralToken) {
+            return amountDeposited;
+        } else {
+            (, amountSharesOut) = ISilo(silo).deposit(asset, amountDeposited, true);
+        }
+    }
+
+    function _redeem(
+        address receiver,
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256 amountTokenOut) {
+        if (tokenOut == collateralToken) {
+            _transferOut(collateralToken, receiver, amountSharesToRedeem);
+            return amountSharesToRedeem;
+        } else {
+            // Silo withdrawing interface only accepts amount of asset as input
+            // Therefore we need to ensure that assetInput.toShareRoundUp() <= amountSharesToRedeem
+
+            amountTokenOut = amountSharesToRedeem;
+
+            // amountAssetToWithdraw should = withdrawnAmount as withdrawing does not
+            // bear any fees
+            ISilo(silo).withdraw(asset, amountTokenOut, true);
+            _transferOut(tokenOut, receiver, amountTokenOut);
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        return PMath.ONE;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               REWARDS-RELATED
+    //////////////////////////////////////////////////////////////*/
+
+    function setIncentiveController(address newController) external onlyOwner {
+        // Claim all pending rewards from old contract
+        _redeemExternalReward();
+
+        address newRewardToken = ISiloIncentiveController(newController).REWARD_TOKEN();
+        if (newRewardToken != defaultRewardToken && !additionalRewardTokens.contains(newRewardToken)) {
+            additionalRewardTokens.push(newRewardToken);
+        }
+        incentiveController = newController;
+
+        emit SetNewIncentiveController(newController);
+    }
+
+    /**
+     * @dev See {IStandardizedYield-getRewardTokens}
+     */
+    function _getRewardTokens() internal view override returns (address[] memory) {
+        return additionalRewardTokens.appendHead(defaultRewardToken);
+    }
+
+    function _redeemExternalReward() internal override {
+        ISiloIncentiveController(incentiveController).claimRewardsToSelf(
+            ArrayLib.create(collateralToken),
+            type(uint256).max
+        );
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view override returns (uint256 amountSharesOut) {
+        return amountTokenToDeposit;
+    }
+
+    function _previewRedeem(
+        address tokenOut,
+        uint256 amountSharesToRedeem
+    ) internal view override returns (uint256 amountTokenOut) {
+        return amountSharesToRedeem;
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory) {
+        return ArrayLib.create(asset, collateralToken);
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory) {
+        return ArrayLib.create(asset, collateralToken);
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == asset || token == collateralToken;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == asset || token == collateralToken;
+    }
+
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.TOKEN, asset, IERC20Metadata(asset).decimals());
+    }
+}

package/contracts/core/StandardizedYield/implementations/Solv/PendleSolvBTCBBNBaseSYUpg.sol

@@ -0,0 +1,103 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.17;
+
+import "../../SYBaseUpg.sol";
+import "./PendleSolvHelperBase.sol";
+import "../../../../interfaces/IPExchangeRateOracle.sol";
+
+contract PendleSolvBTCBBNBaseSYUpg is SYBaseUpg {
+    event SetNewExchangeRateOracle(address oracle);
+
+    address public constant CBBTC = PendleSolvHelperBase.CBBTC;
+    address public constant SOLV_BTC = PendleSolvHelperBase.SOLV_BTC_TOKEN;
+    address public constant SOLV_BTCBBN = PendleSolvHelperBase.SOLV_BTCBBN_TOKEN;
+
+    address public exchangeRateOracle;
+
+    constructor() SYBaseUpg(SOLV_BTCBBN) {}
+
+    function initialize(address _initialExchangeRateOracle) external initializer {
+        __SYBaseUpg_init("SY SolvBTC Babylon", "SY-SolvBTC.BBN");
+        _setExchangeRateOracle(_initialExchangeRateOracle);
+        _safeApproveInf(CBBTC, PendleSolvHelperBase.SOLV_BTC_ROUTER);
+        _safeApproveInf(SOLV_BTC, PendleSolvHelperBase.SOLV_BTCBBN_ROUTER);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    DEPOSIT/REDEEM USING BASE TOKENS
+    //////////////////////////////////////////////////////////////*/
+
+    function _deposit(address tokenIn, uint256 amountDeposited) internal virtual override returns (uint256) {
+        if (tokenIn == SOLV_BTCBBN) {
+            return amountDeposited;
+        }
+        return PendleSolvHelperBase._mintBTCBBN(tokenIn, amountDeposited);
+    }
+
+    function _redeem(
+        address receiver,
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal virtual override returns (uint256) {
+        _transferOut(SOLV_BTCBBN, receiver, amountSharesToRedeem);
+        return amountSharesToRedeem;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                               EXCHANGE-RATE
+    //////////////////////////////////////////////////////////////*/
+
+    function exchangeRate() public view virtual override returns (uint256) {
+        return IPExchangeRateOracle(exchangeRateOracle).getExchangeRate();
+    }
+
+    function setExchangeRateOracle(address newOracle) external virtual onlyOwner {
+        _setExchangeRateOracle(newOracle);
+    }
+
+    function _setExchangeRateOracle(address newOracle) internal virtual {
+        exchangeRateOracle = newOracle;
+        emit SetNewExchangeRateOracle(newOracle);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                MISC FUNCTIONS FOR METADATA
+    //////////////////////////////////////////////////////////////*/
+
+    function _previewDeposit(
+        address tokenIn,
+        uint256 amountTokenToDeposit
+    ) internal view virtual override returns (uint256 /*amountSharesOut*/) {
+        if (tokenIn == SOLV_BTCBBN) {
+            return amountTokenToDeposit;
+        }
+        return PendleSolvHelperBase._previewMintBTCBBN(tokenIn, amountTokenToDeposit);
+    }
+
+    function _previewRedeem(
+        address /*tokenOut*/,
+        uint256 amountSharesToRedeem
+    ) internal view virtual override returns (uint256 amountTokenOut) {
+        return amountSharesToRedeem;
+    }
+
+    function getTokensIn() public view virtual override returns (address[] memory) {
+        return ArrayLib.create(CBBTC, SOLV_BTC, SOLV_BTCBBN);
+    }
+
+    function getTokensOut() public view virtual override returns (address[] memory) {
+        return ArrayLib.create(SOLV_BTCBBN);
+    }
+
+    function isValidTokenIn(address token) public view virtual override returns (bool) {
+        return token == CBBTC || token == SOLV_BTC || token == SOLV_BTCBBN;
+    }
+
+    function isValidTokenOut(address token) public view virtual override returns (bool) {
+        return token == SOLV_BTCBBN;
+    }
+
+    function assetInfo() external view returns (AssetType assetType, address assetAddress, uint8 assetDecimals) {
+        return (AssetType.TOKEN, CBBTC, IERC20Metadata(CBBTC).decimals());
+    }
+}