feat(order): add realized quote and fee onto OrderRecord

canister/oisy_trade.did

@@ -281,6 +281,13 @@ type OrderRecord = record {
     last_updated_at : opt nat64;
     /// Time-in-force policy the order was placed with.
     time_in_force : TimeInForce;
+    /// Cumulative realized quote notional transacted across the order's fills,
+    /// in quote-token smallest units. A buy taker's released reservation
+    /// surplus is excluded; VWAP is `filled_quote × base_scale / filled_quantity`.
+    filled_quote : nat;
+    /// Cumulative realized fee charged across the order's fills, in the order's
+    /// receive token — base for a buy, quote for a sell.
+    filled_fee : nat;
 };
 
 /// Request for `get_my_orders`.

canister/src/order/history/mod.rs

@@ -45,6 +45,15 @@ pub struct OrderRecord {
     /// Time-in-force policy the order was placed with.
     #[n(8)]
     pub time_in_force: TimeInForce,
+    /// Cumulative realized quote notional transacted across the order's fills,
+    /// `Σ (maker_price × fill_quantity / base_scale)`. Always quote-denominated;
+    /// a buy taker's released reservation surplus is excluded.
+    #[n(9)]
+    pub filled_quote: Quantity,
+    /// Cumulative realized fee charged across the order's fills, denominated in
+    /// the order's receive token — base for a buy, quote for a sell.
+    #[n(10)]
+    pub filled_fee: Quantity,
 }
 
 impl From<OrderRecord> for oisy_trade_types::OrderRecord {
@@ -59,17 +68,22 @@ impl From<OrderRecord> for oisy_trade_types::OrderRecord {
             created_at: record.created_at.as_nanos(),
             last_updated_at: record.last_updated_at.map(|t| t.as_nanos()),
             time_in_force: record.time_in_force.into(),
+            filled_quote: record.filled_quote.into(),
+            filled_fee: record.filled_fee.into(),
         }
     }
 }
 
 /// A combined update to an order record, applied in a single read-modify-write
-/// by [`OrderHistory::apply_update`]: an optional status transition plus a
-/// fill delta to add to `filled_quantity`.
+/// by [`OrderHistory::apply_update`]: an optional status transition plus the
+/// fill, quote, and fee deltas to add to `filled_quantity`, `filled_quote`, and
+/// `filled_fee`.
 #[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
 pub struct OrderUpdate {
     pub status: Option<OrderStatus>,
     pub filled_delta: Quantity,
+    pub quote_delta: Quantity,
+    pub fee_delta: Quantity,
 }
 
 impl OrderUpdate {
@@ -78,6 +92,8 @@ impl OrderUpdate {
         Self {
             status: Some(status),
             filled_delta: Quantity::ZERO,
+            quote_delta: Quantity::ZERO,
+            fee_delta: Quantity::ZERO,
         }
     }
 
@@ -86,6 +102,8 @@ impl OrderUpdate {
         Self {
             status: None,
             filled_delta,
+            quote_delta: Quantity::ZERO,
+            fee_delta: Quantity::ZERO,
         }
     }
 
@@ -94,13 +112,16 @@ impl OrderUpdate {
     /// # Panics
     ///
     /// `filled_quantity` is monotonic non-decreasing and must never exceed
-    /// `quantity`; this invariant is enforced by an always-on check that traps
-    /// on violation.
+    /// `quantity`; `filled_quote` and `filled_fee` are monotonic
+    /// non-decreasing. These invariants are enforced by always-on checks that
+    /// trap on violation.
     pub fn apply(self, order: &mut OrderRecord) -> bool {
         let mut changed = false;
         let OrderUpdate {
             status,
             filled_delta,
+            quote_delta,
+            fee_delta,
         } = self;
 
         if let Some(new_status) = status
@@ -125,6 +146,22 @@ impl OrderUpdate {
                 order.created_at,
             );
         }
+
+        if quote_delta != Quantity::ZERO {
+            changed = true;
+            order.filled_quote = order
+                .filled_quote
+                .checked_add(quote_delta)
+                .expect("BUG: filled_quote overflow");
+        }
+
+        if fee_delta != Quantity::ZERO {
+            changed = true;
+            order.filled_fee = order
+                .filled_fee
+                .checked_add(fee_delta)
+                .expect("BUG: filled_fee overflow");
+        }
         changed
     }
 }

