@zoralabs/limit-orders 0.2.0

package/src/libs/LimitOrderLiquidity.sol

@@ -0,0 +1,222 @@
+// SPDX-License-Identifier: ZORA-DELAYED-OSL-v1
+// This software is licensed under the Zora Delayed Open Source License.
+// Under this license, you may use, copy, modify, and distribute this software for
+// non-commercial purposes only. Commercial use and competitive products are prohibited
+// until the "Open Date" (3 years from first public distribution or earlier at Zora's discretion),
+// at which point this software automatically becomes available under the MIT License.
+// Full license terms available at: https://docs.zora.co/coins/license
+pragma solidity ^0.8.23;
+
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
+import {Currency, CurrencyLibrary} from "@uniswap/v4-core/src/types/Currency.sol";
+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
+import {ModifyLiquidityParams} from "@uniswap/v4-core/src/types/PoolOperation.sol";
+import {BalanceDelta} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
+import {TickMath} from "@uniswap/v4-core/src/libraries/TickMath.sol";
+import {TransientStateLibrary} from "@uniswap/v4-core/src/libraries/TransientStateLibrary.sol";
+import {LiquidityAmounts} from "@zoralabs/coins/src/utils/uniswap/LiquidityAmounts.sol";
+
+import {IDeployedCoinVersionLookup} from "@zoralabs/coins/src/interfaces/IDeployedCoinVersionLookup.sol";
+import {LimitOrderTypes} from "./LimitOrderTypes.sol";
+import {IHasSwapPath} from "@zoralabs/coins/src/interfaces/ICoin.sol";
+import {UniV4SwapToCurrency} from "@zoralabs/coins/src/libs/UniV4SwapToCurrency.sol";
+
+library LimitOrderLiquidity {
+    using CurrencyLibrary for Currency;
+
+    function liquidityForOrder(bool isCurrency0, uint256 size, int24 tickLower, int24 tickUpper) internal pure returns (uint128) {
+        uint160 sqrtPriceLower = TickMath.getSqrtPriceAtTick(tickLower);
+        uint160 sqrtPriceUpper = TickMath.getSqrtPriceAtTick(tickUpper);
+        return
+            isCurrency0
+                ? LiquidityAmounts.getLiquidityForAmount0(sqrtPriceLower, sqrtPriceUpper, size)
+                : LiquidityAmounts.getLiquidityForAmount1(sqrtPriceLower, sqrtPriceUpper, size);
+    }
+
+    function refundResidual(PoolKey memory key, bool isCurrency0, address maker, uint128 amount) internal {
+        if (amount == 0) {
+            return;
+        }
+        Currency currency = isCurrency0 ? key.currency0 : key.currency1;
+        currency.transfer(maker, amount);
+    }
+
+    function settleAfterCreate(IPoolManager poolManager, PoolKey memory key, bool isCurrency0) internal {
+        int256 delta0 = TransientStateLibrary.currencyDelta(poolManager, address(this), key.currency0);
+        int256 delta1 = TransientStateLibrary.currencyDelta(poolManager, address(this), key.currency1);
+
+        address payout0 = isCurrency0 ? address(0) : address(this);
+        address payout1 = isCurrency0 ? address(this) : address(0);
+
+        settleDeltas(poolManager, key, delta0, delta1, payout0, payout1);
+    }
+
+    function burnAndPayout(
+        IPoolManager poolManager,
+        PoolKey memory key,
+        LimitOrderTypes.LimitOrder storage order,
+        bytes32 orderId,
+        address feeRecipient,
+        address coinIn,
+        IDeployedCoinVersionLookup coinLookup
+    ) internal returns (Currency makerCoinOut, uint128 makerAmountOut, uint128 referralAmountOut) {
+        (BalanceDelta liqDelta, BalanceDelta feesDelta) = poolManager.modifyLiquidity(
+            key,
+            ModifyLiquidityParams({tickLower: order.tickLower, tickUpper: order.tickUpper, liquidityDelta: -int256(uint256(order.liquidity)), salt: orderId}),
+            ""
+        );
+
+        int128 liquidity0 = liqDelta.amount0();
+        int128 liquidity1 = liqDelta.amount1();
+        int128 fee0Initial = feesDelta.amount0();
+        int128 fee1Initial = feesDelta.amount1();
+
+        int128 makerShareLiquidity0 = feeRecipient == address(0) ? liquidity0 : liquidity0 - fee0Initial;
+        int128 makerShareLiquidity1 = feeRecipient == address(0) ? liquidity1 : liquidity1 - fee1Initial;
+        int128 referralShareLiquidity0 = feeRecipient == address(0) ? int128(0) : int128(fee0Initial);
+        int128 referralShareLiquidity1 = feeRecipient == address(0) ? int128(0) : int128(fee1Initial);
+
+        (bool usePath, IHasSwapPath.PayoutSwapPath memory payoutPath) = _resolvePayoutPath(coinIn, coinLookup);
+
+        (makerCoinOut, makerAmountOut) = _payoutRecipient(poolManager, key, order.maker, makerShareLiquidity0, makerShareLiquidity1, usePath, payoutPath);
+
+        if (referralShareLiquidity0 > 0 || referralShareLiquidity1 > 0) {
+            (, referralAmountOut) = _payoutRecipient(poolManager, key, feeRecipient, referralShareLiquidity0, referralShareLiquidity1, usePath, payoutPath);
+        }
+
+        _settleNegativeDeltas(poolManager, key, liquidity0 + fee0Initial, liquidity1 + fee1Initial);
+    }
+
+    function burnAndRefund(
+        IPoolManager poolManager,
+        PoolKey memory key,
+        int24 tickLower,
+        int24 tickUpper,
+        uint128 liquidity,
+        bytes32 salt,
+        address recipient,
+        bool isCurrency0
+    ) internal returns (uint128 amountOut) {
+        (int128 amount0, int128 amount1) = _burnLiquidity(poolManager, key, tickLower, tickUpper, liquidity, salt);
+
+        if (isCurrency0 && amount0 > 0) {
+            amountOut = uint128(amount0);
+            poolManager.take(key.currency0, recipient, amountOut);
+        } else if (!isCurrency0 && amount1 > 0) {
+            amountOut = uint128(amount1);
+            poolManager.take(key.currency1, recipient, amountOut);
+        }
+
+        _settleNegativeDeltas(poolManager, key, amount0, amount1);
+    }
+
+    function settleDeltas(IPoolManager poolManager, PoolKey memory key, int256 d0, int256 d1, address payout0, address payout1) internal {
+        if (d0 > 0 && payout0 != address(0)) {
+            poolManager.take(key.currency0, payout0, uint256(d0));
+        }
+        if (d0 < 0) {
+            poolManager.sync(key.currency0);
+            key.currency0.transfer(address(poolManager), uint256(uint256(-d0)));
+            poolManager.settle();
+        }
+
+        if (d1 > 0 && payout1 != address(0)) {
+            poolManager.take(key.currency1, payout1, uint256(d1));
+        }
+        if (d1 < 0) {
+            poolManager.sync(key.currency1);
+            key.currency1.transfer(address(poolManager), uint256(uint256(-d1)));
+            poolManager.settle();
+        }
+    }
+
+    function _burnLiquidity(
+        IPoolManager poolManager,
+        PoolKey memory key,
+        int24 tickLower,
+        int24 tickUpper,
+        uint128 liquidity,
+        bytes32 salt
+    ) private returns (int128 amount0, int128 amount1) {
+        (BalanceDelta delta, ) = poolManager.modifyLiquidity(
+            key,
+            ModifyLiquidityParams({tickLower: tickLower, tickUpper: tickUpper, liquidityDelta: -int256(uint256(liquidity)), salt: salt}),
+            ""
+        );
+        amount0 = delta.amount0();
+        amount1 = delta.amount1();
+    }
+
+    function _resolvePayoutPath(
+        address coinIn,
+        IDeployedCoinVersionLookup coinLookup
+    ) private view returns (bool hasPath, IHasSwapPath.PayoutSwapPath memory payoutPath) {
+        if (coinIn == address(0)) {
+            return (false, payoutPath);
+        }
+
+        try coinLookup.getVersionForDeployedCoin(coinIn) returns (uint8 version) {
+            if (version >= 4 && _supportsSwapPath(coinIn)) {
+                payoutPath = IHasSwapPath(coinIn).getPayoutSwapPath(coinLookup);
+                if (payoutPath.path.length > 0) {
+                    return (true, payoutPath);
+                }
+            }
+        } catch {}
+
+        return (false, payoutPath);
+    }
+
+    function _supportsSwapPath(address coin) private view returns (bool) {
+        try IERC165(coin).supportsInterface(type(IHasSwapPath).interfaceId) returns (bool supported) {
+            return supported;
+        } catch {
+            return false;
+        }
+    }
+
+    function _settleNegativeDeltas(IPoolManager poolManager, PoolKey memory key, int128 amount0, int128 amount1) private {
+        int256 repay0 = amount0 < 0 ? int256(amount0) : int256(0);
+        int256 repay1 = amount1 < 0 ? int256(amount1) : int256(0);
+
+        if (repay0 != 0 || repay1 != 0) {
+            settleDeltas(poolManager, key, repay0, repay1, address(0), address(0));
+        }
+    }
+
+    function _payoutRecipient(
+        IPoolManager poolManager,
+        PoolKey memory key,
+        address recipient,
+        int128 amount0,
+        int128 amount1,
+        bool usePath,
+        IHasSwapPath.PayoutSwapPath memory payoutPath
+    ) private returns (Currency coinOut, uint128 amountOut) {
+        if (usePath) {
+            (coinOut, amountOut) = UniV4SwapToCurrency.swapToPath(poolManager, uint128(amount0), uint128(amount1), payoutPath.currencyIn, payoutPath.path);
+            poolManager.take(coinOut, recipient, amountOut);
+        } else {
+            (coinOut, amountOut) = _payCounterAsset(poolManager, key, amount0, amount1, recipient);
+        }
+    }
+
+    function _payCounterAsset(
+        IPoolManager poolManager,
+        PoolKey memory key,
+        int128 amount0,
+        int128 amount1,
+        address recipient
+    ) private returns (Currency coinOut, uint128 amountOut) {
+        if (amount0 > 0) {
+            coinOut = key.currency0;
+            amountOut = uint128(amount0);
+            poolManager.take(coinOut, recipient, amountOut);
+        } else if (amount1 > 0) {
+            coinOut = key.currency1;
+            amountOut = uint128(amount1);
+            poolManager.take(coinOut, recipient, amountOut);
+        }
+    }
+}

