@pendle/core-v2 5.0.4 → 5.0.6

package/contracts/router/swap-aggregator/kyberswap/l2-contracts/InputScalingHelperL2.sol

@@ -11,7 +11,6 @@ import {CalldataWriter} from "./CalldataWriter.sol";
 
 library InputScalingHelperL2 {
     using ExecutorReader for bytes;
-    using ScalingDataL2Lib for bytes;
 
     uint256 private constant _PARTIAL_FILL = 0x01;
     uint256 private constant _REQUIRES_EXTRA_ETH = 0x02;
@@ -31,9 +30,9 @@ library InputScalingHelperL2 {
         Velodrome,
         Fraxswap,
         Camelot,
-        KyberLO,
-        RFQ,
-        Hashflow,
+        KyberLimitOrder, // 5
+        KyberRFQ, // 6
+        Hashflow, // 7
         StableSwap,
         Curve,
         UniswapV3KSElastic,
@@ -53,8 +52,8 @@ library InputScalingHelperL2 {
         Wombat,
         WooFiV2,
         iZiSwap,
-        TraderJoeV2,
-        KyberDSLO,
+        TraderJoeV2, // 27
+        KyberDSLO, // 28
         LevelFiV2,
         GMXGLP,
         PancakeStableSwap,
@@ -63,16 +62,22 @@ library InputScalingHelperL2 {
         Smardex,
         SolidlyV2,
         Kokonut,
-        BalancerV1,
+        BalancerV1, // 37
         SwaapV2,
         NomiswapStable,
         ArbswapStable,
         BancorV3,
         BancorV2,
         Ambient,
-        Native,
+        Native, // 44
         LighterV2,
-        Bebop
+        Bebop, // 46
+        MantleUsd,
+        MaiPSM, // 48
+        Kelp,
+        SymbioticLRT,
+        MaverickV2,
+        Integral
     }
 
     function _getScaledInputData(bytes calldata inputData, uint256 newAmount) internal pure returns (bytes memory) {
@@ -254,99 +259,108 @@ library InputScalingHelperL2 {
         uint8 functionSelectorIndex = uint8(uint32(swap.functionSelector));
 
         if (DexIndex(functionSelectorIndex) == DexIndex.UNI) {
-            swap.data = swap.data.newUniSwap(oldAmount, newAmount);
+            swap.data = ScalingDataL2Lib.newUniSwap(swap.data, oldAmount, newAmount);
         } else if (DexIndex(functionSelectorIndex) == DexIndex.StableSwap) {
-            swap.data = swap.data.newStableSwap(oldAmount, newAmount);
-        } else if (DexIndex(functionSelectorIndex) == DexIndex.Curve) {
-            swap.data = swap.data.newCurveSwap(oldAmount, newAmount);
+            swap.data = ScalingDataL2Lib.newStableSwap(swap.data, oldAmount, newAmount);
+        } else if (
+            DexIndex(functionSelectorIndex) == DexIndex.Curve ||
+            DexIndex(functionSelectorIndex) == DexIndex.PancakeStableSwap
+        ) {
+            swap.data = ScalingDataL2Lib.newCurveSwap(swap.data, oldAmount, newAmount);
         } else if (DexIndex(functionSelectorIndex) == DexIndex.KyberDMM) {
-            swap.data = swap.data.newKyberDMM(oldAmount, newAmount);
+            swap.data = ScalingDataL2Lib.newKyberDMM(swap.data, oldAmount, newAmount);
         } else if (DexIndex(functionSelectorIndex) == DexIndex.UniswapV3KSElastic) {
-            swap.data = swap.data.newUniswapV3KSElastic(oldAmount, newAmount);
-        } else if (DexIndex(functionSelectorIndex) == DexIndex.RFQ) {
-            revert("InputScalingHelper: Can not scale RFQ swap");
+            swap.data = ScalingDataL2Lib.newUniswapV3KSElastic(swap.data, oldAmount, newAmount);
         } else if (DexIndex(functionSelectorIndex) == DexIndex.BalancerV2) {
-            swap.data = swap.data.newBalancerV2(oldAmount, newAmount);
+            swap.data = ScalingDataL2Lib.newBalancerV2(swap.data, oldAmount, newAmount);
         } else if (DexIndex(functionSelectorIndex) == DexIndex.wstETH) {
-            swap.data = swap.data.newWrappedstETHSwap(oldAmount, newAmount);
+            swap.data = ScalingDataL2Lib.newWrappedstETHSwap(swap.data, oldAmount, newAmount);
         } else if (DexIndex(functionSelectorIndex) == DexIndex.stETH) {
-            swap.data = swap.data.newStETHSwap(oldAmount, newAmount);
+            swap.data = ScalingDataL2Lib.newStETHSwap(swap.data, oldAmount, newAmount);
         } else if (DexIndex(functionSelectorIndex) == DexIndex.DODO) {
-            swap.data = swap.data.newDODO(oldAmount, newAmount);
+            swap.data = ScalingDataL2Lib.newDODO(swap.data, oldAmount, newAmount);
         } else if (DexIndex(functionSelectorIndex) == DexIndex.Velodrome) {
-            swap.data = swap.data.newVelodrome(oldAmount, newAmount);
+            swap.data = ScalingDataL2Lib.newVelodrome(swap.data, oldAmount, newAmount);
         } else if (DexIndex(functionSelectorIndex) == DexIndex.GMX) {
-            swap.data = swap.data.newGMX(oldAmount, newAmount);
+            swap.data = ScalingDataL2Lib.newGMX(swap.data, oldAmount, newAmount);
         } else if (DexIndex(functionSelectorIndex) == DexIndex.Synthetix) {
-            swap.data = swap.data.newSynthetix(oldAmount, newAmount);
-        } else if (DexIndex(functionSelectorIndex) == DexIndex.Hashflow) {
-            revert("InputScalingHelper: Can not scale Hashflow swap");
+            swap.data = ScalingDataL2Lib.newSynthetix(swap.data, oldAmount, newAmount);
         } else if (DexIndex(functionSelectorIndex) == DexIndex.Camelot) {
-            swap.data = swap.data.newCamelot(oldAmount, newAmount);
-        } else if (DexIndex(functionSelectorIndex) == DexIndex.KyberLO) {
-            revert("InputScalingHelper: Can not scale KyberLO swap");
+            swap.data = ScalingDataL2Lib.newCamelot(swap.data, oldAmount, newAmount);
         } else if (DexIndex(functionSelectorIndex) == DexIndex.PSM) {
-            swap.data = swap.data.newPSM(oldAmount, newAmount);
+            swap.data = ScalingDataL2Lib.newPSM(swap.data, oldAmount, newAmount);
         } else if (DexIndex(functionSelectorIndex) == DexIndex.Fraxswap) {
-            swap.data = swap.data.newFrax(oldAmount, newAmount);
+            swap.data = ScalingDataL2Lib.newFrax(swap.data, oldAmount, newAmount);
         } else if (DexIndex(functionSelectorIndex) == DexIndex.Platypus) {
-            swap.data = swap.data.newPlatypus(oldAmount, newAmount);
+            swap.data = ScalingDataL2Lib.newPlatypus(swap.data, oldAmount, newAmount);
         } else if (DexIndex(functionSelectorIndex) == DexIndex.Maverick) {
-            swap.data = swap.data.newMaverick(oldAmount, newAmount);
+            swap.data = ScalingDataL2Lib.newMaverick(swap.data, oldAmount, newAmount);
         } else if (DexIndex(functionSelectorIndex) == DexIndex.SyncSwap) {
-            swap.data = swap.data.newSyncSwap(oldAmount, newAmount);
+            swap.data = ScalingDataL2Lib.newSyncSwap(swap.data, oldAmount, newAmount);
         } else if (DexIndex(functionSelectorIndex) == DexIndex.AlgebraV1) {
-            swap.data = swap.data.newAlgebraV1(oldAmount, newAmount);
+            swap.data = ScalingDataL2Lib.newAlgebraV1(swap.data, oldAmount, newAmount);
         } else if (DexIndex(functionSelectorIndex) == DexIndex.BalancerBatch) {
-            swap.data = swap.data.newBalancerBatch(oldAmount, newAmount);
-        } else if (DexIndex(functionSelectorIndex) == DexIndex.Mantis) {
-            swap.data = swap.data.newMantis(oldAmount, newAmount);
-        } else if (DexIndex(functionSelectorIndex) == DexIndex.Wombat) {
-            swap.data = swap.data.newMantis(oldAmount, newAmount); // @dev use identical calldata structure as Mantis
+            swap.data = ScalingDataL2Lib.newBalancerBatch(swap.data, oldAmount, newAmount);
+        } else if (
+            DexIndex(functionSelectorIndex) == DexIndex.Mantis ||
+            DexIndex(functionSelectorIndex) == DexIndex.Wombat ||
+            DexIndex(functionSelectorIndex) == DexIndex.WooFiV2 ||
+            DexIndex(functionSelectorIndex) == DexIndex.Smardex ||
+            DexIndex(functionSelectorIndex) == DexIndex.SolidlyV2 ||
+            DexIndex(functionSelectorIndex) == DexIndex.NomiswapStable ||
+            DexIndex(functionSelectorIndex) == DexIndex.BancorV3
+        ) {
+            swap.data = ScalingDataL2Lib.newMantis(swap.data, oldAmount, newAmount);
         } else if (DexIndex(functionSelectorIndex) == DexIndex.iZiSwap) {
-            swap.data = swap.data.newIziSwap(oldAmount, newAmount);
+            swap.data = ScalingDataL2Lib.newIziSwap(swap.data, oldAmount, newAmount);
         } else if (DexIndex(functionSelectorIndex) == DexIndex.TraderJoeV2) {
-            swap.data = swap.data.newTraderJoeV2(oldAmount, newAmount);
-        } else if (DexIndex(functionSelectorIndex) == DexIndex.WooFiV2) {
-            swap.data = swap.data.newMantis(oldAmount, newAmount); // @dev use identical calldata structure as Mantis
-        } else if (DexIndex(functionSelectorIndex) == DexIndex.KyberDSLO) {
-            revert("InputScalingHelper: Can not scale KyberDSLO swap");
+            swap.data = ScalingDataL2Lib.newTraderJoeV2(swap.data, oldAmount, newAmount);
         } else if (DexIndex(functionSelectorIndex) == DexIndex.LevelFiV2) {
-            swap.data = swap.data.newLevelFiV2(oldAmount, newAmount);
-        } else if (DexIndex(functionSelectorIndex) == DexIndex.PancakeStableSwap) {
-            swap.data = swap.data.newCurveSwap(oldAmount, newAmount); // @dev same encoded data as Curve
+            swap.data = ScalingDataL2Lib.newLevelFiV2(swap.data, oldAmount, newAmount);
         } else if (DexIndex(functionSelectorIndex) == DexIndex.GMXGLP) {
-            swap.data = swap.data.newGMXGLP(oldAmount, newAmount);
+            swap.data = ScalingDataL2Lib.newGMXGLP(swap.data, oldAmount, newAmount);
         } else if (DexIndex(functionSelectorIndex) == DexIndex.Vooi) {
-            swap.data = swap.data.newVooi(oldAmount, newAmount);
+            swap.data = ScalingDataL2Lib.newVooi(swap.data, oldAmount, newAmount);
         } else if (DexIndex(functionSelectorIndex) == DexIndex.VelocoreV2) {
-            swap.data = swap.data.newVelocoreV2(oldAmount, newAmount);
-        } else if (DexIndex(functionSelectorIndex) == DexIndex.Smardex) {
-            swap.data = swap.data.newMantis(oldAmount, newAmount); // @dev use identical calldata structure as Mantis
-        } else if (DexIndex(functionSelectorIndex) == DexIndex.SolidlyV2) {
-            swap.data = swap.data.newMantis(oldAmount, newAmount); // @dev use identical calldata structure as Mantis
+            swap.data = ScalingDataL2Lib.newVelocoreV2(swap.data, oldAmount, newAmount);
         } else if (DexIndex(functionSelectorIndex) == DexIndex.Kokonut) {
-            swap.data = swap.data.newKokonut(oldAmount, newAmount);
+            swap.data = ScalingDataL2Lib.newKokonut(swap.data, oldAmount, newAmount);
         } else if (DexIndex(functionSelectorIndex) == DexIndex.BalancerV1) {
-            swap.data = swap.data.newBalancerV1(oldAmount, newAmount);
-        } else if (DexIndex(functionSelectorIndex) == DexIndex.SwaapV2) {
-            revert("InputScalingHelper: Can not scale SwaapV2 swap");
-        } else if (DexIndex(functionSelectorIndex) == DexIndex.NomiswapStable) {
-            swap.data = swap.data.newMantis(oldAmount, newAmount); // @dev use identical calldata structure as Mantis
+            swap.data = ScalingDataL2Lib.newBalancerV1(swap.data, oldAmount, newAmount);
         } else if (DexIndex(functionSelectorIndex) == DexIndex.ArbswapStable) {
-            swap.data = swap.data.newArbswapStable(oldAmount, newAmount);
+            swap.data = ScalingDataL2Lib.newArbswapStable(swap.data, oldAmount, newAmount);
         } else if (DexIndex(functionSelectorIndex) == DexIndex.BancorV2) {
-            swap.data = swap.data.newBancorV2(oldAmount, newAmount);
-        } else if (DexIndex(functionSelectorIndex) == DexIndex.BancorV3) {
-            swap.data = swap.data.newMantis(oldAmount, newAmount); // @dev use identical calldata structure as Mantis
+            swap.data = ScalingDataL2Lib.newBancorV2(swap.data, oldAmount, newAmount);
         } else if (DexIndex(functionSelectorIndex) == DexIndex.Ambient) {
-            swap.data = swap.data.newAmbient(oldAmount, newAmount);
-        } else if (DexIndex(functionSelectorIndex) == DexIndex.Native) {
-            revert("InputScalingHelper: Can not scale Native swap");
+            swap.data = ScalingDataL2Lib.newAmbient(swap.data, oldAmount, newAmount);
         } else if (DexIndex(functionSelectorIndex) == DexIndex.LighterV2) {
-            swap.data = swap.data.newLighterV2(oldAmount, newAmount);
+            swap.data = ScalingDataL2Lib.newLighterV2(swap.data, oldAmount, newAmount);
         } else if (DexIndex(functionSelectorIndex) == DexIndex.Bebop) {
-            revert("InputScalingHelper: Can not scale Bebop swap");
+            swap.data = ScalingDataL2Lib.newBebop(swap.data, oldAmount, newAmount);
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.KyberLimitOrder) {
+            swap.data = ScalingDataL2Lib.newKyberLimitOrder(swap.data, oldAmount, newAmount);
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.MaiPSM) {
+            swap.data = ScalingDataL2Lib.newMaiPSM(swap.data, oldAmount, newAmount);
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.Native) {
+            swap.data = ScalingDataL2Lib.newNative(swap.data, oldAmount, newAmount);
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.KyberDSLO) {
+            swap.data = ScalingDataL2Lib.newKyberDSLO(swap.data, oldAmount, newAmount);
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.Hashflow) {
+            swap.data = ScalingDataL2Lib.newHashflow(swap.data, oldAmount, newAmount);
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.KyberRFQ) {
+            swap.data = ScalingDataL2Lib.newKyberRFQ(swap.data, oldAmount, newAmount);
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.MantleUsd) {
+            swap.data = ScalingDataL2Lib.newMantleUsd(swap.data, oldAmount, newAmount);
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.Kelp) {
+            swap.data = ScalingDataL2Lib.newKelp(swap.data, oldAmount, newAmount);
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.SymbioticLRT) {
+            swap.data = ScalingDataL2Lib.newSymbioticLRT(swap.data, oldAmount, newAmount);
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.MaverickV2) {
+            swap.data = ScalingDataL2Lib.newMaverickV2(swap.data, oldAmount, newAmount);
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.Integral) {
+            swap.data = ScalingDataL2Lib.newIntegral(swap.data, oldAmount, newAmount);
+        } else if (DexIndex(functionSelectorIndex) == DexIndex.SwaapV2) {
+            revert("InputScalingHelper: Can not scale SwaapV2 swap");
         } else {
             revert("InputScaleHelper: Dex type not supported");
         }

package/contracts/router/swap-aggregator/kyberswap/l2-contracts/ScalingDataL2Lib.sol

@@ -202,4 +202,72 @@ library ScalingDataL2Lib {
     ) internal pure returns (bytes memory) {
         return data.scaleLighterV2(oldAmount, newAmount);
     }
+
+    function newMaiPSM(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
+        return data.scaleMaiPSM(oldAmount, newAmount);
+    }
+
+    function newNative(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
+        return data.scaleNative(oldAmount, newAmount);
+    }
+
+    function newKyberDSLO(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        return data.scaleDSLO(oldAmount, newAmount);
+    }
+
+    function newKyberLimitOrder(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        return data.scaleKyberLimitOrder(oldAmount, newAmount);
+    }
+
+    function newHashflow(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
+        return data.scaleHashflow(oldAmount, newAmount);
+    }
+
+    function newKyberRFQ(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
+        return data.scaleKyberRFQ(oldAmount, newAmount);
+    }
+
+    function newBebop(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
+        return data.scaleBebop(oldAmount, newAmount);
+    }
+
+    function newMantleUsd(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        return data.scaleMantleUsd(oldAmount, newAmount);
+    }
+
+    function newKelp(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
+        return data.scaleKelp(oldAmount, newAmount);
+    }
+
+    function newSymbioticLRT(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        return data.scaleSymbioticLRT(oldAmount, newAmount);
+    }
+
+    function newMaverickV2(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        return data.scaleMaverickV2(oldAmount, newAmount);
+    }
+
+    function newIntegral(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
+        return data.scaleMaverickV2(oldAmount, newAmount); // using kind of same scaling as MaverickV2
+    }
 }

package/contracts/router/swap-aggregator/kyberswap/libraries/BytesHelper.sol

@@ -0,0 +1,32 @@
+pragma solidity ^0.8.0;
+
+library BytesHelper {
+    function update(
+        bytes memory originalCalldata,
+        uint256 newAmount,
+        uint256 amountInOffset
+    ) internal pure returns (bytes memory) {
+        require(amountInOffset + 32 <= originalCalldata.length, "Offset out of bounds");
+
+        // Update the 32 bytes at the specified offset with the new amount
+        for (uint256 i; i < 32; ++i) {
+            originalCalldata[amountInOffset + i] = bytes32(newAmount)[i];
+        }
+
+        return originalCalldata;
+    }
+
+    function splitCalldata(bytes memory data) internal pure returns (bytes4 selector, bytes memory functionCalldata) {
+        require(data.length >= 4, "Calldata too short");
+
+        // Extract the selector
+        assembly {
+            selector := mload(add(data, 32))
+        }
+        // Extract the function calldata
+        functionCalldata = new bytes(data.length - 4);
+        for (uint256 i = 0; i < data.length - 4; i++) {
+            functionCalldata[i] = data[i + 4];
+        }
+    }
+}

package/contracts/router/swap-aggregator/kyberswap/libraries/RevertReasonParser.sol

@@ -0,0 +1,75 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pragma solidity >=0.7.6;
+
+/*
+“Copyright (c) 2019-2021 1inch 
+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 SOFTWARE”.
+*/
+
+library RevertReasonParser {
+    function parse(bytes memory data, string memory prefix) internal pure returns (string memory) {
+        // https://solidity.readthedocs.io/en/latest/control-structures.html#revert
+        // We assume that revert reason is abi-encoded as Error(string)
+
+        // 68 = 4-byte selector 0x08c379a0 + 32 bytes offset + 32 bytes length
+        if (data.length >= 68 && data[0] == "\x08" && data[1] == "\xc3" && data[2] == "\x79" && data[3] == "\xa0") {
+            string memory reason;
+            // solhint-disable no-inline-assembly
+            assembly {
+                // 68 = 32 bytes data length + 4-byte selector + 32 bytes offset
+                reason := add(data, 68)
+            }
+            /*
+                revert reason is padded up to 32 bytes with ABI encoder: Error(string)
+                also sometimes there is extra 32 bytes of zeros padded in the end:
+                https://github.com/ethereum/solidity/issues/10170
+                because of that we can't check for equality and instead check
+                that string length + extra 68 bytes is less than overall data length
+            */
+            require(data.length >= 68 + bytes(reason).length, "Invalid revert reason");
+            return string(abi.encodePacked(prefix, "Error(", reason, ")"));
+        }
+        // 36 = 4-byte selector 0x4e487b71 + 32 bytes integer
+        else if (
+            data.length == 36 && data[0] == "\x4e" && data[1] == "\x48" && data[2] == "\x7b" && data[3] == "\x71"
+        ) {
+            uint256 code;
+            // solhint-disable no-inline-assembly
+            assembly {
+                // 36 = 32 bytes data length + 4-byte selector
+                code := mload(add(data, 36))
+            }
+            return string(abi.encodePacked(prefix, "Panic(", _toHex(code), ")"));
+        }
+
+        return string(abi.encodePacked(prefix, "Unknown(", _toHex(data), ")"));
+    }
+
+    function _toHex(uint256 value) private pure returns (string memory) {
+        return _toHex(abi.encodePacked(value));
+    }
+
+    function _toHex(bytes memory data) private pure returns (string memory) {
+        bytes16 alphabet = 0x30313233343536373839616263646566;
+        bytes memory str = new bytes(2 + data.length * 2);
+        str[0] = "0";
+        str[1] = "x";
+        for (uint256 i = 0; i < data.length; i++) {
+            str[2 * i + 2] = alphabet[uint8(data[i] >> 4)];
+            str[2 * i + 3] = alphabet[uint8(data[i] & 0x0f)];
+        }
+        return string(str);
+    }
+}

package/deployments/1-core.json

@@ -17,6 +17,7 @@
     },
     "baseCodeSplitter": "0x35878C2Cff38cC4032E85283183428170BA618A2",
     "PENDLE": "0x808507121b80c02388fad14726482e061b8da827",
+    "governanceProxy": "0x2aD631F72fB16d91c4953A7f4260A97C2fE2f31e",
     "yieldContractFactory": "0x70ee0A6DB4F5a2Dc4d9c0b57bE97B9987e75BAFD",
     "marketFactory": "0x27b1dAcd74688aF24a64BD3C9C1B143118740784",
     "router": "0x888888888889758F76e7103c6CbF23ABbF58F946",
@@ -29,13 +30,15 @@
         "ActionStorageV4": "0x6a0Ed0A9193FCBe7ae9B0F3D90F88e365Cca64fC"
     },
     "routerStatic": "0x263833d47eA3fA4a30f269323aba6a107f9eB14C",
-    "pendleSwap": "0x1e8b6Ac39f8A33f46a6Eb2D1aCD1047B99180AD1",
+    "pendleSwap": "0x0Cc097AC029A7541C4e894c789c7aaa2A9794A29",
     "pyYtLpOracle": "0x9a9fa8338dd5e5b2188006f1cd2ef26d921650c2",
     "yieldContractFactoryV3": "0xdF3601014686674e53d1Fa52F7602525483F9122",
     "marketFactoryV3": "0x1A6fCc85557BC4fB7B534ed835a03EF056552D52",
     "yieldContractFactoryV4": "0x273b4bFA3Bb30fe8F32c467b5f0046834557F072",
     "marketFactoryV4": "0x3d75Bd20C983edb5fD218A1b7e0024F1056c7A2F",
-    "poolDeployHelper": "0x6DA90eD97e7A0811A107295b3ddd2a8761600756",
+    "yieldContractFactoryV5": "0x35A338522a435D46f77Be32C70E215B813D0e3aC",
+    "marketFactoryV5": "0x6fcf753f2C67b83f7B09746Bbc4FA0047b35D050",
+    "poolDeployHelper": "0x4Df98410c95737FD646D2413AC6CAFc1c04834b9",
     "limitRouter": "0x000000000000c9B3E2C3Ec88B1B4c0cD853f4321",
     "proxyAdmin": "0xA28c08f165116587D4F3E708743B4dEe155c5E64",
     "reflector": "0x5039Da22E5126e7c4e9284376116716A91782faF",
@@ -45,4 +48,4 @@
     "gaugeController": "0x47D74516B33eD5D70ddE7119A40839f6Fcc24e57",
     "feeDistributor": "0xd7b34a6fDCb2A7ceD2115FF7f5fdD72aa6aA4dE2",
     "feeDistributorV2": "0x8C237520a8E14D658170A633D96F8e80764433b9"
-}
+}

