@pendle/core-v2 3.0.0-beta-11 → 3.0.0-beta-12

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

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "./CalldataReader.sol";
+
+library Common {
+    using CalldataReader for bytes;
+
+    function _readPool(bytes memory data, uint256 startByte) internal pure returns (address, uint256) {
+        uint24 poolId;
+        address poolAddress;
+        (poolId, startByte) = data._readUint24(startByte);
+        if (poolId == 0) {
+            (poolAddress, startByte) = data._readAddress(startByte);
+        }
+        return (poolAddress, startByte);
+    }
+
+    function _readRecipient(bytes memory data, uint256 startByte) internal pure returns (address, uint256) {
+        uint8 recipientFlag;
+        address recipient;
+        (recipientFlag, startByte) = data._readUint8(startByte);
+        if (recipientFlag != 2 && recipientFlag != 1) {
+            (recipient, startByte) = data._readAddress(startByte);
+        }
+        return (recipient, startByte);
+    }
+
+    function _readBytes32Array(
+        bytes memory data,
+        uint256 startByte
+    ) internal pure returns (bytes32[] memory bytesArray, uint256) {
+        bytes memory ret;
+        (ret, startByte) = data._calldataVal(startByte, 1);
+        uint256 length = uint256(uint8(bytes1(ret)));
+        bytesArray = new bytes32[](length);
+        for (uint8 i = 0; i < length; ++i) {
+            (bytesArray[i], startByte) = data._readBytes32(startByte);
+        }
+        return (bytesArray, startByte);
+    }
+}

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

