Merge branch 'master' into contract-error-data-msg

xJonathanLEI · Nov 6, 2023 · b3858e8 · b3858e8
2 parents 8db3dfa + 5f1e5cd
commit b3858e8
Show file tree

Hide file tree

Showing 24 changed files with 655 additions and 64 deletions.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -34,9 +34,9 @@ members = [
 all-features = true
 
 [dependencies]
-starknet-ff = { version = "0.3.4", path = "./starknet-ff", default-features = false }
+starknet-ff = { version = "0.3.5", path = "./starknet-ff", default-features = false }
 starknet-crypto = { version = "0.6.1", path = "./starknet-crypto" }
-starknet-core = { version = "0.7.0", path = "./starknet-core", default-features = false }
+starknet-core = { version = "0.7.2", path = "./starknet-core", default-features = false }
 starknet-providers = { version = "0.7.0", path = "./starknet-providers" }
 starknet-contract = { version = "0.6.0", path = "./starknet-contract" }
 starknet-signers = { version = "0.5.0", path = "./starknet-signers" }

diff --git a/examples/starknet-wasm/Cargo.toml b/examples/starknet-wasm/Cargo.toml
@@ -19,7 +19,7 @@ crate-type = ["cdylib", "rlib"]
 default = ["console_error_panic_hook"]
 
 [dependencies]
-starknet-ff = { version = "0.3.4", path = "../../starknet-ff" }
+starknet-ff = { version = "0.3.5", path = "../../starknet-ff" }
 starknet-crypto = { version = "0.6.1", path = "../../starknet-crypto" }
 console_error_panic_hook = { version = "0.1.7", optional = true }
 wasm-bindgen = "0.2.84"
diff --git a/starknet-accounts/Cargo.toml b/starknet-accounts/Cargo.toml
@@ -14,7 +14,7 @@ keywords = ["ethereum", "starknet", "web3"]
 exclude = ["test-data/**"]
 
 [dependencies]
-starknet-core = { version = "0.7.0", path = "../starknet-core" }
+starknet-core = { version = "0.7.2", path = "../starknet-core" }
 starknet-providers = { version = "0.7.0", path = "../starknet-providers" }
 starknet-signers = { version = "0.5.0", path = "../starknet-signers" }
 async-trait = "0.1.68"

diff --git a/starknet-contract/Cargo.toml b/starknet-contract/Cargo.toml
@@ -14,7 +14,7 @@ keywords = ["ethereum", "starknet", "web3"]
 exclude = ["test-data/**"]
 
 [dependencies]
-starknet-core = { version = "0.7.0", path = "../starknet-core" }
+starknet-core = { version = "0.7.2", path = "../starknet-core" }
 starknet-providers = { version = "0.7.0", path = "../starknet-providers" }
 starknet-accounts = { version = "0.6.0", path = "../starknet-accounts" }
 serde = { version = "1.0.160", features = ["derive"] }

diff --git a/starknet-core/Cargo.toml b/starknet-core/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "starknet-core"
-version = "0.7.0"
+version = "0.7.2"
 authors = ["Jonathan LEI <[email protected]>"]
 license = "MIT OR Apache-2.0"
 edition = "2021"
@@ -18,7 +18,7 @@ all-features = true
 
 [dependencies]
 starknet-crypto = { version = "0.6.1", path = "../starknet-crypto", default-features = false, features = ["alloc"] }
-starknet-ff = { version = "0.3.4", path = "../starknet-ff", default-features = false, features = ["serde"] }
+starknet-ff = { version = "0.3.5", path = "../starknet-ff", default-features = false, features = ["serde"] }
 base64 = { version = "0.21.0", default-features = false, features = ["alloc"] }
 flate2 = { version = "1.0.25", optional = true }
 hex = { version = "0.4.3", default-features = false, features = ["alloc"] }

diff --git a/starknet-core/src/serde/byte_array.rs b/starknet-core/src/serde/byte_array.rs
@@ -1,8 +1,10 @@
 pub mod base64 {
-    use alloc::{format, string::String, vec::Vec};
+    use alloc::{fmt::Formatter, format, vec::Vec};
 
     use base64::{engine::general_purpose::STANDARD, Engine};
-    use serde::{Deserialize, Deserializer, Serializer};
+    use serde::{de::Visitor, Deserializer, Serializer};
+
+    struct Base64Visitor;
 
     pub fn serialize<S, T>(value: T, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -16,12 +18,23 @@ pub mod base64 {
     where
         D: Deserializer<'de>,
     {
-        let value = String::deserialize(deserializer)?;
-        match STANDARD.decode(value) {
-            Ok(value) => Ok(value),
-            Err(err) => Err(serde::de::Error::custom(format!(
-                "invalid base64 string: {err}"
-            ))),
+        deserializer.deserialize_any(Base64Visitor)
+    }
+
+    impl<'de> Visitor<'de> for Base64Visitor {
+        type Value = Vec<u8>;
+
+        fn expecting(&self, formatter: &mut Formatter) -> alloc::fmt::Result {
+            write!(formatter, "string")
+        }
+
+        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+        where
+            E: serde::de::Error,
+        {
+            STANDARD
+                .decode(v)
+                .map_err(|err| serde::de::Error::custom(format!("invalid base64 string: {err}")))
         }
     }
 }
diff --git a/starknet-core/src/serde/num_hex.rs b/starknet-core/src/serde/num_hex.rs
@@ -1,7 +1,9 @@
 pub mod u64 {
-    use alloc::{format, string::String};
+    use alloc::{fmt::Formatter, format};
 
-    use serde::{Deserialize, Deserializer, Serializer};
+    use serde::{de::Visitor, Deserializer, Serializer};
+
+    struct NumHexVisitor;
 
     pub fn serialize<S>(value: &u64, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -14,12 +16,22 @@ pub mod u64 {
     where
         D: Deserializer<'de>,
     {
-        let value = String::deserialize(deserializer)?;
-        match u64::from_str_radix(value.trim_start_matches("0x"), 16) {
-            Ok(value) => Ok(value),
-            Err(err) => Err(serde::de::Error::custom(format!(
-                "invalid u64 hex string: {err}"
-            ))),
+        deserializer.deserialize_any(NumHexVisitor)
+    }
+
+    impl<'de> Visitor<'de> for NumHexVisitor {
+        type Value = u64;
+
+        fn expecting(&self, formatter: &mut Formatter) -> alloc::fmt::Result {
+            write!(formatter, "string")
+        }
+
+        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+        where
+            E: serde::de::Error,
+        {
+            u64::from_str_radix(v.trim_start_matches("0x"), 16)
+                .map_err(|err| serde::de::Error::custom(format!("invalid u64 hex string: {err}")))
         }
     }
 }
diff --git a/starknet-core/src/serde/unsigned_field_element.rs b/starknet-core/src/serde/unsigned_field_element.rs
@@ -1,6 +1,9 @@
-use alloc::{format, string::String};
+use alloc::{fmt::Formatter, format};
 
-use serde::{de::Error as DeError, Deserialize, Deserializer, Serializer};
+use serde::{
+    de::{Error as DeError, Visitor},
+    Deserializer, Serializer,
+};
 use serde_with::{DeserializeAs, SerializeAs};
 
 use crate::types::FieldElement;
@@ -11,6 +14,10 @@ pub struct UfeHexOption;
 
 pub struct UfePendingBlockHash;
 
+struct UfeHexVisitor;
+struct UfeHexOptionVisitor;
+struct UfePendingBlockHashVisitor;
+
 impl SerializeAs<FieldElement> for UfeHex {
     fn serialize_as<S>(value: &FieldElement, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -25,11 +32,23 @@ impl<'de> DeserializeAs<'de, FieldElement> for UfeHex {
     where
         D: Deserializer<'de>,
     {
-        let value = String::deserialize(deserializer)?;
-        match FieldElement::from_hex_be(&value) {
-            Ok(value) => Ok(value),
-            Err(err) => Err(DeError::custom(format!("invalid hex string: {err}"))),
-        }
+        deserializer.deserialize_any(UfeHexVisitor)
+    }
+}
+
+impl<'de> Visitor<'de> for UfeHexVisitor {
+    type Value = FieldElement;
+
+    fn expecting(&self, formatter: &mut Formatter) -> alloc::fmt::Result {
+        write!(formatter, "string")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: DeError,
+    {
+        FieldElement::from_hex_be(v)
+            .map_err(|err| DeError::custom(format!("invalid hex string: {err}")))
     }
 }
 
@@ -50,10 +69,24 @@ impl<'de> DeserializeAs<'de, Option<FieldElement>> for UfeHexOption {
     where
         D: Deserializer<'de>,
     {
-        let value = String::deserialize(deserializer)?;
-        match value.as_str() {
+        deserializer.deserialize_any(UfeHexOptionVisitor)
+    }
+}
+
+impl<'de> Visitor<'de> for UfeHexOptionVisitor {
+    type Value = Option<FieldElement>;
+
+    fn expecting(&self, formatter: &mut Formatter) -> alloc::fmt::Result {
+        write!(formatter, "string")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: DeError,
+    {
+        match v {
             "" => Ok(None),
-            _ => match FieldElement::from_hex_be(&value) {
+            _ => match FieldElement::from_hex_be(v) {
                 Ok(value) => Ok(Some(value)),
                 Err(err) => Err(DeError::custom(format!("invalid hex string: {err}"))),
             },
@@ -79,11 +112,25 @@ impl<'de> DeserializeAs<'de, Option<FieldElement>> for UfePendingBlockHash {
     where
         D: Deserializer<'de>,
     {
-        let value = String::deserialize(deserializer)?;
-        if value.is_empty() || value == "pending" || value == "None" {
+        deserializer.deserialize_any(UfePendingBlockHashVisitor)
+    }
+}
+
+impl<'de> Visitor<'de> for UfePendingBlockHashVisitor {
+    type Value = Option<FieldElement>;
+
+    fn expecting(&self, formatter: &mut Formatter) -> alloc::fmt::Result {
+        write!(formatter, "string")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: DeError,
+    {
+        if v.is_empty() || v == "pending" || v == "None" {
             Ok(None)
         } else {
-            match FieldElement::from_hex_be(&value) {
+            match FieldElement::from_hex_be(v) {
                 Ok(value) => Ok(Some(value)),
                 Err(err) => Err(DeError::custom(format!("invalid hex string: {err}"))),
             }
@@ -95,6 +142,7 @@ impl<'de> DeserializeAs<'de, Option<FieldElement>> for UfePendingBlockHash {
 mod tests {
     use super::*;
 
+    use serde::Deserialize;
     use serde_with::serde_as;
 
     #[serde_as]

diff --git a/starknet-core/src/types/eth_address.rs b/starknet-core/src/types/eth_address.rs
@@ -1,7 +1,7 @@
-use alloc::{format, string::String};
+use alloc::{fmt::Formatter, format};
 use core::str::FromStr;
 
-use serde::{Deserialize, Serialize};
+use serde::{de::Visitor, Deserialize, Serialize};
 use starknet_ff::FieldElement;
 
 // 0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF
@@ -17,6 +17,8 @@ pub struct EthAddress {
     inner: [u8; 20],
 }
 
+struct EthAddressVisitor;
+
 mod errors {
     use core::fmt::{Display, Formatter, Result};
 
@@ -84,9 +86,22 @@ impl<'de> Deserialize<'de> for EthAddress {
     where
         D: serde::Deserializer<'de>,
     {
-        let value = String::deserialize(deserializer)?;
-        value
-            .parse()
+        deserializer.deserialize_any(EthAddressVisitor)
+    }
+}
+
+impl<'de> Visitor<'de> for EthAddressVisitor {
+    type Value = EthAddress;
+
+    fn expecting(&self, formatter: &mut Formatter) -> alloc::fmt::Result {
+        write!(formatter, "string")
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: serde::de::Error,
+    {
+        v.parse()
             .map_err(|err| serde::de::Error::custom(format!("{}", err)))
     }
 }

diff --git a/starknet-core/src/types/execution_result.rs b/starknet-core/src/types/execution_result.rs
@@ -68,13 +68,12 @@ impl<'de> Deserialize<'de> for ExecutionResult {
 
         match (raw.execution_status, raw.revert_reason) {
             (TransactionExecutionStatus::Succeeded, None) => Ok(Self::Succeeded),
-            (TransactionExecutionStatus::Reverted, Some(reason)) => Ok(Self::Reverted { reason }),
+            (TransactionExecutionStatus::Reverted, reason) => Ok(Self::Reverted {
+                reason: reason.unwrap_or_default(),
+            }),
             (TransactionExecutionStatus::Succeeded, Some(_)) => Err(serde::de::Error::custom(
                 "field `revert_reason` must not exist when `execution_status` is `SUCCEEDED`",
             )),
-            (TransactionExecutionStatus::Reverted, None) => Err(serde::de::Error::custom(
-                "field `revert_reason` missing when `execution_status` is `REVERTED`",
-            )),
         }
     }
 }