package/src/libs/LimitOrderQueues.sol

@@ -0,0 +1,101 @@
+// SPDX-License-Identifier: ZORA-DELAYED-OSL-v1
+// This software is licensed under the Zora Delayed Open Source License.
+// Under this license, you may use, copy, modify, and distribute this software for
+// non-commercial purposes only. Commercial use and competitive products are prohibited
+// until the "Open Date" (3 years from first public distribution or earlier at Zora's discretion),
+// at which point this software automatically becomes available under the MIT License.
+// Full license terms available at: https://docs.zora.co/coins/license
+pragma solidity ^0.8.23;
+
+import {LimitOrderTypes} from "./LimitOrderTypes.sol";
+
+library LimitOrderQueues {
+    using LimitOrderQueues for LimitOrderTypes.Queue;
+
+    // Slot offsets for doubly-linked list pointers in LimitOrder struct
+    uint256 private constant NEXT_SLOT = 0;
+    uint256 private constant PREV_SLOT = 1;
+
+    /// @notice Appends an order to the tail of a tick's order queue
+    function enqueue(LimitOrderTypes.Queue storage q, mapping(bytes32 => LimitOrderTypes.LimitOrder) storage orders, bytes32 id) internal {
+        bytes32 tail = q.tail;
+
+        if (tail == bytes32(0)) {
+            // Empty tick queue: new order becomes head
+            q.head = id;
+        } else {
+            // Link current tail to new order
+            _writePointer(orders, tail, NEXT_SLOT, id);
+        }
+
+        // Link new order back to old tail (or 0 if empty)
+        _writePointer(orders, id, PREV_SLOT, tail);
+        q.tail = id;
+
+        unchecked {
+            q.length++;
+        }
+    }
+
+    /// @notice Removes an order from a tick's queue and relinks its neighbors
+    /// @return nextId The next order in the queue (for iteration during fills)
+    function unlink(
+        LimitOrderTypes.Queue storage q,
+        mapping(bytes32 => LimitOrderTypes.LimitOrder) storage orders,
+        LimitOrderTypes.LimitOrder storage order
+    ) internal returns (bytes32 nextId) {
+        bytes32 prevId;
+        uint256 baseSlot;
+
+        // Read prev/next pointers directly from storage slots for gas efficiency
+        assembly ("memory-safe") {
+            // Get the base storage slot for this order struct
+            baseSlot := order.slot
+            // Load nextId from slot 0 (first field in struct)
+            nextId := sload(add(baseSlot, NEXT_SLOT))
+            // Load prevId from slot 1 (second field in struct)
+            prevId := sload(add(baseSlot, PREV_SLOT))
+        }
+
+        // Relink previous order (or update head if this was first)
+        if (prevId == bytes32(0)) {
+            q.head = nextId;
+        } else {
+            _writePointer(orders, prevId, NEXT_SLOT, nextId);
+        }
+
+        // Relink next order (or update tail if this was last)
+        if (nextId == bytes32(0)) {
+            q.tail = prevId;
+        } else {
+            _writePointer(orders, nextId, PREV_SLOT, prevId);
+        }
+
+        if (q.length > 0) {
+            unchecked {
+                q.length--;
+            }
+        }
+    }
+
+    /// @notice Clears the linked list pointers of an order after removal
+    function clearLinks(LimitOrderTypes.LimitOrder storage order) internal {
+        uint256 baseSlot;
+        assembly ("memory-safe") {
+            baseSlot := order.slot
+            sstore(add(baseSlot, NEXT_SLOT), 0)
+            sstore(add(baseSlot, PREV_SLOT), 0)
+        }
+    }
+
+    /// @notice Writes a pointer value to a specific slot offset in an order
+    function _writePointer(mapping(bytes32 => LimitOrderTypes.LimitOrder) storage orders, bytes32 id, uint256 slotOffset, bytes32 value) private {
+        assembly ("memory-safe") {
+            // Compute storage slot: keccak256(id . orders.slot) + slotOffset
+            mstore(0x00, id) // Store id at memory[0:32]
+            mstore(0x20, orders.slot) // Store mapping slot at memory[32:64]
+            let base := keccak256(0x00, 0x40)
+            sstore(add(base, slotOffset), value)
+        }
+    }
+}

