Refactor annotated serializations

blockchain/blocks/src/header.rs

@@ -12,8 +12,11 @@ use encoding::{
     ser::{self, Serializer},
     Cbor, Error as EncodingError,
 };
-use num_bigint::{biguint_ser, BigUint};
-use serde::{Deserialize, Serialize};
+use num_bigint::{
+    biguint_ser::{BigUintDe, BigUintSer},
+    BigUint,
+};
+use serde::Deserialize;
 use std::fmt;
 use std::time::{SystemTime, UNIX_EPOCH};
 
@@ -119,28 +122,12 @@ impl ser::Serialize for BlockHeader {
     where
         S: Serializer,
     {
-        #[derive(Serialize)]
-        struct TupleBlockHeader<'a>(
-            &'a Address,                                // miner_address
-            &'a Ticket,                                 // ticket
-            &'a EPostProof,                             // epost_verify
-            &'a TipSetKeys,                             // parents []cid
-            #[serde(with = "biguint_ser")] &'a BigUint, // weight
-            &'a ChainEpoch,                             // epoch
-            &'a Cid,                                    // state_root
-            &'a Cid,                                    // message_receipts
-            &'a Cid,                                    // messages
-            &'a Signature,                              // bls_aggregate
-            &'a u64,                                    // timestamp
-            &'a Signature,                              // signature
-            &'a u64,                                    // fork_signal
-        );
-        TupleBlockHeader(
+        (
             &self.miner_address,
             &self.ticket,
             &self.epost_verify,
             &self.parents,
-            &self.weight,
+            BigUintSer(&self.weight),
             &self.epoch,
             &self.state_root,
             &self.message_receipts,
@@ -150,7 +137,7 @@ impl ser::Serialize for BlockHeader {
             &self.signature,
             &self.fork_signal,
         )
-        .serialize(serializer)
+            .serialize(serializer)
     }
 }
 
@@ -159,28 +146,12 @@ impl<'de> de::Deserialize<'de> for BlockHeader {
     where
         D: Deserializer<'de>,
     {
-        #[derive(Deserialize)]
-        struct TupleBlockHeader(
-            Address,
-            Ticket,
-            EPostProof,
-            TipSetKeys,
-            #[serde(with = "biguint_ser")] BigUint,
-            ChainEpoch,
-            Cid,
-            Cid,
-            Cid,
-            Signature,
-            u64,
-            Signature,
-            u64,
-        );
-        let TupleBlockHeader(
+        let (
             miner_address,
             ticket,
             epost_verify,
             parents,
-            weight,
+            BigUintDe(weight),
             epoch,
             state_root,
             message_receipts,

math/bigint/src/bigint_ser.rs

@@ -2,10 +2,33 @@
 // SPDX-License-Identifier: Apache-2.0, MIT
 
 use num_bigint::{BigInt, Sign};
-use serde::Serialize;
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
-/// Remote derive type for big int
+/// Wrapper for serializing big ints to match filecoin spec. Serializes as bytes.
+pub struct BigIntSer<'a>(pub &'a BigInt);
 
+/// Wrapper for deserializing as BigInt from bytes.
+pub struct BigIntDe(pub BigInt);
+
+impl Serialize for BigIntSer<'_> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serialize(self.0, serializer)
+    }
+}
+
+impl<'de> Deserialize<'de> for BigIntDe {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        Ok(BigIntDe(deserialize(deserializer)?))
+    }
+}
+
+/// Serializes big int as bytes following Filecoin spec.
 pub fn serialize<S>(int: &BigInt, serializer: S) -> Result<S::Ok, S::Error>
 where
     S: serde::Serializer,
@@ -24,6 +47,7 @@ where
     value.serialize(serializer)
 }
 
+/// Deserializes bytes into big int.
 pub fn deserialize<'de, D>(deserializer: D) -> Result<BigInt, D::Error>
 where
     D: serde::Deserializer<'de>,

math/bigint/src/biguint_ser.rs

@@ -2,7 +2,31 @@
 // SPDX-License-Identifier: Apache-2.0, MIT
 
 use num_bigint::BigUint;