package/deployments/1-markets/AGETH-MAINNET-DEC2024.json

@@ -0,0 +1,14 @@
+{
+    "name": "SY RSETH",
+    "SY": "0xb1B9150f2085f6a553b547099977181CA802752A",
+    "YT": "0x3568f1d2e8058F6D99Daa17051Cb4a2930C83978",
+    "PT": "0x7aa68E84bCD8d1B4C9e10B1e565DB993f68a3E09",
+    "market": "0x6010676Bc2534652aD1Ef5Fa8073DcF9AD7EBFBe",
+    "expiry": 1735171200,
+    "scalarRoot": "17892980434000000000",
+    "initAnchor": "1055574575000000000",
+    "lnFeeRateRoot": "999500333000000",
+    "deployTxHash": "0x18755c1a71645c9aa8a63a993abd456424eaa64b3c9d38d3b3c4ba32bd2c13d7",
+    "deployBlockNumber": 20566985,
+    "reversedFee": 0.09999999999164011
+}

package/deployments/1-markets/AMPHRLRT-MAINNET-DEC2024.json

@@ -0,0 +1,14 @@
+{
+    "name": "AMPHRLRT-MAINNET-DEC2024",
+    "SY": "0x33A269066457E5E3Dc9B6dD1c7D854A7Df714B6d",
+    "YT": "0x1211a5b5f5a87B677074C391F0a80019aDF6bBd8",
+    "PT": "0xD53A899B731C52Eeb0f9750b6b507e543661D763",
+    "market": "0x7e0f3511044AFdaD9B4fd5C7Fa327cBeB90BEeBf",
+    "expiry": 1735171200,
+    "scalarRoot": "23352202321000000000",
+    "initAnchor": "1032480618000000000",
+    "lnFeeRateRoot": "1998002662000000",
+    "deployTxHash": "0x0197d7bfbc205d50965095bba67e5f8aa4ee75f25a163584ff2610426a37190b",
+    "deployBlockNumber": 20611872,
+    "reversedFee": 0.19999999993256523
+}