package/src/libs/LimitOrderStorage.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: ZORA-DELAYED-OSL-v1
+// This software is licensed under the Zora Delayed Open Source License.
+// Under this license, you may use, copy, modify, and distribute this software for
+// non-commercial purposes only. Commercial use and competitive products are prohibited
+// until the "Open Date" (3 years from first public distribution or earlier at Zora's discretion),
+// at which point this software automatically becomes available under the MIT License.
+// Full license terms available at: https://docs.zora.co/coins/license
+pragma solidity ^0.8.28;
+
+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
+import {LimitOrderTypes} from "./LimitOrderTypes.sol";
+
+library LimitOrderStorage {
+    // keccak256("zora.limit.order.book.storage")
+    bytes32 internal constant STORAGE_SLOT = 0x98b43bb10ca7bc310641b07883d9e14c04b3983640df6b07dd1c99d10a3c6cec;
+
+    struct Layout {
+        uint256 maxFillCount;
+        mapping(bytes32 orderId => LimitOrderTypes.LimitOrder) limitOrders;
+        mapping(address maker => uint256 nonce) makerNonces;
+        mapping(bytes32 poolKeyHash => PoolKey) poolKeys;
+        mapping(bytes32 poolKeyHash => uint256 epoch) poolEpochs;
+        mapping(bytes32 poolKeyHash => mapping(address coin => mapping(int16 wordPosition => uint256 bitmap))) tickBitmaps;
+        mapping(bytes32 poolKeyHash => mapping(address coin => mapping(int24 tick => LimitOrderTypes.Queue))) tickQueues;
+        mapping(address maker => mapping(address coin => uint256 balance)) makerBalances;
+    }
+
+    function layout() internal pure returns (Layout storage l) {
+        bytes32 slot = STORAGE_SLOT;
+        assembly {
+            l.slot := slot
+        }
+    }
+}

