DiffusalOptionsOrderBook

/// @custom:storage-location erc7201:diffusal.storage.DiffusalOptionsOrderBook
struct DiffusalOptionsOrderBookStorage {
    address owner;
    mapping(bytes32 => uint256) orderFilled;     // Order hash → filled amount
    mapping(bytes32 => bool) orderCancelled;     // Order hash → cancelled flag
    mapping(address => uint256) userNonce;       // User → current nonce
    int256 makerFeeBps;                          // Maker fee (can be negative)
    uint256 takerFeeBps;                         // Taker fee
    uint256 rfqFeeBps;                           // RFQ fee (unused here)
    address feeRecipient;                        // Fee collector address
    address collateralVault;                     // Vault for margin checks
}

struct Order {
    address maker;      // Order creator
    bytes32 seriesId;   // Option series identifier
    bool isBuy;         // true = bid (buy), false = ask (sell)
    uint256 price;      // Premium per contract (WAD)
    uint256 size;       // Number of contracts
    uint256 nonce;      // Must match maker's current nonce
    uint256 expiry;     // Order validity deadline (unix timestamp)
}

seriesId = keccak256(abi.encodePacked(pairId, strike, expiry, isCall));

function fillOrder(
    OrderTypes.Order calldata order,
    bytes calldata signature,
    uint256 fillAmount,
    IDiffusalOptionsSeriesRegistry.SeriesParams calldata seriesParams
) external nonReentrant returns (FillResult memory result)

function fillOrderBatch(
    OrderTypes.Order[] calldata orders,
    bytes[] calldata signatures,
    uint256[] calldata fillAmounts,
    IDiffusalOptionsSeriesRegistry.SeriesParams calldata seriesParams
) external nonReentrant returns (FillResult[] memory results)

function cancelOrder(OrderTypes.Order calldata order, bytes calldata signature) external

function cancelOrderBatch(OrderTypes.Order[] calldata orders, bytes[] calldata signatures) external

function incrementNonce() external

function getOrderHash(OrderTypes.Order calldata order) public view returns (bytes32)

function getOrderStatus(OrderTypes.Order calldata order, bytes calldata signature)
    external view returns (OrderStatus memory status)

struct OrderStatus {
    bool isValid;      // Signature valid
    bool isCancelled;  // Order cancelled
    bool isExpired;    // Order expired
    uint256 filled;    // Amount filled
    uint256 remaining; // Amount remaining
}

function verifySignature(OrderTypes.Order calldata order, bytes calldata signature)
    public view returns (bool)

function orderFilled(bytes32 orderHash) external view returns (uint256)

function orderCancelled(bytes32 orderHash) external view returns (bool)

function userNonce(address user) external view returns (uint256)

function domainSeparator() public view returns (bytes32)

function setFees(int256 _makerFeeBps, uint256 _takerFeeBps, uint256 _rfqFeeBps) external

function setFeeRecipient(address _feeRecipient) external

function setCollateralVault(address _collateralVault) external

function transferOwnership(address newOwner) external

1. Taker calls fillOrder(order, signature, fillAmount, seriesParams)

2. Validation
   ├─ Check fillAmount > 0
   ├─ Check order not expired
   ├─ Check no self-trade
   ├─ Check order not cancelled
   ├─ Verify EIP-712 signature
   ├─ Check nonce matches
   └─ Check fillAmount ≤ remaining

3. Series Registration (lazy)
   └─ SeriesRegistry.getOrCreateSeries()

4. Calculate Premium & Fees
   ├─ premium = (price × fillAmount) / 1e18
   ├─ makerFee = (premium × makerFeeBps) / 10000
   └─ takerFee = (premium × takerFeeBps) / 10000

5. Execute Transfer
   ├─ If isBuy (maker buying):
   │   ├─ Transfer premium: maker → taker
   │   ├─ Position maker: +fillAmount (long)
   │   └─ Position taker: -fillAmount (short)
   └─ If !isBuy (maker selling):
       ├─ Transfer premium: taker → maker
       ├─ Position maker: -fillAmount (short)
       └─ Position taker: +fillAmount (long)

6. Collect Fees
   ├─ Taker fee: taker → feeRecipient
   └─ Maker fee: maker → feeRecipient (or reverse if rebate)

7. Margin Check
   ├─ Check maker isHealthy()
   └─ Check taker isHealthy()

8. Emit Events

if (msg.sender == order.maker) revert Errors.SelfTrade();

if (!vault.isHealthy(order.maker)) revert Errors.InsufficientMargin();
if (!vault.isHealthy(msg.sender)) revert Errors.InsufficientMargin();

if (int256(_takerFeeBps) + _makerFeeBps < 1) revert Errors.InvalidFeeConfiguration();

bytes32 private constant EIP712_DOMAIN_TYPEHASH =
    keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");

string private constant NAME = "DiffusalOptionsOrderBook";
string private constant VERSION = "1";

bytes32 public constant ORDER_TYPEHASH = keccak256(
    "Order(address maker,bytes32 seriesId,bool isBuy,uint256 price,uint256 size,uint256 nonce,uint256 expiry)"
);