@pendle/core-v2 1.2.1-testnet → 1.3.0-testnet

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

@@ -0,0 +1,200 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.17;
+
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import { IExecutorHelper1 } from "./IExecutorHelper1.sol";
+import { IExecutorHelper2 } from "./IExecutorHelper2.sol";
+import { IMetaAggregationRouterV2 } from "./IMetaAggregationRouterV2.sol";
+import { ScaleDataHelperArbitrum } from "./ScaleDataHelperArbitrum.sol";
+
+abstract contract KyberHelperArbitrum {
+    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;
+
+    struct Swap {
+        bytes data;
+        bytes4 selector;
+    }
+
+    struct SimpleSwapData {
+        address[] firstPools;
+        uint256[] firstSwapAmounts;
+        bytes[] swapDatas;
+        uint256 deadline;
+        bytes destTokenFeeData;
+    }
+
+    struct SwapExecutorDescription {
+        Swap[][] swapSequences;
+        address tokenIn;
+        address tokenOut;
+        uint256 minTotalAmountOut;
+        address to;
+        uint256 deadline;
+        bytes destTokenFeeData;
+    }
+
+    function _getKyberScaledInputData(
+        bytes calldata kybercall,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        bytes4 selector = bytes4(kybercall[:4]);
+
+        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");
+    }
+
+    function _getScaledInputDataV2(
+        IMetaAggregationRouterV2.SwapDescriptionV2 memory desc,
+        bytes memory executorData,
+        uint256 newAmount,
+        bool isSimpleMode
+    ) internal pure returns (IMetaAggregationRouterV2.SwapDescriptionV2 memory, bytes memory) {
+        uint256 oldAmount = desc.amount;
+        if (oldAmount == newAmount) {
+            return (desc, executorData);
+        }
+
+        // simple mode swap
+        if (isSimpleMode) {
+            return (
+                _scaledSwapDescriptionV2(desc, oldAmount, newAmount),
+                _scaledSimpleSwapData(executorData, oldAmount, newAmount)
+            );
+        }
+
+        //normal mode swap
+        return (
+            _scaledSwapDescriptionV2(desc, oldAmount, newAmount),
+            _scaledExecutorCallBytesData(executorData, oldAmount, newAmount)
+        );
+    }
+
+    function _scaledSimpleSwapData(
+        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 _scaledExecutorCallBytesData(
+        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;
+
+            if (selector == IExecutorHelper1.executeUniSwap.selector) {
+                swap.data = ScaleDataHelperArbitrum.newUniSwap(swap.data, oldAmount, newAmount);
+            } else if (selector == IExecutorHelper1.executeStableSwap.selector) {
+                swap.data = ScaleDataHelperArbitrum.newStableSwap(swap.data, oldAmount, newAmount);
+            } else if (selector == IExecutorHelper1.executeCurveSwap.selector) {
+                swap.data = ScaleDataHelperArbitrum.newCurveSwap(swap.data, oldAmount, newAmount);
+            } else if (selector == IExecutorHelper1.executeKyberDMMSwap.selector) {
+                swap.data = ScaleDataHelperArbitrum.newKyberDMM(swap.data, oldAmount, newAmount);
+            } else if (selector == IExecutorHelper1.executeUniV3ProMMSwap.selector) {
+                swap.data = ScaleDataHelperArbitrum.newUniV3ProMM(swap.data, oldAmount, newAmount);
+            } else if (selector == IExecutorHelper1.executeRfqSwap.selector) {
+                revert("InputScalingHelper: Can not scale RFQ swap");
+            } else if (selector == IExecutorHelper1.executeBalV2Swap.selector) {
+                swap.data = ScaleDataHelperArbitrum.newBalancerV2(swap.data, oldAmount, newAmount);
+            } else if (selector == IExecutorHelper1.executeDODOSwap.selector) {
+                swap.data = ScaleDataHelperArbitrum.newDODO(swap.data, oldAmount, newAmount);
+            } else if (selector == IExecutorHelper1.executeVelodromeSwap.selector) {
+                swap.data = ScaleDataHelperArbitrum.newVelodrome(swap.data, oldAmount, newAmount);
+            } else if (selector == IExecutorHelper1.executeGMXSwap.selector) {
+                swap.data = ScaleDataHelperArbitrum.newGMX(swap.data, oldAmount, newAmount);
+            } else if (selector == IExecutorHelper1.executeSynthetixSwap.selector) {
+                swap.data = ScaleDataHelperArbitrum.newSynthetix(swap.data, oldAmount, newAmount);
+            } else if (selector == IExecutorHelper1.executeHashflowSwap.selector) {
+                revert("InputScalingHelper: Can not scale RFQ swap");
+            } else if (selector == IExecutorHelper1.executeCamelotSwap.selector) {
+                swap.data = ScaleDataHelperArbitrum.newCamelot(swap.data, oldAmount, newAmount);
+            } else if (selector == IExecutorHelper2.executeKyberLimitOrder.selector) {
+                revert("InputScalingHelper: Can not scale RFQ swap");
+            } else revert("AggregationExecutor: Dex type not supported");
+        }
+        return abi.encode(executorDesc);
+    }
+
+    function _scaledSwapDescriptionV2(
+        IMetaAggregationRouterV2.SwapDescriptionV2 memory desc,
+        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;
+        }
+
+        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 _flagsChecked(uint256 number, uint256 flag) internal pure returns (bool) {
+        return number & flag != 0;
+    }
+}

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/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/swap-aggregator/kyberswap/{interfaces → 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/swap-aggregator/kyberswap/{KyberAggregationRouterHelper.sol → ethereum/KyberHelperEthereum.sol}

@@ -1,12 +1,12 @@
 // SPDX-License-Identifier: MIT
 
 pragma solidity 0.8.17;
-import "./interfaces/IMetaAggregationRouterV2.sol";
-import "./interfaces/IHashflow.sol";
-import "./interfaces/IExecutorHelperEthereum1.sol";
-import "./ScaleDataHelperEthereum1.sol";
+import "./IMetaAggregationRouterV2.sol";
+import "./IHashflow.sol";
+import "./IExecutorHelperEthereum1.sol";
+import "./ScaleDataHelperEthereum.sol";
 
-abstract contract KyberAggregationRouterHelper {
+abstract contract KyberHelperEthereum {
     uint256 private constant _PARTIAL_FILL = 0x01;
     uint256 private constant _REQUIRES_EXTRA_ETH = 0x02;
     uint256 private constant _SHOULD_CLAIM = 0x04;
@@ -37,11 +37,10 @@ abstract contract KyberAggregationRouterHelper {
         bytes destTokenFeeData;
     }
 
-    function _getKyberScaledInputData(bytes calldata kybercall, uint256 newAmount)
-        internal
-        pure
-        returns (bytes memory)
-    {
+    function _getKyberScaledInputData(
+        bytes calldata kybercall,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
         bytes4 selector = bytes4(kybercall[:4]);
 
         if (selector == IMetaAggregationRouterV2.swap.selector) {
@@ -136,47 +135,35 @@ abstract contract KyberAggregationRouterHelper {
             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 = ScaleDataHelperEthereum1.newFrax(swap.data, oldAmount, newAmount);
+                swap.data = ScaleDataHelperEthereum.newFrax(swap.data, oldAmount, newAmount);
             } else revert("AggregationExecutor: Dex type not supported");
         }
         return abi.encode(executorDesc);

package/contracts/router/swap-aggregator/kyberswap/{ScaleDataHelperEthereum1.sol → 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,

package/deployments/43113-core.json

@@ -22,6 +22,7 @@
     "router": "0xFC0F1237961A6ecEacAC86aD407e181Ecd5e673C",
     "pendleSwap": "0xc6404511EF2C4C05A15446aF7D54FB63AFbe4d47",
     "routerStatic": "0x483B13d42f3d72db7C449461289299C095143a05",
+    "routerHelper": "0x0f420b98298321294CE4B8B27591dA6AA07EE9CA",
     "vePendle": "0xB20E3c268C993BC3c9Bc1C1cc5D7491F2268cD91",
     "senderEndpoint": "0x86bD575c36e236386284C035ffeBE66CB6ecd2DD",
     "votingController": "0x40ea97a7E9A4A0520229d1bbdf4D82E36b1a5475",

package/deployments/80001-core.json

@@ -23,6 +23,7 @@
     "router": "0x53FE536228e70cfb2e8C6Fa38D344a57be797237",
     "pendleSwap": "0xFee829Cf47c28b8d81cD9035a05320a51595dB42",
     "routerStatic": "0xeaF504BaddA9b6Ba16e7BB4f3BdcADDAE0468fE6",
+    "routerHelper": "0xe5DDa5a66b39aDD207a447146D56EE38b6eA7e9F",
     "receiverEndpoint": "0x256752c851EDB92c97377C93232A9034c835F376",
     "vePendle": "0xC0BC61112D9fD7bA5809047a86EC245593BA0e1E",
     "gaugeController": "0x9aBcB6a79dD8de67FB41108493787533775d98d3"

package/package.json

@@ -2,7 +2,7 @@
   "name": "@pendle/core-v2",
   "description": "Core smart contracts of Pendle Protocol.",
   "license": "BUSL-1.1",
-  "version": "1.2.1-testnet",
+  "version": "1.3.0-testnet",
   "homepage": "https://pendle.finance",
   "keywords": [
     "pendle",
@@ -25,12 +25,12 @@
   "devDependencies": {
     "@typechain/ethers-v5": "^9.0.0",
     "@typechain/hardhat": "^4.0.0",
-    "hardhat": "^2.12.7",
+    "hardhat": "^2.13.0",
     "hardhat-contract-sizer": "^2.8.0",
-    "prettier": "^2.8.4",
+    "prettier": "^2.8.5",
     "prettier-plugin-solidity": "^1.1.3",
     "solc": "^0.8.19",
-    "solhint": "^3.4.0",
+    "solhint": "^3.4.1",
     "ts-node": "^10.9.1",
     "typechain": "^8.1.1",
     "typescript": "^4.9.5"
@@ -39,7 +39,8 @@
     "compile": "yarn hardhat compile",
     "size": "yarn hardhat size-contracts",
     "clean": "yarn hardhat clean",
-    "fcompile": "yarn clean && yarn compile"
+    "fcompile": "yarn clean && yarn compile",
+    "format": "yarn prettier -w contracts/**/*"
   },
   "packageManager": "yarn@3.3.1",
   "dependencies": {

package/typechain-types/ActionMarketCoreStatic.ts

@@ -890,11 +890,9 @@ export interface ActionMarketCoreStatic extends BaseContract {
         BigNumber,
         BigNumber,
         BigNumber,
-        BigNumber,
         BigNumber
       ] & {
         netTokenOut: BigNumber;
-        netSyToRedeem: BigNumber;
         netSyFee: BigNumber;
         priceImpact: BigNumber;
         exchangeRateAfter: BigNumber;
@@ -1059,11 +1057,9 @@ export interface ActionMarketCoreStatic extends BaseContract {
         BigNumber,
         BigNumber,
         BigNumber,
-        BigNumber,
         BigNumber
       ] & {
         netTokenOut: BigNumber;
-        netSyToRedeem: BigNumber;
         netSyFee: BigNumber;
         priceImpact: BigNumber;
         exchangeRateAfter: BigNumber;

package/typechain-types/ActionStorageStatic.ts

@@ -204,7 +204,7 @@ export interface ActionStorageStatic extends BaseContract {
 
     getOwnerAndPendingOwner(
       overrides?: CallOverrides
-    ): Promise<[string, string]>;
+    ): Promise<[string, string] & { _owner: string; _pendingOwner: string }>;
 
     setBulkSellerFactory(
       _bulkSellerFactory: string,
@@ -241,7 +241,9 @@ export interface ActionStorageStatic extends BaseContract {
     overrides?: CallOverrides
   ): Promise<ApproxParamsStructOutput>;
 
-  getOwnerAndPendingOwner(overrides?: CallOverrides): Promise<[string, string]>;
+  getOwnerAndPendingOwner(
+    overrides?: CallOverrides
+  ): Promise<[string, string] & { _owner: string; _pendingOwner: string }>;
 
   setBulkSellerFactory(
     _bulkSellerFactory: string,
@@ -281,7 +283,7 @@ export interface ActionStorageStatic extends BaseContract {
 
     getOwnerAndPendingOwner(
       overrides?: CallOverrides
-    ): Promise<[string, string]>;
+    ): Promise<[string, string] & { _owner: string; _pendingOwner: string }>;
 
     setBulkSellerFactory(
       _bulkSellerFactory: string,