chore(uov7): Serialize UserOperation numbers as hex 0x prefixed (#4353)

Author: satoshiotomakan

rust/tw_encoding/src/hex.rs

@@ -135,6 +135,31 @@ pub mod as_hex {
     }
 }
 
+pub mod as_hex_prefixed {
+    use crate::hex::encode;
+    use serde::{Deserializer, Serialize, Serializer};
+    use std::fmt;
+
+    /// Serializes the `value` as a `0x` prefixed hex.
+    pub fn serialize<T, S>(value: &T, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        T: AsRef<[u8]>,
+        S: Serializer,
+    {
+        encode(value, true).serialize(serializer)
+    }
+
+    pub fn deserialize<'de, D, T, E>(deserializer: D) -> Result<T, D::Error>
+    where
+        D: Deserializer<'de>,
+        T: for<'a> TryFrom<&'a [u8], Error = E>,
+        E: fmt::Debug,
+    {
+        // `as_hex::deserialize` handles the prefix already.
+        super::as_hex::deserialize(deserializer)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

rust/tw_evm/Cargo.toml

@@ -15,7 +15,7 @@ tw_hash = { path = "../tw_hash" }
 tw_keypair = { path = "../tw_keypair" }
 tw_memory = { path = "../tw_memory" }
 tw_misc = { path = "../tw_misc" }
-tw_number = { path = "../tw_number" }
+tw_number = { path = "../tw_number", features = ["serde"] }
 tw_proto = { path = "../tw_proto" }
 
 [dev-dependencies]

rust/tw_evm/src/signature.rs

@@ -3,7 +3,7 @@
 // Copyright © 2017 Trust Wallet.
 
 use std::ops::BitXor;
-use tw_number::{NumberResult, U256};
+use tw_number::{NumberError, NumberResult, U256};
 
 /// EIP155 Eth encoding of V, of the form 27+v, or 35+chainID*2+v.
 /// cbindgin:ignore
@@ -19,12 +19,19 @@ pub fn replay_protection(chain_id: U256, v: u8) -> NumberResult<U256> {
     }
 }
 
-/// Embeds `chain_id` in `v` param, for replay protection, legacy.
+/// Embeds legacy protection into `v` param.
 #[inline]
 pub fn legacy_replay_protection(v: u8) -> NumberResult<U256> {
     U256::from(v).checked_add(ETHEREUM_SIGNATURE_V_OFFSET)
 }
 
+/// Embeds legacy protection into `v` param.
+#[inline]
+pub fn legacy_replay_protection_u8(v: u8) -> NumberResult<u8> {
+    v.checked_add(ETHEREUM_SIGNATURE_V_OFFSET)
+        .ok_or(NumberError::IntegerOverflow)
+}
+
 /// Embeds `chain_id` in `v` param, for replay protection, EIP155.
 #[inline]
 pub fn eip155_replay_protection(chain_id: U256, v: u8) -> NumberResult<U256> {

rust/tw_evm/src/transaction/user_operation_v0_7.rs

@@ -6,14 +6,17 @@ use crate::abi::encode::encode_tokens;
 use crate::abi::non_empty_array::NonEmptyBytes;
 use crate::abi::token::Token;
 use crate::address::Address;
+use crate::signature::legacy_replay_protection_u8;
 use crate::transaction::signature::Signature;
 use crate::transaction::{SignedTransaction, TransactionCommon, UnsignedTransaction};
-use serde::Serialize;
+use serde::ser::Error as SerError;
+use serde::{Serialize, Serializer};
 use tw_coin_entry::error::prelude::*;
-use tw_encoding::hex;
+use tw_encoding::hex::{self, as_hex_prefixed};
 use tw_hash::sha3::keccak256;
 use tw_hash::H256;
 use tw_memory::Data;
+use tw_number::serde::as_u256_hex;
 use tw_number::U256;
 
 pub struct PackedUserOperation {
@@ -115,22 +118,45 @@ impl PackedUserOperation {
     }
 }
 
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
 pub struct UserOperationV0_7 {
     pub sender: Address,
+    #[serde(serialize_with = "U256::as_hex")]
     pub nonce: U256,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub factory: Option<Address>,
+    #[serde(skip_serializing_if = "Data::is_empty")]
+    #[serde(with = "as_hex_prefixed")]
     pub factory_data: Data,
+
+    #[serde(with = "as_hex_prefixed")]
     pub call_data: Data,
+
+    #[serde(serialize_with = "as_u256_hex")]
     pub call_data_gas_limit: u128,
+    #[serde(serialize_with = "as_u256_hex")]
     pub verification_gas_limit: u128,
+    #[serde(serialize_with = "U256::as_hex")]
     pub pre_verification_gas: U256,
+
+    #[serde(serialize_with = "as_u256_hex")]
     pub max_fee_per_gas: u128,
+    #[serde(serialize_with = "as_u256_hex")]
     pub max_priority_fee_per_gas: u128,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub paymaster: Option<Address>,
+    #[serde(serialize_with = "as_u256_hex")]
     pub paymaster_verification_gas_limit: u128,
+    #[serde(serialize_with = "as_u256_hex")]
     pub paymaster_post_op_gas_limit: u128,
+    #[serde(skip_serializing_if = "Data::is_empty")]
+    #[serde(with = "as_hex_prefixed")]
     pub paymaster_data: Data,
 
+    #[serde(skip)]
     pub entry_point: Address,
 }
 
@@ -165,8 +191,12 @@ impl UnsignedTransaction for UserOperationV0_7 {
     }
 }
 
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
 pub struct SignedUserOperationV0_7 {
+    #[serde(flatten)]
     unsigned: UserOperationV0_7,
+    #[serde(serialize_with = "serialize_signature_with_legacy_replay_protect")]
     signature: Signature,
 }
 
@@ -181,31 +211,7 @@ impl SignedTransaction for SignedUserOperationV0_7 {
     type Signature = Signature;
 
     fn encode(&self) -> Data {
-        let mut signature = self.signature.to_rsv_bytes();
-        signature[64] += 27;
-
-        let prefix = true;
-        let tx = SignedUserOperationV0_7Serde {
-            sender: self.unsigned.sender.to_string(),
-            nonce: self.unsigned.nonce.to_string(),
-            factory: self.unsigned.factory.map(|addr| addr.to_string()),
-            factory_data: hex::encode(&self.unsigned.factory_data, prefix),
-            call_data: hex::encode(&self.unsigned.call_data, prefix),
-            call_data_gas_limit: self.unsigned.call_data_gas_limit.to_string(),
-            verification_gas_limit: self.unsigned.verification_gas_limit.to_string(),
-            pre_verification_gas: self.unsigned.pre_verification_gas.to_string(),
-            max_fee_per_gas: self.unsigned.max_fee_per_gas.to_string(),
-            max_priority_fee_per_gas: self.unsigned.max_priority_fee_per_gas.to_string(),
-            paymaster: self.unsigned.paymaster.map(|addr| addr.to_string()),
-            paymaster_verification_gas_limit: self
-                .unsigned
-                .paymaster_verification_gas_limit
-                .to_string(),
-            paymaster_post_op_gas_limit: self.unsigned.paymaster_post_op_gas_limit.to_string(),
-            paymaster_data: hex::encode(&self.unsigned.paymaster_data, prefix),
-            signature: hex::encode(signature.as_slice(), prefix),
-        };
-        serde_json::to_string(&tx)
+        serde_json::to_string(self)
             .expect("Simple structure should never fail on serialization")
             .into_bytes()
     }
@@ -216,26 +222,6 @@ impl SignedTransaction for SignedUserOperationV0_7 {
     }
 }
 
-#[derive(Serialize)]
-#[serde(rename_all = "camelCase")]
-struct SignedUserOperationV0_7Serde {
-    sender: String,
-    nonce: String,
-    factory: Option<String>,
-    factory_data: String,
-    call_data: String,
-    call_data_gas_limit: String,
-    verification_gas_limit: String,
-    pre_verification_gas: String,
-    max_fee_per_gas: String,
-    max_priority_fee_per_gas: String,
-    paymaster: Option<String>,
-    paymaster_verification_gas_limit: String,
-    paymaster_post_op_gas_limit: String,
-    paymaster_data: String,
-    signature: String,
-}
-
 fn concat_u128_be(a: u128, b: u128) -> [u8; 32] {
     let a = a.to_be_bytes();
     let b = b.to_be_bytes();
@@ -248,6 +234,22 @@ fn concat_u128_be(a: u128, b: u128) -> [u8; 32] {
     })
 }
 
+pub fn serialize_signature_with_legacy_replay_protect<S>(
+    signature: &Signature,
+    serializer: S,
+) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+{
+    let prefix = true;
+    let mut rsv = signature.to_rsv_bytes();
+    rsv[64] =
+        legacy_replay_protection_u8(rsv[64]).map_err(|e| SerError::custom(format!("{e:?}")))?;
+
+    let hex_str = hex::encode(rsv, prefix);
+    serializer.serialize_str(&hex_str)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -310,7 +312,7 @@ mod tests {
             nonce: U256::from(0u64),
             init_code: "f471789937856d80e589f5996cf8b0511ddd9de4f471789937856d80e589f5996cf8b0511ddd9de4".decode_hex().unwrap(),
             call_data: "00".decode_hex().unwrap(),
-            account_gas_limits:concat_u128_be(100000u128, 100000u128).to_vec(),
+            account_gas_limits: concat_u128_be(100000u128, 100000u128).to_vec(),
             pre_verification_gas: U256::from(1000000u64),
             gas_fees: concat_u128_be(100000u128, 100000u128).to_vec(),
             paymaster_and_data: "f62849f9a0b5bf2913b396098f7c7019b51a820a0000000000000000000000000001869f00000000000000000000000000015b3800000000000b0000000000002e234dae75c793f67a35089c9d99245e1c58470b00000000000000000000000000000000000000000000000000000000000186a0072f35038bcacc31bcdeda87c1d9857703a26fb70a053f6e87da5a4e7a1e1f3c4b09fbe2dbff98e7a87ebb45a635234f4b79eff3225d07560039c7764291c97e1b".decode_hex().unwrap(),

rust/tw_evm/tests/barz.rs

@@ -317,8 +317,9 @@ fn test_biz4337_transfer() {
         "68109b9caf49f7971b689307c9a77ceec46e4b8fa88421c4276dd846f782d92c"
     );
 
-    let user_op: serde_json::Value = serde_json::from_slice(&output.encoded).unwrap();
-    assert_eq!(user_op["callData"], "0x76276c82000000000000000000000000dac17f958d2ee523a2206206994597c13d831ec7000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000044095ea7b3000000000000000000000000b0086171ac7b6bd4d046580bca6d6a4b0835c2320000000000000000000000000000000000000000000000000002540befbfbd0000000000000000000000000000000000000000000000000000000000");
+    let expected = r#"{"sender":"0x2EF648D7C03412B832726fd4683E2625deA047Ba","nonce":"0x00","callData":"0x76276c82000000000000000000000000dac17f958d2ee523a2206206994597c13d831ec7000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000044095ea7b3000000000000000000000000b0086171ac7b6bd4d046580bca6d6a4b0835c2320000000000000000000000000000000000000000000000000002540befbfbd0000000000000000000000000000000000000000000000000000000000","callDataGasLimit":"0x0186a0","verificationGasLimit":"0x0186a0","preVerificationGas":"0x0f4240","maxFeePerGas":"0x0186a0","maxPriorityFeePerGas":"0x0186a0","paymaster":"0xb0086171AC7b6BD4D046580bca6d6A4b0835c232","paymasterVerificationGasLimit":"0x01869f","paymasterPostOpGasLimit":"0x015b38","paymasterData":"0x00000000000b0000000000002e234dae75c793f67a35089c9d99245e1c58470b00000000000000000000000000000000000000000000000000000000000186a0072f35038bcacc31bcdeda87c1d9857703a26fb70a053f6e87da5a4e7a1e1f3c4b09fbe2dbff98e7a87ebb45a635234f4b79eff3225d07560039c7764291c97e1b","signature":"0xf6b1f7ad22bcc68ca292bc10d15e82e0eab8c75c1a04f9750e7cff1418d38d9c6c115c510e3f47eb802103d62f88fa7d4a3b2e24e2ddbe7ee68153920ab3f6cc1b"}"#;
+    let actual = String::from_utf8(output.encoded.to_vec()).unwrap();
+    assert_eq!(actual, expected);
 }
 
 #[test]
@@ -404,8 +405,9 @@ fn test_biz4337_transfer_batch() {
         "f6340068891dc3eb78959993151c421dde23982b3a1407c0dbbd62c2c22c3cb8"
     );
 
-    let user_op: serde_json::Value = serde_json::from_slice(&output.encoded).unwrap();
-    assert_eq!(user_op["callData"], "0x26da7d880000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000120000000000000000000000000dac17f958d2ee523a2206206994597c13d831ec7000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000044095ea7b3000000000000000000000000b0086171ac7b6bd4d046580bca6d6a4b0835c2320000000000000000000000000000000000000000000000000002540befbfbd000000000000000000000000000000000000000000000000000000000000000000000000000000000003bbb5660b8687c2aa453a0e42dcb6e0732b1266000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000044a9059cbb0000000000000000000000005ff137d4b0fdcd49dca30c7cf57e578a026d27890000000000000000000000000000000000000000000000008ac7230489e8000000000000000000000000000000000000000000000000000000000000");
+    let expected = r#"{"sender":"0x2EF648D7C03412B832726fd4683E2625deA047Ba","nonce":"0x00","callData":"0x26da7d880000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000120000000000000000000000000dac17f958d2ee523a2206206994597c13d831ec7000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000044095ea7b3000000000000000000000000b0086171ac7b6bd4d046580bca6d6a4b0835c2320000000000000000000000000000000000000000000000000002540befbfbd000000000000000000000000000000000000000000000000000000000000000000000000000000000003bbb5660b8687c2aa453a0e42dcb6e0732b1266000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000044a9059cbb0000000000000000000000005ff137d4b0fdcd49dca30c7cf57e578a026d27890000000000000000000000000000000000000000000000008ac7230489e8000000000000000000000000000000000000000000000000000000000000","callDataGasLimit":"0x0186a0","verificationGasLimit":"0x0186a0","preVerificationGas":"0x0f4240","maxFeePerGas":"0x0186a0","maxPriorityFeePerGas":"0x0186a0","paymaster":"0xb0086171AC7b6BD4D046580bca6d6A4b0835c232","paymasterVerificationGasLimit":"0x01869f","paymasterPostOpGasLimit":"0x015b38","paymasterData":"0x00000000000b0000000000002e234dae75c793f67a35089c9d99245e1c58470b00000000000000000000000000000000000000000000000000000000000186a0072f35038bcacc31bcdeda87c1d9857703a26fb70a053f6e87da5a4e7a1e1f3c4b09fbe2dbff98e7a87ebb45a635234f4b79eff3225d07560039c7764291c97e1b","signature":"0x21ab0bdcd1441aef3e4046a922bab3636d0c74011c1b055c55ad9f39ae9b4dac59bcbf3bc1ff31b367a83360edfc8e9652f1a5c8b07eb76fe5a426835682d6721c"}"#;
+    let actual = String::from_utf8(output.encoded.to_vec()).unwrap();
+    assert_eq!(actual, expected);
 }
 
 #[test]

rust/tw_number/Cargo.toml

@@ -13,6 +13,7 @@ arbitrary = { version = "1", features = ["derive"], optional = true }
 lazy_static = "1.4.0"
 primitive-types = "0.10.1"
 serde = { version = "1.0", features = ["derive"], optional = true }
+tw_encoding = { path = "../tw_encoding" }
 tw_hash = { path = "../tw_hash" }
 tw_memory = { path = "../tw_memory" }
 

rust/tw_number/src/lib.rs

@@ -3,6 +3,7 @@
 // Copyright © 2017 Trust Wallet.
 
 mod i256;
+pub mod serde;
 mod sign;
 mod u256;
 

rust/tw_number/src/serde.rs

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// Copyright © 2017 Trust Wallet.
+
+use crate::U256;
+use serde::Serializer;
+
+pub fn as_u256_hex<T, S>(num: &T, serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+    T: Into<U256> + Copy,
+{
+    let num_u256: U256 = (*num).into();
+    num_u256.as_hex(serializer)
+}

rust/tw_number/src/u256.rs

@@ -236,6 +236,7 @@ mod impl_serde {
     use serde::de::Error as DeError;
     use serde::{Deserialize, Deserializer, Serializer};
     use std::str::FromStr;
+    use tw_encoding::hex;
 
     impl U256 {
         pub fn as_decimal_str<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -259,6 +260,17 @@ mod impl_serde {
         {
             crate::serde_common::from_num_or_decimal_str::<'de, U256, u64, D>(deserializer)
         }
+
+        pub fn as_hex<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+        where
+            S: Serializer,
+        {
+            let prefix = true;
+            let min_bytes_len = 1;
+
+            let hex_str = hex::encode(self.to_big_endian_compact_min_len(min_bytes_len), prefix);
+            serializer.serialize_str(&hex_str)
+        }
     }
 }