Merge branch 'main' into 01/13/25-remove-unused-BadgeExternalLink

.vscode/settings.json

@@ -3,6 +3,7 @@
   "svelte.enable-ts-plugin": true,
 
   "rust-analyzer.linkedProjects": ["./Cargo.toml", "tauri-app/src-tauri/Cargo.toml"],
+
   "[rust]": {
     "editor.defaultFormatter": "rust-lang.rust-analyzer",
     "editor.formatOnSave": true,

Cargo.toml

@@ -6,7 +6,7 @@ resolver = "2"
 [workspace.package]
 edition = "2021"
 license = "LicenseRef-DCL-1.0"
-author = "Rain Open Source LLC"
+author = "Rain Open Source Software Ltd"
 version = "0.0.0-alpha.0"
 homepage = "https://github.com/rainprotocol/rain.orderbook"
 

README.md

@@ -26,3 +26,33 @@ cd packages/webapp && nix develop -c npm run dev
 ```
 nix develop .#tauri-shell --command cargo tauri dev
 ```
+
+## Legal stuff
+
+Everything is under DecentraLicense 1.0 (DCL-1.0) which can be found in `LICENSES/`.
+
+This is basically `CAL-1.0` which is an open source license
+https://opensource.org/license/cal-1-0
+
+The non-legal summary of DCL-1.0 is that the source is open, as expected, but
+also user data in the systems that this code runs on must also be made available
+to those users as relevant, and that private keys remain private.
+
+Roughly it's "not your keys, not your coins" aware, as close as we could get in
+legalese.
+
+This is the default situation on permissionless blockchains, so shouldn't require
+any additional effort by dev-users to adhere to the license terms.
+
+This repo is REUSE 3.2 compliant https://reuse.software/spec-3.2/ and compatible
+with `reuse` tooling (also available in the nix shell here).
+
+```
+nix develop -c rainix-sol-legal
+```
+
+## Contributions
+
+Contributions are welcome **under the same license** as above.
+
+Contributors agree and warrant that their contributions are compliant.

REUSE.toml

@@ -23,16 +23,10 @@ path = [
     ".env.example",
     "tauri-app/.env.example",
     "prep-all.sh",
-]
-SPDX-FileCopyrightText = "Copyright (c) 2020 thedavidmeister"
-SPDX-License-Identifier = "LicenseRef-DCL-1.0"
-
-[[annotations]]
-path = [
     "packages/**/",
     "subgraph/**/",
     "crates/**/",
     "tauri-app/**/",
 ]
-SPDX-FileCopyrightText = "Copyright (c) 2020 Rain Open Source LLC"
+SPDX-FileCopyrightText = "Copyright (c) 2020 Rain Open Source Software Ltd"
 SPDX-License-Identifier = "LicenseRef-DCL-1.0"

crates/common/src/add_order.rs

@@ -60,6 +60,10 @@ pub enum AddOrderArgsError {
     #[cfg(not(target_family = "wasm"))]
     #[error(transparent)]
     ForkCallError(#[from] ForkCallError),
+    #[error("Input token not found for index: {0}")]
+    InputTokenNotFound(String),
+    #[error("Output token not found for index: {0}")]
+    OutputTokenNotFound(String),
 }
 
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
@@ -80,50 +84,60 @@ impl AddOrderArgs {
     ) -> Result<AddOrderArgs, AddOrderArgsError> {
         let random_vault_id: U256 = rand::random();
         let mut inputs = vec![];
-        for input in &deployment.order.inputs {
-            if let Some(decimals) = input.token.decimals {
+        for (i, input) in deployment.order.inputs.iter().enumerate() {
+            let input_token = input
+                .token
+                .as_ref()
+                .ok_or_else(|| AddOrderArgsError::InputTokenNotFound(i.to_string()))?;
+
+            if let Some(decimals) = input_token.decimals {
                 inputs.push(IO {
-                    token: input.token.address,
+                    token: input_token.address,
                     vaultId: input.vault_id.unwrap_or(random_vault_id),
                     decimals,
                 });
             } else {
-                let client = ReadableClientHttp::new_from_url(input.token.network.rpc.to_string())?;
+                let client = ReadableClientHttp::new_from_url(input_token.network.rpc.to_string())?;
                 let parameters = ReadContractParameters {
-                    address: input.token.address,
+                    address: input_token.address,
                     call: decimalsCall {},
                     block_number: None,
                     gas: None,
                 };
                 let decimals = client.read(parameters).await?._0;
                 inputs.push(IO {
-                    token: input.token.address,
+                    token: input_token.address,
                     vaultId: input.vault_id.unwrap_or(random_vault_id),
                     decimals,
                 });
             }
         }
 
         let mut outputs = vec![];
-        for output in &deployment.order.outputs {
-            if let Some(decimals) = output.token.decimals {
+        for (i, output) in deployment.order.outputs.iter().enumerate() {
+            let output_token = output
+                .token
+                .as_ref()
+                .ok_or_else(|| AddOrderArgsError::OutputTokenNotFound(i.to_string()))?;
+
+            if let Some(decimals) = output_token.decimals {
                 outputs.push(IO {
-                    token: output.token.address,
+                    token: output_token.address,
                     vaultId: output.vault_id.unwrap_or(random_vault_id),
                     decimals,
                 });
             } else {
                 let client =
-                    ReadableClientHttp::new_from_url(output.token.network.rpc.to_string())?;
+                    ReadableClientHttp::new_from_url(output_token.network.rpc.to_string())?;
                 let parameters = ReadContractParameters {
-                    address: output.token.address,
+                    address: output_token.address,
                     call: decimalsCall {},
                     block_number: None,
                     gas: None,
                 };
                 let decimals = client.read(parameters).await?._0;
                 outputs.push(IO {
-                    token: output.token.address,
+                    token: output_token.address,
                     vaultId: output.vault_id.unwrap_or(random_vault_id),
                     decimals,
                 });
@@ -489,16 +503,16 @@ price: 2e18;
             key: "".to_string(),
             inputs: vec![
                 OrderIO {
-                    token: token1_arc.clone(),
+                    token: Some(token1_arc.clone()),
                     vault_id: None,
                 },
                 OrderIO {
-                    token: token2_arc.clone(),
+                    token: Some(token2_arc.clone()),
                     vault_id: Some(known_vault_id),
                 },
             ],
             outputs: vec![OrderIO {
-                token: token3_arc.clone(),
+                token: Some(token3_arc.clone()),
                 vault_id: None,
             }],
             network: network_arc.clone(),
@@ -599,16 +613,16 @@ _ _: 0 0;
             key: "".to_string(),
             inputs: vec![
                 OrderIO {
-                    token: token1_arc.clone(),
+                    token: Some(token1_arc.clone()),
                     vault_id: Some(U256::from(2)),
                 },
                 OrderIO {
-                    token: token2_arc.clone(),
+                    token: Some(token2_arc.clone()),
                     vault_id: Some(U256::from(1)),
                 },
             ],
             outputs: vec![OrderIO {
-                token: token3_arc.clone(),
+                token: Some(token3_arc.clone()),
                 vault_id: Some(U256::from(4)),
             }],
             network: network_arc.clone(),
@@ -745,16 +759,16 @@ _ _: 0 0;
             key: "".to_string(),
             inputs: vec![
                 OrderIO {
-                    token: token1_arc.clone(),
+                    token: Some(token1_arc.clone()),
                     vault_id: None,
                 },
                 OrderIO {
-                    token: token2_arc.clone(),
+                    token: Some(token2_arc.clone()),
                     vault_id: Some(known_vault_id),
                 },
             ],
             outputs: vec![OrderIO {
-                token: token3_arc.clone(),
+                token: Some(token3_arc.clone()),
                 vault_id: None,
             }],
             network: network_arc.clone(),

crates/common/src/dotrain_order/calldata.rs

@@ -45,18 +45,23 @@ impl DotrainOrder {
         &self,
         deployment_name: &str,
         owner: &str,
-        token_deposits: &HashMap<Address, U256>,
+        token_deposits: &HashMap<String, U256>,
     ) -> Result<Vec<ApprovalCalldata>, DotrainOrderCalldataError> {
         let deployment = self.get_deployment(deployment_name)?;
         let orderbook = self.get_orderbook(deployment_name)?;
 
         let mut calldatas = Vec::new();
 
-        for output in &deployment.order.outputs {
-            if let Some(deposit_amount) = token_deposits.get(&output.token.address) {
+        for (i, output) in deployment.order.outputs.iter().enumerate() {
+            let output_token = output
+                .token
+                .as_ref()
+                .ok_or_else(|| DotrainOrderCalldataError::OutputTokenNotFound(i.to_string()))?;
+
+            if let Some(deposit_amount) = token_deposits.get(&output_token.key) {
                 let deposit_amount = deposit_amount.to_owned();
                 let deposit_args = DepositArgs {
-                    token: output.token.address,
+                    token: output_token.address,
                     amount: deposit_amount,
                     vault_id: U256::default(),
                 };
@@ -75,7 +80,7 @@ impl DotrainOrder {
                         .get_approve_calldata(transaction_args, allowance)
                         .await?;
                     calldatas.push(ApprovalCalldata {
-                        token: output.token.address,
+                        token: output_token.address,
                         calldata: Bytes::copy_from_slice(&approve_call),
                     });
                 }
@@ -94,22 +99,26 @@ impl DotrainOrder {
         let mut calldatas = Vec::new();
 
         for (i, output) in deployment.order.outputs.iter().enumerate() {
+            let output_token = output
+                .token
+                .as_ref()
+                .ok_or_else(|| DotrainOrderCalldataError::OutputTokenNotFound(i.to_string()))?;
             let vault_id = output
                 .vault_id
                 .ok_or(DotrainOrderCalldataError::VaultIdNotFound(i.to_string()))?;
 
             let token_deposit = token_deposits
-                .get(&(vault_id, output.token.address))
+                .get(&(vault_id, output_token.address))
                 .ok_or(DotrainOrderCalldataError::TokenNotFound(
-                    output.token.address.to_string(),
+                    output_token.address.to_string(),
                 ))?;
 
             if *token_deposit == U256::ZERO {
                 continue;
             }
 
             let calldata = DepositArgs {
-                token: output.token.address,
+                token: output_token.address,
                 amount: token_deposit.to_owned(),
                 vault_id,
             }
@@ -150,12 +159,15 @@ pub enum DotrainOrderCalldataError {
     #[error("Orderbook not found")]
     OrderbookNotFound,
 
-    #[error("Token not found {0}")]
-    TokenNotFound(String),
+    #[error("Token not found for output index: {0}")]
+    OutputTokenNotFound(String),
 
     #[error("Vault id not found for output index: {0}")]
     VaultIdNotFound(String),
 
+    #[error("Token not found {0}")]
+    TokenNotFound(String),
+
     #[error(transparent)]
     DepositError(#[from] DepositError),
 

crates/common/src/types/order_detail_extended.rs

@@ -10,6 +10,8 @@ use typeshare::typeshare;
 #[serde(rename_all = "camelCase")]
 #[typeshare]
 pub struct OrderDetailExtended {
+    #[typeshare(typescript(type = "OrderSubgraph"))]
+    #[cfg_attr(target_family = "wasm", tsify(type = "OrderSubgraph"))]
     pub order: Order,
     pub rainlang: Option<String>,
 }

crates/js_api/src/gui/deposits.rs

@@ -16,12 +16,12 @@ impl DotrainOrderGui {
         let deployment = self.get_current_deployment()?;
         self.deposits
             .iter()
-            .map(|(token, value)| {
+            .map(|(key, value)| {
                 let gui_deposit = deployment
                     .deposits
                     .iter()
-                    .find(|dg| dg.token.key == *token)
-                    .ok_or(GuiError::DepositTokenNotFound(token.clone()))?;
+                    .find(|dg| dg.token.as_ref().map_or(false, |t| t.key == *key))
+                    .ok_or(GuiError::DepositTokenNotFound(key.clone()))?;
                 let amount: String = if value.is_preset {
                     let index = value
                         .value
@@ -35,10 +35,16 @@ impl DotrainOrderGui {
                 } else {
                     value.value.clone()
                 };
+
+                if gui_deposit.token.is_none() {
+                    return Err(GuiError::TokenMustBeSelected(key.clone()));
+                }
+                let token = gui_deposit.token.as_ref().unwrap();
+
                 Ok(TokenDeposit {
-                    token: gui_deposit.token.key.clone(),
+                    token: token.key.clone(),
                     amount,
-                    address: gui_deposit.token.address,
+                    address: token.address,
                 })
             })
             .collect::<Result<Vec<TokenDeposit>, GuiError>>()
@@ -50,7 +56,7 @@ impl DotrainOrderGui {
         let gui_deposit = deployment
             .deposits
             .iter()
-            .find(|dg| dg.token.key == token)
+            .find(|dg| dg.token.as_ref().map_or(false, |t| t.key == token))
             .ok_or(GuiError::DepositTokenNotFound(token.clone()))?;
 
         let value = if let Some(index) = gui_deposit.presets.iter().position(|p| **p == amount) {
@@ -75,13 +81,13 @@ impl DotrainOrderGui {
     }
 
     #[wasm_bindgen(js_name = "getDepositPresets")]
-    pub fn get_deposit_presets(&self, token: String) -> Result<Vec<String>, GuiError> {
+    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.key == token)
-            .ok_or(GuiError::DepositTokenNotFound(token.clone()))?;
+            .find(|dg| dg.token.as_ref().map_or(false, |t| t.key == key))
+            .ok_or(GuiError::DepositTokenNotFound(key.clone()))?;
         Ok(gui_deposit.presets.clone())
     }
 }