-use serde::Serialize;
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+/// Wrapper for serializing big ints to match filecoin spec. Serializes as bytes.
+pub struct BigUintSer<'a>(pub &'a BigUint);
+
+/// Wrapper for deserializing as BigUint from bytes.
+pub struct BigUintDe(pub BigUint);
+
+impl Serialize for BigUintSer<'_> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serialize(self.0, serializer)
+    }
+}
+
+impl<'de> Deserialize<'de> for BigUintDe {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        Ok(BigUintDe(deserialize(deserializer)?))
+    }
+}
 
 pub fn serialize<S>(int: &BigUint, serializer: S) -> Result<S::Ok, S::Error>
 where

node/forest_libp2p/src/hello/message.rs

@@ -4,7 +4,10 @@
 use clock::ChainEpoch;
 use forest_cid::Cid;
 use forest_encoding::{de::Deserializer, ser::Serializer};
-use num_bigint::{bigint_ser, BigInt};
+use num_bigint::{
+    bigint_ser::{BigIntDe, BigIntSer},
+    BigInt,
+};
 use serde::{Deserialize, Serialize};
 
 /// Hello message https://filecoin-project.github.io/specs/#hello-spec
@@ -21,20 +24,13 @@ impl Serialize for HelloMessage {
     where
         S: Serializer,
     {
-        #[derive(Serialize)]
-        struct TupleHelloMessage<'a>(
-            &'a [Cid],
-            &'a ChainEpoch,
-            #[serde(with = "bigint_ser")] &'a BigInt,
-            &'a Cid,
-        );
-        TupleHelloMessage(
+        (
             &self.heaviest_tip_set,
             &self.heaviest_tipset_height,
-            &self.heaviest_tipset_weight,
+            BigIntSer(&self.heaviest_tipset_weight),
             &self.genesis_hash,
         )
-        .serialize(serializer)
+            .serialize(serializer)
     }
 }
 
