@pendle/core-v2 5.2.3-beta → 5.2.3

package/contracts/interfaces/IPBulkSeller.sol

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+struct BulkSellerState {
+    uint256 rateTokenToSy;
+    uint256 rateSyToToken;
+    uint256 totalToken;
+    uint256 totalSy;
+    uint256 feeRate;
+}
+
+interface IPBulkSeller {
+    event SwapExactTokenForSy(address receiver, uint256 netTokenIn, uint256 netSyOut);
+    event SwapExactSyForToken(address receiver, uint256 netSyIn, uint256 netTokenOut);
+    event RateUpdated(
+        uint256 newRateTokenToSy,
+        uint256 newRateSyToToken,
+        uint256 oldRateTokenToSy,
+        uint256 oldRateSyToToken
+    );
+    event ReBalanceTokenToSy(
+        uint256 netTokenDeposit,
+        uint256 netSyFromToken,
+        uint256 newTokenProp,
+        uint256 oldTokenProp
+    );
+    event ReBalanceSyToToken(uint256 netSyRedeem, uint256 netTokenFromSy, uint256 newTokenProp, uint256 oldTokenProp);
+    event ReserveUpdated(uint256 totalToken, uint256 totalSy);
+    event FeeRateUpdated(uint256 newFeeRate, uint256 oldFeeRate);
+
+    function swapExactTokenForSy(
+        address receiver,
+        uint256 netTokenIn,
+        uint256 minSyOut
+    ) external payable returns (uint256 netSyOut);
+
+    function swapExactSyForToken(
+        address receiver,
+        uint256 exactSyIn,
+        uint256 minTokenOut,
+        bool swapFromInternalBalance
+    ) external returns (uint256 netTokenOut);
+
+    function SY() external view returns (address);
+
+    function token() external view returns (address);
+
+    function readState() external view returns (BulkSellerState memory);
+}

package/contracts/interfaces/IPBulkSellerFactory.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface IPBulkSellerFactory {
+    event BulkSellerCreated(address indexed token, address indexed sy, address indexed bulk);
+
+    event UpgradedBeacon(address indexed implementation);
+
+    function get(address token, address SY) external view returns (address);
+
+    function isMaintainer(address addr) external view returns (bool);
+}

package/contracts/interfaces/IPBulkSellerSYCallback.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface IPBulkSellerCallback {
+    function swapCallback(int256 ptToAccount, int256 syToAccount, bytes calldata data) external;
+}

package/contracts/interfaces/IPExternalRewardDistributor.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface IPExternalRewardDistributor {
+    struct MarketRewardData {
+        uint128 rewardPerSec;
+        uint128 accumulatedReward;
+        uint128 lastUpdated;
+        uint128 incentiveEndsAt;
+    }
+
+    event DistributeReward(address indexed market, address indexed rewardToken, uint256 amount);
+
+    event AddRewardToMarket(address indexed market, address indexed token, MarketRewardData data);
+
+    function getRewardTokens(address market) external view returns (address[] memory);
+
+    function redeemRewards() external;
+}

package/contracts/interfaces/IPLinearDistributor.sol

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.17;
+
+interface IPLinearDistributor {
+    event VestQueued(address indexed token, address indexed addr, uint256 amount);
+    event Vested(address indexed token, address indexed addr, uint256 amount, uint256 duration);
+    event Claim(address indexed token, address indexed addr, uint256 amount);
+
+    struct DistributionData {
+        uint128 accruedReward;
+        uint128 unvestedReward;
+        // [irregular uint192] reward tokens might be up to 1e18 decimals, at 1e18 based, the reward per sec might be very close to 1e38 limit of uint128
+        uint192 rewardPerSec;
+        uint32 lastDistributedTime;
+        uint32 endTime;
+    }
+
+    function queueVestAndClaim(address token, uint256 amountToVest) external returns (uint256 amountOut);
+
+    function claim(address token) external returns (uint256 amountOut);
+}

package/contracts/interfaces/IPMarketFactoryV2.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+import "./IPMarketFactory.sol";
+
+interface IPMarketFactoryV2 is IPMarketFactory {
+    function rewardDistributor() external view returns (address);
+}

package/contracts/interfaces/IPPreviewHelper.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface IPPreviewHelper {
+    function previewDeposit(address tokenIn, uint256 amountTokenIn) external view returns (uint256 amountSharesOut);
+
+    function previewRedeem(address tokenOut, uint256 amountSharesToBurn) external view returns (uint256 amountTokenOut);
+}

