chore: address: Cleanup BLS address handling

Author: magik6k

shared/src/address/mod.rs

@@ -17,7 +17,7 @@ use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
 
 pub use self::errors::Error;
 pub use self::network::Network;
-pub use self::payload::{BLSPublicKey, Payload};
+pub use self::payload::Payload;
 pub use self::protocol::Protocol;
 use crate::encoding::{blake2b_variable, serde_bytes, Cbor};
 use crate::ActorID;
@@ -41,7 +41,7 @@ pub const BLS_PUB_LEN: usize = 48;
 pub const FIRST_NON_SINGLETON_ADDR: ActorID = 100;
 
 lazy_static::lazy_static! {
-    static ref BLS_ZERO_ADDR_BYTES: BLSPublicKey = {
+    static ref BLS_ZERO_ADDR_BYTES: [u8; BLS_PUB_LEN] = {
         let bz_addr = Address::from_str("f3yaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaby2smx7a");
         if let Ok(Address {payload: Payload::BLS(pubkey), ..}) = bz_addr {
             pubkey
@@ -127,7 +127,7 @@ impl Address {
         key.copy_from_slice(pubkey);
         Ok(Self {
             network: NETWORK_DEFAULT,
-            payload: Payload::BLS(key.into()),
+            payload: Payload::BLS(key),
         })
     }
 

shared/src/address/payload.rs

@@ -2,50 +2,11 @@
 // SPDX-License-Identifier: Apache-2.0, MIT
 
 use std::convert::TryInto;
-use std::hash::{Hash, Hasher};
-use std::ops::Deref;
-use std::{fmt, u64};
+use std::hash::Hash;
+use std::u64;
 
 use super::{from_leb_bytes, to_leb_bytes, Error, Protocol, BLS_PUB_LEN, PAYLOAD_HASH_LEN};
 
-/// Public key struct used as BLS Address data.
-/// This type is only needed to be able to implement traits on it due to limitations on
-/// arrays within Rust that are greater than 32 length. Can be dereferenced into `[u8; 48]`.
-#[derive(Copy, Clone)]
-pub struct BLSPublicKey(pub [u8; BLS_PUB_LEN]);
-
-impl Hash for BLSPublicKey {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        state.write(&self.0);
-    }
-}
-
-impl Eq for BLSPublicKey {}
-impl PartialEq for BLSPublicKey {
-    fn eq(&self, other: &Self) -> bool {
-        self.0[..].eq(&other.0[..])
-    }
-}
-
-impl fmt::Debug for BLSPublicKey {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        self.0[..].fmt(formatter)
-    }
-}
-
-impl From<[u8; BLS_PUB_LEN]> for BLSPublicKey {
-    fn from(pk: [u8; BLS_PUB_LEN]) -> Self {
-        BLSPublicKey(pk)
-    }
-}
-
-impl Deref for BLSPublicKey {
-    type Target = [u8; BLS_PUB_LEN];
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
 /// Payload is the data of the Address. Variants are the supported Address protocols.
 #[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
 pub enum Payload {
@@ -56,7 +17,7 @@ pub enum Payload {
     /// Actor protocol address, 20 byte hash of actor data
     Actor([u8; PAYLOAD_HASH_LEN]),
     /// BLS key address, full 48 byte public key
-    BLS(BLSPublicKey),
+    BLS([u8; BLS_PUB_LEN]),
 }
 
 impl Payload {
@@ -99,14 +60,11 @@ impl Payload {
                     .try_into()
                     .map_err(|_| Error::InvalidPayloadLength(payload.len()))?,
             ),
-            Protocol::BLS => {
-                if payload.len() != BLS_PUB_LEN {
-                    return Err(Error::InvalidBLSLength(payload.len()));
-                }
-                let mut pk = [0u8; BLS_PUB_LEN];
-                pk.copy_from_slice(payload);
-                Self::BLS(pk.into())
-            }
+            Protocol::BLS => Self::BLS(
+                payload
+                    .try_into()
+                    .map_err(|_| Error::InvalidPayloadLength(payload.len()))?,
+            ),
         };
         Ok(payload)
     }

shared/tests/address_test.rs

@@ -392,11 +392,11 @@ fn invalid_byte_addresses() {
         // BLS Protocol
         StringAddrVec {
             input: bls_l,
-            expected: Error::InvalidBLSLength(49),
+            expected: Error::InvalidPayloadLength(49),
         },
         StringAddrVec {
             input: bls_s,
-            expected: Error::InvalidBLSLength(47),
+            expected: Error::InvalidPayloadLength(47),
         },
     ];