package/src/libs/LimitOrderTypes.sol

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: ZORA-DELAYED-OSL-v1
+// This software is licensed under the Zora Delayed Open Source License.
+// Under this license, you may use, copy, modify, and distribute this software for
+// non-commercial purposes only. Commercial use and competitive products are prohibited
+// until the "Open Date" (3 years from first public distribution or earlier at Zora's discretion),
+// at which point this software automatically becomes available under the MIT License.
+// Full license terms available at: https://docs.zora.co/coins/license
+pragma solidity ^0.8.23;
+
+interface LimitOrderTypes {
+    enum OrderStatus {
+        INACTIVE,
+        OPEN,
+        FILLED
+    }
+
+    struct LimitOrder {
+        // Linked-list pointers
+        bytes32 nextId;
+        bytes32 prevId;
+        // Pool binding
+        bytes32 poolKeyHash;
+        // Amounts (packed)
+        uint128 orderSize;
+        uint128 liquidity;
+        // Small fields + address (packed into one slot)
+        int24 tickLower;
+        int24 tickUpper;
+        uint32 createdEpoch;
+        OrderStatus status;
+        bool isCurrency0;
+        address maker;
+    }
+
+    struct Queue {
+        bytes32 head;
+        bytes32 tail;
+        uint128 length;
+        uint128 balance;
+    }
+}