package/contracts/interfaces/IQiAvax.sol

@@ -0,0 +1,31 @@
+// 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.0;
+import "./IQiToken.sol";
+
+interface IQiAvax is IQiToken {
+    function mint() external payable;
+
+    function redeem(uint256 redeemTokens) external returns (uint256);
+}

package/contracts/interfaces/IQiErc20.sol

@@ -0,0 +1,35 @@
+// 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.0;
+import "./IQiToken.sol";
+
+interface IQiErc20 is IQiToken {
+    function mint(uint256 mintAmount) external returns (uint256);
+
+    function redeem(uint256 redeemTokens) external returns (uint256);
+
+    function balanceOf(address owner) external view returns (uint256);
+
+    function underlying() external view returns (address);
+}

package/contracts/interfaces/IQiToken.sol

@@ -0,0 +1,50 @@
+// 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.0;
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "./IBenQiInterestRateModel.sol";
+
+interface IQiToken is IERC20 {
+    function exchangeRateCurrent() external returns (uint256);
+
+    function exchangeRateStored() external view returns (uint256);
+
+    function comptroller() external view returns (address);
+
+    function accrualBlockTimestamp() external view returns (uint256);
+
+    function getCash() external view returns (uint256);
+
+    function totalBorrows() external view returns (uint256);
+
+    function totalReserves() external view returns (uint256);
+
+    function borrowIndex() external view returns (uint256);
+
+    function interestRateModel() external view returns (IBenQiInterestRateModel);
+
+    function totalSupply() external view returns (uint256);
+
+    function reserveFactorMantissa() external view returns (uint256);
+}

package/contracts/interfaces/IStETH.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface IStETH {
+    function getSharesByPooledEth(uint256 _ethAmount) external view returns (uint256);
+
+    function getPooledEthByShares(uint256 _sharesAmount) external view returns (uint256);
+
+    function submit(address referral) external payable returns (uint256 amount);
+
+    function burnShares(address _account, uint256 _sharesAmount) external returns (uint256 newTotalShares);
+
+    function sharesOf(address account) external view returns (uint256);
+
+    function getTotalShares() external view returns (uint256);
+
+    function getTotalPooledEther() external view returns (uint256);
+}

package/contracts/interfaces/IStargateLP.sol

@@ -0,0 +1,59 @@
+// 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.0;
+
+interface IStargateLP {
+    struct SwapObj {
+        uint256 amount;
+        uint256 eqFee;
+        uint256 eqReward;
+        uint256 lpFee;
+        uint256 protocolFee;
+        uint256 lkbRemove;
+    }
+
+    function swapRemote(
+        uint16 _srcChainId,
+        uint256 _srcPoolId,
+        address _to,
+        SwapObj memory _s
+    ) external returns (uint256 amountLD);
+
+    function poolId() external view returns (uint256);
+
+    function amountLPtoLD(uint256 _amountLP) external view returns (uint256);
+
+    function token() external view returns (address);
+
+    function router() external view returns (address);
+
+    function totalSupply() external view returns (uint256);
+
+    function totalLiquidity() external view returns (uint256);
+
+    function mintFeeBP() external view returns (uint256);
+
+    function convertRate() external view returns (uint256);
+
+    function deltaCredit() external view returns (uint256);
+}

package/contracts/interfaces/IStargateRouter.sol

@@ -0,0 +1,29 @@
+// 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.0;
+
+interface IStargateRouter {
+    function addLiquidity(uint256 _poolId, uint256 _amountLD, address _to) external;
+
+    function instantRedeemLocal(uint16 _srcPoolId, uint256 _amountLP, address _to) external returns (uint256 amountSD);
+}

package/contracts/interfaces/IStargateStaking.sol

@@ -0,0 +1,47 @@
+// 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.0;
+
+interface IStargateStaking {
+    struct PoolInfo {
+        address lpToken; // Address of LP token contract.
+        uint256 allocPoint; // How many allocation points assigned to this pool. STGs to distribute per block.
+        uint256 lastRewardBlock; // Last block number that STGs distribution occurs.
+        uint256 accStargatePerShare; // Accumulated STGs per share, times 1e12. See below.
+    }
+
+    struct UserInfo {
+        uint256 amount; // How many LP tokens the user has provided.
+        uint256 rewardDebt; // Reward debt. See explanation below.
+    }
+
+    function stargate() external view returns (address);
+
+    function deposit(uint256 _pid, uint256 _amount) external;
+
+    function withdraw(uint256 _pid, uint256 _amount) external;
+
+    function poolInfo(uint256 _pid) external view returns (address, uint256, uint256, uint256);
+
+    function userInfo(uint256 _pid, address _user) external view returns (UserInfo memory);
+}

