@paimaexample/evm-contracts 0.3.0

package/src/contracts/orderbook/IOrderbookDex.sol

@@ -0,0 +1,215 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import {IERC1155Receiver} from "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
+
+/// @notice Facilitates base-chain trading of assets that are living on a different app-chain.
+/// @dev Orders are identified by an asset-specific unique incremental `orderId`.
+interface IOrderbookDex is IERC1155Receiver {
+    struct FeeInfo {
+        /// @dev The maker fee collected from the seller when a sell order is filled. Expressed in basis points.
+        uint256 makerFee;
+        /// @dev The taker fee collected from the buyer when a sell order is filled. Expressed in basis points.
+        uint256 takerFee;
+        /// @dev Flag indicating whether the fees are set.
+        bool set;
+    }
+
+    struct Order {
+        /// @dev The asset's unique token identifier.
+        uint256 assetId;
+        /// @dev The amount of the asset that is available to be sold.
+        uint256 assetAmount;
+        /// @dev The price per one unit of asset.
+        uint256 pricePerAsset;
+        /// @dev The seller's address.
+        address payable seller;
+        /// @dev The maker fee in basis points, set when order is created, defined by the asset's fee info.
+        uint256 makerFee;
+        /// @dev The taker fee in basis points, set when order is created, defined by the asset's fee info.
+        uint256 takerFee;
+        /// @dev The order creation fee paid by the seller when creating the order, refunded if sell order is cancelled.
+        uint256 creationFeePaid;
+    }
+
+    /// @param user The address that claimed the balance.
+    /// @param amount The amount that was claimed.
+    event BalanceClaimed(address indexed user, uint256 amount);
+
+    /// @param asset The asset's address (zero address if changing default fees).
+    /// @param makerFee The new maker fee in basis points.
+    /// @param takerFee The new taker fee in basis points.
+    event FeeInfoChanged(address indexed asset, uint256 makerFee, uint256 takerFee);
+
+    /// @param asset The asset's address.
+    /// @param assetId The asset's unique token identifier.
+    /// @param orderId The order's asset-specific unique identifier.
+    /// @param seller The seller's address.
+    /// @param assetAmount The amount of the asset that has been put for sale.
+    /// @param pricePerAsset The requested price per one unit of asset.
+    /// @param makerFee The maker fee in basis points.
+    /// @param takerFee The taker fee in basis points.
+    event OrderCreated(
+        address indexed asset,
+        uint256 indexed assetId,
+        uint256 indexed orderId,
+        address seller,
+        uint256 assetAmount,
+        uint256 pricePerAsset,
+        uint256 makerFee,
+        uint256 takerFee
+    );
+
+    /// @param asset The asset's address.
+    /// @param assetId The asset's unique token identifier.
+    /// @param orderId The order's asset-specific unique identifier.
+    /// @param seller The seller's address.
+    /// @param buyer The buyer's address.
+    /// @param assetAmount The amount of the asset that was traded.
+    /// @param pricePerAsset The price per one unit of asset that was paid.
+    /// @param makerFeeCollected The maker fee in native tokens that was collected.
+    /// @param takerFeeCollected The taker fee in native tokens that was collected.
+    event OrderFilled(
+        address indexed asset,
+        uint256 indexed assetId,
+        uint256 indexed orderId,
+        address seller,
+        address buyer,
+        uint256 assetAmount,
+        uint256 pricePerAsset,
+        uint256 makerFeeCollected,
+        uint256 takerFeeCollected
+    );
+
+    /// @param asset The asset's address.
+    /// @param assetId The asset's unique token identifier.
+    /// @param orderId The order's asset-specific unique identifier.
+    event OrderCancelled(address indexed asset, uint256 indexed assetId, uint256 indexed orderId);
+
+    /// @param oldFee The old fee value.
+    /// @param newFee The new fee value.
+    event OrderCreationFeeChanged(uint256 oldFee, uint256 newFee);
+
+    /// @param receiver The address that received the fees.
+    /// @param amount The amount of fees that were withdrawn.
+    event FeesWithdrawn(address indexed receiver, uint256 amount);
+
+    /// @notice The balance of `user` that's claimable by `claim` function.
+    function balances(address user) external view returns (uint256);
+
+    /// @notice Withdraw the claimable balance of the caller.
+    function claim() external;
+
+    /// @notice The `orderId` of the next sell order for specific `asset`.
+    function currentOrderId(address asset) external view returns (uint256);
+
+    /// @notice The total amount of fees collected by the contract.
+    function collectedFees() external view returns (uint256);
+
+    /// @notice The default maker fee, used if fee information for asset is not set.
+    function defaultMakerFee() external view returns (uint256);
+
+    /// @notice The default taker fee, used if fee information for asset is not set.
+    function defaultTakerFee() external view returns (uint256);
+
+    /// @notice The flat fee paid by the seller when creating a sell order, to prevent spam.
+    function orderCreationFee() external view returns (uint256);
+
+    /// @notice The maximum fee, maker/taker fees cannot be set to exceed this amount.
+    function maxFee() external view returns (uint256);
+
+    /// @notice The fee information of `asset`.
+    function getAssetFeeInfo(address asset) external view returns (FeeInfo memory);
+
+    /// @notice Returns the asset fees if set, otherwise returns the default fees.
+    function getAssetAppliedFees(
+        address asset
+    ) external view returns (uint256 makerFee, uint256 takerFee);
+
+    /// @notice Set the fee information of `asset`. Executable only by the owner.
+    /// @dev MUST revert if `makerFee` or `takerFee` exceeds `maxFee`.
+    /// MUST revert if called by unauthorized account.
+    function setAssetFeeInfo(address asset, uint256 makerFee, uint256 takerFee) external;
+
+    /// @notice Set the default fee information that is used if fee information for asset is not set. Executable only by the owner.
+    /// @dev MUST revert if `makerFee` or `takerFee` exceeds `maxFee`.
+    /// MUST revert if called by unauthorized account.
+    function setDefaultFeeInfo(uint256 makerFee, uint256 takerFee) external;
+
+    /// @notice Set the flat fee paid by the seller when creating a sell order, to prevent spam. Executable only by the owner.
+    /// @dev MUST revert if called by unauthorized account.
+    function setOrderCreationFee(uint256 fee) external;
+
+    /// @notice Returns the Order struct information about an order identified by the `orderId` for specific `asset`.
+    function getOrder(address asset, uint256 orderId) external view returns (Order memory);
+
+    /// @notice Creates a sell order for the `assetAmount` of `asset` with ID `assetId` at `pricePerAsset`. Requires payment of `orderCreationFee`.
+    /// @dev The order information is saved in a mapping `asset -> orderId -> Order`, with `orderId` being an asset-specific unique incremental identifier.
+    /// MUST transfer the `assetAmount` of `asset` with ID `assetId` from the seller to the contract.
+    /// MUST emit `OrderCreated` event.
+    /// MUST revert if `msg.value` is less than `orderCreationFee`.
+    /// @return The asset-specific unique identifier of the created order.
+    function createSellOrder(
+        address asset,
+        uint256 assetId,
+        uint256 assetAmount,
+        uint256 pricePerAsset
+    ) external payable returns (uint256);
+
+    /// @notice Creates a batch of sell orders for the `assetAmount` of `asset` with ID `assetId` at `pricePerAsset`. Requires payment of `orderCreationFee` times the amount of orders.
+    /// @dev This is a batched version of `createSellOrder` that simply iterates through the arrays to call said function.
+    /// MUST revert if `msg.value` is less than `orderCreationFee * assetIds.length`.
+    /// @return The asset-specific unique identifiers of the created orders.
+    function createBatchSellOrder(
+        address asset,
+        uint256[] memory assetIds,
+        uint256[] memory assetAmounts,
+        uint256[] memory pricesPerAssets
+    ) external payable returns (uint256[] memory);
+
+    /// @notice Consecutively fills an array of orders of `asset` identified by the asset-specific `orderId` of each order,
+    /// by providing an exact amount of ETH and requesting a specific minimum amount of asset to receive.
+    /// @dev Transfers portions of msg.value to the orders' sellers according to the price.
+    /// The sum of asset amounts of filled orders MUST be at least `minimumAsset`.
+    /// If msg.value is more than the sum of orders' prices, it MUST refund the excess back to `msg.sender`.
+    /// MUST decrease the `assetAmount` parameter for the specified order according to how much of it was filled,
+    /// and transfer that amount of the order's `asset` with ID `assetId` to the buyer.
+    /// MUST emit `OrderFilled` event for each order accordingly.
+    function fillOrdersExactEth(
+        address asset,
+        uint256 minimumAsset,
+        uint256[] memory orderIds
+    ) external payable;
+
+    /// @notice Consecutively fills an array of orders identified by the asset-specific `orderId` of each order,
+    /// by providing a possibly surplus amount of ETH and requesting an exact amount of asset to receive.
+    /// @dev Transfers portions of msg.value to the orders' sellers according to the price.
+    /// The sum of asset amounts of filled orders MUST be exactly `assetAmount`. Excess ETH MUST be returned back to `msg.sender`.
+    /// MUST decrease the `assetAmount` parameter for the specified order according to how much of it was filled,
+    /// and transfer that amount of the order's `asset` with ID `assetId` to the buyer.
+    /// MUST emit `OrderFilled` event for each order accordingly.
+    /// If msg.value is more than the sum of orders' prices, it MUST refund the difference back to `msg.sender`.
+    function fillOrdersExactAsset(
+        address asset,
+        uint256 assetAmount,
+        uint256[] memory orderIds
+    ) external payable;
+
+    /// @notice Cancels the sell order of `asset` with asset-specific `orderId`, transferring the order's assets back to the seller.
+    /// @dev MUST revert if the order's seller is not `msg.sender`.
+    /// MUST change the `assetAmount` parameter for the specified order to `0`.
+    /// MUST emit `OrderCancelled` event.
+    /// MUST transfer the order's `assetAmount` of `asset` with `assetId` back to the seller.
+    function cancelSellOrder(address asset, uint256 orderId) external;
+
+    /// @notice Cancels a batch of sell orders of `asset` with asset-specific `orderIds`, transferring the orders' assets back to the seller.
+    /// @dev This is a batched version of `cancelSellOrder` that simply iterates through the array to call said function.
+    function cancelBatchSellOrder(address asset, uint256[] memory orderIds) external;
+
+    /// @notice Withdraws the contract balance (containing collected fees) to the owner. Executable only by the owner.
+    /// @dev MUST transfer the entire contract balance to the owner.
+    /// MUST revert if called by unauthorized account.
+    /// MUST emit `FeesWithdrawn` event.
+    function withdrawFees() external;
+}