package/src/libs/LimitOrderWithdraw.sol

@@ -0,0 +1,100 @@
+// SPDX-License-Identifier: ZORA-DELAYED-OSL-v1
+// This software is licensed under the Zora Delayed Open Source License.
+// Under this license, you may use, copy, modify, and distribute this software for
+// non-commercial purposes only. Commercial use and competitive products are prohibited
+// until the "Open Date" (3 years from first public distribution or earlier at Zora's discretion),
+// at which point this software automatically becomes available under the MIT License.
+// Full license terms available at: https://docs.zora.co/coins/license
+pragma solidity ^0.8.28;
+
+import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
+import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
+
+import {LimitOrderStorage} from "./LimitOrderStorage.sol";
+import {IZoraLimitOrderBook} from "../IZoraLimitOrderBook.sol";
+import {LimitOrderTypes} from "./LimitOrderTypes.sol";
+import {LimitOrderCommon} from "./LimitOrderCommon.sol";
+import {LimitOrderLiquidity} from "./LimitOrderLiquidity.sol";
+
+library LimitOrderWithdraw {
+    function handleWithdrawOrdersCallback(LimitOrderStorage.Layout storage state, IPoolManager poolManager, bytes memory payload) internal {
+        IZoraLimitOrderBook.WithdrawOrdersCallbackData memory data = abi.decode(payload, (IZoraLimitOrderBook.WithdrawOrdersCallbackData));
+
+        withdrawOrders(state, poolManager, data.maker, data.orderIds, data.coin, data.minAmountOut, data.recipient);
+    }
+
+    function withdrawOrders(
+        LimitOrderStorage.Layout storage state,
+        IPoolManager poolManager,
+        address maker,
+        bytes32[] memory orderIds,
+        address coin,
+        uint256 minAmountOut,
+        address recipient
+    ) internal {
+        require(recipient != address(0), IZoraLimitOrderBook.AddressZero());
+        uint256 orderCount = orderIds.length;
+        require(orderCount != 0, IZoraLimitOrderBook.InvalidOrder());
+
+        uint256 totalWithdrawn;
+
+        for (uint256 i; i < orderCount; ++i) {
+            bytes32 orderId = orderIds[i];
+            LimitOrderTypes.LimitOrder storage order = state.limitOrders[orderId];
+
+            require(order.maker != address(0), IZoraLimitOrderBook.InvalidOrder());
+            require(order.maker == maker, IZoraLimitOrderBook.OrderNotMaker());
+            require(order.status == LimitOrderTypes.OrderStatus.OPEN, IZoraLimitOrderBook.OrderClosed());
+
+            uint128 orderSize = order.orderSize; // Cache before cancellation
+            address currentCoin = _cancelOrder(state, poolManager, maker, orderId, order, recipient);
+
+            // Validate order coin matches expected coin
+            if (currentCoin != coin) {
+                revert IZoraLimitOrderBook.CoinMismatch(orderId, coin, currentCoin);
+            }
+
+            totalWithdrawn += orderSize;
+
+            // Early termination if threshold reached
+            if (minAmountOut > 0 && totalWithdrawn >= minAmountOut) {
+                break;
+            }
+        }
+
+        // Revert if threshold not reached
+        require(totalWithdrawn >= minAmountOut, IZoraLimitOrderBook.MinAmountNotReached(totalWithdrawn, minAmountOut));
+    }
+
+    function _cancelOrder(
+        LimitOrderStorage.Layout storage state,
+        IPoolManager poolManager,
+        address maker,
+        bytes32 orderId,
+        LimitOrderTypes.LimitOrder storage order,
+        address recipient
+    ) private returns (address coin) {
+        PoolKey memory key = state.poolKeys[order.poolKeyHash];
+        require(key.tickSpacing != 0, IZoraLimitOrderBook.InvalidOrder());
+
+        int24 orderTick = LimitOrderCommon.getOrderTick(order);
+        coin = LimitOrderCommon.getOrderCoin(key, order.isCurrency0);
+
+        LimitOrderTypes.Queue storage tickQueue = state.tickQueues[order.poolKeyHash][coin][orderTick];
+
+        // Cache values needed after state changes
+        int24 tickLower = order.tickLower;
+        int24 tickUpper = order.tickUpper;
+        uint128 liquidity = order.liquidity;
+        bool isCurrency0 = order.isCurrency0;
+
+        // Effects before interactions (CEI pattern)
+        order.status = LimitOrderTypes.OrderStatus.INACTIVE;
+        LimitOrderCommon.removeOrder(state, key, coin, tickQueue, order);
+
+        // External call after state is updated
+        LimitOrderLiquidity.burnAndRefund(poolManager, key, tickLower, tickUpper, liquidity, orderId, recipient, isCurrency0);
+
+        emit IZoraLimitOrderBook.LimitOrderUpdated(maker, coin, order.poolKeyHash, isCurrency0, orderTick, 0, orderId, true);
+    }
+}

