`bindings/cashu-js` use `serde_wasm_bindgen` for generic types

bindings/cashu-js/src/nuts/nut00/token.rs

@@ -27,9 +27,9 @@ impl From<Token> for JsToken {
 impl JsToken {
     // TODO: Simply passing a string for proofs is not ideal
     #[wasm_bindgen(constructor)]
-    pub fn new(mint: String, proofs: String, memo: Option<String>) -> Result<JsToken> {
+    pub fn new(mint: String, proofs: JsValue, memo: Option<String>) -> Result<JsToken> {
         let mint = UncheckedUrl::from_str(&mint).map_err(into_err)?;
-        let proofs = serde_json::from_str(&proofs).map_err(into_err)?;
+        let proofs = serde_wasm_bindgen::from_value(proofs).map_err(into_err)?;
         Ok(Self {
             inner: Token::new(mint, proofs, memo).map_err(into_err)?,
         })
@@ -54,6 +54,4 @@ impl JsToken {
     pub fn as_string(&self) -> Result<String> {
         self.inner.convert_to_string().map_err(into_err)
     }
-
-    // TODO: Getter mint proofs
 }

bindings/cashu-js/src/nuts/nut01/keys.rs

@@ -32,8 +32,8 @@ impl From<Keys> for JsKeys {
 impl JsKeys {
     /// From Hex
     #[wasm_bindgen(constructor)]
-    pub fn new(keys: String) -> Result<JsKeys> {
-        let keys = serde_json::from_str(&keys).map_err(into_err)?;
+    pub fn new(keys: JsValue) -> Result<JsKeys> {
+        let keys = serde_wasm_bindgen::from_value(keys).map_err(into_err)?;
 
         Ok(JsKeys {
             inner: Keys::new(keys),
@@ -42,8 +42,8 @@ impl JsKeys {
 
     /// Keys
     #[wasm_bindgen(js_name = keys)]
-    pub fn keys(&self) -> Result<String> {
-        serde_json::to_string(&self.inner.keys()).map_err(into_err)
+    pub fn keys(&self) -> Result<JsValue> {
+        serde_wasm_bindgen::to_value(&self.inner.keys()).map_err(into_err)
     }
 
     /// Amount Key

bindings/cashu-js/src/nuts/nut02/keyset.rs

@@ -108,14 +108,14 @@ impl From<Response> for JsKeyResponse {
 impl JsKeyResponse {
     /// From Hex
     #[wasm_bindgen(constructor)]
-    pub fn new(keysets: String) -> Result<JsKeyResponse> {
-        let response = serde_json::from_str(&keysets).map_err(into_err)?;
+    pub fn new(keysets: JsValue) -> Result<JsKeyResponse> {
+        let response = serde_wasm_bindgen::from_value(keysets).map_err(into_err)?;
         Ok(Self { inner: response })
     }
 
     /// Get Keysets
     #[wasm_bindgen(getter)]
-    pub fn keysets(&self) -> Result<String> {
-        serde_json::to_string(&self.inner.keysets).map_err(into_err)
+    pub fn keysets(&self) -> Result<JsValue> {
+        serde_wasm_bindgen::to_value(&self.inner.keysets).map_err(into_err)
     }
 }

bindings/cashu-js/src/nuts/nut04.rs

@@ -30,16 +30,16 @@ impl From<MintRequest> for JsMintRequest {
 impl JsMintRequest {
     /// Try From Base 64 String
     #[wasm_bindgen(constructor)]
-    pub fn new(outputs: String) -> Result<JsMintRequest> {
-        let outputs = serde_json::from_str(&outputs).map_err(into_err)?;
+    pub fn new(outputs: JsValue) -> Result<JsMintRequest> {
+        let outputs = serde_wasm_bindgen::from_value(outputs).map_err(into_err)?;
         Ok(JsMintRequest {
             inner: MintRequest { outputs },
         })
     }
 
     #[wasm_bindgen(getter)]
-    pub fn outputs(&self) -> Result<String> {
-        serde_json::to_string(&self.inner.outputs).map_err(into_err)
+    pub fn outputs(&self) -> Result<JsValue> {
+        serde_wasm_bindgen::to_value(&self.inner.outputs).map_err(into_err)
     }
 
     #[wasm_bindgen(js_name = totalAmount)]
@@ -70,15 +70,15 @@ impl From<PostMintResponse> for JsPostMintResponse {
 impl JsPostMintResponse {
     /// Try From Base 64 String
     #[wasm_bindgen(constructor)]
-    pub fn new(promises: String) -> Result<JsPostMintResponse> {
-        let promises = serde_json::from_str(&promises).map_err(into_err)?;
+    pub fn new(promises: JsValue) -> Result<JsPostMintResponse> {
+        let promises = serde_wasm_bindgen::from_value(promises).map_err(into_err)?;
         Ok(JsPostMintResponse {
             inner: PostMintResponse { promises },
         })
     }
 
     #[wasm_bindgen(getter)]
-    pub fn promises(&self) -> Result<String> {
-        serde_json::to_string(&self.inner.promises).map_err(into_err)
+    pub fn promises(&self) -> Result<JsValue> {
+        serde_wasm_bindgen::to_value(&self.inner.promises).map_err(into_err)
     }
 }

bindings/cashu-js/src/nuts/nut06.rs

@@ -29,9 +29,9 @@ impl From<SplitRequest> for JsSplitRequest {
 #[wasm_bindgen(js_class = SplitRequest)]
 impl JsSplitRequest {
     #[wasm_bindgen(constructor)]
-    pub fn new(proofs: String, outputs: String) -> Result<JsSplitRequest> {
-        let proofs = serde_json::from_str(&proofs).map_err(into_err)?;
-        let outputs = serde_json::from_str(&outputs).map_err(into_err)?;
+    pub fn new(proofs: JsValue, outputs: JsValue) -> Result<JsSplitRequest> {
+        let proofs = serde_wasm_bindgen::from_value(proofs).map_err(into_err)?;
+        let outputs = serde_wasm_bindgen::from_value(outputs).map_err(into_err)?;
 
         Ok(JsSplitRequest {
             inner: SplitRequest {
@@ -44,14 +44,14 @@ impl JsSplitRequest {
 
     /// Get Proofs
     #[wasm_bindgen(getter)]
-    pub fn proofs(&self) -> Result<String> {
-        serde_json::to_string(&self.inner.proofs).map_err(into_err)
+    pub fn proofs(&self) -> Result<JsValue> {
+        serde_wasm_bindgen::to_value(&self.inner.proofs).map_err(into_err)
     }
 
     /// Get Outputs
     #[wasm_bindgen(getter)]
-    pub fn outputs(&self) -> Result<String> {
-        serde_json::to_string(&self.inner.outputs).map_err(into_err)
+    pub fn outputs(&self) -> Result<JsValue> {
+        serde_wasm_bindgen::to_value(&self.inner.outputs).map_err(into_err)
     }
 
     /// Proofs Amount
@@ -88,8 +88,8 @@ impl From<SplitResponse> for JsSplitResponse {
 #[wasm_bindgen(js_class = SplitResponse)]
 impl JsSplitResponse {
     #[wasm_bindgen(constructor)]
-    pub fn new(promises: String) -> Result<JsSplitResponse> {
-        let promises = serde_json::from_str(&promises).map_err(into_err)?;
+    pub fn new(promises: JsValue) -> Result<JsSplitResponse> {
+        let promises = serde_wasm_bindgen::from_value(promises).map_err(into_err)?;
 
         Ok(JsSplitResponse {
             inner: SplitResponse {
@@ -102,8 +102,8 @@ impl JsSplitResponse {
 
     /// Get Promises
     #[wasm_bindgen(getter)]
-    pub fn promises(&self) -> Result<String> {
-        serde_json::to_string(&self.inner.promises).map_err(into_err)
+    pub fn promises(&self) -> Result<JsValue> {
+        serde_wasm_bindgen::to_value(&self.inner.promises).map_err(into_err)
     }
 
     /// Promises Amount

bindings/cashu-js/src/nuts/nut07.rs

@@ -27,8 +27,8 @@ impl From<CheckSpendableRequest> for JsCheckSpendableRequest {
 impl JsCheckSpendableRequest {
     // REVIEW: Use into serde
     #[wasm_bindgen(constructor)]
-    pub fn new(proofs: String) -> Result<JsCheckSpendableRequest> {
-        let proofs = serde_json::from_str(&proofs).map_err(into_err)?;
+    pub fn new(proofs: JsValue) -> Result<JsCheckSpendableRequest> {
+        let proofs = serde_wasm_bindgen::from_value(proofs).map_err(into_err)?;
 
         Ok(JsCheckSpendableRequest {
             inner: CheckSpendableRequest { proofs },
@@ -38,8 +38,8 @@ impl JsCheckSpendableRequest {
     /// Get Proofs
     #[wasm_bindgen(getter)]
     // REVIEW: INTO Serde
-    pub fn proofs(&self) -> Result<String> {
-        serde_json::to_string(&self.inner.proofs).map_err(into_err)
+    pub fn proofs(&self) -> Result<JsValue> {
+        serde_wasm_bindgen::to_value(&self.inner.proofs).map_err(into_err)
     }
 }
 
@@ -64,21 +64,10 @@ impl From<CheckSpendableResponse> for JsCheckSpendableResponse {
 #[wasm_bindgen(js_class = CheckSpendableResponse)]
 impl JsCheckSpendableResponse {
     #[wasm_bindgen(constructor)]
-    pub fn new(
-        js_spendable: Box<[JsValue]>,
-        js_pending: Box<[JsValue]>,
-    ) -> Result<JsCheckSpendableResponse> {
-        let spendable: Vec<bool> = js_spendable.iter().flat_map(|s| s.as_bool()).collect();
+    pub fn new(spendable: JsValue, pending: JsValue) -> Result<JsCheckSpendableResponse> {
+        let spendable = serde_wasm_bindgen::from_value(spendable).map_err(into_err)?;
 
-        if spendable.len().ne(&js_spendable.len()) {
-            return Err(JsValue::from_str("Wrong value"));
-        }
-
-        let pending: Vec<bool> = js_pending.iter().flat_map(|p| p.as_bool()).collect();
-
-        if pending.len().ne(&js_pending.len()) {
-            return Err(JsValue::from_str("Wrong value"));
-        }
+        let pending = serde_wasm_bindgen::from_value(pending).map_err(into_err)?;
 
         Ok(JsCheckSpendableResponse {
             inner: CheckSpendableResponse { spendable, pending },