punkkit-sdk 1.0.0

package/contracts/uniswap/DynamicFee.sol

@@ -0,0 +1,100 @@
+// SPDX-License-Identifier: UNLICENSED
+// a uniswapV4 hook that allows the pool use dynamic fees
+pragma solidity ^0.8.20;
+import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
+import {StateLibrary} from "@uniswap/v4-core/src/libraries/StateLibrary.sol";
+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
+import {PoolId, PoolIdLibrary} from "@uniswap/v4-core/src/types/PoolId.sol";
+import {Pool} from "@uniswap/v4-core/src/libraries/Pool.sol";
+import {Hooks} from "@uniswap/v4-core/src/libraries/Hooks.sol";
+import {FullMath} from "@uniswap/v4-core/src/libraries/FullMath.sol";
+import {SafeCast} from "@uniswap/v4-core/src/libraries/SafeCast.sol";
+import {IERC20Minimal} from "@uniswap/v4-core/src/interfaces/external/IERC20Minimal.sol";
+import {IERC1155Receiver} from "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
+import {Currency} from "@uniswap/v4-core/src/libraries/CurrencyDelta.sol";
+import {BalanceDelta, toBalanceDelta} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
+import {BeforeSwapDelta, toBeforeSwapDelta} from "@uniswap/v4-core/src/types/BeforeSwapDelta.sol";
+import {ModifyLiquidityParams, SwapParams} from "@uniswap/v4-core/src/types/PoolOperation.sol";
+
+/// @notice The dynamic fee manager determines fees for pools
+/// @dev note that this pool is only called if the PoolKey fee value is equal to the DYNAMIC_FEE magic value
+interface IDynamicFeeManager {
+    function getFee(PoolKey calldata key) external returns (uint24);
+}
+
+contract DynamicFee is IDynamicFeeManager{
+    using SafeCast for uint256;
+    using Pool for Pool.State;
+    using StateLibrary for IPoolManager;
+
+    uint160 public lastPrice; 
+    uint160 public nowPrice;
+    uint256 public lastBlockNumber;
+    uint24 public feeNow;
+    IPoolManager public immutable poolManager;
+
+    constructor(IPoolManager _poolManager) {
+        poolManager = _poolManager;
+    }
+
+    function getHookPermissions() public pure returns (Hooks.Permissions memory) {
+        return Hooks.Permissions({
+            beforeInitialize: false,
+            afterInitialize: true,
+            beforeAddLiquidity: false,
+            afterAddLiquidity: false,
+            beforeRemoveLiquidity: false,
+            afterRemoveLiquidity: false,
+            beforeSwap: false,
+            afterSwap: true,
+            beforeDonate: false,
+            afterDonate: false,
+            beforeSwapReturnDelta: false,
+            afterSwapReturnDelta: false,
+            afterAddLiquidityReturnDelta: false,
+            afterRemoveLiquidityReturnDelta: false
+        });
+    }
+
+    function afterInitialize(address, PoolKey calldata key, uint160, int24)
+        external
+        virtual
+        returns (bytes4)
+    {
+        // Initializing the nowPrice during the initialization of the contract
+        (nowPrice,,,) = poolManager.getSlot0(PoolIdLibrary.toId(key));
+        lastBlockNumber = block.number;
+
+        return DynamicFee.afterInitialize.selector;
+    }
+
+    function getFee(PoolKey calldata key) external returns (uint24) {
+        if(block.number > lastBlockNumber) {
+            lastPrice = nowPrice;
+
+            // 调用function getSlot0(PoolId id), 获取价格信息存入price_now
+            (nowPrice,,,) = poolManager.getSlot0(PoolIdLibrary.toId(key));
+            
+            // 比较price_now和price_last, 根据price波动率设定fee
+            if(nowPrice > lastPrice) {
+                feeNow = 30;
+            } else {
+                feeNow = 5;
+            }
+            
+            lastBlockNumber = block.number; // Update the last block number
+        }
+        return feeNow;
+    }
+
+    function afterSwap(address, PoolKey calldata, SwapParams calldata, BalanceDelta, bytes calldata)
+        external
+        virtual
+        returns (bytes4, int128) 
+    {
+        // Update lastBlockNumber after the swap
+        lastBlockNumber = block.number;
+        return (DynamicFee.afterSwap.selector, 0);
+    }
+
+}

