Update order quote wasm bindings to use wasm export macro

Cargo.toml

@@ -53,7 +53,7 @@ test-context = "0.3.0"
 portpicker = "0.1.1"
 rain-erc = { git = "https://github.com/rainlanguage/rain.erc", rev = "0106e645ebd49334addc698c5aad9a85370eb54d" }
 rain-error-decoding = { git = "https://github.com/rainlanguage/rain.error", rev = "72d9577fdaf7135113847027ba951f9a43b41827" }
-wasm-bindgen-utils = "0.0.7"
+wasm-bindgen-utils = { git = "https://github.com/rainlanguage/rain.wasm", rev = "4379d24a671742a58ec5cdab2c39fecbda59619d" }
 
 [workspace.dependencies.rain_orderbook_bindings]
 path = "crates/bindings"

crates/js_api/src/gui/state_management.rs

@@ -1,5 +1,4 @@
 use super::*;
-use js_sys::{eval, Reflect};
 use rain_orderbook_app_settings::{gui::GuiDepositCfg, order::OrderIOCfg, token::TokenCfg};
 use sha2::{Digest, Sha256};
 use std::sync::{Arc, RwLock};
@@ -289,6 +288,7 @@ mod tests {
         tests::{initialize_gui, initialize_gui_with_select_tokens, YAML},
     };
     use alloy::primitives::U256;
+    use js_sys::{eval, Reflect};
     use wasm_bindgen_test::wasm_bindgen_test;
 
     const SERIALIZED_STATE: &str = "H4sIAAAAAAAA_21Py4rCQBDMuMsuC3uShT0t7Ac45KkkggcRRfFxEFH0ppNBjZOZmEx8_oSfLGpPRLEPXVXdTXdXTrvFF-Bsyf0ln2NTU_EGaBrG85CFoGBoGVPkA1CKFeX2q22vJx_VN6hEhBRzKrciXv1BbSFlVNZ1JsiULUQiy67hFvU4IjiN2VEdRIohdbo-aP4AzTvD3ekpoTz6hPbg8sO_jd6VbvfsXGYlW2h5Hror0_MKQIMAH-pJVfi4MwqDmtNp-d3NOh6n0-HGbdT6TupY41Jjwgip_CqnlFEi8dU-9mnExD6kXJ4Bw5ytw6gBAAA=";

crates/quote/src/js_api/mod.rs

@@ -1,162 +1,238 @@
 use crate::{error::Error, BatchQuoteSpec, QuoteSpec};
-use crate::{get_order_quotes, BatchQuoteTarget, QuoteTarget};
+use crate::{
+    get_order_quotes, BatchOrderQuotesResponse, BatchQuoteTarget, OrderQuoteValue, QuoteTarget,
+};
+use alloy::hex::FromHexError;
+use alloy::primitives::ruint::ParseError;
 use alloy::primitives::{
     hex::{encode_prefixed, FromHex},
     Address, U256,
 };
 use rain_orderbook_bindings::wasm_traits::TryIntoU256;
 use rain_orderbook_subgraph_client::{types::common::SgOrder, utils::make_order_id};
+use serde::{Deserialize, Serialize};
 use std::str::FromStr;
-use wasm_bindgen_utils::prelude::*;
+use thiserror::Error;
+use wasm_bindgen_utils::{impl_wasm_traits, prelude::*, wasm_export};
+
+#[derive(Serialize, Deserialize, Debug, Clone, Tsify)]
+#[serde(untagged)]
+pub enum QuoteResultEnum {
+    Success {
+        value: OrderQuoteValue,
+        #[tsify(type = "undefined")]
+        error: Option<String>,
+    },
+    Err {
+        #[tsify(type = "undefined")]
+        value: Option<OrderQuoteValue>,
+        error: String,
+    },
+}
+impl_wasm_traits!(QuoteResultEnum);
+
+#[derive(Serialize, Deserialize, Debug, Clone, Tsify)]
+#[serde(rename_all = "camelCase")]
+pub struct DoQuoteTargetsResult(pub Vec<QuoteResultEnum>);
+impl_wasm_traits!(DoQuoteTargetsResult);
+
+#[derive(Serialize, Deserialize, Debug, Clone, Tsify)]
+#[serde(rename_all = "camelCase")]
+pub struct DoQuoteSpecsResult(pub Vec<QuoteResultEnum>);
+impl_wasm_traits!(DoQuoteSpecsResult);
+
+#[derive(Serialize, Deserialize, Debug, Clone, Tsify)]
+#[serde(rename_all = "camelCase")]
+pub struct QuoteTargetResult(
+    #[tsify(type = "(QuoteTarget | undefined)[]")] pub Vec<Option<QuoteTarget>>,
+);
+impl_wasm_traits!(QuoteTargetResult);
+
+#[derive(Serialize, Deserialize, Debug, Clone, Tsify)]
+#[serde(rename_all = "camelCase")]
+pub struct DoOrderQuoteResult(pub Vec<BatchOrderQuotesResponse>);
+impl_wasm_traits!(DoOrderQuoteResult);
 
 /// Get subgraph represented "order_id" of a QuoteTarget
