@pendle/core-v2 1.4.0-mainnet → 1.4.1-testnet

package/contracts/router/swap-aggregator/kyberswap/arbitrum/ScaleDataHelperArbitrum.sol

@@ -0,0 +1,135 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.17;
+
+import { IExecutorHelper1 } from "./IExecutorHelper1.sol";
+
+library ScaleDataHelperArbitrum {
+    function newUniSwap(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        IExecutorHelper1.UniSwap memory uniSwap = abi.decode(data, (IExecutorHelper1.UniSwap));
+        uniSwap.collectAmount = (uniSwap.collectAmount * newAmount) / oldAmount;
+        return abi.encode(uniSwap);
+    }
+
+    function newStableSwap(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        IExecutorHelper1.StableSwap memory stableSwap = abi.decode(
+            data,
+            (IExecutorHelper1.StableSwap)
+        );
+        stableSwap.dx = (stableSwap.dx * newAmount) / oldAmount;
+        return abi.encode(stableSwap);
+    }
+
+    function newCurveSwap(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        IExecutorHelper1.CurveSwap memory curveSwap = abi.decode(
+            data,
+            (IExecutorHelper1.CurveSwap)
+        );
+        curveSwap.dx = (curveSwap.dx * newAmount) / oldAmount;
+        return abi.encode(curveSwap);
+    }
+
+    function newKyberDMM(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        IExecutorHelper1.UniSwap memory kyberDMMSwap = abi.decode(
+            data,
+            (IExecutorHelper1.UniSwap)
+        );
+        kyberDMMSwap.collectAmount = (kyberDMMSwap.collectAmount * newAmount) / oldAmount;
+        return abi.encode(kyberDMMSwap);
+    }
+
+    function newUniV3ProMM(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        IExecutorHelper1.UniSwapV3ProMM memory uniSwapV3ProMM = abi.decode(
+            data,
+            (IExecutorHelper1.UniSwapV3ProMM)
+        );
+        uniSwapV3ProMM.swapAmount = (uniSwapV3ProMM.swapAmount * newAmount) / oldAmount;
+
+        return abi.encode(uniSwapV3ProMM);
+    }
+
+    function newBalancerV2(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        IExecutorHelper1.BalancerV2 memory balancerV2 = abi.decode(
+            data,
+            (IExecutorHelper1.BalancerV2)
+        );
+        balancerV2.amount = (balancerV2.amount * newAmount) / oldAmount;
+        return abi.encode(balancerV2);
+    }
+
+    function newDODO(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        IExecutorHelper1.DODO memory dodo = abi.decode(data, (IExecutorHelper1.DODO));
+        dodo.amount = (dodo.amount * newAmount) / oldAmount;
+        return abi.encode(dodo);
+    }
+
+    function newVelodrome(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        IExecutorHelper1.UniSwap memory velodrome = abi.decode(data, (IExecutorHelper1.UniSwap));
+        velodrome.collectAmount = (velodrome.collectAmount * newAmount) / oldAmount;
+        return abi.encode(velodrome);
+    }
+
+    function newGMX(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        IExecutorHelper1.GMX memory gmx = abi.decode(data, (IExecutorHelper1.GMX));
+        gmx.amount = (gmx.amount * newAmount) / oldAmount;
+        return abi.encode(gmx);
+    }
+
+    function newSynthetix(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        IExecutorHelper1.Synthetix memory synthetix = abi.decode(
+            data,
+            (IExecutorHelper1.Synthetix)
+        );
+        synthetix.sourceAmount = (synthetix.sourceAmount * newAmount) / oldAmount;
+        return abi.encode(synthetix);
+    }
+
+    function newCamelot(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        IExecutorHelper1.UniSwap memory camelot = abi.decode(data, (IExecutorHelper1.UniSwap));
+        camelot.collectAmount = (camelot.collectAmount * newAmount) / oldAmount;
+        return abi.encode(camelot);
+    }
+}

package/contracts/router/swap-aggregator/kyberswap/ethereum/IAggregationExecutor.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.6.12;
+
+interface IAggregationExecutor {
+    function callBytes(bytes calldata data) external payable; // 0xd9c45357
+
+    // callbytes per swap sequence
+    function swapSingleSequence(bytes calldata data) external;
+
+    function finalTransactionProcessing(
+        address tokenIn,
+        address tokenOut,
+        address to,
+        bytes calldata destTokenFeeData
+    ) external;
+}

