Refactor address_codec to render Address serialization consistent with Lotus (#55)

* Refactor address_codec to render Address serialization consistent with Lotus (#55)

Signed-off-by: Eugene Kovalev <[email protected]>

Author: ekovalev

core/primitives/address/CMakeLists.txt

@@ -12,6 +12,7 @@ target_link_libraries(address
     blake2
     blob
     bls_provider
+    cbor
     outcome
     p2p::p2p_secp256k1_provider
     )

core/primitives/address/address_codec.cpp

@@ -23,9 +23,8 @@ namespace fc::primitives::address {
   using base32 = cppcodec::base32_rfc4648;
   using UVarint = libp2p::multi::UVarint;
 
-  std::vector<uint8_t> encode(const Address &address) {
+  std::vector<uint8_t> encode(const Address &address) noexcept {
     std::vector<uint8_t> res{};
-    res.push_back(address.network);
     res.push_back(address.getProtocol());
     std::vector<uint8_t> payload = visit_in_place(
         address.data,
@@ -38,16 +37,13 @@ namespace fc::primitives::address {
   }
 
   outcome::result<Address> decode(const std::vector<uint8_t> &v) {
-    if (v.size() < 3) return outcome::failure(AddressError::INVALID_PAYLOAD);
-    auto pos = v.begin();
+    if (v.size() < 2) return outcome::failure(AddressError::INVALID_PAYLOAD);
 
-    auto net = static_cast<Network>(*(pos++));
-    if (!(net == Network::TESTNET || net == Network::MAINNET)) {
-      return outcome::failure(AddressError::UNKNOWN_NETWORK);
-    }
+    // TODO(ekovalev): [FIL-118] make network configurable; hardcoded for now
+    Network net{Network::TESTNET};
 
-    auto p = static_cast<Protocol>(*(pos++));
-    std::vector<uint8_t> payload(pos, v.end());
+    auto p = static_cast<Protocol>(v[0]);
+    std::vector<uint8_t> payload(std::next(v.begin()), v.end());
     switch (p) {
       case Protocol::ID: {
         boost::optional<UVarint> value = UVarint::create(payload);
@@ -94,8 +90,7 @@ namespace fc::primitives::address {
   std::string encodeToString(const Address &address) {
     std::string res{};
 
-    char networkPrefix = 'f';
-    if (address.network == Network::TESTNET) networkPrefix = 't';
+    char networkPrefix = address.network == Network::TESTNET ? 't' : 'f';
     res.push_back(networkPrefix);
 
     Protocol p = address.getProtocol();
@@ -137,17 +132,11 @@ namespace fc::primitives::address {
   outcome::result<Address> decodeFromString(const std::string &s) {
     if (s.size() < 3) return outcome::failure(AddressError::INVALID_PAYLOAD);
 
-    std::vector<uint8_t> buffer{};
-    Network net{Network::MAINNET};
-
     if (s[0] != 'f' && s[0] != 't')
       return outcome::failure(AddressError::UNKNOWN_NETWORK);
-    if (s[0] == 'f')
-      buffer.push_back(static_cast<uint8_t>(Network::MAINNET));
-    else {
-      buffer.push_back(static_cast<uint8_t>(Network::TESTNET));
-      net = Network::TESTNET;
-    }
+
+    std::vector<uint8_t> buffer{};
+    Network net = s[0] == 't' ? Network::TESTNET : Network::MAINNET;
 
     int protocol = int(s[1]) - int('0');
     if (protocol < Protocol::ID || protocol > Protocol::BLS)
@@ -190,7 +179,9 @@ namespace fc::primitives::address {
                   std::make_move_iterator(payload.begin()),
                   std::make_move_iterator(payload.end()) - 4);
 
-    return decode(buffer);
+    OUTCOME_TRY(address, decode(buffer));
+    address.network = net;
+    return address;
   }
 
   std::vector<uint8_t> checksum(const Address &address) {
@@ -208,13 +199,12 @@ namespace fc::primitives::address {
 
     ingest.push_back(p);
 
-    ingest = visit_in_place(
-        address.data,
-        [&ingest](uint64_t v) { return ingest; },
-        [&ingest](const auto &v) {
-          ingest.insert(ingest.end(), v.begin(), v.end());
-          return ingest;
-        });
+    ingest = visit_in_place(address.data,
+                            [&ingest](uint64_t v) { return ingest; },
+                            [&ingest](const auto &v) {
+                              ingest.insert(ingest.end(), v.begin(), v.end());
+                              return ingest;
+                            });
 
     size_t outlen = 4;
     blake2b(res.data(), outlen, nullptr, 0, ingest.data(), ingest.size());
@@ -227,4 +217,4 @@ namespace fc::primitives::address {
     return digest == expect;
   }
 
-};  // namespace fc::primitives
+};  // namespace fc::primitives::address

core/primitives/address/address_codec.hpp

@@ -9,15 +9,17 @@
 #include <string>
 #include <vector>
 
-#include "common/outcome.hpp"
 #include "address.hpp"
+#include "codec/cbor/cbor.hpp"
+#include "common/outcome.hpp"
+#include "common/outcome_throw.hpp"
 
 namespace fc::primitives::address {
 
   /**
    * @brief Encodes an Address to an array of bytes
    */
-  std::vector<uint8_t> encode(const Address &address);
+  std::vector<uint8_t> encode(const Address &address) noexcept;
 
   /**
    * @brief Decodes an Address from an array of bytes
@@ -34,6 +36,27 @@ namespace fc::primitives::address {
    */
   outcome::result<Address> decodeFromString(const std::string &s);
 
+  template <class Stream,
+            typename = std::enable_if_t<
+                std::remove_reference<Stream>::type::is_cbor_encoder_stream>>
+  Stream &operator<<(Stream &&s, const Address &address) noexcept {
+    return s << encode(address);
+  }
+
+  template <class Stream,
+            typename = std::enable_if_t<
+                std::remove_reference<Stream>::type::is_cbor_decoder_stream>>
+  Stream &operator>>(Stream &&s, Address &address) {
+    std::vector<uint8_t> data{};
+    s >> data;
+    auto res = decode(data);
+    if (res.has_error()) {
+      outcome::raise(AddressError::INVALID_PAYLOAD);
+    }
+    address = std::move(res.value());
+    return s;
+  }
+
   /**
    * @brief A helper function that calculates a checksum of an Address protocol
    * + payload
@@ -46,6 +69,6 @@ namespace fc::primitives::address {
   bool validateChecksum(const Address &address,
                         const std::vector<uint8_t> &expect);
 
-};  // namespace fc::primitives
+};  // namespace fc::primitives::address
 
 #endif  // CPP_FILECOIN_CORE_PRIMITIVES_ADDRESS_CODEC_HPP

core/primitives/address/impl/address_builder_impl.cpp

@@ -14,23 +14,21 @@ namespace fc::primitives::address {
   using Sec256k1PublicKey = libp2p::crypto::secp256k1::PublicKey;
   using BlsPublicKey = crypto::bls::PublicKey;
   using crypto::blake2b::blake2b_160;
-  using primitives::address::decode;
-  using primitives::address::encode;
+  using primitives::address::BLSPublicKeyHash;
   using primitives::address::Protocol;
+  using primitives::address::Secp256k1PublicKeyHash;
 
   outcome::result<Address> AddressBuilderImpl::makeFromSecp256k1PublicKey(
       Network network, const Sec256k1PublicKey &public_key) noexcept {
     OUTCOME_TRY(hash, blake2b_160(public_key));
-    std::vector<uint8_t> sec256k1_bytes{network, Protocol::SECP256K1};
-    sec256k1_bytes.insert(sec256k1_bytes.end(), hash.begin(), hash.end());
-    return decode(sec256k1_bytes);
+    Secp256k1PublicKeyHash secp256k1Hash{hash};
+    return Address{network, secp256k1Hash};
   }
 
   outcome::result<Address> AddressBuilderImpl::makeFromBlsPublicKey(
       Network network, const BlsPublicKey &public_key) noexcept {
-    std::vector<uint8_t> bls_bytes{network, Protocol::BLS};
-    bls_bytes.insert(bls_bytes.end(), public_key.begin(), public_key.end());
-    return decode(bls_bytes);
+    BLSPublicKeyHash blsHash{public_key};
+    return Address{network, blsHash};
   }
 
 }  // namespace fc::primitives::address