Breakdown fees protocol 3/3: DB field and returning on /get_trades

crates/autopilot/src/database/on_settlement_event_updater.rs

@@ -83,6 +83,7 @@ impl super::Postgres {
                     settlement_update.auction_id,
                     settlement_update.block_number,
                     &u256_to_big_decimal(&executed_fee),
+                    None,
                 )
                 .await
                 .context("save_order_executions")?;

crates/database/src/order_execution.rs

@@ -1,33 +1,91 @@
 use {
-    crate::{auction::AuctionId, OrderUid},
+    crate::{auction::AuctionId, Address, OrderUid},
     bigdecimal::BigDecimal,
-    sqlx::PgConnection,
+    sqlx::{
+        postgres::{PgHasArrayType, PgTypeInfo},
+        PgConnection,
+    },
+    std::collections::HashMap,
 };
 
+#[derive(Clone, Debug, Eq, PartialEq, sqlx::Type, sqlx::FromRow)]
+pub struct FeeAsset {
+    pub amount: BigDecimal,
+    pub token: Address,
+}
+
+// explains that the equivalent Postgres type is already defined in the database
+impl PgHasArrayType for FeeAsset {
+    fn array_type_info() -> PgTypeInfo {
+        PgTypeInfo::with_name("_feeasset")
+    }
+}
+
 pub async fn save(
     ex: &mut PgConnection,
     order: &OrderUid,
     auction: AuctionId,
     block_number: i64,
     executed_fee: &BigDecimal,
+    executed_protocol_fees: Option<&[FeeAsset]>,
 ) -> Result<(), sqlx::Error> {
     const QUERY: &str = r#"
-INSERT INTO order_execution (order_uid, auction_id, reward, surplus_fee, block_number)
-VALUES ($1, $2, $3, $4, $5)
+INSERT INTO order_execution (order_uid, auction_id, reward, surplus_fee, block_number, protocol_fees)
+VALUES ($1, $2, $3, $4, $5, $6)
 ON CONFLICT (order_uid, auction_id)
-DO UPDATE SET reward = $3, surplus_fee = $4, block_number = $5
+DO UPDATE SET reward = $3, surplus_fee = $4, block_number = $5, protocol_fees = $6
 ;"#;
     sqlx::query(QUERY)
         .bind(order)
         .bind(auction)
         .bind(0.) // reward is deprecated but saved for historical analysis
         .bind(Some(executed_fee))
         .bind(block_number)
+        .bind(executed_protocol_fees)
         .execute(ex)
         .await?;
     Ok(())
 }
 