package/contracts/interfaces/Karak/IKarakVault.sol

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: SEE LICENSE IN LICENSE
+pragma solidity ^0.8.0;
+
+interface IKarakVault {
+    function assetLimit() external view returns (uint256);
+}

package/contracts/interfaces/Karak/IKarakVaultSupervisor.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: SEE LICENSE IN LICENSE
+pragma solidity ^0.8.0;
+
+interface IKarakVaultSupervisor {
+    function deposit(address vault, uint256 amount, uint256 minSharesOut) external returns (uint256 shares);
+    function gimmieShares(address vault, uint256 shares) external;
+    function returnShares(address vault, uint256 shares) external;
+}

package/contracts/interfaces/KelpDAO/IKelpDepositPool.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface IKelpDepositPool {
+    function lrtConfig() external view returns (address);
+
+    function depositAsset(
+        address asset,
+        uint256 depositAmount,
+        uint256 minRSETHAmountToReceive,
+        string calldata referralId
+    ) external;
+
+    function getRsETHAmountToMint(address asset, uint256 amount) external view returns (uint256 rsethAmountToMint);
+
+    function depositETH(uint256 minRSETHAmountExpected, string calldata referralId) external payable;
+}

package/contracts/interfaces/KelpDAO/IKelpLRTConfig.sol

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity ^0.8.0;
+
+interface IKelpLRTConfig {
+    function getSupportedAssetList() external view returns (address[] memory);
+
+    function isSupportedAsset(address token) external view returns (bool);
+}

package/contracts/interfaces/Kyber/IKyberElasticFactory.sol

