Merge branch 'main' into 2025-02-19-state-management-improvements

crates/cli/src/commands/order/detail.rs

@@ -136,7 +136,8 @@ mod tests {
                             "from": encode_prefixed(alloy::primitives::Address::random())
                         }
                     }],
-                    "trades": []
+                    "trades": [],
+                    "removeEvents": []
                 }
             }
         })

crates/cli/src/commands/order/list.rs

@@ -264,7 +264,8 @@ mod tests {
                             "from": encode_prefixed(alloy::primitives::Address::random())
                         }
                     }],
-                    "trades": []
+                    "trades": [],
+                    "removeEvents": []
                 }]
             }
         })

crates/common/src/dotrain_order/calldata.rs

@@ -15,9 +15,9 @@ use std::{collections::HashMap, str::FromStr, sync::Arc};
 #[cfg_attr(target_family = "wasm", derive(Tsify))]
 pub struct ApprovalCalldata {
     #[cfg_attr(target_family = "wasm", tsify(type = "string"))]
-    token: Address,
+    pub token: Address,
     #[cfg_attr(target_family = "wasm", tsify(type = "string"))]
-    calldata: Bytes,
+    pub calldata: Bytes,
 }
 #[cfg(target_family = "wasm")]
 impl_all_wasm_traits!(ApprovalCalldata);

crates/js_api/src/gui/deposits.rs

@@ -1,4 +1,5 @@
 use super::*;