+// fetch protocol fees for all keys in the filter
+pub async fn executed_protocol_fees(
+    ex: &mut PgConnection,
+    keys_filter: &[(AuctionId, OrderUid)],
+) -> Result<HashMap<(AuctionId, OrderUid), Vec<FeeAsset>>, sqlx::Error> {
+    if keys_filter.is_empty() {
+        return Ok(HashMap::new());
+    }
+
+    let mut fees = HashMap::new();
+    for (auction_id, order_uid) in keys_filter {
+        let protocol_fees = get_protocol_fees(ex, order_uid, *auction_id).await?;
+        fees.insert((*auction_id, *order_uid), protocol_fees.unwrap_or_default());
+    }
+
+    Ok(fees)
+}
+
+// executed procotol fee for a single <order, auction> pair
+async fn get_protocol_fees(
+    ex: &mut PgConnection,
+    order: &OrderUid,
+    auction: AuctionId,
+) -> Result<Option<Vec<FeeAsset>>, sqlx::Error> {
+    const QUERY: &str = r#"
+        SELECT protocol_fees
+        FROM order_execution
+        WHERE order_uid = $1 AND auction_id = $2
+    "#;
+
+    let row = sqlx::query_scalar(QUERY)
+        .bind(order)
+        .bind(auction)
+        .fetch_optional(ex)
+        .await?;
+
+    Ok(row)
+}
+
 #[cfg(test)]
 mod tests {
     use {super::*, sqlx::Connection};
@@ -39,8 +97,54 @@ mod tests {
         let mut db = db.begin().await.unwrap();
         crate::clear_DANGER_(&mut db).await.unwrap();
 
-        save(&mut db, &Default::default(), 1, 0, &Default::default())
+        save(
+            &mut db,
+            &Default::default(),
+            1,
+            0,
+            &Default::default(),
+            Some(&[
+                FeeAsset {
+                    amount: Default::default(),
+                    token: Default::default(),
+                },
+                FeeAsset {
+                    amount: Default::default(),
+                    token: Default::default(),
+                },
+            ]),
+        )
+        .await
+        .unwrap();
+
+        // save entry but without protocol fees (we are still not calculating them)
+        save(
+            &mut db,
+            &Default::default(),
+            2,
+            0,
+            &Default::default(),
+            None,
+        )
+        .await
+        .unwrap();
+
+        let protocol_fees = get_protocol_fees(&mut db, &Default::default(), 1)
+            .await
+            .unwrap()
+            .unwrap();
+        assert_eq!(protocol_fees.len(), 2);
+
+        // existing order but without protocol fees
+        let protocol_fees = get_protocol_fees(&mut db, &Default::default(), 2)
+            .await
+            .unwrap();
+        assert!(protocol_fees.is_none());
+
+        // non-existing order
+        let protocol_fees = get_protocol_fees(&mut db, &Default::default(), 3)
             .await
             .unwrap();
+        assert!(protocol_fees.is_none());
     }
 }

crates/database/src/orders.rs

