@pendle/core-v2 5.2.0 → 5.2.1

package/contracts/oracles/factory/PendleChainlinkOracle.sol

@@ -0,0 +1,134 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "../../interfaces/IPChainlinkOracle.sol";
+import "../PendleLpOracleLib.sol";
+
+/**
+ * @dev The round data returned from this contract will follow:
+ * - There will be only one round (roundId=0)
+ * - startedAt=0, updatedAt=block.timestamp
+ */
+contract PendleChainlinkOracle is IPChainlinkOracle {
+    error InvalidRoundId();
+
+    // solhint-disable immutable-vars-naming
+    address public immutable factory;
+
+    address public immutable market;
+    uint32 public immutable twapDuration;
+    PendleOracleType public immutable baseOracleType;
+
+    uint256 public immutable fromTokenScale;
+    uint256 public immutable toTokenScale;
+
+    function(IPMarket, uint32) internal view returns (uint256) private immutable _getRawPendlePrice;
+
+    modifier roundIdIsZero(uint80 roundId) {
+        if (roundId != 0) {
+            revert InvalidRoundId();
+        }
+        _;
+    }
+
+    constructor(address _market, uint32 _twapDuration, PendleOracleType _baseOracleType) {
+        factory = msg.sender;
+        market = _market;
+        twapDuration = _twapDuration;
+        baseOracleType = _baseOracleType;
+        (uint256 fromTokenDecimals, uint256 toTokenDecimals) = _readDecimals(_market, _baseOracleType);
+        (fromTokenScale, toTokenScale) = (10 ** fromTokenDecimals, 10 ** toTokenDecimals);
+        _getRawPendlePrice = _getRawPendlePriceFunc();
+    }
+
+    // =================================================================
+    //                          CHAINLINK INTERFACE
+    // =================================================================
+
+    /**
+     * @notice The round data returned from this contract will follow:
+     * - answer will satisfy 1 natural unit of PendleToken = (answer/1e18) natural unit of OutputToken
+     * - In other words, 10**(PendleToken.decimals) = (answer/1e18) * 10**(OutputToken.decimals)
+     * @param roundId always 0 for this contract
+     * @param answer The answer (in 18 decimals)
+     * @param startedAt always 0 for this contract
+     * @param updatedAt always block.timestamp for this contract
+     * @param answeredInRound always 0 for this contract
+     */
+    function latestRoundData()
+        public
+        view
+        virtual
+        returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound)
+    {
+        roundId = 0;
+        answer = _getPendleTokenPrice();
+        startedAt = 0;
+        updatedAt = block.timestamp;
+        answeredInRound = 0;
+    }
+
+    function getRoundData(
+        uint80 roundId
+    ) external view roundIdIsZero(roundId) returns (uint80, int256, uint256, uint256, uint80) {
+        return latestRoundData();
+    }
+
+    function decimals() external pure returns (uint8) {
+        return 18;
+    }
+
+    function description() external pure returns (string memory) {
+        return "Pendle Chainlink-compatible Oracle";
+    }
+
+    function version() external pure returns (uint256) {
+        return 1;
+    }
+
+    // =================================================================
+    //                          PRICING FUNCTIONS
+    // =================================================================
+
+    function _getPendleTokenPrice() internal view returns (int256) {
+        return _descalePrice(_getRawPendlePrice(IPMarket(market), twapDuration));
+    }
+
+    function _descalePrice(uint256 price) private view returns (int256 unwrappedPrice) {
+        return PMath.Int((price * fromTokenScale) / toTokenScale);
+    }
+
+    // =================================================================
+    //                          USE ONLY AT INITIALIZATION
+    // =================================================================
+
+    function _getRawPendlePriceFunc()
+        internal
+        view
+        returns (function(IPMarket, uint32) internal view returns (uint256))
+    {
+        if (baseOracleType == PendleOracleType.PT_TO_SY) {
+            return PendlePYOracleLib.getPtToSyRate;
+        } else if (baseOracleType == PendleOracleType.PT_TO_ASSET) {
+            return PendlePYOracleLib.getPtToAssetRate;
+        } else {
+            revert("not supported");
+        }
+    }
+
+    function _readDecimals(
+        address _market,
+        PendleOracleType _oracleType
+    ) internal view returns (uint8 _fromDecimals, uint8 _toDecimals) {
+        (IStandardizedYield SY, , ) = IPMarket(_market).readTokens();
+
+        uint8 syDecimals = SY.decimals();
+        (, , uint8 assetDecimals) = SY.assetInfo();
+
+        if (_oracleType == PendleOracleType.PT_TO_ASSET) {
+            return (assetDecimals, assetDecimals);
+        } else if (_oracleType == PendleOracleType.PT_TO_SY) {
+            return (assetDecimals, syDecimals);
+        }
+    }
+}