package/contracts/uniswap/Example.sol

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+contract Example {
+    uint256 public value;
+
+    constructor(uint256 _value) {
+        value = _value;
+    }
+
+    function setValue(uint256 _value) external {
+        value = _value;
+    }
+
+    function getValue() external view returns (uint256) {
+        return value;
+    }   
+}
+
+
+contract Example2{
+    string public name;
+
+    constructor() {
+        name = "Hello World!";
+    }
+
+    function setName(string calldata _name)  public {
+        name = _name;
+    }
+
+    function getName() public view returns (string memory){
+        return name;
+    }
+}

package/contracts/uniswap/HookMiner.sol

@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity ^0.8.21;
+
+/// @title HookMiner - a library for mining hook addresses
+/// @dev This library is intended for `forge test` environments. There may be gotchas when using salts in `forge script` or `forge create`
+library HookMiner {
+    // mask to slice out the bottom 14 bit of the address
+    uint160 constant FLAG_MASK = 0x3FFF;
+
+    // Maximum number of iterations to find a salt, avoid infinite loops
+    uint256 constant MAX_LOOP = 100_000;
+
+    /// @notice Find a salt that produces a hook address with the desired `flags`
+    /// @param deployer The address that will deploy the hook. In `forge test`, this will be the test contract `address(this)` or the pranking address
+    ///                 In `forge script`, this should be `0x4e59b44847b379578588920cA78FbF26c0B4956C` (CREATE2 Deployer Proxy)
+    /// @param flags The desired flags for the hook address
+    /// @param creationCode The creation code of a hook contract. Example: `type(Counter).creationCode`
+    /// @param constructorArgs The encoded constructor arguments of a hook contract. Example: `abi.encode(address(manager))`
+    /// @return hookAddress salt and corresponding address that was found. The salt can be used in `new Hook{salt: salt}(<constructor arguments>)`
+    function find(address deployer, uint160 flags, bytes memory creationCode, bytes memory constructorArgs)
+        internal
+        view
+        returns (address, bytes32)
+    {
+        address hookAddress;
+        bytes memory creationCodeWithArgs = abi.encodePacked(creationCode, constructorArgs);
+
+        uint256 salt;
+        for (salt; salt < MAX_LOOP; salt++) {
+            hookAddress = computeAddress(deployer, salt, creationCodeWithArgs);
+            if (uint160(hookAddress) & FLAG_MASK == flags && hookAddress.code.length == 0) {
+                return (hookAddress, bytes32(salt));
+            }
+        }
+        revert("HookMiner: could not find salt");
+    }
+
+    /// @notice Precompute a contract address deployed via CREATE2
+    /// @param deployer The address that will deploy the hook. In `forge test`, this will be the test contract `address(this)` or the pranking address
+    ///                 In `forge script`, this should be `0x4e59b44847b379578588920cA78FbF26c0B4956C` (CREATE2 Deployer Proxy)
+    /// @param salt The salt used to deploy the hook
+    /// @param creationCode The creation code of a hook contract
+    function computeAddress(address deployer, uint256 salt, bytes memory creationCode)
+        internal
+        pure
+        returns (address hookAddress)
+    {
+        return address(
+            uint160(uint256(keccak256(abi.encodePacked(bytes1(0xFF), deployer, salt, keccak256(creationCode)))))
+        );
+    }
+}

package/contracts/uniswap/LimitOrder.sol