-#[wasm_bindgen(js_name = "getId")]
-pub fn get_id(orderbook: &str, order_hash: &str) -> String {
-    let mut orderbook_error = "orderbook address, ".to_string();
-    let mut order_hash_error = "order hash, ".to_string();
-    let orderbook = Address::from_hex(orderbook)
-        .inspect_err(|e| orderbook_error.push_str(&e.to_string()))
-        .expect_throw(&orderbook_error);
-    let order_hash = U256::from_str(order_hash)
-        .inspect_err(|e| order_hash_error.push_str(&e.to_string()))
-        .expect_throw(&order_hash_error);
-    encode_prefixed(make_order_id(orderbook, order_hash))
+#[wasm_export(js_name = "getId", unchecked_return_type = "string")]
+pub fn get_id(orderbook: &str, order_hash: &str) -> Result<String, QuoteBindingsError> {
+    let orderbook = Address::from_hex(orderbook)?;
+    let order_hash = U256::from_str(order_hash)?;
+    Ok(encode_prefixed(make_order_id(orderbook, order_hash)))
 }
 
 /// Quotes the target on the given rpc url
 /// Resolves with array of OrderQuoteValue object or a string error
-#[wasm_bindgen(js_name = "doQuoteTargets")]
+#[wasm_export(
+    js_name = "doQuoteTargets",
+    unchecked_return_type = "DoQuoteTargetsResult"
+)]
 pub async fn do_quote_targets(
     quote_targets: &BatchQuoteTarget,
     rpc_url: &str,
     block_number: Option<u64>,
     gas: Option<js_sys::BigInt>,
     multicall_address: Option<String>,
-) -> Result<JsValue, Error> {
-    let mut multicall_address_error = "multicall address, ".to_string();
-    let multicall_address = multicall_address.map(|v| {
-        Address::from_hex(v)
-            .inspect_err(|e| multicall_address_error.push_str(&e.to_string()))
-            .expect_throw(&multicall_address_error)
-    });
-    let mut gas_error = "gas, ".to_string();
-    let gas_value = gas.map(|v| {
-        v.try_into_u256()
-            .inspect_err(|e| gas_error.push_str(&e.to_string()))
-            .expect_throw(&gas_error)
-    });
+) -> Result<DoQuoteTargetsResult, QuoteBindingsError> {
+    let multicall_address = multicall_address
+        .map(|v| Address::from_hex(v))
+        .transpose()?;
+    let gas_value = gas.map(|v| v.try_into_u256()).transpose()?;
     let quote_targets: Vec<QuoteTarget> = quote_targets
         .0
         .iter()
         .map(|v| QuoteTarget::from(v.clone()))
         .collect();
     let batch_quote_target = BatchQuoteTarget(quote_targets);
-    match batch_quote_target
+
+    let quotes = batch_quote_target
         .do_quote(rpc_url, block_number, gas_value, multicall_address)
-        .await
-    {
-        Err(e) => Err(e),
-        Ok(v) => Ok(js_sys::Array::from_iter(
-            v.into_iter()
-                .map(|e| e.map_or_else(JsValue::from, JsValue::from)),
-        )
-        .into()),
-    }
+        .await?;
+
+    let res = quotes
+        .into_iter()
+        .map(|q| match q {
+            Ok(v) => QuoteResultEnum::Success {
+                value: v,
+                error: None,
+            },
+            Err(e) => QuoteResultEnum::Err {
+                value: None,
+                error: e.to_string(),
+            },
+        })
+        .collect();
+
+    Ok(DoQuoteTargetsResult(res))
 }
 
 /// Given a subgraph url, will fetch the order details from the subgraph and
 /// then quotes them using the given rpc url.
 /// Resolves with array of OrderQuoteValue object or a string error
-#[wasm_bindgen(js_name = "doQuoteSpecs")]
+#[wasm_export(js_name = "doQuoteSpecs", unchecked_return_type = "DoQuoteSpecsResult")]
 pub async fn do_quote_specs(
     quote_specs: &BatchQuoteSpec,
     subgraph_url: &str,
     rpc_url: &str,
     block_number: Option<u64>,
     gas: Option<js_sys::BigInt>,
     multicall_address: Option<String>,
-) -> Result<JsValue, Error> {
-    let mut multicall_address_error = "multicall address, ".to_string();
-    let multicall_address = multicall_address.map(|v| {
-        Address::from_hex(v)
-            .inspect_err(|e| multicall_address_error.push_str(&e.to_string()))
-            .expect_throw(&multicall_address_error)
-    });
-    let mut gas_error = "gas, ".to_string();
-    let gas_value = gas.map(|v| {
-        v.try_into_u256()
-            .inspect_err(|e| gas_error.push_str(&e.to_string()))
-            .expect_throw(&gas_error)
-    });
+) -> Result<DoQuoteSpecsResult, QuoteBindingsError> {
+    let multicall_address = multicall_address
+        .map(|v| Address::from_hex(v))
+        .transpose()?;
+    let gas_value = gas.map(|v| v.try_into_u256()).transpose()?;
     let quote_specs: Vec<QuoteSpec> = quote_specs
         .0
         .iter()
         .map(|v| QuoteSpec::from(v.clone()))
         .collect();
     let batch_quote_spec = BatchQuoteSpec(quote_specs);
-    match batch_quote_spec
+
+    let quotes = batch_quote_spec
         .do_quote(
             subgraph_url,
             rpc_url,
             block_number,
             gas_value,
             multicall_address,
         )
-        .await
-    {
-        Err(e) => Err(e),
-        Ok(v) => Ok(js_sys::Array::from_iter(
-            v.into_iter()
-                .map(|e| e.map_or_else(JsValue::from, JsValue::from)),
-        )
-        .into()),
-    }
+        .await?;
+
+    let res = quotes
+        .into_iter()
+        .map(|q| match q {
+            Ok(v) => QuoteResultEnum::Success {
+                value: v,
+                error: None,
+            },
+            Err(e) => QuoteResultEnum::Err {
+                value: None,
+                error: e.to_string(),
+            },
+        })
+        .collect();
+
+    Ok(DoQuoteSpecsResult(res))
 }
 
 /// Given a subgraph url, will fetch orders details and returns their
 /// respective quote targets.
 /// Resolves with array of QuoteTarget object or undefined if no result
 /// found on subgraph for a specific spec