@@ -43,19 +39,13 @@ impl<'de> Deserialize<'de> for HelloMessage {
     where
         D: Deserializer<'de>,
     {
-        #[derive(Deserialize)]
-        struct TupleHelloMessage(
-            Vec<Cid>,
-            ChainEpoch,
-            #[serde(with = "bigint_ser")] BigInt,
-            Cid,
-        );
-        let TupleHelloMessage(
+        let (
             heaviest_tip_set,
             heaviest_tipset_height,
-            heaviest_tipset_weight,
+            BigIntDe(heaviest_tipset_weight),
             genesis_hash,
         ) = Deserialize::deserialize(deserializer)?;
+
         Ok(HelloMessage {
             heaviest_tip_set,
             heaviest_tipset_height,

vm/message/src/unsigned_message.rs

@@ -5,8 +5,11 @@ use super::Message;
 use address::Address;
 use derive_builder::Builder;
 use encoding::{de, ser, Cbor};
-use num_bigint::{biguint_ser, BigUint};
-use serde::{Deserialize, Serialize};
+use num_bigint::{
+    biguint_ser::{BigUintDe, BigUintSer},
+    BigUint,
+};
+use serde::Deserialize;
 use vm::{MethodNum, Serialized, TokenAmount};
 
 /// Default Unsigned VM message type which includes all data needed for a state transition
@@ -64,46 +67,22 @@ impl UnsignedMessage {
     }
 }
 
-// Type declared outside of deserialize block because of clippy bug
-#[derive(Deserialize)]
-pub struct TupleUnsignedMessage(
-    Address,
-    Address,
-    u64,
-    TokenAmount,
-    #[serde(with = "biguint_ser")] BigUint,
-    u64,
-    MethodNum,
-    Serialized,
-);
-
 impl ser::Serialize for UnsignedMessage {
     fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
     where
         S: ser::Serializer,
     {
-        #[derive(Serialize)]
-        pub struct TupleUnsignedMessage<'a>(
-            &'a Address,
-            &'a Address,
-            &'a u64,
-            &'a TokenAmount,
-            #[serde(with = "biguint_ser")] &'a BigUint,
-            &'a u64,
-            &'a MethodNum,
-            &'a Serialized,
-        );
-        TupleUnsignedMessage(
+        (
             &self.to,
             &self.from,
             &self.sequence,
             &self.value,
-            &self.gas_price,
+            BigUintSer(&self.gas_price),
             &self.gas_limit,
             &self.method_num,
             &self.params,
         )
-        .serialize(s)
+            .serialize(s)
     }
 }
 
@@ -112,16 +91,8 @@ impl<'de> de::Deserialize<'de> for UnsignedMessage {
     where
         D: de::Deserializer<'de>,
     {
-        let TupleUnsignedMessage(
-            to,
-            from,
-            sequence,
-            value,
-            gas_price,
-            gas_limit,
-            method_num,
-            params,
-        ) = Deserialize::deserialize(deserializer)?;
+        let (to, from, sequence, value, BigUintDe(gas_price), gas_limit, method_num, params) =
+            Deserialize::deserialize(deserializer)?;
         Ok(Self {
             to,
             from,

vm/src/actor_state.rs

@@ -3,7 +3,10 @@
 
 use cid::Cid;
 use encoding::Cbor;
-use num_bigint::{biguint_ser, BigUint};
+use num_bigint::{
+    biguint_ser::{BigUintDe, BigUintSer},
+    BigUint,
+};
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use std::ops::AddAssign;
 
@@ -33,14 +36,12 @@ impl Serialize for ActorState {
     where
         S: Serializer,
     {
-        #[derive(Serialize)]
-        struct TupleActorState<'a>(
-            &'a Cid,
-            &'a Cid,
-            &'a u64,
-            #[serde(with = "biguint_ser")] &'a BigUint,
-        );
-        TupleActorState(&self.code, &self.state, &self.sequence, &self.balance)
+        (
+            &self.code,
+            &self.state,
+            &self.sequence,
+            BigUintSer(&self.balance),
+        )
             .serialize(serializer)
     }
 }
@@ -50,10 +51,7 @@ impl<'de> Deserialize<'de> for ActorState {
     where
         D: Deserializer<'de>,
     {
-        #[derive(Deserialize)]
-        struct TupleActorState(Cid, Cid, u64, #[serde(with = "biguint_ser")] BigUint);
-        let TupleActorState(code, state, sequence, balance) =
-            Deserialize::deserialize(deserializer)?;
+        let (code, state, sequence, BigUintDe(balance)) = Deserialize::deserialize(deserializer)?;
         Ok(ActorState {
             code,
             state,

vm/src/token.rs

@@ -1,17 +1,17 @@
 // Copyright 2020 ChainSafe Systems
 // SPDX-License-Identifier: Apache-2.0, MIT
 
-use encoding::{de, ser};
 use num_bigint::{biguint_ser, BigUint, ParseBigIntError};
 use num_traits::CheckedSub;
+use serde::{Deserialize, Serialize};
 use std::fmt;
 use std::ops::{Add, AddAssign, Sub};
 use std::str::FromStr;
 
 /// Wrapper around a big int variable to handle token specific functionality
 // TODO verify on finished spec whether or not big int or uint
-#[derive(Default, Clone, PartialEq, Debug, Eq, PartialOrd, Ord)]
-pub struct TokenAmount(pub BigUint);
+#[derive(Default, Clone, PartialEq, Debug, Eq, PartialOrd, Ord, Serialize, Deserialize)]
+pub struct TokenAmount(#[serde(with = "biguint_ser")] pub BigUint);
 
 impl TokenAmount {
     pub fn new(val: u64) -> Self {
@@ -53,24 +53,6 @@ impl fmt::Display for TokenAmount {
     }
 }
 
-impl ser::Serialize for TokenAmount {
-    fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
-    where
-        S: ser::Serializer,
-    {
-        biguint_ser::serialize(&self.0, s)
-    }
-}
-
-impl<'de> de::Deserialize<'de> for TokenAmount {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: de::Deserializer<'de>,
-    {
-        Ok(Self(biguint_ser::deserialize(deserializer)?))
-    }
-}
-
 impl FromStr for TokenAmount {
     type Err = ParseBigIntError;