+use rain_orderbook_app_settings::gui::GuiDeposit;
 
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Tsify)]
 pub struct TokenDeposit {
@@ -11,17 +12,22 @@ impl_all_wasm_traits!(TokenDeposit);
 
 #[wasm_bindgen]
 impl DotrainOrderGui {
+    fn get_gui_deposit(&self, key: &str) -> Result<GuiDeposit, GuiError> {
+        let deployment = self.get_current_deployment()?;
+        let gui_deposit = deployment
+            .deposits
+            .iter()
+            .find(|dg| dg.token.as_ref().map_or(false, |t| t.key == *key))
+            .ok_or(GuiError::DepositTokenNotFound(key.to_string()))?;
+        Ok(gui_deposit.clone())
+    }
+
     #[wasm_bindgen(js_name = "getDeposits")]
     pub fn get_deposits(&self) -> Result<Vec<TokenDeposit>, GuiError> {
-        let deployment = self.get_current_deployment()?;
         self.deposits
             .iter()
             .map(|(key, value)| {
-                let gui_deposit = deployment
-                    .deposits
-                    .iter()
-                    .find(|dg| dg.token.as_ref().map_or(false, |t| t.key == *key))
-                    .ok_or(GuiError::DepositTokenNotFound(key.clone()))?;
+                let gui_deposit = self.get_gui_deposit(key)?;
                 let amount: String = if value.is_preset {
                     let index = value
                         .value
@@ -54,12 +60,7 @@ impl DotrainOrderGui {
 
     #[wasm_bindgen(js_name = "saveDeposit")]
     pub fn save_deposit(&mut self, token: String, amount: String) -> Result<(), GuiError> {
-        let deployment = self.get_current_deployment()?;
-        let gui_deposit = deployment
-            .deposits
-            .iter()
-            .find(|dg| dg.token.as_ref().map_or(false, |t| t.key == token))
-            .ok_or(GuiError::DepositTokenNotFound(token.clone()))?;
+        let gui_deposit = self.get_gui_deposit(&token)?;
 
         if amount.is_empty() {
             self.remove_deposit(token);
@@ -94,12 +95,7 @@ impl DotrainOrderGui {
 
     #[wasm_bindgen(js_name = "getDepositPresets")]
     pub fn get_deposit_presets(&self, key: String) -> Result<Vec<String>, GuiError> {
-        let deployment = self.get_current_deployment()?;
-        let gui_deposit = deployment
-            .deposits
-            .iter()
-            .find(|dg| dg.token.as_ref().map_or(false, |t| t.key == key))
-            .ok_or(GuiError::DepositTokenNotFound(key.clone()))?;
+        let gui_deposit = self.get_gui_deposit(&key)?;
         Ok(gui_deposit.presets.clone().unwrap_or(vec![]))
     }
 

crates/js_api/src/gui/order_operations.rs

@@ -9,6 +9,14 @@ use rain_orderbook_bindings::OrderBook::multicallCall;
 use rain_orderbook_common::{deposit::DepositArgs, dotrain_order, transaction::TransactionArgs};
 use std::{collections::HashMap, str::FromStr, sync::Arc};
 
+pub enum CalldataFunction {
+    Allowance,
+    Approval,
+    Deposit,
+    AddOrder,
+    DepositAndAddOrder,
+}
+
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Tsify)]
 
 pub struct TokenAllowance {
@@ -53,6 +61,24 @@ impl_all_wasm_traits!(DepositAndAddOrderCalldataResult);
 pub struct IOVaultIds(HashMap<String, Vec<Option<U256>>>);
 impl_all_wasm_traits!(IOVaultIds);
 
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Tsify)]
+pub struct ExtendedApprovalCalldata {
+    pub token: Address,
+    pub calldata: Bytes,
+    pub symbol: String,
+}
+impl_all_wasm_traits!(ExtendedApprovalCalldata);
+
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Tsify)]
+#[serde(rename_all = "camelCase")]
+pub struct DeploymentTransactionArgs {
+    approvals: Vec<ExtendedApprovalCalldata>,
+    deployment_calldata: Bytes,
+    orderbook_address: Address,
+    chain_id: u64,
+}
+impl_all_wasm_traits!(DeploymentTransactionArgs);
+
 #[wasm_bindgen]
 impl DotrainOrderGui {
     fn get_orderbook(&self) -> Result<Arc<Orderbook>, GuiError> {
@@ -129,13 +155,32 @@ impl DotrainOrderGui {
         })
     }
 
+    fn prepare_calldata_generation(
+        &mut self,
+        calldata_function: CalldataFunction,
+    ) -> Result<GuiDeployment, GuiError> {
+        let deployment = self.get_current_deployment()?;
+        self.check_select_tokens()?;
+        match calldata_function {
+            CalldataFunction::Deposit => {
+                self.populate_vault_ids(&deployment)?;
+            }
+            CalldataFunction::AddOrder | CalldataFunction::DepositAndAddOrder => {
+                self.check_field_values()?;
+                self.populate_vault_ids(&deployment)?;
+                self.update_bindings(&deployment)?;
+            }
+            _ => {}
+        }
+        Ok(self.get_current_deployment()?)
+    }
+
     /// Check allowances for all inputs and outputs of the order
     ///
     /// Returns a vector of [`TokenAllowance`] objects
     #[wasm_bindgen(js_name = "checkAllowances")]
-    pub async fn check_allowances(&self, owner: String) -> Result<AllowancesResult, GuiError> {
-        let deployment = self.get_current_deployment()?;
-        self.check_select_tokens()?;
+    pub async fn check_allowances(&mut self, owner: String) -> Result<AllowancesResult, GuiError> {
+        let deployment = self.prepare_calldata_generation(CalldataFunction::Allowance)?;
 
         let orderbook = self.get_orderbook()?;
         let vaults_and_deposits = self.get_vaults_and_deposits(&deployment).await?;
@@ -166,11 +211,10 @@ impl DotrainOrderGui {
     /// Returns a vector of [`ApprovalCalldata`] objects
     #[wasm_bindgen(js_name = "generateApprovalCalldatas")]
     pub async fn generate_approval_calldatas(
-        &self,
+        &mut self,
         owner: String,
     ) -> Result<ApprovalCalldataResult, GuiError> {
-        let deployment = self.get_current_deployment()?;
-        self.check_select_tokens()?;
+        let deployment = self.prepare_calldata_generation(CalldataFunction::Approval)?;
 
         let deposits_map = self.get_deposits_as_map().await?;
         if deposits_map.is_empty() {
@@ -210,10 +254,7 @@ impl DotrainOrderGui {
     /// Returns a vector of bytes
     #[wasm_bindgen(js_name = "generateDepositCalldatas")]
     pub async fn generate_deposit_calldatas(&mut self) -> Result<DepositCalldataResult, GuiError> {
-        let deployment = self.get_current_deployment()?;
-        self.check_select_tokens()?;
-        self.populate_vault_ids(&deployment)?;
-        let deployment = self.get_current_deployment()?;
+        let deployment = self.prepare_calldata_generation(CalldataFunction::Deposit)?;
 
         let token_deposits = self
             .get_vaults_and_deposits(&deployment)
@@ -251,13 +292,7 @@ impl DotrainOrderGui {
     pub async fn generate_add_order_calldata(
         &mut self,
     ) -> Result<AddOrderCalldataResult, GuiError> {
-        let deployment = self.get_current_deployment()?;
-        self.check_select_tokens()?;
-        self.check_field_values()?;
-        self.populate_vault_ids(&deployment)?;
-        self.update_bindings(&deployment)?;
-        let deployment = self.get_current_deployment()?;
-
+        let deployment = self.prepare_calldata_generation(CalldataFunction::AddOrder)?;
         let calldata = self
             .dotrain_order
             .generate_add_order_calldata(&deployment.key)
@@ -269,12 +304,7 @@ impl DotrainOrderGui {
     pub async fn generate_deposit_and_add_order_calldatas(
         &mut self,
     ) -> Result<DepositAndAddOrderCalldataResult, GuiError> {
-        let deployment = self.get_current_deployment()?;
-        self.check_select_tokens()?;
-        self.check_field_values()?;
-        self.populate_vault_ids(&deployment)?;
-        self.update_bindings(&deployment)?;
-        let deployment = self.get_current_deployment()?;
+        let deployment = self.prepare_calldata_generation(CalldataFunction::DepositAndAddOrder)?;
 
         let mut calls = Vec::new();
 
@@ -356,4 +386,56 @@ impl DotrainOrderGui {
         self.update_bindings(&deployment)?;
         Ok(())
     }
+
+    #[wasm_bindgen(js_name = "getDeploymentTransactionArgs")]
+    pub async fn get_deployment_transaction_args(
+        &mut self,
+        owner: String,
+    ) -> Result<DeploymentTransactionArgs, GuiError> {
+        let deployment = self.prepare_calldata_generation(CalldataFunction::DepositAndAddOrder)?;
+
+        let mut approvals = Vec::new();
+        let approval_calldata = self.generate_approval_calldatas(owner).await?;
+        match approval_calldata {
+            ApprovalCalldataResult::Calldatas(calldatas) => {
+                let mut output_token_infos = HashMap::new();
+                for output in deployment.deployment.order.outputs.clone() {
+                    if output.token.is_none() {
+                        return Err(GuiError::SelectTokensNotSet);
+                    }
+                    let token = output.token.as_ref().unwrap();
+                    let token_info = self.get_token_info(token.key.clone()).await?;
+                    output_token_infos.insert(token.address.clone(), token_info);
+                }
+
+                for calldata in calldatas.iter() {
+                    let token_info = output_token_infos
+                        .get(&calldata.token)
+                        .ok_or(GuiError::TokenNotFound(calldata.token.to_string()))?;
+                    approvals.push(ExtendedApprovalCalldata {
+                        token: calldata.token,
+                        calldata: calldata.calldata.clone(),
+                        symbol: token_info.symbol.clone(),
+                    });
+                }
+            }
+            _ => {}
+        }
+
+        let deposit_and_add_order_calldata =
+            self.generate_deposit_and_add_order_calldatas().await?;
+
+        Ok(DeploymentTransactionArgs {
+            approvals,
+            deployment_calldata: deposit_and_add_order_calldata.0,
+            orderbook_address: deployment
+                .deployment
+                .order
+                .orderbook
+                .as_ref()
+                .ok_or(GuiError::OrderbookNotFound)?
+                .address,
+            chain_id: deployment.deployment.order.network.chain_id,
+        })
+    }
 }

crates/js_api/src/subgraph/mod.rs

@@ -9,6 +9,7 @@ use wasm_bindgen::{JsError, JsValue};
 
 pub mod add_order;
 pub mod order;
+pub mod remove_order;
 pub mod transaction;
 pub mod vault;
 

crates/js_api/src/subgraph/remove_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 Remove Orders for a given transaction
+/// Returns an array of RemoveOrder structs
+#[wasm_bindgen(js_name = "getTransactionRemoveOrders")]
+pub async fn get_transaction_remove_orders(
+    url: &str,
+    tx_hash: &str,
+) -> Result<JsValue, OrderbookSubgraphClientError> {
+    let client = OrderbookSubgraphClient::new(Url::parse(url)?);
+    let remove_orders = client.transaction_remove_orders(Id::new(tx_hash)).await?;
+    Ok(to_value(&remove_orders)?)
+}

crates/quote/src/cli/mod.rs

@@ -378,7 +378,8 @@ mod tests {
                     }],
                     "meta": null,
                     "timestampAdded": "0",
-                    "trades": []
+                    "trades": [],
+                    "removeEvents": []
                 }]
             }
         });

crates/quote/src/order_quotes.rs

@@ -317,6 +317,7 @@ amount price: context<3 0>() context<4 0>();
             meta: None,
             timestamp_added: BigInt(0.to_string()),
             trades: vec![],
+            remove_events: vec![],
         };
 
         let result = get_order_quotes(vec![order], None, local_evm.url(), None)

crates/quote/src/quote.rs

@@ -431,7 +431,8 @@ mod tests {
             }],
             "meta": null,
             "timestampAdded": "0",
-            "trades": []
+            "trades": [],
+            "removeEvents": []
         });
         let retrun_sg_data = if batch {
             json!({

crates/subgraph/src/orderbook_client.rs

@@ -9,6 +9,7 @@ use crate::types::order::{
     OrdersListQuery,
 };
 use crate::types::order_trade::{OrderTradeDetailQuery, OrderTradesListQuery};
+use crate::types::remove_order::{TransactionRemoveOrdersQuery, TransactionRemoveOrdersVariables};
 use crate::types::transaction::TransactionDetailQuery;
 use crate::types::vault::{VaultDetailQuery, VaultsListQuery};
 use crate::vault_balance_changes_query::VaultBalanceChangesListPageQueryClient;
@@ -416,4 +417,24 @@ impl OrderbookSubgraphClient {
 
         Ok(data.add_orders)
     }
+
+    /// Fetch all remove orders for a given transaction
+    pub async fn transaction_remove_orders(
+        &self,
+        id: Id,
+    ) -> Result<Vec<RemoveOrderWithOrder>, OrderbookSubgraphClientError> {
+        let data = self
+            .query::<TransactionRemoveOrdersQuery, TransactionRemoveOrdersVariables>(
+                TransactionRemoveOrdersVariables {
+                    id: Bytes(id.inner().to_string()),
+                },
+            )
+            .await?;
+
+        if data.remove_orders.is_empty() {
+            return Err(OrderbookSubgraphClientError::Empty);
+        }
+
+        Ok(data.remove_orders)
+    }
 }

crates/subgraph/src/performance/order_performance.rs

@@ -824,6 +824,7 @@ mod test {
             meta: None,
             add_events: vec![],
             trades: vec![],
+            remove_events: vec![],
         }
     }