package/contracts/router/{kyberswap/interfaces → swap-aggregator/kyberswap/ethereum}/IExecutorHelperEthereum1.sol

@@ -182,4 +182,10 @@ interface IExecutorHelperEthereum1 {
         bytes memory data,
         uint256 previousAmountOut
     ) external payable returns (uint256);
+
+    function executeFraxSwap(
+        uint256 index,
+        bytes memory data,
+        uint256 previousAmountOut
+    ) external payable returns (uint256);
 }

package/contracts/router/swap-aggregator/kyberswap/ethereum/IHashflow.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.8.17;
+
+interface IHashflow {
+    enum RFQType {
+        TAKER,
+        MAKER
+    }
+
+    struct Quote {
+        RFQType rfqType;
+        address pool;
+        address eoa;
+        address trader;
+        address effectiveTrader;
+        address baseToken;
+        address quoteToken;
+        uint256 effectiveBaseTokenAmount;
+        uint256 maxBaseTokenAmount;
+        uint256 maxQuoteTokenAmount;
+        uint256 fees;
+        uint256 quoteExpiry;
+        uint256 nonce;
+        bytes32 txid;
+        bytes signedQuote;
+    }
+
+    function tradeSingleHop(Quote memory quote) external payable;
+}

package/contracts/router/{kyberswap/interfaces → swap-aggregator/kyberswap/ethereum}/IMetaAggregationRouterV2.sol

@@ -28,10 +28,9 @@ interface IMetaAggregationRouterV2 {
         bytes clientData;
     }
 