package/contracts/oracles/factory/PendleChainlinkOracleFactory.sol

@@ -0,0 +1,121 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "./PendleChainlinkOracle.sol";
+import "./PendleChainlinkOracleWithQuote.sol";
+import "../../interfaces/IPChainlinkOracleFactory.sol";
+import "../../interfaces/IPPYLpOracle.sol";
+
+contract PendleChainlinkOracleFactory is IPChainlinkOracleFactory {
+    error OracleAlreadyExists();
+
+    error OracleIncreaseCardinalityRequired(uint32 cardinalityRequired);
+    error OracleOldestObservationNotSatisfied();
+
+    // [keccak256(market, duration, baseOracleType)]
+    mapping(bytes32 oracleId => address oracleAddr) internal oracles;
+
+    // [keccak256(market, duration, baseOracleType, quoteOracle)]
+    mapping(bytes32 oracleId => address oracleAddr) internal oraclesWithQuote;
+
+    address public immutable pyLpOracle;
+
+    constructor(address _pyLpOracle) {
+        pyLpOracle = _pyLpOracle;
+    }
+
+    // =================================================================
+    //                          CREATE ORACLE
+    // =================================================================
+
+    function createOracle(
+        address market,
+        uint32 twapDuration,
+        PendleOracleType baseOracleType
+    ) external returns (address oracle) {
+        bytes32 oracleId = getOracleId(market, twapDuration, baseOracleType);
+        if (oracles[oracleId] != address(0)) revert OracleAlreadyExists();
+
+        checkMarketOracleState(market, twapDuration);
+
+        oracle = address(new PendleChainlinkOracle(market, twapDuration, baseOracleType));
+        oracles[oracleId] = oracle;
+        emit OracleCreated(market, twapDuration, baseOracleType, oracle, oracleId);
+    }
+
+    /**
+     * @dev quoteOracle must has Chainlink-compatible interface
+     */
+    function createOracleWithQuote(
+        address market,
+        uint32 twapDuration,
+        PendleOracleType baseOracleType,
+        address quoteOracle
+    ) external returns (address oracle) {
+        bytes32 oracleId = getOracleWithQuoteId(market, twapDuration, baseOracleType, quoteOracle);
+        if (oraclesWithQuote[oracleId] != address(0)) revert OracleAlreadyExists();
+
+        checkMarketOracleState(market, twapDuration);
+
+        oracle = address(new PendleChainlinkOracleWithQuote(market, twapDuration, baseOracleType, quoteOracle));
+        oraclesWithQuote[oracleId] = oracle;
+        emit OracleWithQuoteCreated(market, twapDuration, baseOracleType, quoteOracle, oracle, oracleId);
+    }
+
+    // =================================================================
+    //                          GET ORACLE
+    // =================================================================
+
+    function getOracle(
+        address market,
+        uint32 twapDuration,
+        PendleOracleType baseOracleType
+    ) public view returns (address) {
+        return oracles[getOracleId(market, twapDuration, baseOracleType)];
+    }
+
+    function getOracleWithQuote(
+        address market,
+        uint32 twapDuration,
+        PendleOracleType baseOracleType,
+        address quoteOracle
+    ) public view returns (address) {
+        return oraclesWithQuote[getOracleWithQuoteId(market, twapDuration, baseOracleType, quoteOracle)];
+    }
+
+    function getOracleId(
+        address market,
+        uint32 twapDuration,
+        PendleOracleType baseOracleType
+    ) public pure returns (bytes32) {
+        return keccak256(abi.encode(market, twapDuration, baseOracleType));
+    }
+
+    function getOracleWithQuoteId(
+        address market,
+        uint32 twapDuration,
+        PendleOracleType baseOracleType,
+        address quoteOracle
+    ) public pure returns (bytes32) {
+        return keccak256(abi.encode(market, twapDuration, baseOracleType, quoteOracle));
+    }
+
+    // =================================================================
+    //                          CHECK ORACLE STATE
+    // =================================================================
+
+    function checkMarketOracleState(address market, uint32 twapDuration) public view {
+        (bool increaseCardinalityRequired, uint32 cardinalityRequired, bool oldestObservationSatisfied) = IPPYLpOracle(
+            pyLpOracle
+        ).getOracleState(market, twapDuration);
+
+        if (increaseCardinalityRequired) {
+            // call IPMarket(market).increaseObservationsCardinalityNext(cardinalityRequired) then wait for twapDuration seconds
+            revert OracleIncreaseCardinalityRequired(cardinalityRequired);
+        }
+        if (!oldestObservationSatisfied) {
+            // wait for twapDuration seconds
+            revert OracleOldestObservationNotSatisfied();
+        }
+    }
+}

