@pendle/core-v2 0.1.0

package/contracts/core/router/base/PendleRouterYTBaseUpg.sol

@@ -0,0 +1,212 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.9;
+
+import "../../../interfaces/IPMarketFactory.sol";
+import "../../../interfaces/IPMarket.sol";
+import "../../../interfaces/IPMarketAddRemoveCallback.sol";
+import "../../../interfaces/IPMarketSwapCallback.sol";
+import "../../../SuperComposableYield/SCYUtils.sol";
+import "../../../libraries/math/MarketApproxLib.sol";
+import "openzeppelin-solidity/contracts/token/ERC20/utils/SafeERC20.sol";
+
+abstract contract PendleRouterYTBaseUpg is IPMarketSwapCallback {
+    using FixedPoint for uint256;
+    using FixedPoint for int256;
+    using MarketMathLib for MarketParameters;
+    using MarketApproxLib for MarketParameters;
+    using SafeERC20 for ISuperComposableYield;
+    using SafeERC20 for IPYieldToken;
+
+    // solhint-disable-next-line
+    enum YT_SWAP_TYPE {
+        ExactYtForScy,
+        SCYForExactYt,
+        ExactScyForYt
+    }
+
+    address public immutable marketFactory;
+
+    modifier onlyPendleMarket(address market) {
+        require(IPMarketFactory(marketFactory).isValidMarket(market), "INVALID_MARKET");
+        _;
+    }
+
+    /// @dev since this contract will be proxied, it must not contains non-immutable variables
+    constructor(
+        address _marketFactory //solhint-disable-next-line no-empty-blocks
+    ) {
+        marketFactory = _marketFactory;
+    }
+
+    function _swapExactScyForYt(
+        address receiver,
+        address market,
+        uint256 exactScyIn,
+        uint256 minYtOut,
+        uint256 netYtOutGuessMin,
+        uint256 netYtOutGuessMax,
+        bool doPull
+    ) internal returns (uint256 netYtOut) {
+        {
+            (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
+            {
+                MarketParameters memory state = IPMarket(market).readState();
+
+                netYtOut = state.approxSwapExactScyForYt(
+                    SCYIndexLib.newIndex(SCY),
+                    exactScyIn,
+                    block.timestamp,
+                    netYtOutGuessMin,
+                    netYtOutGuessMax
+                );
+                require(netYtOut >= minYtOut, "insufficient out");
+            }
+
+            if (doPull) {
+                SCY.safeTransferFrom(msg.sender, address(YT), exactScyIn);
+            }
+        }
+
+        {
+            uint256 exactOtIn = netYtOut;
+            IPMarket(market).swapExactOtForScy(
+                receiver,
+                exactOtIn,
+                1,
+                abi.encode(YT_SWAP_TYPE.ExactScyForYt, receiver)
+            );
+        }
+    }
+
+    /**
+    * @dev inner working of this function:
+     - YT is transferred to the YT contract
+     - market.swap is called, which will transfer OT directly to the YT contract, and callback is invoked
+     - callback will call YT's redeemYO, which will redeem the outcome SCY to this router, then
+        all SCY owed to the market will be paid, the rest is transferred to the receiver
+     */
+    function _swapExactYtForScy(
+        address receiver,
+        address market,
+        uint256 exactYtIn,
+        uint256 minScyOut,
+        bool doPull
+    ) internal returns (uint256 netScyOut) {
+        (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
+
+        // takes out the same amount of OT as exactYtIn, to pair together
+        uint256 exactOtOut = exactYtIn;
+
+        uint256 preBalanceScy = SCY.balanceOf(receiver);
+
+        if (doPull) {
+            YT.safeTransferFrom(msg.sender, address(YT), exactYtIn);
+        }
+
+        IPMarket(market).swapScyForExactOt(
+            receiver,
+            exactOtOut,
+            type(uint256).max,
+            abi.encode(YT_SWAP_TYPE.ExactYtForScy, receiver)
+        );
+
+        netScyOut = SCY.balanceOf(receiver) - preBalanceScy;
+        require(netScyOut >= minScyOut, "INSUFFICIENT_SCY_OUT");
+    }
+
+    /**
+     * @dev inner working of this function:
+     - market.swap is called, which will transfer SCY directly to the YT contract, and callback is invoked
+     - callback will pull more SCY if necessary, do call YT's mintYO, which will mint OT to the market & YT to the receiver
+     */
+    function _swapScyForExactYt(
+        address receiver,
+        address market,
+        uint256 exactYtOut,
+        uint256 maxScyIn
+    ) internal returns (uint256 netScyIn) {
+        (ISuperComposableYield SCY, , ) = IPMarket(market).readTokens();
+
+        uint256 exactOtIn = exactYtOut;
+        uint256 preBalanceScy = SCY.balanceOf(receiver);
+
+        IPMarket(market).swapExactOtForScy(
+            receiver,
+            exactOtIn,
+            1,
+            abi.encode(YT_SWAP_TYPE.SCYForExactYt, msg.sender, receiver)
+        );
+
+        netScyIn = preBalanceScy - SCY.balanceOf(receiver);
+
+        require(netScyIn <= maxScyIn, "exceed out limit");
+    }
+
+    function swapCallback(
+        int256 otToAccount,
+        int256 scyToAccount,
+        bytes calldata data
+    ) external override onlyPendleMarket(msg.sender) {
+        (YT_SWAP_TYPE swapType, ) = abi.decode(data, (YT_SWAP_TYPE, bytes));
+
+        if (swapType == YT_SWAP_TYPE.ExactScyForYt) {
+            _swapExactScyForYt_callback(msg.sender, data);
+        } else if (swapType == YT_SWAP_TYPE.ExactYtForScy) {
+            _swapExactYtForScy_callback(msg.sender, scyToAccount, data);
+        } else if (swapType == YT_SWAP_TYPE.SCYForExactYt) {
+            _swapScyForExactYt_callback(msg.sender, otToAccount, scyToAccount, data);
+        } else {
+            require(false, "unknown swapType");
+        }
+    }
+
+    function _swapExactScyForYt_callback(address market, bytes calldata data) internal {
+        (, , IPYieldToken YT) = IPMarket(market).readTokens();
+        (, address receiver) = abi.decode(data, (YT_SWAP_TYPE, address));
+
+        YT.mintYO(market, receiver);
+    }
+
+    function _swapScyForExactYt_callback(
+        address market,
+        int256 otToAccount,
+        int256 scyToAccount,
+        bytes calldata data
+    ) internal {
+        (, address payer, address receiver) = abi.decode(data, (YT_SWAP_TYPE, address, address));
+        (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
+
+        uint256 otOwed = otToAccount.neg().Uint();
+        uint256 scyReceived = scyToAccount.Uint();
+
+        // otOwed = totalAsset
+        uint256 scyNeedTotal = SCYUtils.assetToScy(SCY.scyIndexCurrent(), otOwed);
+
+        uint256 netScyToPull = scyNeedTotal.subMax0(scyReceived);
+        SCY.safeTransferFrom(payer, address(YT), netScyToPull);
+
+        YT.mintYO(market, receiver);
+    }
+
+    /**
+    @dev receive OT -> pair with YT to redeem SCY -> payback SCY
+    */
+    function _swapExactYtForScy_callback(
+        address market,
+        int256 scyToAccount,
+        bytes calldata data
+    ) internal {
+        (, address receiver) = abi.decode(data, (YT_SWAP_TYPE, address));
+        (ISuperComposableYield SCY, , IPYieldToken YT) = IPMarket(market).readTokens();
+
+        uint256 scyOwed = scyToAccount.neg().Uint();
+
+        uint256 netScyReceived = YT.redeemYO(address(this));
+
+        SCY.safeTransfer(market, scyOwed);
+
+        if (receiver != address(this)) {
+            SCY.safeTransfer(receiver, netScyReceived - scyOwed);
+        }
+    }
+}

package/contracts/interfaces/IAToken.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+/*
+ * MIT License
+ * ===========
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ */
+pragma solidity 0.8.9;
+import "openzeppelin-solidity/contracts/token/ERC20/IERC20.sol";
+
+interface IAToken is IERC20 {
+    /**
+     * @dev Returns the scaled balance of the user. The scaled balance is the sum of all the
+     * updated stored balance divided by the reserve's liquidity index at the moment of the update
+     * @param user The user whose balance is calculated
+     * @return The scaled balance of the user
+     **/
+    function scaledBalanceOf(address user) external view returns (uint256);
+}

package/contracts/interfaces/IAavePool.sol

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+/*
+ * MIT License
+ * ===========
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ */
+
+pragma solidity 0.8.9;
+
+interface IAavePool {
+    function supply(
+        address asset,
+        uint256 amount,
+        address onBehalfOf,
+        uint16 referralCode
+    ) external;
+
+    function withdraw(
+        address asset,
+        uint256 amount,
+        address to
+    ) external returns (uint256);
+
+    function getReserveNormalizedIncome(address asset) external view returns (uint256);
+}

package/contracts/interfaces/IAaveRewardsController.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+/*
+ * MIT License
+ * ===========
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ */
+
+pragma solidity 0.8.9;
+
+interface IAaveRewardsController {
+    function claimAllRewards(address[] calldata assets, address to)
+        external
+        returns (address[] memory rewardsList, uint256[] memory claimedAmounts);
+
+    function getRewardsByAsset(address asset) external view returns (address[] memory);
+}

package/contracts/interfaces/IBenQiComptroller.sol

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+/*
+ * MIT License
+ * ===========
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ */
+pragma solidity 0.8.9;
+
+interface IBenQiComptroller {
+    function claimReward(
+        uint8 rewardType,
+        address[] memory holders,
+        address[] memory qiTokens,
+        bool borrowers,
+        bool suppliers
+    ) external;
+}

package/contracts/interfaces/IJoePair.sol

@@ -0,0 +1,98 @@
+// SPDX-License-Identifier: GPL-3.0
+
+pragma solidity >=0.5.0;
+
+interface IJoePair {
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+    event Transfer(address indexed from, address indexed to, uint256 value);
+
+    function name() external pure returns (string memory);
+
+    function symbol() external pure returns (string memory);
+
+    function decimals() external pure returns (uint8);
+
+    function totalSupply() external view returns (uint256);
+
+    function balanceOf(address owner) external view returns (uint256);
+
+    function allowance(address owner, address spender) external view returns (uint256);
+
+    function approve(address spender, uint256 value) external returns (bool);
+
+    function transfer(address to, uint256 value) external returns (bool);
+
+    function transferFrom(
+        address from,
+        address to,
+        uint256 value
+    ) external returns (bool);
+
+    function DOMAIN_SEPARATOR() external view returns (bytes32);
+
+    function PERMIT_TYPEHASH() external pure returns (bytes32);
+
+    function nonces(address owner) external view returns (uint256);
+
+    function permit(
+        address owner,
+        address spender,
+        uint256 value,
+        uint256 deadline,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) external;
+
+    event Mint(address indexed sender, uint256 amount0, uint256 amount1);
+    event Burn(address indexed sender, uint256 amount0, uint256 amount1, address indexed to);
+    event Swap(
+        address indexed sender,
+        uint256 amount0In,
+        uint256 amount1In,
+        uint256 amount0Out,
+        uint256 amount1Out,
+        address indexed to
+    );
+    event Sync(uint112 reserve0, uint112 reserve1);
+
+    function MINIMUM_LIQUIDITY() external pure returns (uint256);
+
+    function factory() external view returns (address);
+
+    function token0() external view returns (address);
+
+    function token1() external view returns (address);
+
+    function getReserves()
+        external
+        view
+        returns (
+            uint112 reserve0,
+            uint112 reserve1,
+            uint32 blockTimestampLast
+        );
+
+    function price0CumulativeLast() external view returns (uint256);
+
+    function price1CumulativeLast() external view returns (uint256);
+
+    function kLast() external view returns (uint256);
+
+    function mint(address to) external returns (uint256 liquidity);
+
+    function burn(address to) external returns (uint256 amount0, uint256 amount1);
+
+    function swap(
+        uint256 amount0Out,
+        uint256 amount1Out,
+        address to,
+        bytes calldata data
+    ) external;
+
+    function skim(address to) external;
+
+    function sync() external;
+
+    function initialize(address, address) external;
+}

package/contracts/interfaces/IJoeRouter01.sol

@@ -0,0 +1,162 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity 0.8.9;
+
+interface IJoeRouter01 {
+    function addLiquidity(
+        address tokenA,
+        address tokenB,
+        uint256 amountADesired,
+        uint256 amountBDesired,
+        uint256 amountAMin,
+        uint256 amountBMin,
+        address to,
+        uint256 deadline
+    )
+        external
+        returns (
+            uint256 amountA,
+            uint256 amountB,
+            uint256 liquidity
+        );
+
+    function addLiquidityAVAX(
+        address token,
+        uint256 amountTokenDesired,
+        uint256 amountTokenMin,
+        uint256 amountAVAXMin,
+        address to,
+        uint256 deadline
+    )
+        external
+        payable
+        returns (
+            uint256 amountToken,
+            uint256 amountAVAX,
+            uint256 liquidity
+        );
+
+    function removeLiquidity(
+        address tokenA,
+        address tokenB,
+        uint256 liquidity,
+        uint256 amountAMin,
+        uint256 amountBMin,
+        address to,
+        uint256 deadline
+    ) external returns (uint256 amountA, uint256 amountB);
+
+    function removeLiquidityAVAX(
+        address token,
+        uint256 liquidity,
+        uint256 amountTokenMin,
+        uint256 amountAVAXMin,
+        address to,
+        uint256 deadline
+    ) external returns (uint256 amountToken, uint256 amountAVAX);
+
+    function removeLiquidityWithPermit(
+        address tokenA,
+        address tokenB,
+        uint256 liquidity,
+        uint256 amountAMin,
+        uint256 amountBMin,
+        address to,
+        uint256 deadline,
+        bool approveMax,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) external returns (uint256 amountA, uint256 amountB);
+
+    function removeLiquidityAVAXWithPermit(
+        address token,
+        uint256 liquidity,
+        uint256 amountTokenMin,
+        uint256 amountAVAXMin,
+        address to,
+        uint256 deadline,
+        bool approveMax,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) external returns (uint256 amountToken, uint256 amountAVAX);
+
+    function swapExactTokensForTokens(
+        uint256 amountIn,
+        uint256 amountOutMin,
+        address[] calldata path,
+        address to,
+        uint256 deadline
+    ) external returns (uint256[] memory amounts);
+
+    function swapTokensForExactTokens(
+        uint256 amountOut,
+        uint256 amountInMax,
+        address[] calldata path,
+        address to,
+        uint256 deadline
+    ) external returns (uint256[] memory amounts);
+
+    function swapExactAVAXForTokens(
+        uint256 amountOutMin,
+        address[] calldata path,
+        address to,
+        uint256 deadline
+    ) external payable returns (uint256[] memory amounts);
+
+    function swapTokensForExactAVAX(
+        uint256 amountOut,
+        uint256 amountInMax,
+        address[] calldata path,
+        address to,
+        uint256 deadline
+    ) external returns (uint256[] memory amounts);
+
+    function swapExactTokensForAVAX(
+        uint256 amountIn,
+        uint256 amountOutMin,
+        address[] calldata path,
+        address to,
+        uint256 deadline
+    ) external returns (uint256[] memory amounts);
+
+    function swapAVAXForExactTokens(
+        uint256 amountOut,
+        address[] calldata path,
+        address to,
+        uint256 deadline
+    ) external payable returns (uint256[] memory amounts);
+
+    function getAmountsOut(uint256 amountIn, address[] calldata path)
+        external
+        view
+        returns (uint256[] memory amounts);
+
+    function getAmountsIn(uint256 amountOut, address[] calldata path)
+        external
+        view
+        returns (uint256[] memory amounts);
+
+    function quote(
+        uint256 amountA,
+        uint256 reserveA,
+        uint256 reserveB
+    ) external pure returns (uint256 amountB);
+
+    function getAmountOut(
+        uint256 amountIn,
+        uint256 reserveIn,
+        uint256 reserveOut
+    ) external pure returns (uint256 amountOut);
+
+    function getAmountIn(
+        uint256 amountOut,
+        uint256 reserveIn,
+        uint256 reserveOut
+    ) external pure returns (uint256 amountIn);
+
+    function factory() external pure returns (address);
+
+    function WAVAX() external pure returns (address);
+}

package/contracts/interfaces/IPBaseToken.sol

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.9;
+import "openzeppelin-solidity/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+
+interface IPBaseToken is IERC20Metadata {
+    function expiry() external view returns (uint256);
+
+    function isExpired() external view returns (bool);
+}

package/contracts/interfaces/IPFlashCallBack.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.9;
+
+interface IPFlashCallback {
+    function pendleFlashCallback(
+        address[] calldata tokens,
+        uint256[] calldata amountsToPay,
+        bytes calldata data
+    ) external;
+}

package/contracts/interfaces/IPGovernanceManager.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+/*
+ * MIT License
+ * ===========
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ */
+
+pragma solidity 0.8.9;
+
+interface IPGovernanceManager {
+    function governance() external view returns (address);
+}