package/src/contracts/orderbook/OrderbookDex.sol

@@ -0,0 +1,435 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import {Address} from "@openzeppelin/contracts/utils/Address.sol";
+import {Arrays} from "@openzeppelin/contracts/utils/Arrays.sol";
+import {ERC1155HolderUpgradeable} from "@openzeppelin/contracts-upgradeable/token/ERC1155/utils/ERC1155HolderUpgradeable.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+import {UUPSUpgradeable} from "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+import {ReentrancyGuardUpgradeable} from "@openzeppelin/contracts-upgradeable/utils/ReentrancyGuardUpgradeable.sol";
+
+import {IInverseProjected1155} from "../token/IInverseProjected1155.sol";
+import {IOrderbookDex} from "./IOrderbookDex.sol";
+
+/// @notice Facilitates base-chain trading of assets that are living on a different app-chain.
+/// @dev Orders are identified by an asset-specific unique incremental `orderId`.
+contract OrderbookDex is
+    IOrderbookDex,
+    ERC1155HolderUpgradeable,
+    OwnableUpgradeable,
+    UUPSUpgradeable,
+    ReentrancyGuardUpgradeable
+{
+    using Address for address payable;
+    using Arrays for uint256[];
+    using Arrays for address[];
+
+    uint256 constant basisPoints = 10000;
+    /// @notice Maximum fee is 10% (1000 bps).
+    uint256 public constant maxFee = basisPoints / 10;
+    /// @inheritdoc IOrderbookDex
+    mapping(address user => uint256 value) public balances;
+    /// @inheritdoc IOrderbookDex
+    mapping(address asset => uint256 orderId) public currentOrderId;
+    mapping(address asset => mapping(uint256 orderId => Order)) internal orders;
+    mapping(address asset => FeeInfo) internal assetFeeInfo;
+    /// @inheritdoc IOrderbookDex
+    uint256 public collectedFees;
+    /// @inheritdoc IOrderbookDex
+    uint256 public defaultMakerFee;
+    /// @inheritdoc IOrderbookDex
+    uint256 public defaultTakerFee;
+    /// @inheritdoc IOrderbookDex
+    uint256 public orderCreationFee;
+
+    error FeeTooHigh();
+    error OrderDoesNotExist(uint256 orderId);
+    error InsufficientEndAmount(uint256 expectedAmount, uint256 actualAmount);
+    error InsufficientPayment();
+    error InvalidArrayLength();
+    error InvalidInput(uint256 input);
+    error Unauthorized(address sender);
+
+    /// @custom:oz-upgrades-unsafe-allow constructor
+    constructor() {
+        _disableInitializers();
+    }
+
+    function initialize(
+        address _owner,
+        uint256 _defaultMakerFee,
+        uint256 _defaultTakerFee,
+        uint256 _orderCreationFee
+    ) public initializer {
+        __Ownable_init(_owner);
+        __UUPSUpgradeable_init();
+        __ERC1155Holder_init();
+        __ReentrancyGuard_init();
+
+        defaultMakerFee = _defaultMakerFee;
+        defaultTakerFee = _defaultTakerFee;
+        orderCreationFee = _orderCreationFee;
+    }
+
+    /// @inheritdoc IOrderbookDex
+    function claim() external {
+        uint256 amount = balances[msg.sender];
+        delete balances[msg.sender];
+        emit BalanceClaimed(msg.sender, amount);
+        payable(msg.sender).sendValue(amount);
+    }
+
+    /// @inheritdoc IOrderbookDex
+    function getAssetFeeInfo(address asset) public view virtual returns (FeeInfo memory) {
+        return assetFeeInfo[asset];
+    }
+
+    /// @inheritdoc IOrderbookDex
+    function getAssetAppliedFees(
+        address asset
+    ) public view virtual returns (uint256 makerFee, uint256 takerFee) {
+        FeeInfo memory feeInfo = assetFeeInfo[asset];
+        if (feeInfo.set) {
+            return (feeInfo.makerFee, feeInfo.takerFee);
+        }
+        return (defaultMakerFee, defaultTakerFee);
+    }
+
+    /// @inheritdoc IOrderbookDex
+    function setAssetFeeInfo(address asset, uint256 makerFee, uint256 takerFee) public onlyOwner {
+        if (makerFee > maxFee || takerFee > maxFee) {
+            revert FeeTooHigh();
+        }
+        assetFeeInfo[asset] = FeeInfo({makerFee: makerFee, takerFee: takerFee, set: true});
+        emit FeeInfoChanged(asset, makerFee, takerFee);
+    }
+
+    /// @inheritdoc IOrderbookDex
+    function setDefaultFeeInfo(uint256 makerFee, uint256 takerFee) public onlyOwner {
+        if (makerFee > maxFee || takerFee > maxFee) {
+            revert FeeTooHigh();
+        }
+        defaultMakerFee = makerFee;
+        defaultTakerFee = takerFee;
+        emit FeeInfoChanged(address(0), makerFee, takerFee);
+    }
+
+    /// @inheritdoc IOrderbookDex
+    function setOrderCreationFee(uint256 fee) public onlyOwner {
+        emit OrderCreationFeeChanged(orderCreationFee, fee);
+        orderCreationFee = fee;
+    }
+
+    /// @inheritdoc IOrderbookDex
+    function getOrder(address asset, uint256 orderId) public view virtual returns (Order memory) {
+        return orders[asset][orderId];
+    }
+
+    /// @inheritdoc IOrderbookDex
+    function createSellOrder(
+        address asset,
+        uint256 assetId,
+        uint256 assetAmount,
+        uint256 pricePerAsset
+    ) external payable virtual nonReentrant returns (uint256) {
+        if (msg.value < orderCreationFee) {
+            revert InsufficientPayment();
+        }
+        collectedFees += msg.value;
+        return _createSellOrder(asset, assetId, assetAmount, pricePerAsset);
+    }
+
+    /// @inheritdoc IOrderbookDex
+    function createBatchSellOrder(
+        address asset,
+        uint256[] memory assetIds,
+        uint256[] memory assetAmounts,
+        uint256[] memory pricesPerAssets
+    ) external payable virtual nonReentrant returns (uint256[] memory) {
+        if (assetIds.length != assetAmounts.length || assetIds.length != pricesPerAssets.length) {
+            revert InvalidArrayLength();
+        }
+        if (msg.value < orderCreationFee * assetIds.length) {
+            revert InsufficientPayment();
+        }
+        collectedFees += msg.value;
+        uint256[] memory orderIds = new uint256[](assetIds.length);
+        for (uint256 i; i < assetIds.length; ) {
+            orderIds[i] = _createSellOrder(
+                asset,
+                assetIds.unsafeMemoryAccess(i),
+                assetAmounts.unsafeMemoryAccess(i),
+                pricesPerAssets.unsafeMemoryAccess(i)
+            );
+            unchecked {
+                ++i;
+            }
+        }
+        return orderIds;
+    }
+
+    /// @inheritdoc IOrderbookDex
+    function fillOrdersExactEth(
+        address asset,
+        uint256 minimumAsset,
+        uint256[] memory orderIds
+    ) external payable virtual nonReentrant {
+        uint256 length = orderIds.length;
+        uint256 remainingEth = msg.value;
+        uint256 totalAssetReceived;
+        for (uint256 i; i < length; ++i) {
+            uint256 orderId = orderIds.unsafeMemoryAccess(i);
+            Order storage order = orders[asset][orderId];
+            if (order.assetAmount == 0) {
+                continue;
+            }
+
+            uint256 purchaseCost = (remainingEth * basisPoints) / (order.takerFee + basisPoints);
+            // After the integer division by fees, purchase cost needs to be rounded up (fees are rounded down)
+            if (purchaseCost * (order.takerFee + basisPoints) != (remainingEth * basisPoints)) {
+                ++purchaseCost;
+            }
+            uint256 assetsToBuy = purchaseCost / order.pricePerAsset;
+
+            if (assetsToBuy == 0) {
+                continue;
+            }
+            if (assetsToBuy > order.assetAmount) {
+                assetsToBuy = order.assetAmount;
+            }
+            purchaseCost = assetsToBuy * order.pricePerAsset;
+
+            // Can be unchecked because assetsToBuy is less than or equal to order.assetAmount.
+            unchecked {
+                order.assetAmount -= assetsToBuy;
+            }
+
+            uint256 makerFee = (purchaseCost * order.makerFee) / basisPoints;
+            uint256 takerFee = (purchaseCost * order.takerFee) / basisPoints;
+
+            if (remainingEth < purchaseCost + takerFee) {
+                revert InsufficientPayment();
+            }
+
+            // Can be unchecked because (purchaseCost + takerFee) is less than or equal to remainingEth.
+            unchecked {
+                remainingEth -= (purchaseCost + takerFee);
+            }
+
+            collectedFees += makerFee + takerFee;
+
+            totalAssetReceived += assetsToBuy;
+            IInverseProjected1155(asset).safeTransferFrom(
+                address(this),
+                msg.sender,
+                order.assetId,
+                assetsToBuy,
+                bytes("")
+            );
+            balances[order.seller] += purchaseCost - makerFee;
+            emit OrderFilled(
+                asset,
+                order.assetId,
+                orderId,
+                order.seller,
+                msg.sender,
+                assetsToBuy,
+                order.pricePerAsset,
+                makerFee,
+                takerFee
+            );
+            if (remainingEth == 0) {
+                break;
+            }
+        }
+        if (totalAssetReceived < minimumAsset) {
+            revert InsufficientEndAmount(minimumAsset, totalAssetReceived);
+        }
+        if (remainingEth > 0) {
+            payable(msg.sender).sendValue(remainingEth);
+        }
+    }
+
+    /// @inheritdoc IOrderbookDex
+    function fillOrdersExactAsset(
+        address asset,
+        uint256 assetAmount,
+        uint256[] memory orderIds
+    ) external payable virtual nonReentrant {
+        uint256 length = orderIds.length;
+        uint256 remainingAsset = assetAmount;
+        uint256 remainingEth = msg.value;
+        for (uint256 i; i < length; ++i) {
+            uint256 orderId = orderIds.unsafeMemoryAccess(i);
+            Order storage order = orders[asset][orderId];
+            if (order.assetAmount == 0) {
+                continue;
+            }
+            uint256 assetsToBuy = order.assetAmount;
+            if (assetsToBuy > remainingAsset) {
+                assetsToBuy = remainingAsset;
+            }
+            if (assetsToBuy == 0) {
+                continue;
+            }
+
+            // Can be unchecked because assetsToBuy is less than or equal to order.assetAmount.
+            unchecked {
+                order.assetAmount -= assetsToBuy;
+            }
+
+            uint256 purchaseCost = assetsToBuy * order.pricePerAsset;
+            uint256 makerFee = (purchaseCost * order.makerFee) / basisPoints;
+            uint256 takerFee = (purchaseCost * order.takerFee) / basisPoints;
+
+            if (remainingEth < purchaseCost + takerFee) {
+                revert InsufficientPayment();
+            }
+
+            // Can be unchecked because (purchaseCost + takerFee) is less than or equal to remainingEth.
+            unchecked {
+                remainingEth -= (purchaseCost + takerFee);
+            }
+            // Can be unchecked because assetsToBuy is less than or equal to remainingAsset.
+            unchecked {
+                remainingAsset -= assetsToBuy;
+            }
+
+            collectedFees += makerFee + takerFee;
+
+            IInverseProjected1155(asset).safeTransferFrom(
+                address(this),
+                msg.sender,
+                order.assetId,
+                assetsToBuy,
+                bytes("")
+            );
+            balances[order.seller] += purchaseCost - makerFee;
+            emit OrderFilled(
+                asset,
+                order.assetId,
+                orderId,
+                order.seller,
+                msg.sender,
+                assetsToBuy,
+                order.pricePerAsset,
+                makerFee,
+                takerFee
+            );
+            if (remainingAsset == 0) {
+                break;
+            }
+        }
+        if (remainingAsset > 0) {
+            revert InsufficientEndAmount(assetAmount, assetAmount - remainingAsset);
+        }
+        if (remainingEth > 0) {
+            payable(msg.sender).sendValue(remainingEth);
+        }
+    }
+
+    /// @inheritdoc IOrderbookDex
+    function cancelSellOrder(address asset, uint256 orderId) external virtual nonReentrant {
+        uint256 creationFeePaid = orders[asset][orderId].creationFeePaid;
+        _cancelSellOrder(asset, orderId);
+        collectedFees -= creationFeePaid;
+        payable(msg.sender).sendValue(creationFeePaid);
+    }
+
+    /// @inheritdoc IOrderbookDex
+    function cancelBatchSellOrder(
+        address asset,
+        uint256[] memory orderIds
+    ) external virtual nonReentrant {
+        uint256 totalCreationFeePaid;
+        for (uint256 i; i < orderIds.length; ) {
+            totalCreationFeePaid += orders[asset][orderIds.unsafeMemoryAccess(i)].creationFeePaid;
+            _cancelSellOrder(asset, orderIds.unsafeMemoryAccess(i));
+            unchecked {
+                ++i;
+            }
+        }
+        collectedFees -= totalCreationFeePaid;
+        payable(msg.sender).sendValue(totalCreationFeePaid);
+    }
+
+    /// @inheritdoc IOrderbookDex
+    function withdrawFees() external onlyOwner {
+        uint256 amount = collectedFees;
+        delete collectedFees;
+        emit FeesWithdrawn(owner(), amount);
+        payable(owner()).sendValue(amount);
+    }
+
+    /// @dev Returns true if this contract implements the interface defined by `interfaceId`. See EIP165.
+    function supportsInterface(
+        bytes4 interfaceId
+    ) public view virtual override(ERC1155HolderUpgradeable, IERC165) returns (bool) {
+        return
+            interfaceId == type(IOrderbookDex).interfaceId || super.supportsInterface(interfaceId);
+    }
+
+    function _authorizeUpgrade(address) internal override onlyOwner {}
+
+    function _createSellOrder(
+        address asset,
+        uint256 assetId,
+        uint256 assetAmount,
+        uint256 pricePerAsset
+    ) internal virtual returns (uint256) {
+        if (assetAmount == 0 || pricePerAsset == 0) {
+            revert InvalidInput(0);
+        }
+        IInverseProjected1155(asset).safeTransferFrom(
+            msg.sender,
+            address(this),
+            assetId,
+            assetAmount,
+            bytes("")
+        );
+        (uint256 makerFee, uint256 takerFee) = getAssetAppliedFees(asset);
+        Order memory newOrder = Order({
+            assetId: assetId,
+            assetAmount: assetAmount,
+            pricePerAsset: pricePerAsset,
+            seller: payable(msg.sender),
+            makerFee: makerFee,
+            takerFee: takerFee,
+            creationFeePaid: orderCreationFee
+        });
+        uint256 orderId = currentOrderId[asset];
+        orders[asset][orderId] = newOrder;
+        emit OrderCreated(
+            asset,
+            assetId,
+            orderId,
+            msg.sender,
+            assetAmount,
+            pricePerAsset,
+            makerFee,
+            takerFee
+        );
+        ++currentOrderId[asset];
+        return orderId;
+    }
+
+    function _cancelSellOrder(address asset, uint256 orderId) internal virtual {
+        Order storage order = orders[asset][orderId];
+        if (msg.sender != order.seller) {
+            revert Unauthorized(msg.sender);
+        }
+        uint256 assetAmount = order.assetAmount;
+        delete order.assetAmount;
+        delete order.creationFeePaid;
+        IInverseProjected1155(asset).safeTransferFrom(
+            address(this),
+            msg.sender,
+            order.assetId,
+            assetAmount,
+            bytes("")
+        );
+        emit OrderCancelled(asset, order.assetId, orderId);
+    }
+}

package/src/contracts/token/IERC4906Agnostic.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: MIT
+// Forked from OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC4906.sol)
+
+pragma solidity ^0.8.13;
+
+/// @title Agnostic Metadata Update Extension
+interface IERC4906Agnostic {
+    /// @dev This event emits when the metadata of a token is changed.
+    /// So that the third-party platforms such as NFT market could
+    /// timely update the images and related attributes of the token.
+    event MetadataUpdate(uint256 _tokenId);
+
+    /// @dev This event emits when the metadata of a range of tokens is changed.
+    /// So that the third-party platforms such as NFT market could
+    /// timely update the images and related attributes of the tokens.
+    event BatchMetadataUpdate(uint256 _fromTokenId, uint256 _toTokenId);
+}