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

crates/autopilot/src/domain/settlement/solution/mod.rs

@@ -92,7 +92,13 @@ impl Solution {
                     match (total, protocol) {
                         (Ok(total), Ok(protocol)) => {
                             let network =
-                                total.saturating_sub(protocol.iter().map(|(fee, _)| *fee).sum());
+                                total.saturating_sub(protocol.iter().map(|(_, fee, _)| *fee).sum());
+                            let protocol = protocol
+                                .into_iter()
+                                .map(|(token, amount, policy)| {
+                                    (ExecutedProtocolFee { token, amount }, policy)
+                                })
+                                .collect();
                             Some(ExecutedFee { protocol, network })
                         }
                         _ => None,
@@ -198,13 +204,21 @@ pub struct ExecutedFee {
     pub network: eth::SellTokenAmount,
     /// Breakdown of protocol fees. Executed protocol fees are in the same order
     /// as policies are defined for an order.
-    pub protocol: Vec<(eth::SellTokenAmount, fee::Policy)>,
+    pub protocol: Vec<(ExecutedProtocolFee, fee::Policy)>,
+}
+
+#[derive(Debug, Clone)]
+pub struct ExecutedProtocolFee {
+    /// Token in which the fee was paid
+    pub token: eth::TokenAddress,
+    /// Amount of the fee
+    pub amount: eth::SellTokenAmount,
 }
 
 impl ExecutedFee {
     /// Total fee paid for the trade.
     pub fn total(&self) -> eth::SellTokenAmount {
-        self.network + self.protocol.iter().map(|(fee, _)| *fee).sum()
+        self.network + self.protocol.iter().map(|(fee, _)| fee.amount).sum()
     }
 }
 

crates/autopilot/src/domain/settlement/solution/trade.rs

@@ -191,10 +191,16 @@ impl Trade {
     pub fn protocol_fees_in_sell_token(
         &self,
         auction: &settlement::Auction,
-    ) -> Result<Vec<(eth::SellTokenAmount, fee::Policy)>, Error> {
+    ) -> Result<Vec<(eth::TokenAddress, eth::SellTokenAmount, fee::Policy)>, Error> {
         self.protocol_fees(auction)?
             .into_iter()
-            .map(|(fee, policy)| Ok((self.fee_into_sell_token(fee.amount)?, policy)))
+            .map(|(fee, policy)| {
+                Ok((
+                    self.sell.token,
+                    self.fee_into_sell_token(fee.amount)?,
+                    policy,
+                ))
+            })
             .collect()
     }
 

crates/autopilot/src/infra/persistence/mod.rs

@@ -472,15 +472,29 @@ impl Persistence {
             )
             .await;
 
-            for (order, executed_fee) in order_fees {
+            for (order, order_fee) in order_fees {
+                let executed_fee = order_fee
+                    .as_ref()
+                    .map(|fee| u256_to_big_decimal(&fee.total().0))
+                    .unwrap_or_default();
+                let executed_protocol_fees = order_fee
+                    .map(|fee| {
+                        fee.protocol
+                            .into_iter()
+                            .map(|(fee, _)| database::order_execution::FeeAsset {
+                                token: ByteArray(fee.token.0 .0),
+                                amount: u256_to_big_decimal(&fee.amount.0),
+                            })
+                            .collect::<Vec<_>>()
+                    })
+                    .unwrap_or_default();
                 database::order_execution::save(
                     &mut ex,
                     &ByteArray(order.0),
                     auction_id,
                     block_number,
-                    &u256_to_big_decimal(
-                        &executed_fee.map(|fee| fee.total()).unwrap_or_default().0,
-                    ),
+                    &executed_fee,
+                    &executed_protocol_fees,
                 )
                 .await?;
             }

crates/database/src/order_execution.rs

@@ -1,33 +1,103 @@
 use {
-    crate::{auction::AuctionId, OrderUid},
+    crate::{auction::AuctionId, Address, OrderUid},
     bigdecimal::BigDecimal,
-    sqlx::PgConnection,
+    sqlx::{PgConnection, QueryBuilder},
+    std::collections::HashMap,
 };
 
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct FeeAsset {
+    pub amount: BigDecimal,
+    pub token: Address,
+}
+
 pub async fn save(
     ex: &mut PgConnection,
     order: &OrderUid,
     auction: AuctionId,
     block_number: i64,
     executed_fee: &BigDecimal,
+    executed_protocol_fees: &[FeeAsset],
 ) -> Result<(), sqlx::Error> {
+    let (protocol_fee_tokens, protocol_fee_amounts) = executed_protocol_fees.iter().fold(
+        (Vec::new(), Vec::new()),
+        |(mut tokens, mut amounts), fee| {
+            tokens.push(fee.token);
+            amounts.push(fee.amount.clone());
+            (tokens, amounts)
+        },
+    );
+
     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_fee_tokens, protocol_fee_amounts)
+VALUES ($1, $2, $3, $4, $5, $6, $7)
 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_fee_tokens = $6, protocol_fee_amounts = $7
 ;"#;
     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(protocol_fee_tokens)
+        .bind(protocol_fee_amounts)
         .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 query_builder = QueryBuilder::new(
+        "SELECT order_uid, auction_id, protocol_fee_tokens, protocol_fee_amounts FROM \
+         order_execution WHERE ",
+    );
+
+    for (i, (auction_id, order_uid)) in keys_filter.iter().enumerate() {
+        if i > 0 {
+            query_builder.push(" OR ");
+        }
+        query_builder
+            .push("(order_uid = ")
+            .push_bind(order_uid)
+            .push(" AND auction_id = ")
+            .push_bind(auction_id)
+            .push(")");
+    }
+
+    #[derive(Clone, Debug, Eq, PartialEq, sqlx::Type, sqlx::FromRow)]
+    struct ProtocolFees {
+        pub order_uid: OrderUid,
+        pub auction_id: AuctionId,
+        pub protocol_fee_tokens: Vec<Address>,
+        pub protocol_fee_amounts: Vec<BigDecimal>,
+    }
+    let query = query_builder.build_query_as::<ProtocolFees>();
+    let rows: Vec<ProtocolFees> = query.fetch_all(ex).await?;
+
+    let mut fees = HashMap::new();
+    for row in rows {
+        fees.insert(
+            (row.auction_id, row.order_uid),
+            row.protocol_fee_tokens
+                .into_iter()
+                .zip(row.protocol_fee_amounts)
+                .map(|(token, amount)| FeeAsset { token, amount })
+                .collect(),
+        );
+    }
+
+    Ok(fees)
+}
+
 #[cfg(test)]
 mod tests {
     use {super::*, sqlx::Connection};
@@ -39,8 +109,40 @@ 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 entry with protocol fees
+        save(
+            &mut db,
+            &Default::default(),
+            1,
+            0,
+            &Default::default(),
+            &[
+                FeeAsset {
+                    amount: Default::default(),
+                    token: Default::default(),
+                },
+                FeeAsset {
+                    amount: Default::default(),
+                    token: Default::default(),
+                },
+            ],
+        )
+        .await
+        .unwrap();
+
+        // save entry without protocol fees (simulate case when we are still not
+        // calculating them)
+        save(&mut db, &Default::default(), 2, 0, &Default::default(), &[])
             .await
             .unwrap();
+
+        let keys: Vec<(AuctionId, OrderUid)> = vec![
+            (1, Default::default()),
+            (2, Default::default()),
+            (3, Default::default()),
+        ];
+
+        let protocol_fees = executed_protocol_fees(&mut db, &keys).await.unwrap();
+        assert_eq!(protocol_fees.len(), 2);
     }
 }

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, &[])
             .await
             .unwrap();
 

crates/e2e/tests/e2e/limit_orders.rs

@@ -819,11 +819,14 @@ async fn no_liquidity_limit_order(web3: Web3) {
     assert!(balance_after.checked_sub(balance_before).unwrap() >= to_wei(5));
 
     let trades = services.get_trades(&order_id).await.unwrap();
+    let (policy, executed_protocol_fee) = trades.first().unwrap().fee_policies.first().unwrap();
     assert_eq!(
-        trades.first().unwrap().fee_policies,
-        vec![model::fee_policy::FeePolicy::Surplus {
+        policy,
+        &model::fee_policy::FeePolicy::Surplus {
             factor: 0.5,
             max_volume_factor: 0.01
-        }],
+        }
     );
+    assert_eq!(executed_protocol_fee.token, token_a.address());
+    assert!(executed_protocol_fee.amount > U256::zero());
 }

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,
+}