@pendle/core-v2 0.11.1-testnet → 0.11.2-testnet

package/contracts/core/LiquidityMining/GaugeController/PendleGaugeControllerBaseUpg.sol

@@ -62,7 +62,7 @@ abstract contract PendleGaugeControllerBaseUpg is IPGaugeController, BoringOwnab
         - rewardData[market] is updated with the data up to now
         - all accumulatedPendle is transferred out & the accumulatedPendle is set to 0
      */
-    function redeemMarketReward() external onlyPendleMarket {
+    function claimMarketReward() external onlyPendleMarket {
         address market = msg.sender;
         rewardData[market] = _getUpdatedMarketReward(market);
 

package/contracts/core/LiquidityMining/PendleGauge.sol

@@ -97,7 +97,7 @@ abstract contract PendleGauge is RewardManager, IPGauge {
 
     function _redeemExternalReward() internal virtual override {
         ISuperComposableYield(SCY).claimRewards(address(this));
-        IPGaugeController(gaugeController).redeemMarketReward();
+        IPGaugeController(gaugeController).claimMarketReward();
     }
 
     function _stakedBalance(address user) internal view virtual returns (uint256);

package/contracts/core/LiquidityMining/VotingController/PendleVotingControllerUpg.sol

@@ -7,7 +7,8 @@ import "../../../libraries/VeBalanceLib.sol";
 import "../../../libraries/math/Math.sol";
 import "../../../interfaces/IPGaugeControllerMainchain.sol";
 import "../../../interfaces/IPVotingController.sol";
-import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
 
 /*
 Voting accounting:

package/contracts/core/LiquidityMining/VotingEscrow/VotingEscrowTokenBase.sol

@@ -23,9 +23,9 @@ abstract contract VotingEscrowTokenBase is IPVeToken {
     using VeBalanceLib for VeBalance;
     using VeBalanceLib for LockedPosition;
 
-    uint128 public constant WEEK = 2 hours;
+    uint128 public constant WEEK = 1 weeks;
     uint128 public constant MAX_LOCK_TIME = 104 weeks;
-    uint128 public constant MIN_LOCK_TIME = 1 hours;
+    uint128 public constant MIN_LOCK_TIME = 1 weeks;
 
     VeBalance internal _totalSupply;
     uint128 public lastSlopeChangeAppliedAt;

package/contracts/core/Market/PendleMarketFactory.sol

@@ -17,47 +17,52 @@ contract PendleMarketFactory is BoringOwnableUpgradeable, IPMarketFactory {
 
     struct MarketConfig {
         address treasury;
-        uint88 lnFeeRateRoot;
-        uint8 reserveFeePercent;
+        uint96 lnFeeRateRoot;
         // 1 SLOT = 256 bits
+        uint8 reserveFeePercent;
+        // 1 SLOT = 8 bits
     }
 
+    uint256 private constant MIN_RATE_ORACLE_TIME_WINDOW = 300 seconds;
+
     address public immutable yieldContractFactory;
-    address public immutable marketCreationCodePointer;
+    address public marketCreationCodePointer;
     uint256 public immutable maxLnFeeRateRoot;
 
     // PT -> scalarRoot -> initialAnchor
     mapping(address => mapping(int256 => mapping(int256 => address))) internal markets;
     EnumerableSet.AddressSet internal allMarkets;
+
     address public vePendle;
     address public gaugeController;
 
     MarketConfig public marketConfig;
 
-    constructor(address _yieldContractFactory, address _marketCreationCodePointer) {
+    constructor(
+        address _yieldContractFactory
+    ) {
         require(_yieldContractFactory != address(0), "zero address");
         yieldContractFactory = _yieldContractFactory;
         maxLnFeeRateRoot = uint256(LogExpMath.ln(int256((105 * Math.IONE) / 100))); // ln(1.05)
-
-        marketCreationCodePointer = _marketCreationCodePointer;
     }
 
     function initialize(
         address _treasury,
-        uint88 _lnFeeRateRoot,
+        uint96 _lnFeeRateRoot,
         uint8 _reserveFeePercent,
         address newVePendle,
-        address newGaugeController
+        address newGaugeController,
+        bytes memory _marketCreationCode
     ) external initializer {
-        require(newVePendle != address(0) && newGaugeController != address(0), "zero address");
-
         __BoringOwnable_init();
         setTreasury(_treasury);
         setlnFeeRateRoot(_lnFeeRateRoot);
         setReserveFeePercent(_reserveFeePercent);
 
+        require(newVePendle != address(0) && newGaugeController != address(0), "zero address");
         vePendle = newVePendle;
         gaugeController = newGaugeController;
+        marketCreationCodePointer = SSTORE2Deployer.setCreationCode(_marketCreationCode);
     }
 
     /**
@@ -101,7 +106,7 @@ contract PendleMarketFactory is BoringOwnableUpgradeable, IPMarketFactory {
         _emitNewMarketConfigEvent();
     }
 
-    function setlnFeeRateRoot(uint88 newlnFeeRateRoot) public onlyOwner {
+    function setlnFeeRateRoot(uint96 newlnFeeRateRoot) public onlyOwner {
         require(newlnFeeRateRoot <= maxLnFeeRateRoot, "invalid fee rate root");
         marketConfig.lnFeeRateRoot = newlnFeeRateRoot;
         _emitNewMarketConfigEvent();

package/contracts/core/PendleRouter.sol

@@ -1,7 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.15;
 
-import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
 import "@openzeppelin/contracts/proxy/Proxy.sol";
 import "../interfaces/IPAllAction.sol";
 import "../interfaces/IPMarketSwapCallback.sol";
@@ -37,6 +38,7 @@ contract PendleRouter is Proxy, Initializable, UUPSUpgradeable, BoringOwnableUpg
     }
 
     function initialize() external initializer {
+        __UUPSUpgradeable_init();
         __BoringOwnable_init();
     }
 

package/contracts/core/YieldContracts/PendlePrincipalToken.sol

@@ -6,7 +6,7 @@ import "../../interfaces/IPYieldToken.sol";
 
 import "../PendleERC20.sol";
 import "../../libraries/helpers/MiniHelpers.sol";
-import "@openzeppelin/contracts/proxy/utils/Initializable.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 
 contract PendlePrincipalToken is PendleERC20, Initializable, IPPrincipalToken {
     address public immutable SCY;

package/contracts/core/YieldContracts/PendleYieldContractFactory.sol

@@ -44,7 +44,7 @@ contract PendleYieldContractFactory is BoringOwnableUpgradeable, IPYieldContract
     string private constant PT_PREFIX = "PT";
     string private constant YT_PREFIX = "YT";
 
-    address public immutable pendleYtCreationCodePointer;
+    address public pendleYtCreationCodePointer;
 
     // 1 SLOT
     uint128 public interestFeeRate; // a fixed point number
@@ -60,21 +60,21 @@ contract PendleYieldContractFactory is BoringOwnableUpgradeable, IPYieldContract
     mapping(address => bool) public isPT;
     mapping(address => bool) public isYT;
 
-    constructor(address _pendleYtCreationCodePointer) {
-        pendleYtCreationCodePointer = _pendleYtCreationCodePointer;
-    }
+    constructor() {}
 
     function initialize(
         uint96 _expiryDivisor,
         uint128 _interestFeeRate,
         uint128 _rewardFeeRate,
-        address _treasury
+        address _treasury,
+        bytes memory _pendleYtCreationCode
     ) external initializer {
         __BoringOwnable_init();
         setExpiryDivisor(_expiryDivisor);
         setInterestFeeRate(_interestFeeRate);
         setRewardFeeRate(_rewardFeeRate);
         setTreasury(_treasury);
+        pendleYtCreationCodePointer = SSTORE2Deployer.setCreationCode(_pendleYtCreationCode);
     }
 
     /**

package/contracts/core/actions/base/ActionBaseMintRedeem.sol

@@ -68,6 +68,7 @@ abstract contract ActionBaseMintRedeem is TokenHelper, KyberSwapHelper {
                 output.tokenRedeemScy,
                 1
             );
+            _safeApproveInf(output.tokenRedeemScy, SCY);
             _kyberswap(output.tokenRedeemScy, netTokenRedeemed, output.kybercall);
 
             netTokenOut = _selfBalance(output.tokenOut);

package/contracts/interfaces/IPGaugeController.sol

@@ -12,7 +12,7 @@ interface IPGaugeController {
 
     function pendle() external returns (address);
 
-    function redeemMarketReward() external;
+    function claimMarketReward() external;
 
     function rewardData(address pool)
         external

package/contracts/interfaces/IPMarketFactory.sol

@@ -21,7 +21,7 @@ interface IPMarketFactory {
         view
         returns (
             address treasury,
-            uint88 lnFeeRateRoot,
+            uint96 lnFeeRateRoot,
             uint8 reserveFeePercent
         );
 }

package/contracts/interfaces/ISJoe.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 pragma solidity 0.8.15;
 
-import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
 
 interface ISJoe {
     function joe() external view returns (address);
@@ -23,7 +23,7 @@ interface ISJoe {
      * @return The amount of JOE user has deposited
      * @return The reward debt for the chosen token
      */
-    function getUserInfo(address _user, IERC20 _rewardToken)
+    function getUserInfo(address _user, IERC20Upgradeable _rewardToken)
         external
         view
         returns (uint256, uint256);
@@ -42,7 +42,10 @@ interface ISJoe {
      * @param _token The address of the token
      * @return `_user`'s pending reward token
      */
-    function pendingReward(address _user, IERC20 _token) external view returns (uint256);
+    function pendingReward(address _user, IERC20Upgradeable _token)
+        external
+        view
+        returns (uint256);
 
     /**
      * @notice Withdraw JOE and harvest the rewards

package/contracts/libraries/kyberswap/KyberSwapHelper.sol

@@ -26,7 +26,6 @@ import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import "@openzeppelin/contracts/utils/Address.sol";
 import "../helpers/TokenHelper.sol";
-import "./AggregationRouterHelper.sol";
 
 struct TokenInput {
     address tokenIn;
@@ -54,14 +53,9 @@ abstract contract KyberSwapHelper is TokenHelper {
     function _kyberswap(
         address tokenIn,
         uint256 amountIn,
-        bytes calldata rawKybercall
+        bytes calldata kybercall
     ) internal {
         _safeApproveInf(tokenIn, kyberSwapRouter);
-
-        bytes memory kybercall = AggregationRouterHelper.getScaledInputData(
-            rawKybercall,
-            amountIn
-        );
         kyberSwapRouter.functionCallWithValue(kybercall, tokenIn == NATIVE ? amountIn : 0);
     }
 }

package/contracts/libraries/math/WeekMath.sol

@@ -3,7 +3,7 @@
 pragma solidity 0.8.15;
 
 library WeekMath {
-    uint128 internal constant WEEK = 2 hours;
+    uint128 internal constant WEEK = 7 days;
 
     function getWeekStartTimestamp(uint128 timestamp) internal pure returns (uint128) {
         return (timestamp / WEEK) * WEEK;

package/contracts/offchain-helpers/RouterStatic.sol

@@ -4,12 +4,12 @@ pragma solidity 0.8.15;
 import "../interfaces/IPYieldContractFactory.sol";
 import "../interfaces/IPMarketFactory.sol";
 import "./MarketMathStatic.sol";
-import "@openzeppelin/contracts/proxy/utils/Initializable.sol";
-import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
-import "../periphery/BoringOwnableUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
 
 /// EXCLUDED FROM ALL AUDITS, TO BE CALLED ONLY BY PENDLE's SDK
-contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeable {
+contract RouterStatic is OwnableUpgradeable, UUPSUpgradeable {
     using Math for uint256;
 
     struct TokenAmount {
@@ -56,7 +56,7 @@ contract RouterStatic is Initializable, BoringOwnableUpgradeable, UUPSUpgradeabl
     }
 
     function initialize() external initializer {
-        __BoringOwnable_init();
+        __Ownable_init();
     }
 
     function getDefaultApproxParams() public pure returns (ApproxParams memory) {

package/contracts/periphery/BoringOwnableUpgradeable.sol

@@ -1,14 +1,14 @@
 // SPDX-License-Identifier: MIT
 pragma solidity 0.8.15;
 
-import "@openzeppelin/contracts/proxy/utils/Initializable.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 
 contract BoringOwnableUpgradeableData {
     address public owner;
     address public pendingOwner;
 }
 
-abstract contract BoringOwnableUpgradeable is BoringOwnableUpgradeableData, Initializable {
+contract BoringOwnableUpgradeable is BoringOwnableUpgradeableData, Initializable {
     event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
 
     function __BoringOwnable_init() internal onlyInitializing {

package/contracts/periphery/PendleGovernanceManager.sol

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+contract PendleGovernanceManager {
+    address public governance;
+    address public pendingGovernance;
+
+    event GovernanceTransferred(address newGovernance, address previousGovernance);
+
+    modifier onlyGovernance() {
+        require(msg.sender == governance, "ONLY_GOVERNANCE");
+        _;
+    }
+
+    constructor(address _governance) {
+        require(_governance != address(0), "zero address");
+        governance = _governance;
+    }
+
+    /**
+     * @dev Allows the pendingGovernance address to finalize the change governance process.
+     */
+    function claimGovernance() external {
+        require(pendingGovernance == msg.sender, "FORBIDDEN");
+        emit GovernanceTransferred(pendingGovernance, governance);
+        governance = pendingGovernance;
+        pendingGovernance = address(0);
+    }
+
+    /**
+     * @dev Allows the current governance to set the pendingGovernance address.
+     * @param newGovernance The address to transfer ownership to.
+     */
+    function transferGovernance(address newGovernance) external onlyGovernance {
+        require(newGovernance != address(0), "zero address");
+        pendingGovernance = newGovernance;
+    }
+}

package/contracts/periphery/PermissionsV2Upg.sol

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.15;
+
+import "../interfaces/IPGovernanceManager.sol";
+import "../interfaces/IPPermissionsV2Upg.sol";
+
+/// This contract is upgradable because
+/// - its constructor only sets immutable variables
+/// - it has storage gaps for safe addition of future variables
+/// - it inherits only upgradable contract
+abstract contract PermissionsV2Upg is IPermissionsV2Upg {
+    address public immutable governanceManager;
+
+    uint256[100] private __gap;
+
+    modifier onlyGovernance() {
+        require(msg.sender == _governance(), "ONLY_GOVERNANCE");
+        _;
+    }
+
+    constructor(address _governanceManager) {
+        require(_governanceManager != address(0), "ZERO_ADDRESS");
+        governanceManager = _governanceManager;
+    }
+
+    function _governance() internal view returns (address) {
+        return IPGovernanceManager(governanceManager).governance();
+    }
+}

package/deployments/43113-core.json

@@ -1,16 +1,15 @@
 {
     "deployer": "0x1FcCC097db89A86Bfc474A1028F93958295b1Fb7",
-    "sstore2": "0x00E8aAE633b426cb67614f432B4604C6fA2BF101",
     "network": 43113,
     "celerBus": "0xE9533976C590200E32d95C53f06AE12d292cFc47",
     "treasury": "0xB4E292AD98Ba0D5531Ca573757f7b7d6c0C205d8",
     "PENDLE": "0x83B694f9Ef84D22BECe87257f0cd4513737A505e",
-    "yieldContractFactory": "0x2e5DF6e3DA5Ae730aC357Ca1b6a823A9B0EAFaC0",
-    "marketFactory": "0x3Ba006773B0cfd7f3549B2D4259524FCb3dCC8E2",
-    "router": "0x17C433893321F4457066045E1356e8E8B0C5F596",
-    "routerStatic": "0x8CC254DcaE3d01c4Aff79A396d94623E4D9dD2b1",
+    "yieldContractFactory": "0x38E5A1D591553b5FF18b151B587745a4A9B206d2",
+    "marketFactory": "0xE646E5425fD448b2f9dDF6de12383CcF5275143B",
+    "router": "0xa4C21f51DE870a283f362A7331f0C4f8288c3e41",
+    "routerStatic": "0xc875e3b8aED24cc54C4750D790036D631F6cacbD",
     "startTime": 1657756800,
-    "vePendle": "0xdc6aFe3Aae143f73Abc84766E9c99f18fF3c5aAe",
-    "votingController": "0x7d9Bd862090337D572c50068b40E39F76b8dFE03",
-    "gaugeController": "0xcE19aEaBE9229F8070ADe311A2d3aAf4f6864B26"
+    "vePendle": "0x3AE0fee115057cCF8A0B5255751027C26D83B912",
+    "votingController": "0x76815E13679C7F18a406f5BA94E352E656BeE378",
+    "gaugeController": "0xD9F5f311dA64645D4b38D055e1726D8B217272e7"
 }

package/deployments/43113-markets/benqi-market-10D931.json

@@ -0,0 +1,8 @@
+{
+    "symbol": "SCY-qiUSDC",
+    "SCY": "0x0930810274379bDE70534068F37562eA660de10e",
+    "expiry": 1675382400,
+    "PT": "0x30773E8c6243AD6D31B1664335d851a845fD4246",
+    "YT": "0x1cF1e47c4AFE6e0099fB51345B89408B26eAD9a7",
+    "market": "0xF0f539F6Ff098403c3034A57657dAd9b3510D931"
+}

package/deployments/43113-markets/benqi-market-9fbD64.json

@@ -0,0 +1,8 @@
+{
+    "symbol": "SCY-qiUSDC",
+    "SCY": "0x0930810274379bDE70534068F37562eA660de10e",
+    "expiry": 1663804800,
+    "PT": "0xff445E1FA4f8B5b6Ca237b21e83063eF1C3f2D53",
+    "YT": "0x0cD7b5ec16366B40bF0B95EBdD157361B4263296",
+    "market": "0x9F9C7750edABDa9a822E7ca9141511c35B9fbD64"
+}

package/deployments/43113-markets/benqi-market-A12361.json

@@ -0,0 +1,8 @@
+{
+    "symbol": "SCY-qiWETH",
+    "SCY": "0x5e243CC04e9B122B7dFA828f5f46681E4bF1Af55",
+    "expiry": 1669852800,
+    "PT": "0x393Dc55047838E3e123edecd0AC1125ACdbDC9Bd",
+    "YT": "0xCaB06ad3df61691e7B506C7F5B965510494D9CfB",
+    "market": "0x55481608A45ED862f0eC2996283ddF6967A12361"
+}

package/deployments/43113-testenv.json

@@ -1,7 +1,7 @@
 {
     "tokens": {
         "fundKeeper": "0x45e03eB183962884d50eC0Af39B03970333426cb",
-        "faucet": "0x6C881F2b27aB065c6b6fbDf1407f2895104D5856",
+        "faucet": "0x1A2775c9bEe6e798De971c369849CF9130D3e25a",
         "WAVAX": "0xe43a7aD7C09d8fAE3ADe7361f0b847b23adD5094",
         "DAI": "0xCd3748CE3Bf75A01D99Bf301668E0748558a592C",
         "USDC": "0xc2A6b8d7d0FAB3749A6Bda84cEdb58D2d58f045e",

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pendle/core-v2",
   "description": "Core smart contracts of Pendle Protocol.",
   "license": "BUSL-1.1",
-  "version": "0.11.1-testnet",
+  "version": "0.11.2-testnet",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",
@@ -25,7 +25,7 @@
   "devDependencies": {
     "@typechain/ethers-v5": "^9.0.0",
     "@typechain/hardhat": "^4.0.0",
-    "hardhat": "^2.11.0",
+    "hardhat": "^2.10.2",
     "hardhat-contract-sizer": "^2.6.1",
     "hardhat-storage-layout-diff": "^0.0.4",
     "prettier": "^2.7.1",
@@ -34,7 +34,7 @@
     "solhint": "^3.3.7",
     "ts-node": "^10.9.1",
     "typechain": "^8.1.0",
-    "typescript": "^4.8.2"
+    "typescript": "^4.7.4"
   },
   "scripts": {
     "compile": "yarn hardhat compile",
@@ -44,6 +44,7 @@
   },
   "packageManager": "yarn@3.2.2",
   "dependencies": {
-    "@openzeppelin/contracts": "^4.5.0"
+    "@openzeppelin/contracts": "^4.5.0",
+    "@openzeppelin/contracts-upgradeable": "^4.5.2"
   }
 }

package/contracts/libraries/kyberswap/AggregationRouterHelper.sol

@@ -1,308 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-pragma solidity 0.8.15;
-import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
-import "./IMultihopRouter.sol";
-
-library AggregationRouterHelper {
-    uint256 private constant _PARTIAL_FILL = 0x01;
-    uint256 private constant _REQUIRES_EXTRA_ETH = 0x02;
-    uint256 private constant _SHOULD_CLAIM = 0x04;
-    uint256 private constant _BURN_FROM_MSG_SENDER = 0x08;
-    uint256 private constant _BURN_FROM_TX_ORIGIN = 0x10;
-    uint256 private constant _SIMPLE_SWAP = 0x20;
-
-    uint256 private constant SLIPPAGE_RANGE = 10; // over 100
-
-    enum DexType {
-        UNI,
-        STABLESWAP,
-        CURVE,
-        KYBERDMM,
-        SADDLE,
-        UNIV3PROMM,
-        BALANCERV2,
-        KYBERRFQ,
-        DODO,
-        VELODROME,
-        PLATYPUS
-    }
-
-    struct SwapDescription {
-        IERC20 srcToken;
-        IERC20 dstToken;
-        address[] srcReceivers;
-        uint256[] srcAmounts;
-        address dstReceiver;
-        uint256 amount;
-        uint256 minReturnAmount;
-        uint256 flags;
-        bytes permit;
-    }
-
-    struct SimpleSwapData {
-        address[] firstPools;
-        uint256[] firstSwapAmounts;
-        bytes[] swapDatas;
-        uint256 deadline;
-        bytes destTokenFeeData;
-    }
-
-    struct SwapExecutorDescription {
-        IMultihopRouter.Swap[][] swapSequences;
-        address tokenIn;
-        address tokenOut;
-        uint256 minTotalAmountOut;
-        address to;
-        uint256 deadline;
-        bytes destTokenFeeData;
-    }
-
-    function getScaledInputData(bytes calldata kybercall, uint256 newAmount)
-        external
-        pure
-        returns (bytes memory)
-    {
-        bytes4 selector = bytes4(kybercall[:4]);
-        (
-            address caller,
-            SwapDescription memory desc,
-            bytes memory executorData,
-            bytes memory clientData
-        ) = abi.decode(kybercall[4:], (address, SwapDescription, bytes, bytes));
-
-        (desc, executorData) = _getScaledInputData(desc, executorData, newAmount);
-        return abi.encodeWithSelector(selector, caller, desc, executorData, clientData);
-    }
-
-    function _getScaledInputData(
-        SwapDescription memory desc,
-        bytes memory executorData,
-        uint256 newAmount
-    ) internal pure returns (SwapDescription memory, bytes memory) {
-        uint256 flags = desc.flags;
-        uint256 oldAmount = desc.amount;
-        if (oldAmount == newAmount) {
-            return (desc, executorData);
-        }
-
-        //if the difference of newAmount and oldAmount > 5%, revert
-        require(
-            (oldAmount * (100 - SLIPPAGE_RANGE)) / 100 <= newAmount &&
-                newAmount <= (oldAmount * (100 + SLIPPAGE_RANGE)) / 100,
-            "kyber: difference too large"
-        );
-
-        // simple mode swap
-        if (flags & _SIMPLE_SWAP != 0) {
-            require(desc.srcReceivers.length == 0, "kyber: can't scale if take fee");
-            return (
-                _getNewDescription(desc, oldAmount, newAmount),
-                _getNewSimpleSwapData(executorData, oldAmount, newAmount)
-            );
-        }
-
-        //normal mode swap
-        bytes memory newExecutorData = _getNewExecutorData(executorData, oldAmount, newAmount);
-        return (_getNewDescription(desc, oldAmount, newAmount), newExecutorData);
-    }
-
-    function _getNewDescription(
-        SwapDescription memory desc,
-        uint256 oldAmount,
-        uint256 newAmount
-    ) internal pure returns (SwapDescription memory) {
-        uint256 oldMinReturnAmount = desc.minReturnAmount;
-        desc.minReturnAmount = (desc.minReturnAmount * newAmount) / oldAmount;
-        //newMinReturnAmount should no be 0 if oldMinReturnAmount > 0
-        if (oldMinReturnAmount > 0 && desc.minReturnAmount == 0) desc.minReturnAmount = 1;
-        desc.amount = newAmount;
-        if (desc.srcReceivers.length == 0) {
-            return desc;
-        }
-
-        uint256 newTotal;
-        for (uint256 i = 0; i < desc.srcReceivers.length; i++) {
-            if (i == desc.srcReceivers.length - 1) {
-                desc.srcAmounts[i] = newAmount - newTotal;
-            } else {
-                desc.srcAmounts[i] = (desc.srcAmounts[i] * newAmount) / oldAmount;
-            }
-            newTotal += desc.srcAmounts[i];
-        }
-        return desc;
-    }
-
-    function _getNewSimpleSwapData(
-        bytes memory data,
-        uint256 oldAmount,
-        uint256 newAmount
-    ) internal pure returns (bytes memory) {
-        SimpleSwapData memory swapData = abi.decode(data, (SimpleSwapData));
-        uint256 numberSeq = swapData.firstPools.length;
-        uint256 newTotalSwapAmount;
-        for (uint256 i = 0; i < numberSeq; i++) {
-            if (i == numberSeq - 1) {
-                swapData.firstSwapAmounts[i] = newAmount - newTotalSwapAmount;
-            } else {
-                swapData.firstSwapAmounts[i] =
-                    (swapData.firstSwapAmounts[i] * newAmount) /
-                    oldAmount;
-            }
-            newTotalSwapAmount += swapData.firstSwapAmounts[i];
-        }
-        return abi.encode(swapData);
-    }
-
-    function _getNewExecutorData(
-        bytes memory data,
-        uint256 oldAmount,
-        uint256 newAmount
-    ) internal pure returns (bytes memory) {
-        SwapExecutorDescription memory swapExecutorDescription = abi.decode(
-            data,
-            (SwapExecutorDescription)
-        );
-        swapExecutorDescription.minTotalAmountOut =
-            (swapExecutorDescription.minTotalAmountOut * newAmount) /
-            oldAmount;
-
-        uint256 newTotalSwapAmount;
-        for (uint256 i = 0; i < swapExecutorDescription.swapSequences.length; i++) {
-            IMultihopRouter.Swap memory swap = swapExecutorDescription.swapSequences[i][0];
-            uint8 dexType = uint8(swap.dexOption >> 8);
-            uint256 value;
-            if (i == swapExecutorDescription.swapSequences.length - 1)
-                value = newAmount - newTotalSwapAmount;
-
-            if (dexType == uint8(DexType.UNI)) {
-                (swap.data, value) = _newUniSwap(swap.data, value, oldAmount, newAmount);
-            } else if (dexType == uint8(DexType.STABLESWAP) || dexType == uint8(DexType.SADDLE)) {
-                (swap.data, value) = _newStableSwap(swap.data, value, oldAmount, newAmount);
-            } else if (dexType == uint8(DexType.CURVE)) {
-                (swap.data, value) = _newCurveSwap(swap.data, value, oldAmount, newAmount);
-            } else if (dexType == uint8(DexType.KYBERDMM)) {
-                (swap.data, value) = _newKyberDMMSwap(swap.data, value, oldAmount, newAmount);
-            } else if (dexType == uint8(DexType.UNIV3PROMM)) {
-                (swap.data, value) = _newUniV3ProMMSwap(swap.data, value, oldAmount, newAmount);
-            } else if (dexType == uint8(DexType.BALANCERV2)) {
-                (swap.data, value) = _newBalancerV2Swap(swap.data, value, oldAmount, newAmount);
-            } else if (dexType == uint8(DexType.KYBERRFQ)) {
-                revert("kyber: can't scale kyberrfq");
-            } else if (dexType == uint8(DexType.DODO)) {
-                (swap.data, value) = _newDODOSwap(swap.data, value, oldAmount, newAmount);
-            } else if (dexType == uint8(DexType.VELODROME)) {
-                (swap.data, value) = _newVelodromeSwap(swap.data, value, oldAmount, newAmount);
-            } else {
-                revert("AggregationExecutor: Dex type not supported");
-            }
-            newTotalSwapAmount += value;
-        }
-        return abi.encode(swapExecutorDescription);
-    }
-
-    function _newUniSwap(
-        bytes memory data,
-        uint256 value,
-        uint256 oldAmount,
-        uint256 newAmount
-    ) internal pure returns (bytes memory, uint256) {
-        IMultihopRouter.UniSwap memory uniSwap = abi.decode(data, (IMultihopRouter.UniSwap));
-        if (value > 0) uniSwap.collectAmount = value;
-        else uniSwap.collectAmount = (uniSwap.collectAmount * newAmount) / oldAmount;
-        return (abi.encode(uniSwap), uniSwap.collectAmount);
-    }
-
-    function _newStableSwap(
-        bytes memory data,
-        uint256 value,
-        uint256 oldAmount,
-        uint256 newAmount
-    ) internal pure returns (bytes memory, uint256) {
-        IMultihopRouter.StableSwap memory stableSwap = abi.decode(
-            data,
-            (IMultihopRouter.StableSwap)
-        );
-        if (value > 0) stableSwap.dx = value;
-        else stableSwap.dx = (stableSwap.dx * newAmount) / oldAmount;
-        return (abi.encode(stableSwap), stableSwap.dx);
-    }
-
-    function _newCurveSwap(
-        bytes memory data,
-        uint256 value,
-        uint256 oldAmount,
-        uint256 newAmount
-    ) internal pure returns (bytes memory, uint256) {
-        IMultihopRouter.CurveSwap memory curveSwap = abi.decode(data, (IMultihopRouter.CurveSwap));
-        if (value > 0) curveSwap.dx = value;
-        else curveSwap.dx = (curveSwap.dx * newAmount) / oldAmount;
-        return (abi.encode(curveSwap), curveSwap.dx);
-    }
-
-    function _newKyberDMMSwap(
-        bytes memory data,
-        uint256 value,
-        uint256 oldAmount,
-        uint256 newAmount
-    ) internal pure returns (bytes memory, uint256) {
-        IMultihopRouter.UniSwap memory kyberDMMSwap = abi.decode(data, (IMultihopRouter.UniSwap));
-        if (value > 0) kyberDMMSwap.collectAmount = value;
-        else kyberDMMSwap.collectAmount = (kyberDMMSwap.collectAmount * newAmount) / oldAmount;
-        return (abi.encode(kyberDMMSwap), kyberDMMSwap.collectAmount);
-    }
-
-    function _newUniV3ProMMSwap(
-        bytes memory data,
-        uint256 value,
-        uint256 oldAmount,
-        uint256 newAmount
-    ) internal pure returns (bytes memory, uint256) {
-        IMultihopRouter.UniSwapV3ProMM memory uniSwapV3ProMM = abi.decode(
-            data,
-            (IMultihopRouter.UniSwapV3ProMM)
-        );
-        if (value > 0) uniSwapV3ProMM.swapAmount = value;
-        else uniSwapV3ProMM.swapAmount = (uniSwapV3ProMM.swapAmount * newAmount) / oldAmount;
-        return (abi.encode(uniSwapV3ProMM), uniSwapV3ProMM.swapAmount);
-    }
-
-    function _newBalancerV2Swap(
-        bytes memory data,
-        uint256 value,
-        uint256 oldAmount,
-        uint256 newAmount
-    ) internal pure returns (bytes memory, uint256) {
-        IMultihopRouter.BalancerV2 memory balancerV2 = abi.decode(
-            data,
-            (IMultihopRouter.BalancerV2)
-        );
-        if (value > 0) balancerV2.amount = value;
-        else balancerV2.amount = (balancerV2.amount * newAmount) / oldAmount;
-        return (abi.encode(balancerV2, balancerV2.amount), balancerV2.amount);
-    }
-
-    function _newDODOSwap(
-        bytes memory data,
-        uint256 value,
-        uint256 oldAmount,
-        uint256 newAmount
-    ) internal pure returns (bytes memory, uint256) {
-        IMultihopRouter.DODO memory dodo = abi.decode(data, (IMultihopRouter.DODO));
-        if (value > 0) dodo.amount = value;
-        else dodo.amount = (dodo.amount * newAmount) / oldAmount;
-        return (abi.encode(dodo), dodo.amount);
-    }
-
-    function _newVelodromeSwap(
-        bytes memory data,
-        uint256 value,
-        uint256 oldAmount,
-        uint256 newAmount
-    ) internal pure returns (bytes memory, uint256) {
-        IMultihopRouter.UniSwap memory velodrome = abi.decode(data, (IMultihopRouter.UniSwap));
-        if (value > 0) velodrome.collectAmount = value;
-        else velodrome.collectAmount = (velodrome.collectAmount * newAmount) / oldAmount;
-        return (abi.encode(velodrome), velodrome.collectAmount);
-    }
-}

package/contracts/libraries/kyberswap/IMultihopRouter.sol

@@ -1,139 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-pragma solidity >=0.7.6;
-
-pragma abicoder v2;
-
-interface IMultihopRouter {
-    enum DexType {
-        UNI,
-        STABLESWAP,
-        CURVE,
-        KYBERDMM,
-        SADDLE,
-        UNIV3PROMM,
-        BALANCERV2,
-        KYBERRFQ,
-        DODO,
-        VELODROME,
-        PLATYPUS
-    }
-
-    event Exchange(address pair, uint256 amountOut, address output);
-    struct Swap {
-        bytes data;
-        //dexType:
-        //  0: uni
-        //  1: stable swap
-        //  2: curve
-        //  3: kyber dmm
-        //  4: saddle
-        //  5: univ3 or kyber ProMM
-        //  6: balancerv2
-        //  7: kyber RFQ
-        //  8: dodo
-        //  9: velodrome
-        //  10: platypus
-        //dexId:
-        //  0: firebird
-        uint16 dexOption; //dexType(8bit) + dexId(8bit)
-    }
-
-    struct UniSwap {
-        address pool;
-        address tokenIn;
-        address tokenOut;
-        address recipient;
-        uint256 collectAmount; // amount that should be transferred to the pool
-        uint256 limitReturnAmount;
-    }
-
-    struct StableSwap {
-        address pool;
-        address tokenFrom;
-        address tokenTo;
-        uint8 tokenIndexFrom;
-        uint8 tokenIndexTo;
-        uint256 dx;
-        uint256 minDy;
-        uint256 poolLength;
-        address poolLp;
-    }
-
-    struct CurveSwap {
-        address pool;
-        address tokenFrom;
-        address tokenTo;
-        int128 tokenIndexFrom;
-        int128 tokenIndexTo;
-        uint256 dx;
-        uint256 minDy;
-        bool usePoolUnderlying;
-        bool useTriCrypto;
-    }
-
-    struct UniSwapV3ProMM {
-        address recipient;
-        address pool;
-        address tokenIn;
-        address tokenOut;
-        uint256 swapAmount;
-        uint256 limitReturnAmount;
-        uint160 sqrtPriceLimitX96;
-        bool isUniV3; // true = UniV3, false = ProMM
-    }
-    struct SwapCallbackData {
-        bytes path;
-        address payer;
-    }
-    struct SwapCallbackDataPath {
-        address pool;
-        address tokenIn;
-        address tokenOut;
-    }
-
-    struct BalancerV2 {
-        address vault;
-        bytes32 poolId;
-        address assetIn;
-        address assetOut;
-        uint256 amount;
-        uint256 limit;
-    }
-
-    struct KyberRFQ {
-        address rfq;
-        bytes order;
-        bytes signature;
-        uint256 amount;
-        address payable target;
-    }
-
-    struct DODO {
-        address recipient;
-        address pool;
-        address tokenFrom;
-        address tokenTo;
-        uint256 amount;
-        uint256 minReceiveQuote;
-        address sellHelper;
-        bool isSellBase;
-        bool isVersion2;
-    }
-
-    function factory() external view returns (address);
-
-    function formula() external view returns (address);
-
-    function WETH() external view returns (address);
-
-    function multihopBatchSwapExactIn(
-        Swap[][] memory swapSequences,
-        address tokenIn,
-        address tokenOut,
-        uint256 minTotalAmountOut,
-        address to,
-        uint256 deadline,
-        bytes memory destTokenFeeData
-    ) external payable returns (uint256 totalAmountOut);
-}

package/contracts/offchain-helpers/SSTORE2DeployerContract.sol

@@ -1,21 +0,0 @@
-// SPDX-License-Identifier: GPL-3.0-or-later
-pragma solidity 0.8.15;
-import "../libraries/helpers/SSTORE2Deployer.sol";
-import "../periphery/BoringOwnableUpgradeable.sol";
-
-contract SSTORE2DeployerContract is BoringOwnableUpgradeable {
-    event Deployed(string name, address addr);
-
-    constructor() {
-        __BoringOwnable_init();
-    }
-
-    function deploy(string memory name, bytes calldata creationCode)
-        external
-        onlyOwner
-        returns (address res)
-    {
-        res = SSTORE2Deployer.setCreationCode(creationCode);
-        emit Deployed(name, res);
-    }
-}

package/deployments/43113-markets/benqi-market-QI-USDC-FEB-2ND.json

@@ -1,8 +0,0 @@
-{
-    "symbol": "SCY-qiUSDC",
-    "SCY": "0xe41eebdC5124693cD9C18162D375590273a911Ed",
-    "expiry": 1675382400,
-    "PT": "0xF8F6ca86D40A8a9FFc0aC2D9F96a1A439b5535A8",
-    "YT": "0x924b41c12FE9b9DAA311E0e0B050C16538c70283",
-    "market": "0x485991210C8ec45644588EC1f4957d3d0aA0cE39"
-}

package/deployments/43113-markets/benqi-market-QI-USDC-SEP-22TH.json

@@ -1,8 +0,0 @@
-{
-    "symbol": "SCY-qiUSDC",
-    "SCY": "0xe41eebdC5124693cD9C18162D375590273a911Ed",
-    "expiry": 1663804800,
-    "PT": "0x549b110782B89bd40018c12BC1770Cc55e6a2267",
-    "YT": "0x80F8302a86775A810c2233e3AbE62990f7cc1051",
-    "market": "0x6b2CC53E2c08b9054D00a4a84bf22462a18A249f"
-}

package/deployments/43113-markets/benqi-market-QI-WETH-DEC-1ST.json

@@ -1,8 +0,0 @@
-{
-    "symbol": "SCY-qiWETH",
-    "SCY": "0x92A502318c1d77f3b2eFCb1BD8ee625Ad206A8d5",
-    "expiry": 1669852800,
-    "PT": "0x59E95f6f2191bc7dB730a3125cB76c3a4A35a835",
-    "YT": "0xf400888C27f134E8cd6313E33d10d2526dec8697",
-    "market": "0xbF23860F807Dbc7678Cf53be78D06A14A5c36D16"
-}