@pendle/core-v2 0.21.0-testnet → 1.0.1-mainnet

package/contracts/router/kyberswap/AggregationRouterHelper.sol

@@ -1,19 +1,12 @@
-// SPDX-License-Identifier: MIT
+// SPDX-License-Identifier: GPL-3.0-or-later
 
 pragma solidity 0.8.17;
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "./IMultihopRouter.sol";
+import "./IAggregatorRouterHelper.sol";
 import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
 import "../../core/libraries/BoringOwnableUpgradeable.sol";
 
-import "../../interfaces/IWETH.sol";
-
-import "./interfaces/IMetaAggregationRouter.sol";
-import "./interfaces/IMetaAggregationRouterV2.sol";
-import "./interfaces/IHashflow.sol";
-import "./interfaces/IExecutorHelperEthereum1.sol";
-
-import "./IAggregatorRouterHelper.sol";
-import "./ScaleDataHelperEthereum1.sol";
-
 contract AggregationRouterHelper is
     IAggregationRouterHelper,
     Initializable,
@@ -27,6 +20,8 @@ contract AggregationRouterHelper is
     uint256 private constant _BURN_FROM_TX_ORIGIN = 0x10;
     uint256 private constant _SIMPLE_SWAP = 0x20;
 
+    uint256 private constant SLIPPAGE_RANGE = 10; // over 100
+
     constructor() initializer {}
 
     function initialize() external initializer {
@@ -35,9 +30,30 @@ contract AggregationRouterHelper is
 
     function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
 
-    struct Swap {
-        bytes data;
-        bytes4 selector;
+    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 {
@@ -49,7 +65,7 @@ contract AggregationRouterHelper is
     }
 
     struct SwapExecutorDescription {
-        Swap[][] swapSequences;
+        IMultihopRouter.Swap[][] swapSequences;
         address tokenIn;
         address tokenOut;
         uint256 minTotalAmountOut;
@@ -64,129 +80,47 @@ contract AggregationRouterHelper is
         returns (bytes memory)
     {
         bytes4 selector = bytes4(kybercall[:4]);
-
-        if (selector == IWETH.deposit.selector) {
-            return kybercall; // no scaling needed
-        }
-
-        if (selector == IWETH.withdraw.selector) {
-            return abi.encodeWithSelector(selector, newAmount);
-        }
-
-        if (
-            selector == IMetaAggregationRouter.swap.selector ||
-            selector == IMetaAggregationRouter.swapSimpleMode.selector
-        ) {
-            (
-                address callTarget,
-                IMetaAggregationRouter.SwapDescription memory desc,
-                bytes memory targetData,
-                bytes memory clientData
-            ) = abi.decode(
-                    kybercall[4:],
-                    (address, IMetaAggregationRouter.SwapDescription, bytes, bytes)
-                );
-
-            (desc, targetData) = _getScaledInputDataV1(
-                desc,
-                targetData,
-                newAmount,
-                selector == IMetaAggregationRouter.swapSimpleMode.selector ||
-                    _flagsChecked(desc.flags, _SIMPLE_SWAP)
-            );
-            return abi.encodeWithSelector(selector, callTarget, desc, targetData, clientData);
-        }
-
-        if (selector == IMetaAggregationRouterV2.swap.selector) {
-            IMetaAggregationRouterV2.SwapExecutionParams memory params = abi.decode(
-                kybercall[4:],
-                (IMetaAggregationRouterV2.SwapExecutionParams)
-            );
-
-            (params.desc, params.targetData) = _getScaledInputDataV2(
-                params.desc,
-                params.targetData,
-                newAmount,
-                _flagsChecked(params.desc.flags, _SIMPLE_SWAP)
-            );
-            return abi.encodeWithSelector(selector, params);
-        }
-
-        if (selector == IMetaAggregationRouterV2.swapSimpleMode.selector) {
-            (
-                address callTarget,
-                IMetaAggregationRouterV2.SwapDescriptionV2 memory desc,
-                bytes memory targetData,
-                bytes memory clientData
-            ) = abi.decode(
-                    kybercall[4:],
-                    (address, IMetaAggregationRouterV2.SwapDescriptionV2, bytes, bytes)
-                );
-
-            (desc, targetData) = _getScaledInputDataV2(desc, targetData, newAmount, true);
-            return abi.encodeWithSelector(selector, callTarget, desc, targetData, clientData);
-        }
-
-        revert("InputScalingHelper: Invalid selector");
+        (
+            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 _getScaledInputDataV1(
-        IMetaAggregationRouter.SwapDescription memory desc,
+    function _getScaledInputData(
+        SwapDescription memory desc,
         bytes memory executorData,
-        uint256 newAmount,
-        bool isSimpleMode
-    ) internal pure returns (IMetaAggregationRouter.SwapDescription memory, bytes memory) {
-        uint256 oldAmount = desc.amount;
-        if (oldAmount == newAmount) {
-            return (desc, executorData);
-        }
-
-        // simple mode swap
-        if (isSimpleMode) {
-            return (
-                _scaledSwapDescriptionV1(desc, oldAmount, newAmount),
-                _scaledSimpleSwapData(executorData, oldAmount, newAmount)
-            );
-        }
-
-        //normal mode swap
-        return (
-            _scaledSwapDescriptionV1(desc, oldAmount, newAmount),
-            _scaledExecutorCallBytesData(executorData, oldAmount, newAmount)
-        );
-    }
-
-    function _getScaledInputDataV2(
-        IMetaAggregationRouterV2.SwapDescriptionV2 memory desc,
-        bytes memory executorData,
-        uint256 newAmount,
-        bool isSimpleMode
-    ) internal pure returns (IMetaAggregationRouterV2.SwapDescriptionV2 memory, bytes memory) {
+        uint256 newAmount
+    ) internal pure returns (SwapDescription memory, bytes memory) {
+        uint256 flags = desc.flags;
         uint256 oldAmount = desc.amount;
         if (oldAmount == newAmount) {
             return (desc, executorData);
         }
 
         // simple mode swap
-        if (isSimpleMode) {
+        if (flags & _SIMPLE_SWAP != 0) {
+            require(desc.srcReceivers.length == 0, "kyber: can't scale if take fee");
             return (
-                _scaledSwapDescriptionV2(desc, oldAmount, newAmount),
-                _scaledSimpleSwapData(executorData, oldAmount, newAmount)
+                _getNewDescription(desc, oldAmount, newAmount),
+                _getNewSimpleSwapData(executorData, oldAmount, newAmount)
             );
         }
 
         //normal mode swap
-        return (
-            _scaledSwapDescriptionV2(desc, oldAmount, newAmount),
-            _scaledExecutorCallBytesData(executorData, oldAmount, newAmount)
-        );
+        bytes memory newExecutorData = _getNewExecutorData(executorData, oldAmount, newAmount);
+        return (_getNewDescription(desc, oldAmount, newAmount), newExecutorData);
     }
 
-    function _scaledSwapDescriptionV1(
-        IMetaAggregationRouter.SwapDescription memory desc,
+    function _getNewDescription(
+        SwapDescription memory desc,
         uint256 oldAmount,
         uint256 newAmount
-    ) internal pure returns (IMetaAggregationRouter.SwapDescription memory) {
+    ) internal pure returns (SwapDescription memory) {
         uint256 oldMinReturnAmount = desc.minReturnAmount;
         desc.minReturnAmount = (desc.minReturnAmount * newAmount) / oldAmount;
         //newMinReturnAmount should no be 0 if oldMinReturnAmount > 0
@@ -208,7 +142,7 @@ contract AggregationRouterHelper is
         return desc;
     }
 
-    function _scaledSimpleSwapData(
+    function _getNewSimpleSwapData(
         bytes memory data,
         uint256 oldAmount,
         uint256 newAmount
@@ -229,91 +163,155 @@ contract AggregationRouterHelper is
         return abi.encode(swapData);
     }
 
-    function _scaledExecutorCallBytesData(
+    function _getNewExecutorData(
         bytes memory data,
         uint256 oldAmount,
         uint256 newAmount
     ) internal pure returns (bytes memory) {
-        SwapExecutorDescription memory executorDesc = abi.decode(data, (SwapExecutorDescription));
-        executorDesc.minTotalAmountOut = (executorDesc.minTotalAmountOut * newAmount) / oldAmount;
-        for (uint256 i = 0; i < executorDesc.swapSequences.length; i++) {
-            Swap memory swap = executorDesc.swapSequences[i][0];
-            bytes4 selector = swap.selector;
+        SwapExecutorDescription memory swapExecutorDescription = abi.decode(
+            data,
+            (SwapExecutorDescription)
+        );
+        swapExecutorDescription.minTotalAmountOut =
+            (swapExecutorDescription.minTotalAmountOut * newAmount) /
+            oldAmount;
 
-            if (selector == IExecutorHelperEthereum1.executeUniSwap.selector) {
-                swap.data = ScaleDataHelperEthereum1.newUniSwap(swap.data, oldAmount, newAmount);
-            } else if (selector == IExecutorHelperEthereum1.executeStableSwap.selector) {
-                swap.data = ScaleDataHelperEthereum1.newStableSwap(
-                    swap.data,
-                    oldAmount,
-                    newAmount
-                );
-            } else if (selector == IExecutorHelperEthereum1.executeCurveSwap.selector) {
-                swap.data = ScaleDataHelperEthereum1.newCurveSwap(swap.data, oldAmount, newAmount);
-            } else if (selector == IExecutorHelperEthereum1.executeKyberDMMSwap.selector) {
-                swap.data = ScaleDataHelperEthereum1.newKyberDMM(swap.data, oldAmount, newAmount);
-            } else if (selector == IExecutorHelperEthereum1.executeUniV3ProMMSwap.selector) {
-                swap.data = ScaleDataHelperEthereum1.newUniV3ProMM(
-                    swap.data,
-                    oldAmount,
-                    newAmount
-                );
-            } else if (selector == IExecutorHelperEthereum1.executeRfqSwap.selector) {
-                revert("InputScalingHelper: Can not scale RFQ swap");
-            } else if (selector == IExecutorHelperEthereum1.executeBalV2Swap.selector) {
-                swap.data = ScaleDataHelperEthereum1.newBalancerV2(
-                    swap.data,
-                    oldAmount,
-                    newAmount
-                );
-            } else if (selector == IExecutorHelperEthereum1.executeDODOSwap.selector) {
-                swap.data = ScaleDataHelperEthereum1.newDODO(swap.data, oldAmount, newAmount);
-            } else if (selector == IExecutorHelperEthereum1.executeWrappedstETHSwap.selector) {
-                swap.data = ScaleDataHelperEthereum1.newWrappedstETHSwap(
-                    swap.data,
-                    oldAmount,
-                    newAmount
-                );
-            } else if (selector == IExecutorHelperEthereum1.executeSynthetixSwap.selector) {
-                swap.data = ScaleDataHelperEthereum1.newSynthetix(swap.data, oldAmount, newAmount);
-            } else if (selector == IExecutorHelperEthereum1.executePSMSwap.selector) {
-                swap.data = ScaleDataHelperEthereum1.newPSM(swap.data, oldAmount, newAmount);
-            } else if (selector == IExecutorHelperEthereum1.executeHashflowSwap.selector) {
-                revert("InputScalingHelper: Can not scale RFQ swap");
-            } else if (selector == IExecutorHelperEthereum1.executeFraxSwap.selector) {
-                swap.data = ScaleDataHelperEthereum1.newFrax(swap.data, oldAmount, newAmount);
-            } else revert("AggregationExecutor: Dex type not supported");
+        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(executorDesc);
+        return abi.encode(swapExecutorDescription);
     }
 
-    function _scaledSwapDescriptionV2(
-        IMetaAggregationRouterV2.SwapDescriptionV2 memory desc,
+    function _newUniSwap(
+        bytes memory data,
+        uint256 value,
         uint256 oldAmount,
         uint256 newAmount
-    ) internal pure returns (IMetaAggregationRouterV2.SwapDescriptionV2 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;
-        }
+    ) 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);
+    }
 
-        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 _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 _flagsChecked(uint256 number, uint256 flag) internal pure returns (bool) {
-        return number & flag != 0;
+    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/router/kyberswap/IMultihopRouter.sol

@@ -0,0 +1,139 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+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/deployments/1-core.json

@@ -0,0 +1,29 @@
+{
+    "deployer": "0x1FcCC097db89A86Bfc474A1028F93958295b1Fb7",
+    "network": {
+        "chainId": 1,
+        "treasury": "0x8270400d528c34e1596EF367eeDEc99080A1b592",
+        "governance": "0x8119EC16F0573B7dAc7C0CB94EB504FB32456ee1",
+        "pendle": "0x808507121b80c02388fad14726482e061b8da827",
+        "lzEndpoint": "0x66A71Dcef29A0fFBDBE3c6a460a3B5BC225Cd675",
+        "wrappedNative": "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
+        "initialRewardFee": "30000000000000000",
+        "initialInterestFee": "30000000000000000",
+        "initialFeeRateRoot": "999500333083533",
+        "initialReserveFeePercent": "80",
+        "initialPendlePerSec": "826719576719576719",
+        "safeWaitTime": 15000
+    },
+    "baseCodeSplitter": "0x35878C2Cff38cC4032E85283183428170BA618A2",
+    "PENDLE": "0x808507121b80c02388fad14726482e061b8da827",
+    "yieldContractFactory": "0x70ee0A6DB4F5a2Dc4d9c0b57bE97B9987e75BAFD",
+    "marketFactory": "0x27b1dAcd74688aF24a64BD3C9C1B143118740784",
+    "bulkSellerFactory": "0x4B1da107B50529d53e5C906a79eaEcDCbC0E1dE3",
+    "bulkSellerOffchain": "0x9ACc60F915dFcd190D270fc92567aE71776bd320",
+    "router": "0x41FAD93F225b5C1C95f2445A5d7fcB85bA46713f",
+    "routerStatic": "0xcF45b92cd0B0859FC42a767fAac2354909f937e9",
+    "vePendle": "0x4f30A9D41B80ecC5B94306AB4364951AE3170210",
+    "senderEndpoint": "0x07b1014c88f14C9E910092526db57A20052E989F",
+    "votingController": "0x44087E105137a5095c008AaB6a6530182821F2F0",
+    "gaugeController": "0x47D74516B33eD5D70ddE7119A40839f6Fcc24e57"
+}

package/deployments/1-markets/FRAXUSDC-CURVELP-MARCH30.json

@@ -0,0 +1,11 @@
+{
+    "name": "SY FRAXUSDC_CurveLP Convex",
+    "SY": "0xD393D1dDd6B8811A86D925F5E14014282581bC04",
+    "YT": "0xC5Cd692e9b4622ab8Cdb57C83A0f99f874A169Cd",
+    "PT": "0x5fe30Ac5cb1aBB0e44CdffB2916c254AEb368650",
+    "market": "0x7b246B8dBC2a640BF2D8221890cEe8327fC23917",
+    "expiry": 1680134400,
+    "bulkSeller": "0xBb05ce1299467a2C4c43090c162f170892C30b7A",
+    "scalarRoot": "27800000000000000000",
+    "initAnchor": "1010699999000000000"
+}

package/deployments/1-markets/LOOKS-STAKING-MARCH30.json

@@ -0,0 +1,10 @@
+{
+    "name": "SY LOOKS Staking",
+    "SY": "0x35C16314D6Ee4753289E5cC15A5C5E1Dd4eaD345",
+    "YT": "0xC20dc81e8844F8fF154A67003849cEA8e951dEdc",
+    "PT": "0x293811f161fBFea8f417e222B226BB821548Ba63",
+    "market": "0x44474D98d1484C26E8d296a43a721998731Cf775",
+    "expiry": 1680134400,
+    "scalarRoot": "2200000000000000000",
+    "initAnchor": "1151500000000000000"
+}

package/deployments/1-markets/STETH-JUNE29.json

@@ -0,0 +1,10 @@
+{
+    "name": "SY stETH",
+    "SY": "0xcbC72d92b2dc8187414F6734718563898740C0BC",
+    "YT": "0x0D459a3287Afec25c0580691e9944d65fEaBb155",
+    "PT": "0xb3b61D1587C05eADEC579b616c45939F19435703",
+    "market": "0x9eC4c502D989F04FfA9312C9D6E3F872EC91A0F9",
+    "expiry": 1687996800,
+    "scalarRoot": "21900000000000000000",
+    "initAnchor": "1035400000000000000"
+}