package/deployments/1-markets/EBTC-MAINNET-DEC2024.json

@@ -0,0 +1,14 @@
+{
+    "name": "SY eBTC",
+    "SY": "0x7aCDF2012aAC69D70B86677FE91eb66e08961880",
+    "YT": "0xeB993B610b68F2631f70CA1cf4Fe651dB81f368e",
+    "PT": "0xB997B3418935A1Df0F914Ee901ec83927c1509A0",
+    "market": "0x36d3ca43ae7939645C306E26603ce16e39A89192",
+    "expiry": 1735171200,
+    "scalarRoot": "23352202321000000000",
+    "initAnchor": "1032480618000000000",
+    "lnFeeRateRoot": "1998002662000000",
+    "deployTxHash": "0x3bffcc742dea33d279c75a78c96f2700ae05fc9f2a0f4c01b10fff464c5f7f1f",
+    "deployBlockNumber": 20620220,
+    "reversedFee": 0.19999999993256523
+}

package/deployments/1-markets/MELLOW-AMPHRETH-MAINNET-DEC2024.json

@@ -0,0 +1,14 @@
+{
+    "name": "MELLOW-AMPHRETH-MAINNET-DEC2024",
+    "SY": "0x198139F26d42F2028C10427a161e2d0e8bb00346",
+    "YT": "0x5dB8a2391a72F1114BbaE30eFc9CD89f4a29F988",
+    "PT": "0x76F327150224393ff07AAFA3449FBB23103fb279",
+    "market": "0x1C48cD1179Aa0C503A48fcD5852559942492E31b",
+    "expiry": 1735171200,
+    "scalarRoot": "23352202321000000000",
+    "initAnchor": "1032480618000000000",
+    "lnFeeRateRoot": "1998002662000000",
+    "deployTxHash": "0x814cd51d20e1c24887bd6c57cf05100f53ba0a16f5b9c04e9fb872bbf2d29485",
+    "deployBlockNumber": 20611855,
+    "reversedFee": 0.19999999993256523
+}

