@pendle/core-v2 5.0.3 → 5.0.5

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

@@ -1,6 +1,10 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.0;
 
+import {IExecutorHelperL2Struct as L2Struct} from "../interfaces/IExecutorHelperL2Struct.sol";
+import {IKyberDSLO} from "../interfaces/pools/IKyberDSLO.sol";
+import {IKyberLO} from "../interfaces/pools/IKyberLO.sol";
+
 library CalldataReader {
     /// @notice read the bytes value of data from a starting position and length
     /// @param data bytes array of data
@@ -31,6 +35,225 @@ library CalldataReader {
         return (retVal, length + startByte);
     }
 
+    function _readRFQTQuote(
+        bytes memory data,
+        uint256 startByte
+    ) internal pure returns (L2Struct.RFQTQuote memory rfqQuote, uint256, uint256 ebtaStartByte) {
+        (rfqQuote.pool, startByte) = _readAddress(data, startByte);
+        (rfqQuote.externalAccount, startByte) = _readAddress(data, startByte);
+        (rfqQuote.trader, startByte) = _readAddress(data, startByte);
+        (rfqQuote.effectiveTrader, startByte) = _readAddress(data, startByte);
+        // (rfqQuote.baseToken, startByte) = _readAddress(data, startByte);
+        (rfqQuote.quoteToken, startByte) = _readAddress(data, startByte);
+        ebtaStartByte = startByte;
+        (rfqQuote.effectiveBaseTokenAmount, startByte) = _readUint128AsUint256(data, startByte);
+        (rfqQuote.baseTokenAmount, startByte) = _readUint128AsUint256(data, startByte);
+        (rfqQuote.quoteTokenAmount, startByte) = _readUint128AsUint256(data, startByte);
+        (rfqQuote.quoteExpiry, startByte) = _readUint128AsUint256(data, startByte);
+        (rfqQuote.nonce, startByte) = _readUint128AsUint256(data, startByte);
+        (rfqQuote.txid, startByte) = _readBytes32(data, startByte);
+        (rfqQuote.signature, startByte) = _readBytes(data, startByte);
+        return (rfqQuote, startByte, ebtaStartByte);
+    }
+
+    function _readOrderRFQ(
+        bytes memory data,
+        uint256 startByte
+    ) internal pure returns (L2Struct.OrderRFQ memory orderRfq, uint256) {
+        (orderRfq.info, startByte) = _readUint256(data, startByte);
+
+        (orderRfq.makerAsset, startByte) = _readAddress(data, startByte);
+
+        (orderRfq.takerAsset, startByte) = _readAddress(data, startByte);
+
+        (orderRfq.maker, startByte) = _readAddress(data, startByte);
+
+        (orderRfq.allowedSender, startByte) = _readAddress(data, startByte);
+
+        (orderRfq.makingAmount, startByte) = _readUint128AsUint256(data, startByte);
+
+        (orderRfq.takingAmount, startByte) = _readUint128AsUint256(data, startByte);
+
+        return (orderRfq, startByte);
+    }
+
+    function _readDSLOFillBatchOrdersParams(
+        bytes memory data,
+        uint256 startByte
+    )
+        internal
+        pure
+        returns (
+            IKyberDSLO.FillBatchOrdersParams memory params,
+            uint256,
+            uint256 takingAmountStartByte,
+            uint256 thresholdStartByte
+        )
+    {
+        (params.orders, startByte) = _readDSLOOrderArray(data, startByte);
+
+        (params.signatures, startByte) = _readDSLOSignatureArray(data, startByte);
+
+        (params.opExpireTimes, startByte) = _readUint32Array(data, startByte);
+
+        // read taking amount and start byte to scale
+        takingAmountStartByte = startByte;
+        (params.takingAmount, startByte) = _readUint128AsUint256(data, startByte);
+
+        // read threshold amount and start byte to update if scale dơn
+        thresholdStartByte = startByte;
+        (params.thresholdAmount, startByte) = _readUint128AsUint256(data, startByte);
+
+        (params.target, startByte) = _readAddress(data, startByte);
+        return (params, startByte, takingAmountStartByte, thresholdStartByte);
+    }
+
+    function _readLOFillBatchOrdersParams(
+        bytes memory data,
+        uint256 startByte
+    )
+        internal
+        pure
+        returns (
+            IKyberLO.FillBatchOrdersParams memory params,
+            uint256,
+            uint256 takingAmountStartByte,
+            uint256 thresholdStartByte
+        )
+    {
+        (params.orders, startByte) = _readLOOrderArray(data, startByte);
+
+        (params.signatures, startByte) = _readLOSignatureArray(data, startByte);
+
+        takingAmountStartByte = startByte;
+        (params.takingAmount, startByte) = _readUint128AsUint256(data, startByte);
+
+        thresholdStartByte = startByte;
+        (params.thresholdAmount, startByte) = _readUint128AsUint256(data, startByte);
+
+        (params.target, startByte) = _readAddress(data, startByte);
+        return (params, startByte, takingAmountStartByte, thresholdStartByte);
+    }
+
+    function _readLOSignatureArray(
+        bytes memory data,
+        uint256 startByte
+    ) internal pure returns (bytes[] memory signatures, uint256) {
+        bytes memory ret;
+
+        (ret, startByte) = _calldataVal(data, startByte, 1);
+        uint256 length = uint256(uint8(bytes1(ret)));
+
+        signatures = new bytes[](length);
+        for (uint8 i = 0; i < length; ++i) {
+            (signatures[i], startByte) = _readBytes(data, startByte);
+        }
+        return (signatures, startByte);
+    }
+
+    function _readDSLOSignatureArray(
+        bytes memory data,
+        uint256 startByte
+    ) internal pure returns (IKyberDSLO.Signature[] memory signatures, uint256) {
+        bytes memory ret;
+
+        (ret, startByte) = _calldataVal(data, startByte, 1);
+        uint256 length = uint256(uint8(bytes1(ret)));
+
+        signatures = new IKyberDSLO.Signature[](length);
+        for (uint8 i = 0; i < length; ++i) {
+            (signatures[i], startByte) = _readDSLOSignature(data, startByte);
+        }
+        return (signatures, startByte);
+    }
+
+    function _readDSLOSignature(
+        bytes memory data,
+        uint256 startByte
+    ) internal pure returns (IKyberDSLO.Signature memory signature, uint256) {
+        (signature.orderSignature, startByte) = _readBytes(data, startByte);
+        (signature.opSignature, startByte) = _readBytes(data, startByte);
+        return (signature, startByte);
+    }
+
+    function _readLOOrderArray(
+        bytes memory data,
+        uint256 startByte
+    ) internal pure returns (IKyberLO.Order[] memory orders, uint256) {
+        bytes memory ret;
+
+        (ret, startByte) = _calldataVal(data, startByte, 1);
+        uint256 length = uint256(uint8(bytes1(ret)));
+
+        orders = new IKyberLO.Order[](length);
+        for (uint8 i = 0; i < length; ++i) {
+            (orders[i], startByte) = _readLOOrder(data, startByte);
+        }
+        return (orders, startByte);
+    }
+
+    function _readDSLOOrderArray(
+        bytes memory data,
+        uint256 startByte
+    ) internal pure returns (IKyberDSLO.Order[] memory orders, uint256) {
+        bytes memory ret;
+
+        (ret, startByte) = _calldataVal(data, startByte, 1);
+        uint256 length = uint256(uint8(bytes1(ret)));
+
+        orders = new IKyberDSLO.Order[](length);
+        for (uint8 i = 0; i < length; ++i) {
+            (orders[i], startByte) = _readDSLOOrder(data, startByte);
+        }
+        return (orders, startByte);
+    }
+
+    function _readDSLOOrder(
+        bytes memory data,
+        uint256 startByte
+    ) internal pure returns (IKyberDSLO.Order memory orders, uint256) {
+        (orders.salt, startByte) = _readUint128AsUint256(data, startByte);
+        (orders.makerAsset, startByte) = _readAddress(data, startByte);
+        (orders.takerAsset, startByte) = _readAddress(data, startByte);
+        (orders.maker, startByte) = _readAddress(data, startByte);
+        (orders.receiver, startByte) = _readAddress(data, startByte);
+        (orders.allowedSender, startByte) = _readAddress(data, startByte);
+        (orders.makingAmount, startByte) = _readUint128AsUint256(data, startByte);
+        (orders.takingAmount, startByte) = _readUint128AsUint256(data, startByte);
+        (orders.feeConfig, startByte) = _readUint200(data, startByte);
+        (orders.makerAssetData, startByte) = _readBytes(data, startByte);
+        (orders.takerAssetData, startByte) = _readBytes(data, startByte);
+        (orders.getMakerAmount, startByte) = _readBytes(data, startByte);
+        (orders.getTakerAmount, startByte) = _readBytes(data, startByte);
+        (orders.predicate, startByte) = _readBytes(data, startByte);
+        (orders.interaction, startByte) = _readBytes(data, startByte);
+        return (orders, startByte);
+    }
+
+    function _readLOOrder(
+        bytes memory data,
+        uint256 startByte
+    ) internal pure returns (IKyberLO.Order memory orders, uint256) {
+        (orders.salt, startByte) = _readUint128AsUint256(data, startByte);
+        (orders.makerAsset, startByte) = _readAddress(data, startByte);
+        (orders.takerAsset, startByte) = _readAddress(data, startByte);
+        (orders.maker, startByte) = _readAddress(data, startByte);
+        (orders.receiver, startByte) = _readAddress(data, startByte);
+        (orders.allowedSender, startByte) = _readAddress(data, startByte);
+        (orders.makingAmount, startByte) = _readUint128AsUint256(data, startByte);
+        (orders.takingAmount, startByte) = _readUint128AsUint256(data, startByte);
+        (orders.feeRecipient, startByte) = _readAddress(data, startByte);
+        (orders.makerTokenFeePercent, startByte) = _readUint32(data, startByte);
+        (orders.makerAssetData, startByte) = _readBytes(data, startByte);
+        (orders.takerAssetData, startByte) = _readBytes(data, startByte);
+        (orders.getMakerAmount, startByte) = _readBytes(data, startByte);
+        (orders.getTakerAmount, startByte) = _readBytes(data, startByte);
+        (orders.predicate, startByte) = _readBytes(data, startByte);
+        (orders.permit, startByte) = _readBytes(data, startByte);
+        (orders.interaction, startByte) = _readBytes(data, startByte);
+        return (orders, startByte);
+    }
+
     function _readBool(bytes memory data, uint256 startByte) internal pure returns (bool, uint256) {
         bytes memory ret;
         (ret, startByte) = _calldataVal(data, startByte, 1);
@@ -67,6 +290,18 @@ library CalldataReader {
         return (uint160(bytes20(ret)), startByte);
     }
 
+    function _readUint200(bytes memory data, uint256 startByte) internal pure returns (uint200, uint256) {
+        bytes memory ret;
+        (ret, startByte) = _calldataVal(data, startByte, 25);
+        return (uint200(bytes25(ret)), startByte);
+    }
+
+    function _readUint256(bytes memory data, uint256 startByte) internal pure returns (uint256, uint256) {
+        bytes memory ret;
+        (ret, startByte) = _calldataVal(data, startByte, 32);
+        return (uint256(bytes32(ret)), startByte);
+    }
+
     /// @dev only when sure that the value of uint256 never exceed uint128
     function _readUint128AsUint256(bytes memory data, uint256 startByte) internal pure returns (uint256, uint256) {
         bytes memory ret;
@@ -152,4 +387,18 @@ library CalldataReader {
         }
         return (us, startByte);
     }
+
+    function _readUint32Array(
+        bytes memory data,
+        uint256 startByte
+    ) internal pure returns (uint32[] memory arr, uint256) {
+        bytes memory ret;
+        (ret, startByte) = _calldataVal(data, startByte, 1);
+        uint256 length = uint256(uint8(bytes1(ret)));
+        arr = new uint32[](length);
+        for (uint8 i = 0; i < length; ++i) {
+            (arr[i], startByte) = _readUint32(data, startByte);
+        }
+        return (arr, startByte);
+    }
 }

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

@@ -1,4 +1,3 @@
-// SPDX-License-Identifier: MIT
 pragma solidity ^0.8.0;
 
 import "./CalldataReader.sol";

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

@@ -1,10 +1,14 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.0;
 
-import "./CalldataReader.sol";
-import "../interfaces/IExecutorHelperL2.sol";
+import {CalldataReader} from "./CalldataReader.sol";
+import {IExecutorHelperL2} from "../interfaces/IExecutorHelperL2.sol";
+import {IExecutorHelperL2Struct} from "../interfaces/IExecutorHelperL2Struct.sol";
+import {IBebopV3} from "../interfaces/pools/IBebopV3.sol";
 import {BytesHelper} from "./BytesHelper.sol";
 import {Common} from "./Common.sol";
+import {IKyberDSLO} from "../interfaces/pools/IKyberDSLO.sol";
+import {IKyberLO} from "../interfaces/pools/IKyberLO.sol";
 
 /// @title DexScaler
 /// @notice Contain functions to scale DEX structs
@@ -446,8 +450,235 @@ library DexScaler {
 
         (, startByte) = data._readPool(startByte); // orderbook
 
-        (uint128 amount, ) = data._readUint128(startByte); // amount
+        (uint256 amount, ) = data._readUint128AsUint256(startByte); // amount
 
         return data.write16Bytes(startByte, oldAmount == 0 ? 0 : (amount * newAmount) / oldAmount, "scaleLighterV2");
     }
+
+    function scaleMaiPSM(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, "scaleMaiPSM");
+    }
+
+    function scaleKyberRFQ(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        uint256 startByte;
+        (, startByte) = data._readPool(startByte); // rfq
+        (, startByte) = data._readOrderRFQ(startByte); // order
+        (, startByte) = data._readBytes(startByte); // signature
+        (uint256 amount, ) = data._readUint128AsUint256(startByte); // amount
+        return data.write16Bytes(startByte, oldAmount == 0 ? 0 : (amount * newAmount) / oldAmount, "scaleKyberRFQ");
+    }
+
+    function scaleDSLO(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
+        uint256 startByte;
+
+        (, startByte) = data._readPool(startByte); // kyberLOAddress
+
+        (, startByte) = data._readAddress(startByte); // makerAsset
+
+        // (, startByte) = data._readAddress(startByte); // don't have takerAsset
+
+        (
+            IKyberDSLO.FillBatchOrdersParams memory params,
+            ,
+            uint256 takingAmountStartByte,
+            uint256 thresholdStartByte
+        ) = data._readDSLOFillBatchOrdersParams(startByte); // FillBatchOrdersParams
+
+        data = data.write16Bytes(
+            takingAmountStartByte,
+            oldAmount == 0 ? 0 : (params.takingAmount * newAmount) / oldAmount,
+            "scaleDSLO"
+        );
+
+        return data.write16Bytes(thresholdStartByte, 1, "scaleThreshold");
+    }
+
+    function scaleKyberLimitOrder(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        uint256 startByte;
+
+        (, startByte) = data._readPool(startByte); // kyberLOAddress
+
+        (, startByte) = data._readAddress(startByte); // makerAsset
+
+        // (, startByte) = data._readAddress(startByte); // takerAsset
+
+        (
+            IKyberLO.FillBatchOrdersParams memory params,
+            ,
+            uint256 takingAmountStartByte,
+            uint256 thresholdStartByte
+        ) = data._readLOFillBatchOrdersParams(startByte); // FillBatchOrdersParams
+
+        data = data.write16Bytes(
+            takingAmountStartByte,
+            oldAmount == 0 ? 0 : (params.takingAmount * newAmount) / oldAmount,
+            "scaleLO"
+        );
+        return data.write16Bytes(thresholdStartByte, 1, "scaleThreshold");
+    }
+
+    function scaleHashflow(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        uint256 startByte;
+
+        (, startByte) = data._readAddress(startByte); // router
+
+        (IExecutorHelperL2.RFQTQuote memory rfqQuote, , uint256 ebtaStartByte) = data._readRFQTQuote(startByte); // RFQTQuote
+
+        return
+            data.write16Bytes(
+                ebtaStartByte,
+                oldAmount == 0 ? 0 : (rfqQuote.effectiveBaseTokenAmount * newAmount) / oldAmount,
+                "scaleHashflow"
+            );
+    }
+
+    function scaleNative(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
+        require(newAmount < oldAmount, "Native: not support scale up");
+
+        uint256 startByte;
+        bytes memory strData;
+        uint256 amountStartByte;
+        uint256 amount;
+        uint256 multihopAndOffset;
+        uint256 strDataStartByte;
+
+        (, startByte) = data._readAddress(startByte); // target
+
+        amountStartByte = startByte;
+        (amount, startByte) = data._readUint128AsUint256(startByte); // amount
+
+        strDataStartByte = startByte;
+        (strData, startByte) = data._readBytes(startByte); // data
+
+        (, startByte) = data._readAddress(startByte); // tokenIn
+        (, startByte) = data._readAddress(startByte); // tokenOut
+        (, startByte) = data._readAddress(startByte); // recipient
+        (multihopAndOffset, startByte) = data._readUint256(startByte); // multihopAndOffset
+
+        require(multihopAndOffset >> 255 == 0, "Native: Multihop not supported");
+
+        amount = (amount * newAmount) / oldAmount;
+
+        uint256 amountInOffset = uint256(uint64(multihopAndOffset >> 64));
+        uint256 amountOutMinOffset = uint256(uint64(multihopAndOffset));
+        // bytes memory newCallData = strData;
+
+        strData = strData.write32Bytes(amountInOffset, amount, "ScaleStructDataAmount");
+
+        // update amount out min if needed
+        if (amountOutMinOffset != 0) {
+            strData = strData.write32Bytes(amountOutMinOffset, 1, "ScaleStructDataAmountOutMin");
+        }
+
+        data.write16Bytes(amountStartByte, amount, "scaleNativeAmount");
+
+        return data.writeBytes(strDataStartByte + 4, strData);
+    }
+
+    function scaleBebop(bytes memory data, uint256 oldAmount, uint256 newAmount) internal pure returns (bytes memory) {
+        require(newAmount < oldAmount, "Bebop: not support scale up");
+
+        uint256 startByte;
+        uint256 amount;
+        uint256 amountStartByte;
+        uint256 txDataStartByte;
+        bytes memory txData;
+
+        (, startByte) = data._readPool(startByte); // pool
+
+        amountStartByte = startByte;
+        (amount, startByte) = data._readUint128AsUint256(startByte); // amount
+        txDataStartByte = startByte;
+        (txData, startByte) = data._readBytes(startByte); // data
+
+        amount = (amount * newAmount) / oldAmount;
+
+        {
+            // update calldata with new swap amount
+            (bytes4 selector, bytes memory callData) = txData.splitCalldata();
+
+            (IBebopV3.Single memory s, IBebopV3.MakerSignature memory m, ) = abi.decode(
+                callData,
+                (IBebopV3.Single, IBebopV3.MakerSignature, uint256)
+            );
+
+            txData = bytes.concat(bytes4(selector), abi.encode(s, m, amount));
+        }
+
+        data.write16Bytes(amountStartByte, amount, "scaleBebopAmount");
+
+        return data.writeBytes(txDataStartByte + 4, txData);
+    }
+
+    function scaleMantleUsd(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        (uint256 isWrapAndAmount, ) = data._readUint256(0);
+
+        bool _isWrap = isWrapAndAmount >> 255 == 1;
+        uint256 _amount = uint256(uint128(isWrapAndAmount));
+
+        //scale amount
+        _amount = oldAmount == 0 ? 0 : (_amount * newAmount) / oldAmount;
+
+        // reset and create new variable for isWrap and amount
+        isWrapAndAmount = 0;
+        isWrapAndAmount |= uint256(uint128(_amount));
+        isWrapAndAmount |= uint256(_isWrap ? 1 : 0) << 255;
+        return abi.encode(isWrapAndAmount);
+    }
+
+    function scaleKelp(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, "scaleKelp");
+    }
+
+    function scaleSymbioticLRT(
+        bytes memory data,
+        uint256 oldAmount,
+        uint256 newAmount
+    ) internal pure returns (bytes memory) {
+        uint256 startByte;
+
+        (, startByte) = data._readPool(startByte); // vault
+
+        (uint256 amount, ) = data._readUint128AsUint256(startByte); // amount
+        return data.write16Bytes(startByte, oldAmount == 0 ? 0 : (amount * newAmount) / oldAmount, "scaleSymbioticLRT");
+    }
+
+    function scaleMaverickV2(
+        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, "scaleMaverickV2");
+    }
 }