light-client-js: remove the syn version pin (informalsystems#1242)

* light-client-js: remove the syn version pin

The bug this used to work around is closed and the problem
no longer seems to persist.

* light-client-js: use serde-wasm-bindgen

To remove deprecation warnings and do the right thing,
use serde-wasm-bindgen utilities for serializing and deserializing
Rust types to and from JsValue.

* proto: fix deserialization for PartSerHeader.total

Accept also signed integers as these are produced from JSON
by serde-wasm-bindgen.

* light-client-js: pass by value to the entry point

Now that deserialization likes to take ownership of our JS values,
it does not make sense to pass them by reference from JavaScript
only to clone them immediately.
This is not a breaking change for the JavaScript API.

Author: mzabaluev

.changelog/unreleased/improvements/1242-serde-wasm-bindgen.md

@@ -0,0 +1,2 @@
+- `[tendermint-light-client-js]` Switch to serde-wasm-bindgen for marshalling
+  JS values ([#1242](https://github.com/informalsystems/tendermint-rs/pull/1242))

light-client-js/Cargo.toml

@@ -22,11 +22,10 @@ default = ["console_error_panic_hook"]
 [dependencies]
 serde = { version = "1.0", default-features = false, features = [ "derive" ] }
 serde_json = { version = "1.0", default-features = false }
-# TODO(thane): Remove once https://github.com/rustwasm/wasm-bindgen/issues/2508 is resolved
-syn = { version = "=1.0.65", default-features = false }
 tendermint = { version = "0.27.0", default-features = false, path = "../tendermint" }
 tendermint-light-client-verifier = { version = "0.27.0", default-features = false, path = "../light-client-verifier" }
 wasm-bindgen = { version = "0.2.63", default-features = false, features = [ "serde-serialize" ] }
+serde-wasm-bindgen = { version = "0.4.5", default-features = false }
 
 # The `console_error_panic_hook` crate provides better debugging of panics by
 # logging them with `console.error`. This is great for development, but requires

light-client-js/src/lib.rs

@@ -24,7 +24,7 @@ use wasm_bindgen::{prelude::*, JsValue};
 
 /// Check whether a given untrusted block can be trusted.
 #[wasm_bindgen]
-pub fn verify(untrusted: &JsValue, trusted: &JsValue, options: &JsValue, now: &JsValue) -> JsValue {
+pub fn verify(untrusted: JsValue, trusted: JsValue, options: JsValue, now: JsValue) -> JsValue {
     let result = deserialize_params(untrusted, trusted, options, now).map(
         |(untrusted, trusted, options, now)| {
             let verifier = ProdVerifier::default();
@@ -36,35 +36,35 @@ pub fn verify(untrusted: &JsValue, trusted: &JsValue, options: &JsValue, now: &J
             )
         },
     );
-    JsValue::from_serde(&result).unwrap()
+    serde_wasm_bindgen::to_value(&result).unwrap()
 }
 
 fn deserialize_params(
-    untrusted: &JsValue,
-    trusted: &JsValue,
-    options: &JsValue,
-    now: &JsValue,
+    untrusted: JsValue,
+    trusted: JsValue,
+    options: JsValue,
+    now: JsValue,
 ) -> Result<(LightBlock, LightBlock, Options, Time), Error> {
-    let untrusted = untrusted.into_serde().map_err(|e| Error::Serialization {
-        param: "untrusted".to_string(),
-        msg: e.to_string(),
-    })?;
+    let untrusted =
+        serde_wasm_bindgen::from_value(untrusted).map_err(|e| Error::Serialization {
+            param: "untrusted".into(),
+            msg: e.to_string(),
+        })?;
 
-    let trusted = trusted.into_serde().map_err(|e| Error::Serialization {
-        param: "trusted".to_string(),
+    let trusted = serde_wasm_bindgen::from_value(trusted).map_err(|e| Error::Serialization {
+        param: "trusted".into(),
         msg: e.to_string(),
     })?;
 
-    let options = options
-        .into_serde::<JsOptions>()
+    let options = serde_wasm_bindgen::from_value::<JsOptions>(options)
         .map(Into::into)
         .map_err(|e| Error::Serialization {
-            param: "options".to_string(),
+            param: "options".into(),
             msg: e.to_string(),
         })?;
 
-    let now = now.into_serde().map_err(|e| Error::Serialization {
-        param: "now".to_string(),
+    let now = serde_wasm_bindgen::from_value(now).map_err(|e| Error::Serialization {
+        param: "now".into(),
         msg: e.to_string(),
     })?;
 

light-client-js/tests/web.rs

@@ -161,10 +161,11 @@ fn successful_verification() {
     let options = test_options();
     // Choose a "now" value within the trusting period
     let now =
-        JsValue::from_serde(&Time::parse_from_rfc3339("1970-01-07T00:00:00Z").unwrap()).unwrap();
-    let js_result = verify(&untrusted_block, &trusted_block, &options, &now);
+        serde_wasm_bindgen::to_value(&Time::parse_from_rfc3339("1970-01-07T00:00:00Z").unwrap())
+            .unwrap();
+    let js_result = verify(untrusted_block, trusted_block, options, now);
     console_log!("js_result = {:?}", js_result);
-    let verdict = JsValue::into_serde::<Result<Verdict, Error>>(&js_result)
+    let verdict = serde_wasm_bindgen::from_value::<Result<Verdict, Error>>(js_result)
         .unwrap()
         .unwrap();
     assert_eq!(verdict, Verdict::Success);
@@ -176,12 +177,13 @@ fn failed_verification_outside_trusting_period() {
     let options = test_options();
     // Choose a "now" value outside the trusting period
     let now =
-        JsValue::from_serde(&Time::parse_from_rfc3339("1970-01-16T00:00:00Z").unwrap()).unwrap();
-    let js_result = verify(&untrusted_block, &trusted_block, &options, &now);
+        serde_wasm_bindgen::to_value(&Time::parse_from_rfc3339("1970-01-16T00:00:00Z").unwrap())
+            .unwrap();
+    let js_result = verify(untrusted_block, trusted_block, options, now);
     console_log!("js_result = {:?}", js_result);
     // The result is Ok because we successfully obtained a verdict, even if the
     // verdict isn't Verdict::Success.
-    let verdict = JsValue::into_serde::<Result<Verdict, Error>>(&js_result)
+    let verdict = serde_wasm_bindgen::from_value::<Result<Verdict, Error>>(js_result)
         .unwrap()
         .unwrap();
     match verdict {
@@ -192,14 +194,16 @@ fn failed_verification_outside_trusting_period() {
 
 fn test_blocks() -> (JsValue, JsValue) {
     let untrusted_block =
-        JsValue::from_serde(&serde_json::from_str::<LightBlock>(UNTRUSTED_BLOCK).unwrap()).unwrap();
+        serde_wasm_bindgen::to_value(&serde_json::from_str::<LightBlock>(UNTRUSTED_BLOCK).unwrap())
+            .unwrap();
     let trusted_block =
-        JsValue::from_serde(&serde_json::from_str::<LightBlock>(TRUSTED_BLOCK).unwrap()).unwrap();
+        serde_wasm_bindgen::to_value(&serde_json::from_str::<LightBlock>(TRUSTED_BLOCK).unwrap())
+            .unwrap();
     (untrusted_block, trusted_block)
 }
 
 fn test_options() -> JsValue {
-    JsValue::from_serde(&JsOptions {
+    serde_wasm_bindgen::to_value(&JsOptions {
         trust_threshold: (1, 3),
         trusting_period: 1209600, // 2 weeks
         clock_drift: 5,           // 5 seconds

proto/src/serializers/part_set_header_total.rs

@@ -36,7 +36,7 @@ impl<'de> Visitor<'de> for PartSetHeaderTotalStringOrU32 {
     type Value = u32;
 
     fn expecting(&self, formatter: &mut Formatter<'_>) -> core::fmt::Result {
-        formatter.write_str("an u32 integer or string between 0 and 2^32")
+        formatter.write_str("an integer or string between 0 and 2^32")
     }
 
     fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
@@ -46,6 +46,13 @@ impl<'de> Visitor<'de> for PartSetHeaderTotalStringOrU32 {
         u32::try_from(v).map_err(|e| E::custom(format!("part_set_header.total {}", e)))
     }
 
+    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
+    where
+        E: Error,
+    {
+        u32::try_from(v).map_err(|e| E::custom(format!("part_set_header.total {}", e)))
+    }
+
     fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
     where
         E: Error,