package/contracts/oracles/factory/PendleChainlinkOracleWithQuote.sol

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+import "./PendleChainlinkOracle.sol";
+
+/**
+ * @dev The round data returned from this contract will follow:
+ * - There will be only one round (roundId=0)
+ * - startedAt=0, updatedAt=quoteOracle.updatedAt()
+ */
+contract PendleChainlinkOracleWithQuote is PendleChainlinkOracle {
+    // solhint-disable immutable-vars-naming
+    address public immutable quoteOracle;
+    int256 public immutable quoteScale;
+
+    constructor(
+        address _market,
+        uint32 _twapDuration,
+        PendleOracleType _baseOracleType,
+        address _quoteOracle
+    ) PendleChainlinkOracle(_market, _twapDuration, _baseOracleType) {
+        quoteOracle = _quoteOracle;
+        quoteScale = PMath.Int(10 ** AggregatorV3Interface(_quoteOracle).decimals());
+    }
+
+    /**
+     * @notice The round data returned from this contract will follow:
+     * - answer will satisfy 1 natural unit of PendleToken = (answer/1e18) natural unit of quoteToken
+     * - In other words, 10**(PendleToken.decimals) = (answer/1e18) * 10**(quoteToken.decimals)
+     * @return roundId always 0 for this contract
+     * @return answer The answer (in 18 decimals)
+     * @return startedAt always 0 for this contract
+     * @return updatedAt will be the same as quoteOracle.updatedAt()
+     * @return answeredInRound always 0 for this contract
+     */
+    function latestRoundData()
+        public
+        view
+        override
+        returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound)
+    {
+        (, int256 quoteAnswer, , uint256 quoteUpdatedAt, ) = AggregatorV3Interface(quoteOracle).latestRoundData();
+
+        roundId = 0;
+        answer = (_getPendleTokenPrice() * quoteAnswer) / quoteScale;
+        updatedAt = quoteUpdatedAt;
+        startedAt = 0;
+        answeredInRound = 0;
+    }
+}

package/deployments/1-markets/MORPHO-PWBTC-JUN2025.json

@@ -0,0 +1,14 @@
+{
+    "name": "SY WBTC",
+    "SY": "0x59E5a339701797a55465c590b2fE484855Be1a7B",
+    "YT": "0x31a7308A2308CC2bCa8E1e701c53A8d8D0B55254",
+    "PT": "0x6E96041a7F6A3a974a90016f277fb7457a64Ef9B",
+    "market": "0x461CD9222e130D1dc0Bd79DAb4643952430937c1",
+    "expiry": 1750896000,
+    "scalarRoot": "64394909743000000000",
+    "initAnchor": "1038014324000000000",
+    "lnFeeRateRoot": "999500333000000",
+    "deployTxHash": "0xd5ab3f4625f4e33814372a52428e67364a5e0db365def81749dc903d62f444f2",
+    "deployBlockNumber": 21269402,
+    "reversedFee": 0.09999999999164011
+}

package/deployments/1-markets/SUSDS-MAINNET-MAR2025-RELAUNCH.json

@@ -0,0 +1,12 @@
+{
+    "name": "SY sUSDS",
+    "SY": "0xBe3d4ec488A0a042BB86F9176C24f8CD54018BA7",
+    "YT": "0xe88580889A3F02a03e27f9b9c65dD43AD685fC8f",
+    "PT": "0x152b8629fee8105248bA3b7ba6afb94f7a468302",
+    "market": "0x21D85Ff3BEDFF031EF466C7d5295240C8AB2a2b8",
+    "expiry": 1743033600,
+    "scalarRoot": "66210056099000000000",
+    "initAnchor": "1028441141000000000",
+    "lnFeeRateRoot": "499875041000000",
+    "reversedFee": 0.04999999993486881
+}

package/deployments/1-markets/USD0++-MAINNET-JUN2025.json

@@ -0,0 +1,14 @@
+{
+    "name": "SY USD0++",
+    "SY": "0x52453825c287dDef62D647ce51C0979D27c461f7",
+    "YT": "0xEAD01319c2aB0dC2C690EfF5DfC5f465Cd38FC87",
+    "PT": "0xf696FE29Ef85E892b5926313897D178288faA07e",
+    "market": "0x048680F64d6DFf1748ba6D9a01F578433787e24B",
+    "expiry": 1750896000,
+    "scalarRoot": "25840344753000000000",
+    "initAnchor": "1094579386000000000",
+    "lnFeeRateRoot": "1998002662000000",
+    "deployTxHash": "0x84d55092d8c0a23fb5ee3801d2ed904685eb2cc289338a58aed49accac686ab9",
+    "deployBlockNumber": 21220847,
+    "reversedFee": 0.19999999993256523
+}

