Storing call_data in quotes and order_quotes tables

crates/autopilot/src/database/onchain_order_events.rs

@@ -487,6 +487,8 @@ async fn parse_general_onchain_order_placement_data<'a>(
                     sell_amount: u256_to_big_decimal(&quote.sell_amount),
                     buy_amount: u256_to_big_decimal(&quote.buy_amount),
                     solver: ByteArray(quote.data.solver.0),
+                    call_data: order_data.1.call_data.clone(),
+                    verified: quote.data.verified,
                 }),
                 Err(err) => {
                     let err_label = err.to_metrics_label();
@@ -620,6 +622,7 @@ fn convert_onchain_order_placement(
             true => OrderClass::Limit,
             false => OrderClass::Market,
         },
+        call_data: String::new(),
     };
     let onchain_order_placement_event = OnchainOrderPlacement {
         order_uid: ByteArray(order_uid.0),
@@ -925,6 +928,7 @@ mod test {
             buy_token_balance: buy_token_destination_into(expected_order_data.buy_token_balance),
             full_fee_amount: u256_to_big_decimal(&expected_order_data.fee_amount),
             cancellation_timestamp: None,
+            call_data: String::new(),
         };
         assert_eq!(onchain_order_placement, expected_onchain_order_placement);
         assert_eq!(order, expected_order);
@@ -1036,6 +1040,7 @@ mod test {
             buy_token_balance: buy_token_destination_into(expected_order_data.buy_token_balance),
             full_fee_amount: u256_to_big_decimal(&U256::zero()),
             cancellation_timestamp: None,
+            call_data: String::new(),
         };
         assert_eq!(onchain_order_placement, expected_onchain_order_placement);
         assert_eq!(order, expected_order);
@@ -1187,6 +1192,8 @@ mod test {
             sell_amount: u256_to_big_decimal(&quote.sell_amount),
             buy_amount: u256_to_big_decimal(&quote.buy_amount),
             solver: ByteArray(quote.data.solver.0),
+            call_data: String::new(),
+            verified: quote.data.verified,
         };
         assert_eq!(result.1, vec![Some(expected_quote)]);
         assert_eq!(

crates/database/src/orders.rs

@@ -99,6 +99,7 @@ pub struct Order {
     pub full_fee_amount: BigDecimal,
     pub cancellation_timestamp: Option<DateTime<Utc>>,
     pub class: OrderClass,
+    pub call_data: String,
 }
 
 pub async fn insert_orders_and_ignore_conflicts(
@@ -142,9 +143,10 @@ INSERT INTO orders (
     buy_token_balance,
     full_fee_amount,
     cancellation_timestamp,
-    class
+    class,
+    call_data
 )
-VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21)
+VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19, $20, $21, $22)
     "#;
 
 pub async fn insert_order_and_ignore_conflicts(
@@ -186,6 +188,7 @@ async fn insert_order_execute_sqlx(
         .bind(&order.full_fee_amount)
         .bind(order.cancellation_timestamp)
         .bind(order.class)
+        .bind(&order.call_data)
         .execute(ex)
         .await?;
     Ok(())
@@ -329,6 +332,8 @@ pub struct Quote {
     pub sell_amount: BigDecimal,
     pub buy_amount: BigDecimal,
     pub solver: Address,
+    pub call_data: String,
+    pub verified: bool,
 }
 
 pub async fn insert_quotes(ex: &mut PgConnection, quotes: &[Quote]) -> Result<(), sqlx::Error> {
@@ -346,9 +351,11 @@ INSERT INTO order_quotes (
     sell_token_price,
     sell_amount,
     buy_amount,
-    solver
+    solver,
+    call_data,
+    verified,
 )
-VALUES ($1, $2, $3, $4, $5, $6, $7)"#;
+VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)"#;
 
 pub async fn insert_quote_and_update_on_conflict(
     ex: &mut PgConnection,
@@ -362,7 +369,7 @@ pub async fn insert_quote_and_update_on_conflict(
         " ON CONFLICT (order_uid) DO UPDATE
 SET gas_amount = $2, gas_price = $3,
 sell_token_price = $4, sell_amount = $5,
-buy_amount = $6
+buy_amount = $6, call_data = $8, verified = $9
     "
     );
     sqlx::query(QUERY)
@@ -373,6 +380,8 @@ buy_amount = $6
         .bind(&quote.sell_amount)
         .bind(&quote.buy_amount)
         .bind(quote.solver)
+        .bind(&quote.call_data)
+        .bind(quote.verified)
         .execute(ex)
         .await?;
     Ok(())
@@ -387,6 +396,8 @@ pub async fn insert_quote(ex: &mut PgConnection, quote: &Quote) -> Result<(), sq
         .bind(&quote.sell_amount)
         .bind(&quote.buy_amount)
         .bind(quote.solver)
+        .bind(&quote.call_data)
+        .bind(quote.verified)
         .execute(ex)
         .await?;
     Ok(())
@@ -487,6 +498,7 @@ pub struct FullOrder {
     pub onchain_placement_error: Option<OnchainOrderPlacementError>,
     pub executed_surplus_fee: BigDecimal,
     pub full_app_data: Option<Vec<u8>>,
+    pub call_data: Option<String>,
 }
 
 #[derive(Debug, sqlx::FromRow)]
@@ -498,6 +510,7 @@ pub struct FullOrderWithQuote {
     pub quote_gas_amount: Option<f64>,
     pub quote_gas_price: Option<f64>,
     pub quote_sell_token_price: Option<f64>,
+    pub quote_verified: Option<bool>,
     pub solver: Option<Address>,
 }
 
@@ -538,7 +551,7 @@ pub const SELECT: &str = r#"
 o.uid, o.owner, o.creation_timestamp, o.sell_token, o.buy_token, o.sell_amount, o.buy_amount,
 o.valid_to, o.app_data, o.fee_amount, o.full_fee_amount, o.kind, o.partially_fillable, o.signature,
 o.receiver, o.signing_scheme, o.settlement_contract, o.sell_token_balance, o.buy_token_balance,
-o.class,
+o.class, o.call_data,
 (SELECT COALESCE(SUM(t.buy_amount), 0) FROM trades t WHERE t.order_uid = o.uid) AS sum_buy,
 (SELECT COALESCE(SUM(t.sell_amount), 0) FROM trades t WHERE t.order_uid = o.uid) AS sum_sell,
 (SELECT COALESCE(SUM(t.fee_amount), 0) FROM trades t WHERE t.order_uid = o.uid) AS sum_fee,
@@ -591,6 +604,7 @@ pub async fn single_full_order_with_quote(
         ", o_quotes.gas_amount as quote_gas_amount",
         ", o_quotes.gas_price as quote_gas_price",
         ", o_quotes.sell_token_price as quote_sell_token_price",
+        ", o_quotes.verified as quote_verified",
         ", o_quotes.solver as solver",
         " FROM ", FROM,
         " LEFT JOIN order_quotes o_quotes ON o.uid = o_quotes.order_uid",
@@ -1201,6 +1215,8 @@ mod tests {
             sell_amount: 4.into(),
             buy_amount: 5.into(),
             solver: ByteArray([1; 20]),
+            call_data: String::new(),
+            verified: false,
         };
         insert_quote(&mut db, &quote).await.unwrap();
         insert_quote_and_update_on_conflict(&mut db, &quote)
@@ -1261,6 +1277,8 @@ mod tests {
             sell_amount: 4.into(),
             buy_amount: 5.into(),
             solver: ByteArray([1; 20]),
+            call_data: String::new(),
+            verified: false,
         };
         insert_quote(&mut db, &quote).await.unwrap();
         let quote_ = read_quote(&mut db, &quote.order_uid)
@@ -1287,6 +1305,8 @@ mod tests {
             sell_amount: 4.into(),
             buy_amount: 5.into(),
             solver: ByteArray([1; 20]),
+            call_data: String::new(),
+            verified: false,
         };
         insert_quote(&mut db, &quote).await.unwrap();
         let order_with_quote = single_full_order_with_quote(&mut db, &quote.order_uid)

crates/orderbook/src/database/orders.rs

@@ -100,6 +100,8 @@ impl OrderWithQuote {
                 sell_amount: u256_to_big_decimal(&quote.sell_amount),
                 buy_amount: u256_to_big_decimal(&quote.buy_amount),
                 solver: ByteArray(quote.data.solver.0),
+                call_data: order.metadata.full_app_data.clone().unwrap_or_default(),
+                verified: quote.data.verified,
             }),
             order,
         }
@@ -202,6 +204,7 @@ async fn insert_order(order: &Order, ex: &mut PgConnection) -> Result<(), Insert
         buy_token_balance: buy_token_destination_into(order.data.buy_token_balance),
         full_fee_amount: u256_to_big_decimal(&order.metadata.full_fee_amount),
         cancellation_timestamp: None,
+        call_data: order.metadata.full_app_data.clone().unwrap_or_default(),
     };
 
     database::orders::insert_order(ex, &order)
@@ -221,18 +224,20 @@ async fn insert_order(order: &Order, ex: &mut PgConnection) -> Result<(), Insert
 }
 
 async fn insert_quote(
-    uid: &OrderUid,
+    order: &Order,
     quote: &Quote,
     ex: &mut PgConnection,
 ) -> Result<(), InsertionError> {
     let quote = database::orders::Quote {
-        order_uid: ByteArray(uid.0),
+        order_uid: ByteArray(order.metadata.uid.0),
         gas_amount: quote.data.fee_parameters.gas_amount,
         gas_price: quote.data.fee_parameters.gas_price,
         sell_token_price: quote.data.fee_parameters.sell_token_price,
         sell_amount: u256_to_big_decimal(&quote.sell_amount),
         buy_amount: u256_to_big_decimal(&quote.buy_amount),
         solver: ByteArray(quote.data.solver.0),
+        call_data: order.metadata.full_app_data.clone().unwrap_or_default(),
+        verified: quote.data.verified,
     };
     database::orders::insert_quote(ex, &quote)
         .await
@@ -258,7 +263,7 @@ impl OrderStoring for Postgres {
 
         insert_order(&order, &mut ex).await?;
         if let Some(quote) = quote {
-            insert_quote(&order.metadata.uid, &quote, &mut ex).await?;
+            insert_quote(&order, &quote, &mut ex).await?;
         }
         Self::insert_order_app_data(&order, &mut ex).await?;
 
@@ -318,7 +323,7 @@ impl OrderStoring for Postgres {
                     .await?;
                     insert_order(&new_order, ex).await?;
                     if let Some(quote) = new_quote {
-                        insert_quote(&new_order.metadata.uid, &quote, ex).await?;
+                        insert_quote(&new_order, &quote, ex).await?;
                     }
                     Self::insert_order_app_data(&new_order, ex).await?;
 
@@ -356,12 +361,14 @@ impl OrderStoring for Postgres {
         let order = orders::single_full_order_with_quote(&mut ex, &ByteArray(uid.0)).await?;
         order
             .map(|order_with_quote| {
+                let call_data = order_with_quote.full_order.call_data.clone().unwrap_or_default();
                 let quote = match (
                     order_with_quote.quote_buy_amount,
                     order_with_quote.quote_sell_amount,
                     order_with_quote.quote_gas_amount,
                     order_with_quote.quote_gas_price,
                     order_with_quote.quote_sell_token_price,
+                    order_with_quote.quote_verified,
                     order_with_quote.solver,
                 ) {
                     (
@@ -370,6 +377,7 @@ impl OrderStoring for Postgres {
                         Some(gas_amount),
                         Some(gas_price),
                         Some(sell_token_price),
+                        Some(verified),
                         Some(solver),
                     ) => Some(orders::Quote {
                         order_uid: order_with_quote.full_order.uid,
@@ -379,6 +387,8 @@ impl OrderStoring for Postgres {
                         sell_amount,
                         buy_amount,
                         solver,
+                        call_data,
+                        verified
                     }),
                     _ => None,
                 };
@@ -708,6 +718,7 @@ mod tests {
             onchain_placement_error: None,
             executed_surplus_fee: Default::default(),
             full_app_data: Default::default(),
+            call_data: None,
         };
 
         // Open - sell (filled - 0%)