@@ -0,0 +1,382 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "./CalldataReader.sol";
+import "../interfaces/IExecutorHelperL2.sol";
+import {BytesHelper} from "./BytesHelper.sol";
+import {Common} from "./Common.sol";
+
+/// @title DexScaler
+/// @notice Contain functions to scale DEX structs
+/// @dev For this repo's scope, we only care about swap amounts, so we just need to decode until we get swap amounts
+library DexScaler {
+    using BytesHelper for bytes;
+    using CalldataReader for bytes;
+    using Common for bytes;
+
+    function scaleUniSwap(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        uint256 startByte;
+        // decode
+        (, startByte) = data._readPool(startByte);
+        (, startByte) = data._readRecipient(startByte);
+        (uint256 swapAmount, ) = data._readUint128AsUint256(startByte);
+        return data.write16Bytes(startByte, oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount, "scaleUniSwap");
+    }
+
+    function scaleStableSwap(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        uint256 startByte;
+        (, startByte) = data._readPool(startByte);
+        (, startByte) = data._readUint8(startByte);
+        (uint256 swapAmount, ) = data._readUint128AsUint256(startByte);
+        return
+            data.write16Bytes(startByte, oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount, "scaleStableSwap");
+    }
+
+    function scaleCurveSwap(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        uint256 startByte;
+        bool canGetIndex;
+        (canGetIndex, startByte) = data._readBool(0);
+        (, startByte) = data._readPool(startByte);
+        if (!canGetIndex) {
+            (, startByte) = data._readAddress(startByte);
+            (, startByte) = data._readUint8(startByte);
+        }
+        (, startByte) = data._readUint8(startByte);
+        (uint256 swapAmount, ) = data._readUint128AsUint256(startByte);
+        return
+            data.write16Bytes(startByte, oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount, "scaleCurveSwap");
+    }
+
+    function scaleUniswapV3KSElastic(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        uint256 startByte;
+        (, startByte) = data._readRecipient(startByte);
+        (, startByte) = data._readPool(startByte);
+        (uint256 swapAmount, ) = data._readUint128AsUint256(startByte);
+        return
+            data.write16Bytes(
+                startByte,
+                oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount,
+                "scaleUniswapV3KSElastic"
+            );
+    }
+
+    function scaleBalancerV2(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        uint256 startByte;
+        (, startByte) = data._readPool(startByte);
+        (, startByte) = data._readBytes32(startByte);
+        (, startByte) = data._readUint8(startByte);
+        (uint256 swapAmount, ) = data._readUint128AsUint256(startByte);
+        return
+            data.write16Bytes(startByte, oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount, "scaleBalancerV2");
+    }
+
+    function scaleDODO(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
+        uint256 startByte;
+        (, startByte) = data._readRecipient(startByte);
+        (, startByte) = data._readPool(startByte);
+        (uint256 swapAmount, ) = data._readUint128AsUint256(startByte);
+        return data.write16Bytes(startByte, oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount, "scaleDODO");
+    }
+
+    function scaleGMX(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
+        uint256 startByte;
+        // decode
+        (, startByte) = data._readPool(startByte);
+
+        (, startByte) = data._readAddress(startByte);
+
+        (uint256 swapAmount, ) = data._readUint128AsUint256(startByte);
+        return data.write16Bytes(startByte, oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount, "scaleGMX");
+    }
+
+    function scaleSynthetix(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        uint256 startByte;
+
+        // decode
+        (, startByte) = data._readPool(startByte);
+
+        (, startByte) = data._readAddress(startByte);
+        (, startByte) = data._readBytes32(startByte);
+
+        (uint256 swapAmount, ) = data._readUint128AsUint256(startByte);
+        return
+            data.write16Bytes(startByte, oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount, "scaleSynthetix");
+    }
+
+    function scaleWrappedstETH(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        uint256 startByte;
+
+        // decode
+        (, startByte) = data._readPool(startByte);
+
+        (uint256 swapAmount, ) = data._readUint128AsUint256(startByte);
+        return
+            data.write16Bytes(
+                startByte,
+                oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount,
+                "scaleWrappedstETH"
+            );
+    }
+
+    function scaleStETH(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
+        (uint256 swapAmount, ) = data._readUint128AsUint256(0);
+        return data.write16Bytes(0, oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount, "scaleStETH");
+    }
+
+    function scalePlatypus(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        uint256 startByte;
+
+        // decode
+        (, startByte) = data._readPool(startByte);
+
+        (, startByte) = data._readAddress(startByte);
+
+        (, startByte) = data._readRecipient(startByte);
+
+        (uint256 swapAmount, ) = data._readUint128AsUint256(startByte);
+        return data.write16Bytes(startByte, oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount, "scalePlatypus");
+    }
+
+    function scalePSM(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
+        uint256 startByte;
+
+        // decode
+        (, startByte) = data._readPool(startByte);
+
+        (, startByte) = data._readAddress(startByte);
+
+        (uint256 swapAmount, ) = data._readUint128AsUint256(startByte);
+
+        return data.write16Bytes(startByte, oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount, "scalePSM");
+    }
+
+    function scaleMaverick(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        uint256 startByte;
+
+        // decode
+        (, startByte) = data._readPool(startByte);
+
+        (, startByte) = data._readAddress(startByte);
+
+        (, startByte) = data._readRecipient(startByte);
+
+        (uint256 swapAmount, ) = data._readUint128AsUint256(startByte);
+        return data.write16Bytes(startByte, oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount, "scaleMaverick");
+    }
+
+    function scaleSyncSwap(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        uint256 startByte;
+
+        // decode
+        (, startByte) = data._readBytes(startByte);
+        (, startByte) = data._readPool(startByte);
+
+        (, startByte) = data._readAddress(startByte);
+
+        (uint256 swapAmount, ) = data._readUint128AsUint256(startByte);
+        return data.write16Bytes(startByte, oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount, "scaleSyncSwap");
+    }
+
+    function scaleAlgebraV1(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        uint256 startByte;
+
+        (, startByte) = data._readRecipient(startByte);
+
+        (, startByte) = data._readPool(startByte);
+
+        (, startByte) = data._readAddress(startByte);
+
+        (uint256 swapAmount, ) = data._readUint128AsUint256(startByte);
+
+        return
+            data.write16Bytes(startByte, oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount, "scaleAlgebraV1");
+    }
+
+    function scaleBalancerBatch(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        uint256 startByte;
+
+        // decode
+        (, startByte) = data._readPool(startByte);
+
+        (, startByte) = data._readBytes32Array(startByte);
+        (, startByte) = data._readAddressArray(startByte);
+        (, startByte) = data._readBytesArray(startByte);
+
+        (uint256 swapAmount, ) = data._readUint128AsUint256(startByte);
+        return
+            data.write16Bytes(
+                startByte,
+                oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount,
+                "scaleBalancerBatch"
+            );
+    }
+
+    function scaleMantis(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
+        uint256 startByte;
+
+        (, startByte) = data._readPool(startByte); // pool
+
+        (, startByte) = data._readAddress(startByte); // tokenOut
+
+        (uint256 swapAmount, ) = data._readUint128AsUint256(startByte); // amount
+        return data.write16Bytes(startByte, oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount, "scaleMantis");
+    }
+
+    function scaleIziSwap(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        uint256 startByte;
+
+        (, startByte) = data._readPool(startByte); // pool
+
+        (, startByte) = data._readAddress(startByte); // tokenOut
+
+        // recipient
+        (, startByte) = data._readRecipient(startByte);
+
+        (uint256 swapAmount, ) = data._readUint128AsUint256(startByte); // amount
+        return data.write16Bytes(startByte, oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount, "scaleIziSwap");
+    }
+
+    function scaleTraderJoeV2(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        uint256 startByte;
+
+        // recipient
+        (, startByte) = data._readRecipient(startByte);
+
+        (, startByte) = data._readPool(startByte); // pool
+
+        (, startByte) = data._readAddress(startByte); // tokenOut
+
+        (, startByte) = data._readBool(startByte); // isV2
+
+        (uint256 swapAmount, ) = data._readUint128AsUint256(startByte); // amount
+        return
+            data.write16Bytes(startByte, oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount, "scaleTraderJoeV2");
+    }
+
+    function scaleLevelFiV2(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        uint256 startByte;
+
+        (, startByte) = data._readPool(startByte); // pool
+
+        (, startByte) = data._readAddress(startByte); // tokenOut
+
+        (uint256 swapAmount, ) = data._readUint128AsUint256(startByte); // amount
+        return
+            data.write16Bytes(startByte, oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount, "scaleLevelFiV2");
+    }
+
+    function scaleGMXGLP(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
+        uint256 startByte;
+
+        (, startByte) = data._readPool(startByte); // pool
+
+        (, startByte) = data._readAddress(startByte); // yearnVault
+
+        uint8 directionFlag;
+        (directionFlag, startByte) = data._readUint8(startByte);
+        if (directionFlag == 1) (, startByte) = data._readAddress(startByte); // tokenOut
+
+        (uint256 swapAmount, ) = data._readUint128AsUint256(startByte); // amount
+        return data.write16Bytes(startByte, oldAmount == 0 ? 0 : (swapAmount * newAmount) / oldAmount, "scaleGMXGLP");
+    }
+
+    function scaleVooi(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
+        uint256 startByte;
+
+        (, startByte) = data._readPool(startByte); // pool
+
+        (, startByte) = data._readUint8(startByte); // toId
+
+        (uint256 fromAmount, ) = data._readUint128AsUint256(startByte); // amount
+
+        return data.write16Bytes(startByte, oldAmount == 0 ? 0 : (fromAmount * newAmount) / oldAmount, "scaleVooi");
+    }
+
+    function scaleVelocoreV2(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        uint256 startByte;
+
+        (, startByte) = data._readPool(startByte); // pool
+
+        (, startByte) = data._readAddress(startByte); // tokenOut
+
+        (uint256 amount, ) = data._readUint128AsUint256(startByte); // amount
+        return data.write16Bytes(startByte, oldAmount == 0 ? 0 : (amount * newAmount) / oldAmount, "scaleVelocoreV2");
+    }
+
+    function scaleKokonut(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        uint256 startByte;
+
+        (, startByte) = data._readPool(startByte); // pool
+
+        (uint256 amount, ) = data._readUint128AsUint256(startByte); // amount
+        return data.write16Bytes(startByte, oldAmount == 0 ? 0 : (amount * newAmount) / oldAmount, "scaleKokonut");
+    }
+}

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

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "./CalldataReader.sol";
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "../interfaces/IAggregationExecutorOptimistic.sol";
+
+library ExecutorReader {
+    function readSwapExecutorDescription(bytes memory data) internal pure returns (bytes memory) {
+        uint256 startByte = 0;
+        IAggregationExecutorOptimistic.SwapExecutorDescription memory desc;
+
+        // Swap array
+        bytes memory ret;
+        (ret, startByte) = CalldataReader._calldataVal(data, startByte, 1);
+        uint256 lX = uint256(uint8(bytes1(ret)));
+        desc.swapSequences = new IAggregationExecutorOptimistic.Swap[][](lX);
+        for (uint8 i = 0; i < lX; ++i) {
+            (ret, startByte) = CalldataReader._calldataVal(data, startByte, 1);
+            uint256 lY = uint256(uint8(bytes1(ret)));
+            desc.swapSequences[i] = new IAggregationExecutorOptimistic.Swap[](lY);
+            for (uint8 j = 0; j < lY; ++j) {
+                (desc.swapSequences[i][j], startByte) = _readSwap(data, startByte);
+            }
+        }
+
+        // basic members
+        (desc.tokenIn, startByte) = CalldataReader._readAddress(data, startByte);
+        (desc.tokenOut, startByte) = CalldataReader._readAddress(data, startByte);
+        (desc.to, startByte) = CalldataReader._readAddress(data, startByte);
+        (desc.deadline, startByte) = CalldataReader._readUint128AsUint256(data, startByte);
+        (desc.positiveSlippageData, startByte) = CalldataReader._readBytes(data, startByte);
+
+        return abi.encode(desc);
+    }
+
+    function readSwapSingleSequence(
+        bytes memory data
+    ) internal pure returns (IAggregationExecutorOptimistic.Swap[] memory swaps, address tokenIn) {
+        uint256 startByte = 0;
+        bytes memory ret;
+        (ret, startByte) = CalldataReader._calldataVal(data, startByte, 1);
+        uint256 len = uint256(uint8(bytes1(ret)));
+        swaps = new IAggregationExecutorOptimistic.Swap[](len);
+        for (uint8 i = 0; i < len; ++i) {
+            (swaps[i], startByte) = _readSwap(data, startByte);
+        }
+        (tokenIn, startByte) = CalldataReader._readAddress(data, startByte);
+    }
+
+    function _readSwap(
+        bytes memory data,
+        uint256 startByte
+    ) internal pure returns (IAggregationExecutorOptimistic.Swap memory swap, uint256) {
+        (swap.data, startByte) = CalldataReader._readBytes(data, startByte);
+        bytes1 t;
+        (t, startByte) = CalldataReader._readBytes1(data, startByte);
+        swap.functionSelector = bytes4(uint32(uint8(t)));
+        return (swap, startByte);
+    }
+}