-#[wasm_bindgen(js_name = "getQuoteTargetFromSubgraph")]
+#[wasm_export(
+    js_name = "getQuoteTargetFromSubgraph",
+    unchecked_return_type = "QuoteTargetResult"
+)]
 pub async fn get_batch_quote_target_from_subgraph(
     quote_specs: &BatchQuoteSpec,
     subgraph_url: &str,
-) -> Result<JsValue, Error> {
+) -> Result<QuoteTargetResult, QuoteBindingsError> {
     let quote_specs: Vec<QuoteSpec> = quote_specs
         .0
         .iter()
         .map(|v| QuoteSpec::from(v.clone()))
         .collect();
     let batch_quote_spec = BatchQuoteSpec(quote_specs);
-    match batch_quote_spec
+
+    let quote_targets = batch_quote_spec
         .get_batch_quote_target_from_subgraph(subgraph_url)
-        .await
-    {
-        Err(e) => Err(e),
-        Ok(v) => Ok(to_js_value(
-            &v.into_iter()
-                .map(|e| e.map(QuoteTarget::from))
-                .collect::<Vec<_>>(),
-        )?),
-    }
+        .await?;
+    Ok(QuoteTargetResult(quote_targets))
 }
 
 /// Get the quote for an order
 /// Resolves with a BatchOrderQuotesResponse object
-#[wasm_bindgen(js_name = "getOrderQuote")]
+#[wasm_export(
+    js_name = "getOrderQuote",
+    unchecked_return_type = "DoOrderQuoteResult"
+)]
 pub async fn get_order_quote(
     order: Vec<SgOrder>,
     rpc_url: &str,
     block_number: Option<u64>,
     gas: Option<js_sys::BigInt>,
-) -> Result<JsValue, Error> {
-    let mut gas_error = "gas, ".to_string();
-    let gas_value = gas.map(|v| {
-        v.try_into_u256()
-            .inspect_err(|e| gas_error.push_str(&e.to_string()))
-            .expect_throw(&gas_error)
-    });
-    Ok(to_js_value(
-        &get_order_quotes(order, block_number, rpc_url.to_string(), gas_value).await?,
-    )?)
+) -> Result<DoOrderQuoteResult, QuoteBindingsError> {
+    let gas_value = gas.map(|v| v.try_into_u256()).transpose()?;
+    let order_quotes =
+        get_order_quotes(order, block_number, rpc_url.to_string(), gas_value).await?;
+    Ok(DoOrderQuoteResult(order_quotes))
+}
+
+#[derive(Error, Debug)]
+pub enum QuoteBindingsError {
+    #[error(transparent)]
+    QuoteError(#[from] Error),
+    #[error(transparent)]
+    FromHexError(#[from] FromHexError),
+    #[error(transparent)]
+    U256ParseError(#[from] ParseError),
+    #[error(transparent)]
+    SerdeWasmBindgenError(#[from] serde_wasm_bindgen::Error),
+}
+
+impl QuoteBindingsError {
+    pub fn to_readable_msg(&self) -> String {
+        match self {
+            Self::QuoteError(e) => format!("Quote error: {}", e),
+            Self::FromHexError(e) => format!("Failed to parse orderbook address: {}", e),
+            Self::U256ParseError(e) => format!("Failed to parse u256 value: {}", e),
+            Self::SerdeWasmBindgenError(err) => format!("Data serialization error: {}", err),
+        }
+    }
+}
+
+impl From<QuoteBindingsError> for JsValue {
+    fn from(value: QuoteBindingsError) -> Self {
+        JsError::new(&value.to_string()).into()
+    }
+}
+
+impl From<QuoteBindingsError> for WasmEncodedError {
+    fn from(value: QuoteBindingsError) -> Self {
+        WasmEncodedError {
+            msg: value.to_string(),
+            readable_msg: value.to_readable_msg(),
+        }
+    }
 }