package/deployments/42161-markets/GUSDC-ARBITRUM-JUN2025.json

@@ -0,0 +1,14 @@
+{
+    "name": "SY gUSDC",
+    "SY": "0x0a9eD458E6c283D1E84237e3347333Aa08221d09",
+    "YT": "0xeb044f64aE0dFD5433726fC5418d6643897cbb6B",
+    "PT": "0x0b6121b4c00ca4FbBb6516C11eB4BF61722E0f8d",
+    "market": "0x22e0F26320aCE985e3CB2434095F18Bfe114E28e",
+    "expiry": 1750896000,
+    "scalarRoot": "21136461043000000000",
+    "initAnchor": "1094191809000000000",
+    "lnFeeRateRoot": "1998002662000000",
+    "deployTxHash": "0xab4a74917f0c839df3b13f6eb81e4286f2c3dcbf268ef51be4cf3a85f658c7ac",
+    "deployBlockNumber": 276038148,
+    "reversedFee": 0.19999999993256523
+}

package/deployments/42161-markets/MUXLP-ARBITRUM-JUN2025.json

@@ -0,0 +1,14 @@
+{
+    "name": "SY MUX",
+    "SY": "0x5220E1Ef8CE83Aa9fE0CCE1b8395cD698d04bc7E",
+    "YT": "0xa661223676633a701B3D1E51bd8c47e2Da07C1f6",
+    "PT": "0x9D8eADeb4e7311e340A5EE39DbF62d7694F1aa85",
+    "market": "0xF1De71573Ee482f13AE4DcF980e83bFAba8b233d",
+    "expiry": 1750896000,
+    "scalarRoot": "23175451492000000000",
+    "initAnchor": "1088578948000000000",
+    "lnFeeRateRoot": "1998002662000000",
+    "deployTxHash": "0x3500a5b6f2145e7172c6fe3a814a455b512be2b5822df332b0f4e90b2564168e",
+    "deployBlockNumber": 276038060,
+    "reversedFee": 0.19999999993256523
+}

package/deployments/8453-markets/CBETH-BASE-DEC2025.json

@@ -0,0 +1,14 @@
+{
+    "name": "SY cbETH",
+    "SY": "0x75372F72EC752a761E96Cbcb3395f4b9586d9aFd",
+    "YT": "0xf9dA8F69D518d7f6488179014f475E843EE2DefD",
+    "PT": "0xE46c8bA948f8071b425a1f7Ba45c0a65CBAcea2e",
+    "market": "0x483f2e223c58a5eF19c4B32fbC6dE57709749cb3",
+    "expiry": 1766620800,
+    "scalarRoot": "146013418776000000000",
+    "initAnchor": "1038333098000000000",
+    "lnFeeRateRoot": "499875041000000",
+    "deployTxHash": "0x69c5a2b100f19a52dbc6346127e9970426df36da60407654e6b90fd8f0c7b96f",
+    "deployBlockNumber": 22727510,
+    "reversedFee": 0.04999999993486881
+}

package/deployments/8453-markets/LBTC-BASE-MAY2025.json

@@ -0,0 +1,14 @@
+{
+    "name": "SY LBTC",
+    "SY": "0xB261266Cb30c255CB9c73EBf4A3eaD9398D23AB4",
+    "YT": "0x5fd84c3dd5C00Ab9E04bd94685B55e8Dd0c1e3fD",
+    "PT": "0x5d746848005507DA0b1717C137A10C30AD9ee307",
+    "market": "0x727cEbAcfb10fFd353Fc221D06A862B437eC1735",
+    "expiry": 1748476800,
+    "scalarRoot": "99858759456000000000",
+    "initAnchor": "1024261630000000000",
+    "lnFeeRateRoot": "999500333000000",
+    "deployTxHash": "0x2b7ca2264698cbd59e9699296bbc8827344008b483674de81d940b463fab1556",
+    "deployBlockNumber": 22920673,
+    "reversedFee": 0.09999999999164011
+}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pendle/core-v2",
   "description": "Core smart contracts of Pendle Protocol.",
   "license": "BUSL-1.1",
-  "version": "5.2.0",
+  "version": "5.2.1",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",

package/typechain-types/IERC4626.ts