package/deployments/1-markets/MELLOW-RE7LRT-MAINNET-DEC2024.json

@@ -0,0 +1,14 @@
+{
+    "name": "MELLOW-RE7LRT-MAINNET-DEC2024",
+    "SY": "0xE833C7A12A10A44Cb8b19BdF0931053AC136F105",
+    "YT": "0x89E7f4E5210A77Ac0f20511389Df71eC98ce9971",
+    "PT": "0x0F5f14C2ed1161640891703A4988E59A4930b79d",
+    "market": "0x1C5B54c0BD500A7430Ed34BD2413aF17725A7840",
+    "expiry": 1735171200,
+    "scalarRoot": "23352202321000000000",
+    "initAnchor": "1032480618000000000",
+    "lnFeeRateRoot": "1998002662000000",
+    "deployTxHash": "0x33e7b955df23cd5925089bd2aa94259e9d418ffc52d6b4f22c1403b60c17bb7c",
+    "deployBlockNumber": 20611854,
+    "reversedFee": 0.19999999993256523
+}

package/deployments/1-markets/MELLOW-RSTETH-MAINNET-DEC2024.json

@@ -0,0 +1,14 @@
+{
+    "name": "MELLOW-RSTETH-MAINNET-DEC2024",
+    "SY": "0x553cD5e6D2072723f5FE5457576Ed6D06b0905b2",
+    "YT": "0x11CCff2F748a0100dBd457FF7170A54e12064Aba",
+    "PT": "0x5A33492Ed5eCCdC158f60ED119d73ffDAB94b97B",
+    "market": "0x409b499780Ac04dC4780F9B79fBEdE665Ac773d5",
+    "expiry": 1735171200,
+    "scalarRoot": "23352202321000000000",
+    "initAnchor": "1032480618000000000",
+    "lnFeeRateRoot": "1998002662000000",
+    "deployTxHash": "0x4104b7e8e70255710ed467500fbd8c2d1c68794e2050db1241d68b3b3015e8c5",
+    "deployBlockNumber": 20611856,
+    "reversedFee": 0.19999999993256523
+}