@@ -0,0 +1,486 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.19;
+
+import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
+import {StateLibrary} from "@uniswap/v4-core/src/libraries/StateLibrary.sol";
+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
+import {PoolId, PoolIdLibrary} from "@uniswap/v4-core/src/types/PoolId.sol";
+import {Hooks} from "@uniswap/v4-core/src/libraries/Hooks.sol";
+import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
+import {FullMath} from "@uniswap/v4-core/src/libraries/FullMath.sol";
+import {SafeCast} from "@uniswap/v4-core/src/libraries/SafeCast.sol";
+// import {IERC20Minimal} from "@uniswap/v4-core/src/interfaces/external/IERC20Minimal.sol";
+import {IUnlockCallback} from '@uniswap/v4-core/src/interfaces/callback/IUnlockCallback.sol';
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import {IERC1155Receiver} from "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
+import {Currency, CurrencyDelta} from "@uniswap/v4-core/src/libraries/CurrencyDelta.sol";
+import {BalanceDelta, toBalanceDelta} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
+import {BeforeSwapDelta, toBeforeSwapDelta} from "@uniswap/v4-core/src/types/BeforeSwapDelta.sol";
+import {ModifyLiquidityParams, SwapParams} from "@uniswap/v4-core/src/types/PoolOperation.sol";
+import "hardhat/console.sol";
+
+type Epoch is uint232;
+
+library EpochLibrary {
+    function equals(Epoch a, Epoch b) internal pure returns (bool) {
+        return Epoch.unwrap(a) == Epoch.unwrap(b);
+    }
+
+    function unsafeIncrement(Epoch a) internal pure returns (Epoch) {
+        unchecked {
+            return Epoch.wrap(Epoch.unwrap(a) + 1);
+        }
+    }
+}
+
+contract LimitOrder is IUnlockCallback{
+    using EpochLibrary for Epoch;
+    using PoolIdLibrary for PoolKey;
+    using CurrencyDelta for Currency;
+    using StateLibrary for IPoolManager;
+    using SafeERC20 for IERC20;
+
+    error ZeroLiquidity();
+    error InRange();
+    error CrossedRange();
+    error Filled();
+    error NotFilled();
+    error NotPoolManagerToken();
+    error InvalidFunc(bytes4 funcsig);
+    error InvalidPool();
+    error NotPoolManager();
+
+    event Place(
+        address indexed owner,
+        Epoch indexed epoch,
+        PoolKey key,
+        int24 tickLower,
+        bool zeroForOne,
+        uint128 liquidity
+    );
+
+    event Fill(Epoch indexed epoch, PoolKey key, int24 tickLower, bool zeroForOne);
+
+    event Kill(
+        address indexed owner,
+        Epoch indexed epoch,
+        PoolKey key,
+        int24 tickLower,
+        bool zeroForOne,
+        uint128 liquidity
+    );
+
+    event Withdraw(address indexed owner, Epoch indexed epoch, uint128 liquidity);
+
+    Epoch private constant EPOCH_DEFAULT = Epoch.wrap(0);
+
+    mapping(PoolId => int24) public tickLowerLasts;
+    Epoch public epochNext = Epoch.wrap(1);
+
+    struct EpochInfo {
+        bool filled;
+        Currency currency0;
+        Currency currency1;
+        uint256 token0Total;
+        uint256 token1Total;
+        uint128 liquidityTotal;
+        mapping(address => uint128) liquidity;
+    }
+
+    mapping(bytes32 => Epoch) public epochs;
+    mapping(Epoch => EpochInfo) public epochInfos;
+
+    IPoolManager public immutable poolManager;
+    constructor(IPoolManager _poolManager)  {
+        poolManager = _poolManager;
+    }
+
+    // modifer 修饰的函数，会在_的位置执行
+    modifier onlyByPoolManager() {
+        if (msg.sender != address(poolManager)) revert NotPoolManager();
+        _;  // 被修饰函数执行逻辑
+    }
+    modifier onlyValidPools(IHooks hooks) {
+        if (address(hooks) != address(this)) revert InvalidPool();
+        _;
+    }
+
+    function getHookPermissions() public pure returns (Hooks.Permissions memory) {
+        return Hooks.Permissions({
+            beforeInitialize: false,
+            afterInitialize: true,
+            beforeAddLiquidity: false,
+            afterAddLiquidity: false,
+            beforeRemoveLiquidity: false,
+            afterRemoveLiquidity: false,
+            beforeSwap: false,
+            afterSwap: true,
+            beforeDonate: false,
+            afterDonate: false,
+            beforeSwapReturnDelta: false,
+            afterSwapReturnDelta: false,
+            afterAddLiquidityReturnDelta: false,
+            afterRemoveLiquidityReturnDelta: false
+        });
+    }
+
+    function getTickLowerLast(PoolId poolId) public view returns (int24) {
+        return tickLowerLasts[poolId];
+    }
+
+    function setTickLowerLast(PoolId poolId, int24 tickLower) private {
+        tickLowerLasts[poolId] = tickLower;
+    }
+
+    function getEpoch(PoolKey memory key, int24 tickLower, bool zeroForOne) public view returns (Epoch) {
+        return epochs[keccak256(abi.encode(key, tickLower, zeroForOne))];
+    }
+
+    function setEpoch(PoolKey memory key, int24 tickLower, bool zeroForOne, Epoch epoch) private {
+        epochs[keccak256(abi.encode(key, tickLower, zeroForOne))] = epoch;
+    }
+
+    function getEpochLiquidity(Epoch epoch, address owner) external view returns (uint256) {
+        return epochInfos[epoch].liquidity[owner];
+    }
+
+    function getTick(PoolId poolId) private view returns (int24 tick) {
+        (,tick,,) = poolManager.getSlot0(poolId);
+    }
+
+    function getTickLower(int24 tick, int24 tickSpacing) private pure returns (int24) {
+        int24 compressed = tick / tickSpacing;
+        if (tick < 0 && tick % tickSpacing != 0) compressed--; // round towards negative infinity
+        return compressed * tickSpacing;
+    }
+
+    // see src/base/SafeCallback.sol
+    function unlockCallback(bytes calldata data) external returns (bytes memory) {
+        bytes4 funcSig = bytes4(data[:4]);
+        bytes memory args = bytes(data[4:]);
+
+        if (funcSig == this.lockAcquiredPlace.selector) {
+            (PoolKey memory key, int24 tickLower, bool zeroForOne, int256 liquidityDelta, address owner, bytes32 salt) = abi.decode(args, (PoolKey, int24, bool, int256, address, bytes32));
+            lockAcquiredPlace(key, tickLower, zeroForOne, liquidityDelta, owner, salt);
+        } else if (funcSig == this.lockAcquiredKill.selector) {
+            (PoolKey memory key, int24 tickLower, int256 liquidityDelta, address to, bool removingAllLiquidity, bytes32 salt) = abi.decode(args, (PoolKey, int24, int256, address, bool, bytes32));
+            (uint256 amount0, uint256 amount1, uint128 amount0Fee, uint128 amount1Fee) = lockAcquiredKill(key, tickLower, liquidityDelta, to, removingAllLiquidity, salt);   
+            return abi.encode(amount0, amount1, amount0Fee, amount1Fee);
+        } else if (funcSig == this.lockAcquiredWithdraw.selector) {
+            (Currency currency0, Currency currency1, uint256 token0Amount, uint256 token1Amount, address to) = abi.decode(args, (Currency, Currency, uint256, uint256, address));
+            lockAcquiredWithdraw(currency0, currency1, token0Amount, token1Amount, to);
+        } else {
+            // todo: reverted with an unrecognized custom error (return data: 0x29c3b7ee)
+            revert InvalidFunc(funcSig);
+        }
+
+        return bytes("");
+    }
+
+    function afterInitialize(address, PoolKey calldata key, uint160, int24 tick)
+        external
+        returns (bytes4)
+    {
+        setTickLowerLast(key.toId(), getTickLower(tick, key.tickSpacing));
+        return LimitOrder.afterInitialize.selector;
+    }
+
+    function afterSwap(
+        address,
+        PoolKey calldata key,
+        SwapParams calldata params,
+        BalanceDelta,
+        bytes calldata hookData
+    ) external returns (bytes4, int128) {
+        (int24 tickLower, int24 lower, int24 upper) = _getCrossedTicks(key.toId(), key.tickSpacing);
+        if (lower > upper) return (LimitOrder.afterSwap.selector, 0);
+
+        bytes32 salt = abi.decode(hookData, (bytes32));
+        salt=bytes32(0); // 临时修改为0，方便测试""
+
+        // note that a zeroForOne swap means that the pool is actually gaining token0, so limit
+        // order fills are the opposite of swap fills, hence the inversion below
+        bool zeroForOne = !params.zeroForOne;
+        for (; lower <= upper; lower += key.tickSpacing) {
+            Epoch epoch = getEpoch(key, lower, zeroForOne);
+
+            if (!epoch.equals(EPOCH_DEFAULT)) {
+                EpochInfo storage epochInfo = epochInfos[epoch];
+                epochInfo.filled = true;
+                console.log("epoch(set true):", uint256(Epoch.unwrap(epoch)));
+                (uint256 amount0, uint256 amount1) = lockAcquiredFill(key, lower, -int256(uint256(epochInfo.liquidityTotal)), salt);
+                unchecked {
+                    epochInfo.token0Total += amount0;
+                    epochInfo.token1Total += amount1;
+                }
+                // 惰性删除，等到withdraw再删除
+                setEpoch(key, lower, zeroForOne, EPOCH_DEFAULT);
+                emit Fill(epoch, key, lower, zeroForOne);
+            }
+        }
+        setTickLowerLast(key.toId(), tickLower);
+        return (LimitOrder.afterSwap.selector, 0);
+    }
+
+    function _getCrossedTicks(PoolId poolId, int24 tickSpacing)
+        internal
+        view
+        returns (int24 tickLower, int24 lower, int24 upper)
+    {
+        tickLower = getTickLower(getTick(poolId), tickSpacing);
+        int24 tickLowerLast = getTickLowerLast(poolId);
+
+        if (tickLower < tickLowerLast) {
+            lower = tickLower + tickSpacing;
+            upper = tickLowerLast;
+        } else {
+            lower = tickLowerLast;
+            upper = tickLower - tickSpacing;
+        }
+    }
+
+    function lockAcquiredFill(PoolKey memory key, int24 tickLower, int256 liquidityDelta, bytes32 salt)
+        internal
+        onlyByPoolManager
+        returns (uint128 amount0, uint128 amount1)
+    {
+        console.log("lockAcquiredFill called with tickLower:", uint256(uint24(tickLower)));
+        console.log("liquidityDelta");
+        console.logInt(liquidityDelta);
+        console.log("salt:");
+        console.logBytes32(salt);
+        //  整形溢出问题。
+        (BalanceDelta delta, ) = poolManager.modifyLiquidity(
+            key,
+            ModifyLiquidityParams({
+                tickLower: tickLower,
+                tickUpper: tickLower + key.tickSpacing,
+                liquidityDelta: liquidityDelta,
+                salt: salt
+            }),
+            hex'00' // used for beforeModifyLiquidity/afterModifyLiquidity
+        );
+        console.log("lockAcquiredFill liquidity modified.");
+        if (delta.amount0() > 0) poolManager.mint(address(this), key.currency0.toId(), amount0 = uint128(delta.amount0()));
+        if (delta.amount1() > 0) poolManager.mint(address(this), key.currency1.toId(), amount1 = uint128(delta.amount1()));
+    }
+
+    function place(PoolKey calldata key, int24 tickLower, bool zeroForOne, uint128 liquidity)
+        external
+        onlyValidPools(key.hooks)
+    {
+        if (liquidity == 0) revert ZeroLiquidity();
+
+        // Used to identify liquidity modifications from this.tx.sender, not limitorder contract.
+        // bytes32 salt = bytes32(uint256(uint160(msg.sender)));
+        bytes32 salt=bytes32(0); // 临时修改为0，方便测试
+
+        poolManager.unlock(
+            abi.encodeCall(this.lockAcquiredPlace, (key, tickLower, zeroForOne, int256(uint256(liquidity)), msg.sender, salt))
+        );
+
+        EpochInfo storage epochInfo;
+        Epoch epoch = getEpoch(key, tickLower, zeroForOne);
+        if (epoch.equals(EPOCH_DEFAULT)) {
+            unchecked {
+                setEpoch(key, tickLower, zeroForOne, epoch = epochNext);
+                epochNext = epoch.unsafeIncrement();
+            }
+            epochInfo = epochInfos[epoch];
+            epochInfo.currency0 = key.currency0;
+            epochInfo.currency1 = key.currency1;
+        } else {
+            epochInfo = epochInfos[epoch];
+        }
+        unchecked {
+            epochInfo.liquidityTotal += liquidity;
+            epochInfo.liquidity[msg.sender] += liquidity;
+        }
+
+        emit Place(msg.sender, epoch, key, tickLower, zeroForOne, liquidity);
+    }
+
+    function lockAcquiredPlace(
+        PoolKey memory key,
+        int24 tickLower,
+        bool zeroForOne,
+        int256 liquidityDelta,
+        address owner,
+        bytes32 salt
+    ) public onlyByPoolManager {
+        (BalanceDelta delta, ) = poolManager.modifyLiquidity(
+            key,
+            ModifyLiquidityParams({
+                tickLower: tickLower,
+                tickUpper: tickLower + key.tickSpacing,
+                liquidityDelta: liquidityDelta,
+                salt: salt
+            }),
+            hex'00'
+        );
+
+        // [Mark] based on lib/v4-core/src/libraries/StateLibrary.sol
+        // the amount0 is computed negative when liquidity is positive
+        // same to LiquidityPool: function _settleCurrencyBalance
+        if (delta.amount0() < 0) {
+            if (delta.amount1() != 0) revert InRange();
+            if (!zeroForOne) revert CrossedRange();
+            poolManager.sync(key.currency0);
+            IERC20(Currency.unwrap(key.currency0)).safeTransferFrom(
+                owner, address(poolManager), uint256(uint128(-delta.amount0()))
+            );
+            poolManager.settle();
+        } else {
+            if (delta.amount0() != 0) revert InRange();
+            if (zeroForOne) revert CrossedRange();
+            poolManager.sync(key.currency1);
+            IERC20(Currency.unwrap(key.currency1)).safeTransferFrom(
+                owner, address(poolManager), uint256(uint128(-delta.amount1()))
+            );
+            poolManager.settle();
+        }
+    }
+
+    function kill(PoolKey calldata key, int24 tickLower, bool zeroForOne, address to) 
+        external
+        returns (uint256 amount0, uint256 amount1)
+    {
+        Epoch epoch = getEpoch(key, tickLower, zeroForOne);
+        console.log("[kill] epoch", uint256(Epoch.unwrap(epoch)));
+
+        EpochInfo storage epochInfo = epochInfos[epoch];
+
+        if (epochInfo.filled) revert Filled();
+
+        uint128 liquidity = epochInfo.liquidity[msg.sender];
+        if (liquidity == 0) revert ZeroLiquidity();
+        delete epochInfo.liquidity[msg.sender];
+        
+        uint128 liquidityTotal = epochInfo.liquidityTotal;
+        epochInfo.liquidityTotal = liquidityTotal - liquidity;
+
+        // [Custom]
+        bytes32 salt = bytes32(0);
+        uint256 amount0Fee;
+        uint256 amount1Fee;
+        (amount0, amount1, amount0Fee, amount1Fee) = abi.decode(
+            poolManager.unlock(
+                abi.encodeCall(
+                    this.lockAcquiredKill,
+                    (key, tickLower, -int256(uint256(liquidity)), to, liquidity == liquidityTotal, salt)
+                )
+            ),
+            (uint256, uint256, uint256, uint256)
+        );
+
+        unchecked {
+            epochInfo.token0Total += amount0Fee;
+            epochInfo.token1Total += amount1Fee;
+        }
+
+        emit Kill(msg.sender, epoch, key, tickLower, zeroForOne, liquidity);
+    }
+
+    function lockAcquiredKill(
+        PoolKey memory key,
+        int24 tickLower,
+        int256 liquidityDelta,
+        address to,
+        bool removingAllLiquidity,
+        bytes32 salt
+    ) public onlyByPoolManager returns (uint256 amount0, uint256 amount1, uint128 amount0Fee, uint128 amount1Fee) {
+        int24 tickUpper = tickLower + key.tickSpacing;
+
+        // because `modifyPosition` includes not just principal value but also fees, we cannot allocate
+        // the proceeds pro-rata. if we were to do so, users who have been in a limit order that's partially filled
+        // could be unfairly diluted by a user sychronously placing then killing a limit order to skim off fees.
+        // to prevent this, we allocate all fee revenue to remaining limit order placers, unless this is the last order.
+        if (!removingAllLiquidity) {
+            (BalanceDelta deltaFee, ) = poolManager.modifyLiquidity(
+                key, ModifyLiquidityParams({tickLower: tickLower, tickUpper: tickUpper, liquidityDelta: 0, salt: salt}), hex'00'
+            );
+
+            if (deltaFee.amount0() > 0) {
+                poolManager.mint(address(this), key.currency0.toId(), amount0Fee = uint128(deltaFee.amount0()));
+            }
+            if (deltaFee.amount1() > 0) {
+                poolManager.mint(address(this), key.currency1.toId(), amount1Fee = uint128(deltaFee.amount1()));
+            }
+        }
+
+        (BalanceDelta delta, ) = poolManager.modifyLiquidity(
+            key,
+            ModifyLiquidityParams({
+                tickLower: tickLower,
+                tickUpper: tickUpper,
+                liquidityDelta: liquidityDelta,
+                salt: salt
+            }),
+            hex'00'
+        );
+
+        // [Mark]
+        if (delta.amount0() > 0) poolManager.take(key.currency0, to, amount0 = uint128(delta.amount0()));
+        if (delta.amount1() > 0) poolManager.take(key.currency1, to, amount1 = uint128(delta.amount1()));
+    }
+
+    function withdraw(Epoch epoch, address to) external returns (uint256 amount0, uint256 amount1) {
+        EpochInfo storage epochInfo = epochInfos[epoch];
+
+        // 检查限价单是否已经完成
+        if (!epochInfo.filled) revert NotFilled();
+
+        uint128 liquidity = epochInfo.liquidity[msg.sender];
+        if (liquidity == 0) revert ZeroLiquidity();
+        delete epochInfo.liquidity[msg.sender];
+
+        uint256 token0Total = epochInfo.token0Total;
+        uint256 token1Total = epochInfo.token1Total;
+        uint128 liquidityTotal = epochInfo.liquidityTotal;
+
+        amount0 = FullMath.mulDiv(token0Total, liquidity, liquidityTotal);
+        amount1 = FullMath.mulDiv(token1Total, liquidity, liquidityTotal);
+
+        epochInfo.token0Total = token0Total - amount0;
+        epochInfo.token1Total = token1Total - amount1;
+        epochInfo.liquidityTotal = liquidityTotal - liquidity;
+
+        poolManager.unlock(
+            abi.encodeCall(this.lockAcquiredWithdraw, (epochInfo.currency0, epochInfo.currency1, amount0, amount1, to))
+        );
+
+        emit Withdraw(msg.sender, epoch, liquidity);
+    }
+
+    function lockAcquiredWithdraw(
+        Currency currency0,
+        Currency currency1,
+        uint256 token0Amount,
+        uint256 token1Amount,
+        address to
+    ) public onlyByPoolManager {
+        if (token0Amount > 0) {
+            poolManager.burn(address(this), currency0.toId(), token0Amount);
+            poolManager.take(currency0, to, token0Amount);
+        }
+        if (token1Amount > 0) {
+            // Note: instead of poolManager.safeTransferFrom, we use poolManager.burn 
+            // poolManager need to call currency.transfer, thus poolManager.take is needed
+            // inorder to balance the NonZeroDeltaCount of poolManager.take, we use poolManager.burn
+            // poolManager.safeTransferFrom only modify the state of ERC6909, but not applicable for poolManager.sync() and settle()
+            /*
+            poolManager.safeTransferFrom(
+                address(this), address(poolManager), uint256(uint160(Currency.unwrap(currency1))), token1Amount, ""
+            );*/
+            poolManager.burn(address(this), currency1.toId(), token1Amount);
+            poolManager.take(currency1, to, token1Amount);
+        }
+    }
+
+    function onERC1155Received(address, address, uint256, uint256, bytes calldata) external view returns (bytes4) {
+        if (msg.sender != address(poolManager)) revert NotPoolManagerToken();
+        return IERC1155Receiver.onERC1155Received.selector;
+    }
+
+}