@@ -33,6 +33,7 @@ export interface IERC4626Interface extends utils.Interface {
     "convertToShares(uint256)": FunctionFragment;
     "decimals()": FunctionFragment;
     "deposit(uint256,address)": FunctionFragment;
+    "maxMint(address)": FunctionFragment;
     "name()": FunctionFragment;
     "previewDeposit(uint256)": FunctionFragment;
     "previewRedeem(uint256)": FunctionFragment;
@@ -67,6 +68,7 @@ export interface IERC4626Interface extends utils.Interface {
     functionFragment: "deposit",
     values: [BigNumberish, string]
   ): string;
+  encodeFunctionData(functionFragment: "maxMint", values: [string]): string;
   encodeFunctionData(functionFragment: "name", values?: undefined): string;
   encodeFunctionData(
     functionFragment: "previewDeposit",
@@ -112,6 +114,7 @@ export interface IERC4626Interface extends utils.Interface {
   ): Result;
   decodeFunctionResult(functionFragment: "decimals", data: BytesLike): Result;
   decodeFunctionResult(functionFragment: "deposit", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "maxMint", data: BytesLike): Result;
   decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
   decodeFunctionResult(
     functionFragment: "previewDeposit",
@@ -222,6 +225,8 @@ export interface IERC4626 extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
+    maxMint(arg0: string, overrides?: CallOverrides): Promise<[BigNumber]>;
+
     name(overrides?: CallOverrides): Promise<[string]>;
 
     previewDeposit(
@@ -295,6 +300,8 @@ export interface IERC4626 extends BaseContract {
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
+  maxMint(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;
+
   name(overrides?: CallOverrides): Promise<string>;
 
   previewDeposit(
@@ -368,6 +375,8 @@ export interface IERC4626 extends BaseContract {
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
+    maxMint(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;
+
     name(overrides?: CallOverrides): Promise<string>;
 
     previewDeposit(
@@ -466,6 +475,8 @@ export interface IERC4626 extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
+    maxMint(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;
+
     name(overrides?: CallOverrides): Promise<BigNumber>;
 
     previewDeposit(
@@ -543,6 +554,11 @@ export interface IERC4626 extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
+    maxMint(
+      arg0: string,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
     name(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
     previewDeposit(

package/typechain-types/ILBTCMinterBase.ts

@@ -0,0 +1,159 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import {
+  BaseContract,
+  BigNumber,
+  BigNumberish,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  Overrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import { FunctionFragment, Result } from "@ethersproject/abi";
+import { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+} from "./common";
+
+export interface ILBTCMinterBaseInterface extends utils.Interface {
+  contractName: "ILBTCMinterBase";
+  functions: {
+    "relativeFee()": FunctionFragment;
+    "remainingStake()": FunctionFragment;
+    "stakeLimit()": FunctionFragment;
+    "swapCBBTCToLBTC(uint256)": FunctionFragment;
+  };
+
+  encodeFunctionData(
+    functionFragment: "relativeFee",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "remainingStake",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "stakeLimit",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "swapCBBTCToLBTC",
+    values: [BigNumberish]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "relativeFee",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "remainingStake",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "stakeLimit", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "swapCBBTCToLBTC",
+    data: BytesLike
+  ): Result;
+
+  events: {};
+}
+
+export interface ILBTCMinterBase extends BaseContract {
+  contractName: "ILBTCMinterBase";
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: ILBTCMinterBaseInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    relativeFee(overrides?: CallOverrides): Promise<[number]>;
+
+    remainingStake(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    stakeLimit(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    swapCBBTCToLBTC(
+      amount: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+  };
+
+  relativeFee(overrides?: CallOverrides): Promise<number>;
+
+  remainingStake(overrides?: CallOverrides): Promise<BigNumber>;
+
+  stakeLimit(overrides?: CallOverrides): Promise<BigNumber>;
+
+  swapCBBTCToLBTC(
+    amount: BigNumberish,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  callStatic: {
+    relativeFee(overrides?: CallOverrides): Promise<number>;
+
+    remainingStake(overrides?: CallOverrides): Promise<BigNumber>;
+
+    stakeLimit(overrides?: CallOverrides): Promise<BigNumber>;
+
+    swapCBBTCToLBTC(
+      amount: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<void>;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    relativeFee(overrides?: CallOverrides): Promise<BigNumber>;
+
+    remainingStake(overrides?: CallOverrides): Promise<BigNumber>;
+
+    stakeLimit(overrides?: CallOverrides): Promise<BigNumber>;
+
+    swapCBBTCToLBTC(
+      amount: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    relativeFee(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    remainingStake(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    stakeLimit(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    swapCBBTCToLBTC(
+      amount: BigNumberish,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+  };
+}