canister/src/order/history/tests.rs

@@ -29,6 +29,8 @@ fn test_record() -> OrderRecord {
         created_at: Timestamp::EPOCH,
         last_updated_at: None,
         time_in_force: TimeInForce::FillOrKill,
+        filled_quote: Quantity::ZERO,
+        filled_fee: Quantity::ZERO,
     }
 }
 
@@ -134,6 +136,8 @@ fn apply_update_status_and_delta_in_one_write() {
         OrderUpdate {
             status: Some(OrderStatus::Open),
             filled_delta: Quantity::from(300_000u64),
+            quote_delta: Quantity::from(3u64),
+            fee_delta: Quantity::from(1u64),
         },
         Timestamp::new(11),
     );
@@ -142,16 +146,80 @@ fn apply_update_status_and_delta_in_one_write() {
         OrderUpdate {
             status: Some(OrderStatus::Filled),
             filled_delta: Quantity::from(700_000u64),
+            quote_delta: Quantity::from(7u64),
+            fee_delta: Quantity::from(2u64),
         },
         Timestamp::new(13),
     );
     let record = history.get(&id).expect("record present");
-    // Deltas accumulate; status reflects the latest update.
+    // The fill, quote, and fee deltas all accumulate within the same single
+    // read-modify-write; status reflects the latest update.
     assert_eq!(record.status, OrderStatus::Filled);
     assert_eq!(record.filled_quantity, Quantity::from(1_000_000u64));
+    assert_eq!(record.filled_quote, Quantity::from(10u64));
+    assert_eq!(record.filled_fee, Quantity::from(3u64));
     assert_eq!(record.last_updated_at, Some(Timestamp::new(13)));
 }
 
+#[test]
+fn apply_update_accumulates_quote_and_fee_in_one_write() {
+    let mut history = history();
+    let id = order_id(0);
+    history.insert_once(UserId::new(0), id, test_record());
+
+    // A fill-only update that carries quote and fee deltas writes all three
+    // scalars (and `last_updated_at`) in a single read-modify-write, leaving
+    // status untouched.
+    history.apply_update(
+        &id,
+        OrderUpdate {
+            status: None,
+            filled_delta: Quantity::from(200_000u64),
+            quote_delta: Quantity::from(20_000_000u64),
+            fee_delta: Quantity::from(10_000u64),
+        },
+        Timestamp::new(5),
+    );
+    let record = history.get(&id).expect("record present");
+    assert_eq!(record.status, OrderStatus::Pending);
+    assert_eq!(record.filled_quantity, Quantity::from(200_000u64));
+    assert_eq!(record.filled_quote, Quantity::from(20_000_000u64));
+    assert_eq!(record.filled_fee, Quantity::from(10_000u64));
+    assert_eq!(record.last_updated_at, Some(Timestamp::new(5)));
+}
+
+#[test]
+#[should_panic(expected = "BUG: filled_quote overflow")]
+fn apply_update_traps_on_filled_quote_overflow() {
+    // The monotonic `filled_quote` invariant is enforced by an always-on trap,
+    // not a `debug_assert!` compiled out of the release canister: starting from
+    // `Quantity::MAX`, any positive `quote_delta` overflows and must panic even
+    // when tests run in release config.
+    let mut record = test_record();
+    record.filled_quote = Quantity::MAX;
+    OrderUpdate {
+        status: None,
+        filled_delta: Quantity::ZERO,
+        quote_delta: Quantity::from(1u64),
+        fee_delta: Quantity::ZERO,
+    }
+    .apply(&mut record);
+}
+
+#[test]
+#[should_panic(expected = "BUG: filled_fee overflow")]
+fn apply_update_traps_on_filled_fee_overflow() {
+    let mut record = test_record();
+    record.filled_fee = Quantity::MAX;
+    OrderUpdate {
+        status: None,
+        filled_delta: Quantity::ZERO,
+        quote_delta: Quantity::ZERO,
+        fee_delta: Quantity::from(1u64),
+    }
+    .apply(&mut record);
+}
+
 #[test]
 fn apply_update_is_a_noop_when_update_is_a_noop() {
     let mut history = history();