-    function swap(SwapExecutionParams calldata execution)
-        external
-        payable
-        returns (uint256, uint256);
+    function swap(
+        SwapExecutionParams calldata execution
+    ) external payable returns (uint256, uint256);
 
     function swapSimpleMode(
         IAggregationExecutor caller,

package/contracts/router/{kyberswap/AggregationRouterHelper.sol → swap-aggregator/kyberswap/ethereum/KyberHelperEthereum.sol}

@@ -1,25 +1,12 @@
 // SPDX-License-Identifier: MIT
 
 pragma solidity 0.8.17;
-import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
-import "../../core/libraries/BoringOwnableUpgradeable.sol";
+import "./IMetaAggregationRouterV2.sol";
+import "./IHashflow.sol";
+import "./IExecutorHelperEthereum1.sol";
+import "./ScaleDataHelperEthereum.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,
-    UUPSUpgradeable,
-    BoringOwnableUpgradeable
-{
+abstract contract KyberHelperEthereum {
     uint256 private constant _PARTIAL_FILL = 0x01;
     uint256 private constant _REQUIRES_EXTRA_ETH = 0x02;
     uint256 private constant _SHOULD_CLAIM = 0x04;
@@ -27,14 +14,6 @@ contract AggregationRouterHelper is
     uint256 private constant _BURN_FROM_TX_ORIGIN = 0x10;
     uint256 private constant _SIMPLE_SWAP = 0x20;
 
-    constructor() initializer {}
-
-    function initialize() external initializer {
-        __BoringOwnable_init();
-    }
-
-    function _authorizeUpgrade(address newImplementation) internal override onlyOwner {}
-
     struct Swap {
         bytes data;
         bytes4 selector;
@@ -58,45 +37,12 @@ contract AggregationRouterHelper is
         bytes destTokenFeeData;
     }
 
-    function getScaledInputData(bytes calldata kybercall, uint256 newAmount)
-        external
-        pure
-        returns (bytes memory)
-    {
+    function _getKyberScaledInputData(
+        bytes calldata kybercall,
+        uint256 newAmount
+    ) internal pure 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:],
@@ -130,32 +76,6 @@ contract AggregationRouterHelper is
         revert("InputScalingHelper: Invalid selector");
     }
 
-    function _getScaledInputDataV1(
-        IMetaAggregationRouter.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,
@@ -182,32 +102,6 @@ contract AggregationRouterHelper is
         );
     }
 
-    function _scaledSwapDescriptionV1(
-        IMetaAggregationRouter.SwapDescription memory desc,
-        uint256 oldAmount,
-        uint256 newAmount
-    ) internal pure returns (IMetaAggregationRouter.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 _scaledSimpleSwapData(
         bytes memory data,
         uint256 oldAmount,
@@ -241,45 +135,35 @@ contract AggregationRouterHelper is
             bytes4 selector = swap.selector;
 
             if (selector == IExecutorHelperEthereum1.executeUniSwap.selector) {
-                swap.data = ScaleDataHelperEthereum1.newUniSwap(swap.data, oldAmount, newAmount);
+                swap.data = ScaleDataHelperEthereum.newUniSwap(swap.data, oldAmount, newAmount);
             } else if (selector == IExecutorHelperEthereum1.executeStableSwap.selector) {
-                swap.data = ScaleDataHelperEthereum1.newStableSwap(
-                    swap.data,
-                    oldAmount,
-                    newAmount
-                );
+                swap.data = ScaleDataHelperEthereum.newStableSwap(swap.data, oldAmount, newAmount);
             } else if (selector == IExecutorHelperEthereum1.executeCurveSwap.selector) {
-                swap.data = ScaleDataHelperEthereum1.newCurveSwap(swap.data, oldAmount, newAmount);
+                swap.data = ScaleDataHelperEthereum.newCurveSwap(swap.data, oldAmount, newAmount);
             } else if (selector == IExecutorHelperEthereum1.executeKyberDMMSwap.selector) {
-                swap.data = ScaleDataHelperEthereum1.newKyberDMM(swap.data, oldAmount, newAmount);
+                swap.data = ScaleDataHelperEthereum.newKyberDMM(swap.data, oldAmount, newAmount);
             } else if (selector == IExecutorHelperEthereum1.executeUniV3ProMMSwap.selector) {
-                swap.data = ScaleDataHelperEthereum1.newUniV3ProMM(
-                    swap.data,
-                    oldAmount,
-                    newAmount
-                );
+                swap.data = ScaleDataHelperEthereum.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
-                );
+                swap.data = ScaleDataHelperEthereum.newBalancerV2(swap.data, oldAmount, newAmount);
             } else if (selector == IExecutorHelperEthereum1.executeDODOSwap.selector) {
-                swap.data = ScaleDataHelperEthereum1.newDODO(swap.data, oldAmount, newAmount);
+                swap.data = ScaleDataHelperEthereum.newDODO(swap.data, oldAmount, newAmount);
             } else if (selector == IExecutorHelperEthereum1.executeWrappedstETHSwap.selector) {
-                swap.data = ScaleDataHelperEthereum1.newWrappedstETHSwap(
+                swap.data = ScaleDataHelperEthereum.newWrappedstETHSwap(
                     swap.data,
                     oldAmount,
                     newAmount
                 );
             } else if (selector == IExecutorHelperEthereum1.executeSynthetixSwap.selector) {
-                swap.data = ScaleDataHelperEthereum1.newSynthetix(swap.data, oldAmount, newAmount);
+                swap.data = ScaleDataHelperEthereum.newSynthetix(swap.data, oldAmount, newAmount);
             } else if (selector == IExecutorHelperEthereum1.executePSMSwap.selector) {
-                swap.data = ScaleDataHelperEthereum1.newPSM(swap.data, oldAmount, newAmount);
+                swap.data = ScaleDataHelperEthereum.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 = ScaleDataHelperEthereum.newFrax(swap.data, oldAmount, newAmount);
             } else revert("AggregationExecutor: Dex type not supported");
         }
         return abi.encode(executorDesc);

package/contracts/router/{kyberswap/ScaleDataHelperEthereum1.sol → swap-aggregator/kyberswap/ethereum/ScaleDataHelperEthereum.sol}

@@ -1,9 +1,9 @@
 // SPDX-License-Identifier: MIT
 pragma solidity 0.8.17;
 
-import "./interfaces/IExecutorHelperEthereum1.sol";
+import "./IExecutorHelperEthereum1.sol";
 
-library ScaleDataHelperEthereum1 {
+library ScaleDataHelperEthereum {
     function newUniSwap(
         bytes memory data,
         uint256 oldAmount,
@@ -131,4 +131,17 @@ library ScaleDataHelperEthereum1 {
         psm.amountIn = (psm.amountIn * newAmount) / oldAmount;
         return abi.encode(psm);
     }
+
+    function newFrax(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        IExecutorHelperEthereum1.UniSwap memory frax = abi.decode(
+            data,
+            (IExecutorHelperEthereum1.UniSwap)
+        );
+        frax.collectAmount = (frax.collectAmount * newAmount) / oldAmount;
+        return abi.encode(frax);
+    }
 }

package/deployments/43113-core.json

@@ -0,0 +1,31 @@
+{
+    "deployer": "0x1FcCC097db89A86Bfc474A1028F93958295b1Fb7",
+    "network": {
+        "chainId": 43113,
+        "treasury": "0x243b7CFD29AcAF9cDe98C1958902FAA3B1F095D5",
+        "governance": "0x1FcCC097db89A86Bfc474A1028F93958295b1Fb7",
+        "pendle": "0xB7609dec1C926204c3B67345cbCd54bc4aa7a940",
+        "lzEndpoint": "0x93f54D755A063cE7bB9e6Ac47Eccc8e33411d706",
+        "wrappedNative": "0xe43a7aD7C09d8fAE3ADe7361f0b847b23adD5094",
+        "initialRewardFee": "30000000000000000",
+        "initialInterestFee": "30000000000000000",
+        "initialFeeRateRoot": "999500333083533",
+        "initialReserveFeePercent": "80",
+        "initialPendlePerSec": "826719576719576719",
+        "safeWaitTime": 15000
+    },
+    "PENDLE": "0xB7609dec1C926204c3B67345cbCd54bc4aa7a940",
+    "yieldContractFactory": "0xe189c0F1EABDD23AB7DcA0d7657FF60c8f137356",
+    "marketFactory": "0x24265d37C87d3ffE64D6B0274c168945d44D1ba2",
+    "bulkSellerFactory": "0x137404E334a80fa741AD03d8965ee4b5b8A20259",
+    "bulkSellerOffchain": "0x85C369B1aD9A981DCf4Fd8F00F74cB783cacec34",
+    "router": "0xFC0F1237961A6ecEacAC86aD407e181Ecd5e673C",
+    "pendleSwap": "0xc6404511EF2C4C05A15446aF7D54FB63AFbe4d47",
+    "routerStatic": "0x483B13d42f3d72db7C449461289299C095143a05",
+    "routerHelper": "0xc10f77aAf3b4cF67a6094bC37aAC516c9d85cB2F",
+    "vePendle": "0xB20E3c268C993BC3c9Bc1C1cc5D7491F2268cD91",
+    "senderEndpoint": "0x86bD575c36e236386284C035ffeBE66CB6ecd2DD",
+    "votingController": "0x40ea97a7E9A4A0520229d1bbdf4D82E36b1a5475",
+    "gaugeController": "0x90Fa61ea34f61e31e9471CEB0ED22b12bBf4263E",
+    "feeDistributor": "0x40160f3439317bCD0ec8eB09545dD6A30771A7B6"
+}

package/deployments/43113-markets/APE-30-MARCH.json

@@ -0,0 +1,10 @@
+{
+    "name": "sAPE",
+    "SY": "0xDE080bEeB90e62F61936C113Fb46E62aa766cF1f",
+    "YT": "0x6537939Ec3e9da193D234A36bC5664B3cA570bc8",
+    "PT": "0x1432364a6a56d30810087fbD2ed197e609451299",
+    "market": "0x94B81B4cF70849E994f17b872C0e8E448443aE9b",
+    "expiry": 1680134400,
+    "scalarRoot": "2200000000000000000",
+    "initAnchor": "1151500000000000000"
+}

package/deployments/43113-markets/USDC-FEB-2ND-2024.json

@@ -0,0 +1,10 @@
+{
+    "name": "SY Benqi USDC",
+    "SY": "0x2b530d59e3046CDf93E64406113e33698d4f8C0d",
+    "YT": "0xEB997044293a9eD86faD68EA4BEE269B5Aa9E756",
+    "PT": "0x4ab617BD4347F3C55f3B48995B6521Cfb4890AdB",
+    "market": "0x87f956788937b2fd140B7852477F688d1Fd5E49c",
+    "expiry": 1706832000,
+    "scalarRoot": "62000000000000000000",
+    "initAnchor": "1012600000000000000"
+}

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

@@ -0,0 +1,10 @@
+{
+    "name": "SY Benqi USDC",
+    "SY": "0x0209b7e742ea0C0cD466eB7cdDA596d7a624387F",
+    "YT": "0x7cDE2A6E964Ef46CF88e73D0f4b9D99705638C5E",
+    "PT": "0xb7a1e3aFA053E2ff4B525900b3359749BeAb101F",
+    "market": "0x0e303BbD4F9F316c797AaEDc71ebE7342a5269C6",
+    "expiry": 1675382400,
+    "scalarRoot": "62000000000000000000",
+    "initAnchor": "1012600000000000000"
+}

package/deployments/43113-markets/USDC-FEB-4TH.json

@@ -0,0 +1,10 @@
+{
+    "name": "SY Benqi USDC",
+    "SY": "0x4F84e0469F8ba5Eb6b39F017301A221Cc08FDD84",
+    "YT": "0x89Bb92d1D5ce9050697d994dFA38631c6CeB29ee",
+    "PT": "0x59a4972802cA006801Fb7a0b551fA8385B54D2B1",
+    "market": "0xF1Fd2085Ef3403a422999996F3E1d7915a453E46",
+    "expiry": 1675468800,
+    "scalarRoot": "62000000000000000000",
+    "initAnchor": "1012600000000000000"
+}

package/deployments/43113-markets/USDC-MAR-28TH.json

@@ -0,0 +1,10 @@
+{
+    "name": "SY Benqi USDC",
+    "SY": "0x2b530d59e3046CDf93E64406113e33698d4f8C0d",
+    "YT": "0x686C9AcDEc950ADC31158764077e7aB69b30C7C8",
+    "PT": "0x2f25ec055eEeC9dFed81647cC5F06EDeBBF7505A",
+    "market": "0xc479dD1faB9B8985867C7066530484C337203c2C",
+    "expiry": 1679961600,
+    "scalarRoot": "62000000000000000000",
+    "initAnchor": "1012600000000000000"
+}

package/deployments/43113-markets/WETH-FEB-2ND.json

@@ -0,0 +1,11 @@
+{
+    "name": "SY Benqi WETH",
+    "SY": "0x2E6cDFD2c1379270553EF1Ab8bbeDE0BCB9eF737",
+    "YT": "0xc0eD42Fa7521936f26DdCc226D2761fBb47000A4",
+    "PT": "0x4CFe3aB9cF4bDA9b668497E373baA00E875f722C",
+    "market": "0x671610F13e56bD530Dc2A3b9504eba2F402913d7",
+    "expiry": 1675382400,
+    "bulkSeller": "0x9118368BdbA84B86507AFb1D15c349099Cd41c9D",
+    "scalarRoot": "62000000000000000000",
+    "initAnchor": "1012600000000000000"
+}

package/deployments/43113-markets/WETH-FEB-4TH.json

@@ -0,0 +1,11 @@
+{
+    "name": "SY Benqi WETH",
+    "SY": "0xBb4C4cEcafAA16911b98C29650bdC37dbc14cA0e",
+    "YT": "0xCf51520AaCec976a6144a4584eacbFa6EC25Ad8D",
+    "PT": "0x491BecB8976b7540Dfd809c758e514f4296D585d",
+    "market": "0x2ad1F05C047fb08ACFA5a3C5BEb793bb4500e1da",
+    "expiry": 1675468800,
+    "bulkSeller": "0xED4403ef6f7Dfa260676CE330a6d3E38324385ff",
+    "scalarRoot": "62000000000000000000",
+    "initAnchor": "1012600000000000000"
+}

package/deployments/43113-offchain-helper.json

@@ -0,0 +1,4 @@
+{
+    "implicitSwapfeeContract": "0x14A59F6e482B25BAc872a8788E7AfF3F254604Fa",
+    "multicall": "0x44099Cc077E7e4c619b217474ee459532169C563"
+}

package/deployments/43113-testenv.json

@@ -0,0 +1,22 @@
+{
+    "tokens": {
+        "fundKeeper": "0x45e03eB183962884d50eC0Af39B03970333426cb",
+        "faucet": "0xf9d2A793b446D200deC9FBB6f29a9DadcD0521cC",
+        "WAVAX": "0xe43a7aD7C09d8fAE3ADe7361f0b847b23adD5094",
+        "DAI": "0xCd3748CE3Bf75A01D99Bf301668E0748558a592C",
+        "USDC": "0xc2A6b8d7d0FAB3749A6Bda84cEdb58D2d58f045e",
+        "USDT": "0x9BE875cdBB8409DbC1a553c8ddc1FC05cdDF80Ce",
+        "WBTC": "0x82c18D07253603D04d25C8B1F1E60134a59C39ce",
+        "WETH": "0x1e2e40697603CA5b5ffc102c9D7A3310EA3f2Aa3",
+        "qiUSDC": "0xEE3a174F1478198fBc669132B1e2cc13B5686F94",
+        "qiWETH": "0xE5710EC5e4CeB255fb14d2c2BFC93E64d0c30A2c",
+        "qiAVAX": "0xf9aEd3b927dce44C6d53B334Cb759f4D230D9b9c"
+    },
+    "benqi": {
+        "comptroller": "0x4Af3e9CA6f86E655C01f03C13519BcAF867286EE",
+        "QI": "0x63554C4d2038c9B7973190f3E41f5158939Fe972",
+        "interestRateModel": "0xd66C253151539b3bE0a0C11699fB024E054227d4",
+        "qiErc20Impl": "0x184622Dd7B63299F87CBf21f11FF25c9c302fd5d",
+        "oracle": "0x44b789cBC190b7888d438cEb58f1Eb8A3Ae2d897"
+    }
+}

package/deployments/80001-core.json

@@ -0,0 +1,30 @@
+{
+    "deployer": "0x1FcCC097db89A86Bfc474A1028F93958295b1Fb7",
+    "network": {
+        "chainId": 80001,
+        "treasury": "0x7D301Cc4F91A9eDd8EDE1801344bd6516b5FA3d2",
+        "governance": "0x1FcCC097db89A86Bfc474A1028F93958295b1Fb7",
+        "pendle": "0xa6dc67fF3b241DEdeC6aF907Ff24bB5cFC3EEeAf",
+        "lzEndpoint": "0xf69186dfBa60DdB133E91E9A4B5673624293d8F8",
+        "wrappedNative": "0x9c3C9283D3e44854697Cd22D3Faa240Cfb032889",
+        "initialRewardFee": "30000000000000000",
+        "initialInterestFee": "30000000000000000",
+        "initialFeeRateRoot": "999500333083533",
+        "initialReserveFeePercent": "80",
+        "initialPendlePerSec": "826719576719576719",
+        "safeWaitTime": 15000
+    },
+    "baseCodeSplitter": "0xc5E332F1c3123E66C0b1bf0dFb9Cb4BA86a175C9",
+    "PENDLE": "0xa6dc67fF3b241DEdeC6aF907Ff24bB5cFC3EEeAf",
+    "yieldContractFactory": "0x8091897bE27CC11d80De8F48049168C9C7A5B1aC",
+    "marketFactory": "0xeB2AEd0aE414c76e4f9D4d43cD01064Fec010dfB",
+    "bulkSellerFactory": "0x4707f0CC2Ad4211172EdBAFc453E60DBd1C9D854",
+    "bulkSellerOffchain": "0x7Fb3626D95449d69f991a37e304b8C9A0a5D0e0c",
+    "router": "0x53FE536228e70cfb2e8C6Fa38D344a57be797237",
+    "pendleSwap": "0xFee829Cf47c28b8d81cD9035a05320a51595dB42",
+    "routerStatic": "0xeaF504BaddA9b6Ba16e7BB4f3BdcADDAE0468fE6",
+    "routerHelper": "0xe5DDa5a66b39aDD207a447146D56EE38b6eA7e9F",
+    "receiverEndpoint": "0x256752c851EDB92c97377C93232A9034c835F376",
+    "vePendle": "0xC0BC61112D9fD7bA5809047a86EC245593BA0e1E",
+    "gaugeController": "0x9aBcB6a79dD8de67FB41108493787533775d98d3"
+}

package/deployments/80001-markets/GLP-DEC-8TH.json

@@ -0,0 +1,10 @@
+{
+    "name": "SY GLP",
+    "SY": "0x1A2775c9bEe6e798De971c369849CF9130D3e25a",
+    "YT": "0x77F02e40d08eB6d368401b5EaF5500F992b27cC2",
+    "PT": "0xC4d7D9881c6b4e87E1325F06A56d6abB675998b9",
+    "market": "0xB08e72153925ccEc1B43b0d9BF2E1c57eea5E2AB",
+    "expiry": 1701993600,
+    "scalarRoot": "62000000000000000000",
+    "initAnchor": "1012600000000000000"
+}

package/deployments/80001-markets/USDC-DEC-8TH.json

@@ -0,0 +1,10 @@
+{
+    "name": "SY Benqi USDC",
+    "SY": "0x2b6891918CE19e854daB4fce31a1246ECef575E6",
+    "YT": "0x38692a41E857Fcc28Cf7e5782F6245Cd54a04C7E",
+    "PT": "0x721036540c0Ca715e546286df70c2Be6196d0561",
+    "market": "0x9D6913b06d7B42d921e812c46A63cFb580F5cCfc",
+    "expiry": 1701993600,
+    "scalarRoot": "62000000000000000000",
+    "initAnchor": "1012600000000000000"
+}