Merge branch 'main' into 02/14/25-disclaime-modal

crates/js_api/src/gui/mod.rs

@@ -162,6 +162,19 @@ impl DotrainOrderGui {
         Ok(DeploymentDetails(deployment_details.into_iter().collect()))
     }
 
+    #[wasm_bindgen(js_name = "getDeploymentDetail")]
+    pub async fn get_deployment_detail(
+        dotrain: String,
+        key: String,
+    ) -> Result<NameAndDescription, GuiError> {
+        let deployment_details = DotrainOrderGui::get_deployment_details(dotrain).await?;
+        let deployment_detail = deployment_details
+            .0
+            .get(&key)
+            .ok_or(GuiError::DeploymentNotFound(key))?;
+        Ok(deployment_detail.clone())
+    }
+
     #[wasm_bindgen(js_name = "generateDotrainText")]
     pub fn generate_dotrain_text(&self) -> Result<String, GuiError> {
         let rain_document = RainDocument::create(self.dotrain_order.dotrain(), None, None, None);

crates/js_api/src/gui/order_operations.rs

@@ -310,7 +310,7 @@ impl DotrainOrderGui {
         &mut self,
         is_input: bool,
         index: u8,
-        vault_id: String,
+        vault_id: Option<String>,
     ) -> Result<(), GuiError> {
         let deployment = self.get_current_deployment()?;
         self.dotrain_order

crates/js_api/src/gui/state_management.rs

@@ -220,13 +220,11 @@ impl DotrainOrderGui {
             &state.selected_deployment,
         )?;
         for ((is_input, index), vault_id) in state.vault_ids {
-            if let Some(vault_id) = vault_id {
-                dotrain_order_gui
-                    .dotrain_order
-                    .dotrain_yaml()
-                    .get_order(&order_key)
-                    .and_then(|mut order| order.update_vault_id(is_input, index, vault_id))?;
-            }
+            dotrain_order_gui
+                .dotrain_order
+                .dotrain_yaml()
+                .get_order(&order_key)
+                .and_then(|mut order| order.update_vault_id(is_input, index, vault_id))?;
         }
 
         Ok(dotrain_order_gui)

crates/js_api/src/subgraph/add_order.rs

@@ -0,0 +1,16 @@
+use cynic::Id;
+use rain_orderbook_bindings::wasm_traits::prelude::*;
+use rain_orderbook_subgraph_client::{OrderbookSubgraphClient, OrderbookSubgraphClientError};
+use reqwest::Url;
+
+/// Internal function to fetch Add Orders for a given transaction
+/// Returns an array of AddOrder structs
+#[wasm_bindgen(js_name = "getTransactionAddOrders")]
+pub async fn get_transaction_add_orders(
+    url: &str,
+    tx_hash: &str,
+) -> Result<JsValue, OrderbookSubgraphClientError> {
+    let client = OrderbookSubgraphClient::new(Url::parse(url)?);
+    let add_orders = client.transaction_add_orders(Id::new(tx_hash)).await?;
+    Ok(to_value(&add_orders)?)
+}

crates/js_api/src/subgraph/mod.rs

@@ -7,6 +7,7 @@ use rain_orderbook_subgraph_client::OrderbookSubgraphClientError;
 use thiserror::Error;
 use wasm_bindgen::{JsError, JsValue};
 
+pub mod add_order;
 pub mod order;
 pub mod transaction;
 pub mod vault;

crates/settings/src/order.rs

@@ -69,9 +69,32 @@ impl Order {
         &mut self,
         is_input: bool,
         index: u8,
-        vault_id: String,
+        vault_id: Option<String>,
     ) -> Result<Self, YamlError> {
-        let new_vault_id = Order::validate_vault_id(&vault_id)?;
+        let new_vault_id = if let Some(ref v) = vault_id {
+            if v.is_empty() {
+                None
+            } else {
+                match Order::validate_vault_id(v) {
+                    Ok(id) => Some(id),
+                    Err(e) => {
+                        return Err(YamlError::Field {
+                            kind: FieldErrorKind::InvalidValue {
+                                field: "vault-id".to_string(),
+                                reason: e.to_string(),
+                            },
+                            location: format!(
+                                "index '{index}' of {} in order '{}'",
+                                if is_input { "inputs" } else { "outputs" },
+                                self.key
+                            ),
+                        });
+                    }
+                }
+            }
+        } else {
+            None
+        };
 
         let mut document = self
             .document
@@ -91,14 +114,23 @@ impl Order {
                     {
                         if let Some(item) = vec.get_mut(index as usize) {
                             if let StrictYaml::Hash(ref mut item_hash) = item {
-                                item_hash.insert(
-                                    StrictYaml::String("vault-id".to_string()),
-                                    StrictYaml::String(vault_id.to_string()),
-                                );
-                                if is_input {
-                                    self.inputs[index as usize].vault_id = Some(new_vault_id);
+                                if let Some(vault_id) = new_vault_id {
+                                    item_hash.insert(
+                                        StrictYaml::String("vault-id".to_string()),
+                                        StrictYaml::String(vault_id.to_string()),
+                                    );
+                                    if is_input {
+                                        self.inputs[index as usize].vault_id = Some(vault_id);
+                                    } else {
+                                        self.outputs[index as usize].vault_id = Some(vault_id);
+                                    }
                                 } else {
-                                    self.outputs[index as usize].vault_id = Some(new_vault_id);
+                                    item_hash.remove(&StrictYaml::String("vault-id".to_string()));
+                                    if is_input {
+                                        self.inputs[index as usize].vault_id = None;
+                                    } else {
+                                        self.outputs[index as usize].vault_id = None;
+                                    }
                                 }
                             } else {
                                 return Err(YamlError::Field {
@@ -767,7 +799,7 @@ pub enum ParseOrderConfigSourceError {
         expected: String,
         found: String,
     },
-    #[error("Failed to parse vault {}", 0)]
+    #[error("Failed to parse vault id")]
     VaultParseError(#[from] alloy::primitives::ruint::ParseError),
 }
 

crates/settings/src/yaml/dotrain.rs

@@ -549,9 +549,11 @@ mod tests {
         assert!(order.inputs[0].vault_id.is_none());
         assert!(order.outputs[0].vault_id.is_none());
 
-        let mut updated_order = order.update_vault_id(true, 0, "1".to_string()).unwrap();
+        let mut updated_order = order
+            .update_vault_id(true, 0, Some("1".to_string()))
+            .unwrap();
         let updated_order = updated_order
-            .update_vault_id(false, 0, "11".to_string())
+            .update_vault_id(false, 0, Some("11".to_string()))
             .unwrap();
 
         assert_eq!(updated_order.inputs[0].vault_id, Some(U256::from(1)));
@@ -561,9 +563,11 @@ mod tests {
         assert_eq!(order.inputs[0].vault_id, Some(U256::from(1)));
         assert_eq!(order.outputs[0].vault_id, Some(U256::from(11)));
 
-        let mut updated_order = order.update_vault_id(true, 0, "3".to_string()).unwrap();
+        let mut updated_order = order
+            .update_vault_id(true, 0, Some("3".to_string()))
+            .unwrap();
         let updated_order = updated_order
-            .update_vault_id(false, 0, "33".to_string())
+            .update_vault_id(false, 0, Some("33".to_string()))
             .unwrap();
         assert_eq!(updated_order.inputs[0].vault_id, Some(U256::from(3)));
         assert_eq!(updated_order.outputs[0].vault_id, Some(U256::from(33)));

crates/subgraph/src/orderbook_client.rs

@@ -2,6 +2,7 @@ use crate::cynic_client::{CynicClient, CynicClientError};
 use crate::pagination::{PaginationArgs, PaginationClient, PaginationClientError};
 use crate::performance::vol::{get_vaults_vol, VaultVolume};
 use crate::performance::OrderPerformance;
+use crate::types::add_order::{TransactionAddOrdersQuery, TransactionAddOrdersVariables};
 use crate::types::common::*;
 use crate::types::order::{
     BatchOrderDetailQuery, BatchOrderDetailQueryVariables, OrderDetailQuery, OrderIdList,
@@ -395,4 +396,24 @@ impl OrderbookSubgraphClient {
             .ok_or(OrderbookSubgraphClientError::Empty)?;
         Ok(transaction)
     }
+
+    /// Fetch all add orders for a given transaction
+    pub async fn transaction_add_orders(
+        &self,
+        id: Id,
+    ) -> Result<Vec<AddOrderWithOrder>, OrderbookSubgraphClientError> {
+        let data = self
+            .query::<TransactionAddOrdersQuery, TransactionAddOrdersVariables>(
+                TransactionAddOrdersVariables {
+                    id: Bytes(id.inner().to_string()),
+                },
+            )
+            .await?;
+
+        if data.add_orders.is_empty() {
+            return Err(OrderbookSubgraphClientError::Empty);
+        }
+
+        Ok(data.add_orders)
+    }
 }

crates/subgraph/src/types/add_order.rs

@@ -0,0 +1,16 @@
+use super::common::{AddOrderWithOrder, Bytes};
+use crate::schema;
+use typeshare::typeshare;
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct TransactionAddOrdersVariables {
+    pub id: Bytes,
+}
+
+#[derive(cynic::QueryFragment, Debug)]
+#[cynic(graphql_type = "Query", variables = "TransactionAddOrdersVariables")]
+#[typeshare]
+pub struct TransactionAddOrdersQuery {
+    #[arguments(where: { transaction_: { id: $id } })]
+    pub add_orders: Vec<AddOrderWithOrder>,
+}

crates/subgraph/src/types/common.rs

@@ -382,6 +382,15 @@ pub struct AddOrder {
     pub transaction: Transaction,
 }
 
+#[derive(cynic::QueryFragment, Debug, Serialize, Clone)]
+#[cfg_attr(target_family = "wasm", derive(Tsify))]
+#[cynic(graphql_type = "AddOrder")]
+pub struct AddOrderWithOrder {
+    pub transaction: Transaction,
+    #[cfg_attr(target_family = "wasm", tsify(type = "OrderSubgraph"))]
+    pub order: Order,
+}
+
 #[derive(cynic::Scalar, Debug, Clone, PartialEq, Eq, Hash)]
 #[cfg_attr(target_family = "wasm", derive(Tsify), serde(rename = "SgBigInt"))]
 #[typeshare]

crates/subgraph/src/types/mod.rs

@@ -1,3 +1,4 @@
+pub mod add_order;
 pub mod common;
 mod impls;
 pub mod order;