package/deployments/1-markets/MELLOW-STEAKLRT-MAINNET-DEC2024.json

@@ -0,0 +1,14 @@
+{
+    "name": "MELLOW-STEAKLRT-MAINNET-DEC2024",
+    "SY": "0x998a1d40f097fd36bff15ca78fc0673bd2a8280c",
+    "YT": "0xd6A4271F065DC7597aa37AFCDD4490000995719A",
+    "PT": "0xE0a5Fe2c7b188D47490778995f4fa8C0bc8eBA8B",
+    "market": "0x67Ec4046800bC2C27A51528e9D382d43c3146D29",
+    "expiry": 1735171200,
+    "scalarRoot": "23352202321000000000",
+    "initAnchor": "1032480618000000000",
+    "lnFeeRateRoot": "1998002662000000",
+    "deployTxHash": "0xe9a6fa4568511a4d88ac9c073f3d68a33aee0d9a48fe11f18670f531e2ea18a3",
+    "deployBlockNumber": 20611857,
+    "reversedFee": 0.19999999993256523
+}

package/deployments/1-markets/RSETH-MAINNET-DEC2024.json

@@ -0,0 +1,14 @@
+{
+    "name": "SY rsETH",
+    "SY": "0x730A5E2AcEbccAA5e9095723B3CB862739DA793c",
+    "YT": "0x5576aD59d4223F8e49Ed1E8f45172f1cb18FF11e",
+    "PT": "0xB07b9fDd62DC478E521E8bDe3630a777725B0eB4",
+    "market": "0x84a50177a84dAd50Fdbf665DFBFb39914b52DFf2",
+    "expiry": 1735171200,
+    "scalarRoot": "35580362140000000000",
+    "initAnchor": "1029743938000000000",
+    "lnFeeRateRoot": "999500333000000",
+    "deployTxHash": "0x938d286377d10a7191eb5275501f6d498a87ed9cfee53a4b9e2b0bd53ac86282",
+    "deployBlockNumber": 20568538,
+    "reversedFee": 0.09999999999164011
+}