package/src/libs/Permit2Payments.sol

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {IAllowanceTransfer} from "permit2/src/interfaces/IAllowanceTransfer.sol";
+import {SafeCast160} from "permit2/src/libraries/SafeCast160.sol";
+
+/// @title Payments through Permit2
+/// @notice Performs interactions with Permit2 to transfer tokens
+/// @dev Based on Uniswap's universal-router Permit2Payments module
+abstract contract Permit2Payments {
+    using SafeCast160 for uint256;
+
+    /// @notice The Permit2 contract address (immutable, same on all chains)
+    IAllowanceTransfer internal immutable PERMIT2;
+
+    error FromAddressIsNotOwner();
+
+    constructor(address permit2_) {
+        PERMIT2 = IAllowanceTransfer(permit2_);
+    }
+
+    /// @notice Performs a transferFrom on Permit2
+    /// @param token The token to transfer
+    /// @param from The address to transfer from
+    /// @param to The recipient of the transfer
+    /// @param amount The amount to transfer
+    function permit2TransferFrom(address token, address from, address to, uint160 amount) internal {
+        PERMIT2.transferFrom(from, to, amount, token);
+    }
+
+    /// @notice Performs a batch transferFrom on Permit2
+    /// @param batchDetails An array detailing each of the transfers that should occur
+    /// @param owner The address that should be the owner of all transfers
+    function permit2TransferFrom(IAllowanceTransfer.AllowanceTransferDetails[] calldata batchDetails, address owner) internal {
+        uint256 batchLength = batchDetails.length;
+        for (uint256 i = 0; i < batchLength; ++i) {
+            if (batchDetails[i].from != owner) revert FromAddressIsNotOwner();
+        }
+        PERMIT2.transferFrom(batchDetails);
+    }
+}