@@ -1854,7 +1854,7 @@ mod tests {
         assert_eq!(order.executed_surplus_fee, 0.into());
 
         let fee: BigDecimal = 1.into();
-        crate::order_execution::save(&mut db, &order_uid, 1, 0, &fee)
+        crate::order_execution::save(&mut db, &order_uid, 1, 0, &fee, None)
             .await
             .unwrap();
 

crates/e2e/tests/e2e/limit_orders.rs

@@ -809,9 +809,12 @@ async fn no_liquidity_limit_order(web3: Web3) {
     let trades = services.get_trades(&order_id).await.unwrap();
     assert_eq!(
         trades.first().unwrap().fee_policies,
-        vec![model::fee_policy::FeePolicy::Surplus {
-            factor: 0.5,
-            max_volume_factor: 0.01
-        }],
+        vec![(
+            model::fee_policy::FeePolicy::Surplus {
+                factor: 0.5,
+                max_volume_factor: 0.01
+            },
+            None
+        )],
     );
 }

crates/model/src/fee_policy.rs

@@ -1,6 +1,6 @@
 use {
     number::serialization::HexOrDecimalU256,
-    primitive_types::U256,
+    primitive_types::{H160, U256},
     serde::Serialize,
     serde_with::serde_as,
 };
@@ -34,3 +34,13 @@ pub struct Quote {
     #[serde_as(as = "HexOrDecimalU256")]
     pub fee: U256,
 }
+
+#[serde_as]
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+#[cfg_attr(any(test, feature = "e2e"), derive(serde::Deserialize))]
+#[serde(rename_all = "camelCase")]
+pub struct ExecutedFee {
+    #[serde_as(as = "HexOrDecimalU256")]
+    pub amount: U256,
+    pub token: H160,
+}

crates/model/src/trade.rs

@@ -2,7 +2,10 @@
 //! as described by the openapi documentation.
 
 use {
-    crate::{fee_policy::FeePolicy, order::OrderUid},
+    crate::{
+        fee_policy::{ExecutedFee, FeePolicy},
+        order::OrderUid,
+    },
     num::BigUint,
     primitive_types::{H160, H256},
     serde::Serialize,
@@ -30,7 +33,7 @@ pub struct Trade {
     // Settlement Data
     pub tx_hash: Option<H256>,
     // Fee Policy Data
-    pub fee_policies: Vec<FeePolicy>,
+    pub fee_policies: Vec<(FeePolicy, Option<ExecutedFee>)>,
 }
 
 #[cfg(test)]
@@ -58,18 +61,18 @@ mod tests {
             "buyToken": "0x0000000000000000000000000000000000000009",
             "txHash": "0x0000000000000000000000000000000000000000000000000000000000000040",
             "feePolicies": [
-                {
+                [{
                     "surplus": {
                         "factor": 1.1,
                         "maxVolumeFactor": 2.2
                     }
-                },
-                {
+                }, null],
+                [{
                     "volume": {
                         "factor": 0.9
                     }
-                },
-                {
+                }, null],
+                [{
                     "priceImprovement": {
                         "factor": 1.2,
                         "maxVolumeFactor": 1.5,
@@ -79,7 +82,10 @@ mod tests {
                             "fee": "5"
                         }
                     }
-                }
+                }, {
+                    "amount": "5",
+                    "token": "0x000000000000000000000000000000000000000a"
+                }]
             ]
         });
         let expected = Trade {
@@ -94,20 +100,29 @@ mod tests {
             sell_token: H160::from_low_u64_be(10),
             tx_hash: Some(H256::from_low_u64_be(64)),
             fee_policies: vec![
-                FeePolicy::Surplus {
-                    factor: 1.1,
-                    max_volume_factor: 2.2,
-                },
-                FeePolicy::Volume { factor: 0.9 },
-                FeePolicy::PriceImprovement {
-                    factor: 1.2,
-                    max_volume_factor: 1.5,
-                    quote: Quote {
-                        sell_amount: U256::from(100u64),
-                        buy_amount: U256::from(150u64),
-                        fee: U256::from(5u64),
+                (
+                    FeePolicy::Surplus {
+                        factor: 1.1,
+                        max_volume_factor: 2.2,
                     },
-                },
+                    None,
+                ),
+                (FeePolicy::Volume { factor: 0.9 }, None),
+                (
+                    FeePolicy::PriceImprovement {
+                        factor: 1.2,
+                        max_volume_factor: 1.5,
+                        quote: Quote {
+                            sell_amount: U256::from(100u64),
+                            buy_amount: U256::from(150u64),
+                            fee: U256::from(5u64),
+                        },
+                    },
+                    Some(ExecutedFee {
+                        amount: U256::from(5u64),
+                        token: H160::from_low_u64_be(10),
+                    }),
+                ),
             ],
         };
 

crates/orderbook/openapi.yml

@@ -1194,10 +1194,10 @@ components:
           nullable: true
         feePolicies:
           description: | 
-           The fee policies that were used to compute the fees for this trade. Listed in the order they got applied.
+           The fee policies that were used to compute the fees for this trade, together with the executed amount of protocol fee. Listed in the order they got applied.
           type: array
           items:
-            $ref: "#/components/schemas/FeePolicy"
+            $ref: "#/components/schemas/FeePolicyWithExecutedFee"
       required:
         - blockNumber
         - logIndex
@@ -1667,3 +1667,23 @@ components:
         - $ref: "#/components/schemas/Surplus"
         - $ref: "#/components/schemas/Volume"
         - $ref: "#/components/schemas/PriceImprovement"
+    ExecutedFee:
+      type: object
+      properties:
+        amount:
+          description: "Fee amount taken"
+          $ref: "#/components/schemas/TokenAmount"
+        token:
+          description: "The token in which the fee is taken"
+          $ref: "#/components/schemas/Address"
+      required:
+        - amount
+        - token
+    FeePolicyWithExecutedFee:
+      type: object
+      properties:
+        fee_policy:
+          $ref: '#/components/schemas/FeePolicy'
+        executed_fee:
+          $ref: '#/components/schemas/ExecutedFee'
+          nullable: true