@@ -0,0 +1,157 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+/// @title KyberSwap v2 factory
+/// @notice Deploys KyberSwap v2 pools and manages control over government fees
+interface IKyberElasticFactory {
+    /// @notice Emitted when a pool is created
+    /// @param token0 First pool token by address sort order
+    /// @param token1 Second pool token by address sort order
+    /// @param swapFeeUnits Fee to be collected upon every swap in the pool, in fee units
+    /// @param tickDistance Minimum number of ticks between initialized ticks
+    /// @param pool The address of the created pool
+    event PoolCreated(
+        address indexed token0,
+        address indexed token1,
+        uint24 indexed swapFeeUnits,
+        int24 tickDistance,
+        address pool
+    );
+
+    /// @notice Emitted when a new fee is enabled for pool creation via the factory
+    /// @param swapFeeUnits Fee to be collected upon every swap in the pool, in fee units
+    /// @param tickDistance Minimum number of ticks between initialized ticks for pools created with the given fee
+    event SwapFeeEnabled(uint24 indexed swapFeeUnits, int24 indexed tickDistance);
+
+    /// @notice Emitted when vesting period changes
+    /// @param vestingPeriod The maximum time duration for which LP fees
+    /// are proportionally burnt upon LP removals
+    event VestingPeriodUpdated(uint32 vestingPeriod);
+
+    /// @notice Emitted when configMaster changes
+    /// @param oldConfigMaster configMaster before the update
+    /// @param newConfigMaster configMaster after the update
+    event ConfigMasterUpdated(address oldConfigMaster, address newConfigMaster);
+
+    /// @notice Emitted when fee configuration changes
+    /// @param feeTo Recipient of government fees
+    /// @param governmentFeeUnits Fee amount, in fee units,
+    /// to be collected out of the fee charged for a pool swap
+    event FeeConfigurationUpdated(address feeTo, uint24 governmentFeeUnits);
+
+    /// @notice Emitted when whitelist feature is enabled
+    event WhitelistEnabled();
+
+    /// @notice Emitted when whitelist feature is disabled
+    event WhitelistDisabled();
+
+    /// @notice Returns the maximum time duration for which LP fees
+    /// are proportionally burnt upon LP removals
+    function vestingPeriod() external view returns (uint32);
+
+    /// @notice Returns the tick distance for a specified fee.
+    /// @dev Once added, cannot be updated or removed.
+    /// @param swapFeeUnits Swap fee, in fee units.
+    /// @return The tick distance. Returns 0 if fee has not been added.
+    function feeAmountTickDistance(uint24 swapFeeUnits) external view returns (int24);
+
+    /// @notice Returns the address which can update the fee configuration
+    function configMaster() external view returns (address);
+
+    /// @notice Returns the keccak256 hash of the Pool creation code
+    /// This is used for pre-computation of pool addresses
+    function poolInitHash() external view returns (bytes32);
+
+    /// @notice Returns the pool oracle contract for twap
+    function poolOracle() external view returns (address);
+
+    /// @notice Fetches the recipient of government fees
+    /// and current government fee charged in fee units
+    function feeConfiguration() external view returns (address _feeTo, uint24 _governmentFeeUnits);
+
+    /// @notice Returns the status of whitelisting feature of NFT managers
+    /// If true, anyone can mint liquidity tokens
+    /// Otherwise, only whitelisted NFT manager(s) are allowed to mint liquidity tokens
+    function whitelistDisabled() external view returns (bool);
+
+    //// @notice Returns all whitelisted NFT managers
+    /// If the whitelisting feature is turned on,
+    /// only whitelisted NFT manager(s) are allowed to mint liquidity tokens
+    function getWhitelistedNFTManagers() external view returns (address[] memory);
+
+    /// @notice Checks if sender is a whitelisted NFT manager
+    /// If the whitelisting feature is turned on,
+    /// only whitelisted NFT manager(s) are allowed to mint liquidity tokens
+    /// @param sender address to be checked
+    /// @return true if sender is a whistelisted NFT manager, false otherwise
+    function isWhitelistedNFTManager(address sender) external view returns (bool);
+
+    /// @notice Returns the pool address for a given pair of tokens and a swap fee
+    /// @dev Token order does not matter
+    /// @param tokenA Contract address of either token0 or token1
+    /// @param tokenB Contract address of the other token
+    /// @param swapFeeUnits Fee to be collected upon every swap in the pool, in fee units
+    /// @return pool The pool address. Returns null address if it does not exist
+    function getPool(address tokenA, address tokenB, uint24 swapFeeUnits) external view returns (address pool);
+
+    /// @notice Fetch parameters to be used for pool creation
+    /// @dev Called by the pool constructor to fetch the parameters of the pool
+    /// @return factory The factory address
+    /// @return poolOracle The pool oracle for twap
+    /// @return token0 First pool token by address sort order
+    /// @return token1 Second pool token by address sort order
+    /// @return swapFeeUnits Fee to be collected upon every swap in the pool, in fee units
+    /// @return tickDistance Minimum number of ticks between initialized ticks
+    function parameters()
+        external
+        view
+        returns (
+            address factory,
+            address poolOracle,
+            address token0,
+            address token1,
+            uint24 swapFeeUnits,
+            int24 tickDistance
+        );
+
+    /// @notice Creates a pool for the given two tokens and fee
+    /// @param tokenA One of the two tokens in the desired pool
+    /// @param tokenB The other of the two tokens in the desired pool
+    /// @param swapFeeUnits Desired swap fee for the pool, in fee units
+    /// @dev Token order does not matter. tickDistance is determined from the fee.
+    /// Call will revert under any of these conditions:
+    ///     1) pool already exists
+    ///     2) invalid swap fee
+    ///     3) invalid token arguments
+    /// @return pool The address of the newly created pool
+    function createPool(address tokenA, address tokenB, uint24 swapFeeUnits) external returns (address pool);
+
+    /// @notice Enables a fee amount with the given tickDistance
+    /// @dev Fee amounts may never be removed once enabled
+    /// @param swapFeeUnits The fee amount to enable, in fee units
+    /// @param tickDistance The distance between ticks to be enforced for all pools created with the given fee amount
+    function enableSwapFee(uint24 swapFeeUnits, int24 tickDistance) external;
+
+    /// @notice Updates the address which can update the fee configuration
+    /// @dev Must be called by the current configMaster
+    function updateConfigMaster(address) external;
+
+    /// @notice Updates the vesting period
+    /// @dev Must be called by the current configMaster
+    function updateVestingPeriod(uint32) external;
+
+    /// @notice Updates the address receiving government fees and fee quantity
+    /// @dev Only configMaster is able to perform the update
+    /// @param feeTo Address to receive government fees collected from pools
+    /// @param governmentFeeUnits Fee amount, in fee units,
+    /// to be collected out of the fee charged for a pool swap
+    function updateFeeConfiguration(address feeTo, uint24 governmentFeeUnits) external;
+
+    /// @notice Enables the whitelisting feature
+    /// @dev Only configMaster is able to perform the update
+    function enableWhitelist() external;
+
+    /// @notice Disables the whitelisting feature
+    /// @dev Only configMaster is able to perform the update
+    function disableWhitelist() external;
+}