package/deployments/1-markets/SOPHON-PEPE-MAINNET-DEC2024.json

@@ -0,0 +1,14 @@
+{
+    "name": "SY Sophon PEPE",
+    "SY": "0x065347C1Dd7A23Aa043e3844B4D0746ff7715246",
+    "YT": "0xD6cbbd0ce608B4b694bb7aED474AF7621c94D7C3",
+    "PT": "0xB00834d31102DCfc9bB266127cc9F9ef03BefEe1",
+    "market": "0x02f67a8E59b79891ae0C4c4dEbcb332d644512e1",
+    "expiry": 1735171200,
+    "scalarRoot": "10057120364000000000",
+    "initAnchor": "1079608524000000000",
+    "lnFeeRateRoot": "999500333000000",
+    "deployTxHash": "0x4b6cca95af69cb185b2e65469e3820f6f53a8e6a56a60f141af186513083ebaf",
+    "deployBlockNumber": 20559351,
+    "reversedFee": 0.09999999999164011
+}

package/deployments/1-markets/SOPHON-PEPE-MAINNET-SEP2024.json

@@ -0,0 +1,14 @@
+{
+    "name": "SY Sophon PEPE",
+    "SY": "0x065347C1Dd7A23Aa043e3844B4D0746ff7715246",
+    "YT": "0x9500f306CD233BF2BCff1Cc90D565c64626a162c",
+    "PT": "0x53D26803a068d5DB4270EC72ad8E49a822556334",
+    "market": "0x1C1b087B612C541658E7008f56e02A75f99c91Cb",
+    "expiry": 1727308800,
+    "scalarRoot": "10628717660000000000",
+    "initAnchor": "1019822971000000000",
+    "lnFeeRateRoot": "999500333000000",
+    "deployTxHash": "0x4cfab187e5f417e96c49972c09765955aee13487458b50f32e11d4871b7fe1aa",
+    "deployBlockNumber": 20612872,
+    "reversedFee": 0.09999999999164011
+}

package/deployments/1-markets/WEETHS-MAINNET-DEC2024.json

@@ -0,0 +1,15 @@
+{
+    "name": "WEETHS-MAINNET-DEC2024",
+    "SY": "0x9e8f10574ACc2c62C6e5d19500CEd39163Da37A9",
+    "YT": "0x719B51Dd92B7809A80A2E8c91D89367BF58f1D7A",
+    "PT": "0x1D27254125246873a19580B7364BFf322c5DEF0f",
+    "market": "0x40789E8536C668c6A249aF61c81b9dfaC3EB8F32",
+    "expiry": 1735171200,
+    "lnFeeRateRoot": "999500333000000",
+    "scalarRoot": "23269791254000000000",
+    "initAnchor": "1036217388000000000",
+    "doCacheIndexSameBlock": true,
+    "deployTxHash": "0x0b84ed4e6f632d35b34bde69322bfaebf4ce51cc27a650b48c635ddea13835c1",
+    "deployBlockNumber": 20518020,
+    "reversedFee": 0.09999999999164011
+}