Serialization vectors (#152)

Signed-off-by: turuslan <turuslan.devbox@gmail.com>

Author: turuslan

.gitmodules

@@ -4,3 +4,6 @@
 [submodule "deps/filecoin-ffi"]
 	path = deps/filecoin-ffi
 	url = https://github.com/filecoin-project/filecoin-ffi.git
+[submodule "test/core/serialization/serialization_vectors"]
+	path = test/core/serialization/serialization_vectors
+	url = https://github.com/filecoin-project/serialization-vectors.git

core/api/CMakeLists.txt

@@ -10,6 +10,7 @@ target_link_libraries(api
     address
     chain_store
     cid
+    message
     )
 
 add_library(rpc

core/api/rpc/json.hpp

@@ -11,6 +11,7 @@
 
 #include "api/api.hpp"
 #include "api/rpc/json_errors.hpp"
+#include "common/enum.hpp"
 #include "primitives/address/address_codec.hpp"
 
 #define COMMA ,
@@ -26,6 +27,7 @@ namespace fc::api {
   using crypto::signature::Signature;
   using primitives::BigInt;
   using primitives::block::BlockHeader;
+  using primitives::sector::PoStProof;
   using primitives::ticket::EPostProof;
   using primitives::ticket::EPostTicket;
   using primitives::ticket::Ticket;
@@ -35,6 +37,8 @@ namespace fc::api {
   using vm::actor::builtin::payment_channel::Merge;
   using vm::actor::builtin::payment_channel::ModularVerificationParameter;
   using base64 = cppcodec::base64_rfc4648;
+  using SignatureType = crypto::signature::Type;
+  using primitives::sector::RegisteredProof;
 
   struct Request {
     uint64_t id;
@@ -82,7 +86,10 @@ namespace fc::api {
       Set(j, key, encode(v));
     }
 
-    static auto decodeBase64(const Value &j) {
+    static std::vector<uint8_t> decodeBase64(const Value &j) {
+      if (j.IsNull()) {
+        return {};
+      }
       return base64::decode(AsString(j));
     }
 
@@ -229,16 +236,16 @@ namespace fc::api {
     }
 
     ENCODE(Signature) {
-      const char *type;
+      uint64_t type;
       gsl::span<const uint8_t> data;
       visit_in_place(
           v,
           [&](const BlsSignature &bls) {
-            type = "bls";
+            type = SignatureType::BLS;
             data = gsl::make_span(bls);
           },
           [&](const Secp256k1Signature &secp) {
-            type = "secp256k1";
+            type = SignatureType::SECP256K1;
             data = gsl::make_span(secp);
           });
       Value j{rapidjson::kObjectType};
@@ -248,11 +255,12 @@ namespace fc::api {
     }
 
     DECODE(Signature) {
-      auto type = AsString(Get(j, "Type"));
+      uint64_t type;
+      decode(type, Get(j, "Type"));
       auto &data = Get(j, "Data");
-      if (type == "bls") {
+      if (type == SignatureType::BLS) {
         v = decode<BlsSignature>(data);
-      } else if (type == "secp256k1") {
+      } else if (type == SignatureType::SECP256K1) {
         v = decode<Secp256k1Signature>(data);
       } else {
         outcome::raise(JsonError::WRONG_ENUM);
@@ -273,16 +281,30 @@ namespace fc::api {
       decode(v.challenge_index, Get(j, "ChallengeIndex"));
     }
 
+    ENCODE(PoStProof) {
+      Value j{rapidjson::kObjectType};
+      Set(j, "RegisteredProof", common::to_int(v.registered_proof));
+      Set(j, "ProofBytes", gsl::make_span(v.proof));
+      return j;
+    }
+
+    DECODE(PoStProof) {
+      std::underlying_type_t<RegisteredProof> registered_proof;
+      decode(registered_proof, Get(j, "RegisteredProof"));
+      v.registered_proof = RegisteredProof{registered_proof};
+      decode(v.proof, Get(j, "ProofBytes"));
+    }
+
     ENCODE(EPostProof) {
       Value j{rapidjson::kObjectType};
-      Set(j, "Proof", gsl::make_span(v.proof));
+      Set(j, "Proofs", v.proofs);
       Set(j, "PostRand", gsl::make_span(v.post_rand));
       Set(j, "Candidates", v.candidates);
       return j;
     }
 
     DECODE(EPostProof) {
-      decode(v.proof, Get(j, "Proof"));
+      decode(v.proofs, Get(j, "Proofs"));
       decode(v.post_rand, Get(j, "PostRand"));
       decode(v.candidates, Get(j, "Candidates"));
     }

core/primitives/sector/sector.hpp

@@ -89,6 +89,11 @@ namespace fc::primitives::sector {
     Proof proof;
   };
 
+  inline bool operator==(const PoStProof &lhs, const PoStProof &rhs) {
+    return lhs.registered_proof == rhs.registered_proof
+           && lhs.proof == rhs.proof;
+  }
+
   struct PrivatePoStCandidateProof {
     RegisteredProof registered_proof;
     Buffer externalized;

core/primitives/ticket/epost_ticket.cpp

@@ -12,7 +12,7 @@ namespace fc::primitives::ticket {
   }
 
   bool operator==(const EPostProof &lhs, const EPostProof &rhs) {
-    return lhs.proof == rhs.proof && lhs.post_rand == rhs.post_rand
+    return lhs.proofs == rhs.proofs && lhs.post_rand == rhs.post_rand
            && lhs.candidates == rhs.candidates;
   }
 }  // namespace fc::primitives::ticket

core/primitives/ticket/epost_ticket.hpp

@@ -9,6 +9,7 @@
 #include "common/blob.hpp"
 #include "common/buffer.hpp"
 #include "crypto/vrf/vrf_types.hpp"
+#include "primitives/sector/sector.hpp"
 
 namespace fc::primitives::ticket {
   /**
@@ -27,8 +28,8 @@ namespace fc::primitives::ticket {
    * @struct EPostProof proof of space/time
    */
   struct EPostProof {
-    common::Buffer proof;      ///< number of bytes is not known beforehand
-    PostRandomness post_rand;  ///< randomness
+    std::vector<sector::PoStProof> proofs;
+    PostRandomness post_rand;             ///< randomness
     std::vector<EPostTicket> candidates;  ///< candidates
   };
 

core/primitives/ticket/epost_ticket_codec.hpp

@@ -42,7 +42,7 @@ namespace fc::primitives::ticket {
     return s;
   }
 
-  CBOR_ENCODE_TUPLE(EPostProof, proof, post_rand, candidates)
+  CBOR_ENCODE_TUPLE(EPostProof, proofs, post_rand, candidates)
 
   /**
    * @brief cbor-decodes EPostProof instance
@@ -52,10 +52,8 @@ namespace fc::primitives::ticket {
    * @return stream reference
    */
   CBOR_DECODE(EPostProof, epp) {
-    std::vector<uint8_t> proof;
     std::vector<uint8_t> rand;
-    s.list() >> proof >> rand >> epp.candidates;
-    epp.proof = common::Buffer(std::move(proof));
+    s.list() >> epp.proofs >> rand >> epp.candidates;
     if (rand.size() != epp.post_rand.size()) {
       outcome::raise(EPoSTTicketCodecError::INVALID_POST_RAND_LENGTH);
     }

core/primitives/types.hpp

@@ -27,6 +27,8 @@ namespace fc::primitives {
 
   using DealId = uint64_t;
 
+  using GasAmount = int64_t;
+
   struct SectorStorageWeightDesc {
     SectorSize sector_size;
     EpochDuration duration;

core/vm/message/message.hpp

@@ -15,6 +15,7 @@
 #include "primitives/address/address.hpp"
 #include "primitives/address/address_codec.hpp"
 #include "primitives/big_int.hpp"
+#include "primitives/types.hpp"
 #include "vm/actor/actor.hpp"
 
 namespace fc::vm::message {
@@ -32,6 +33,7 @@ namespace fc::vm::message {
   using actor::MethodParams;
   using crypto::signature::Signature;
   using primitives::BigInt;
+  using primitives::GasAmount;
   using primitives::address::Address;
 
   /**
@@ -45,7 +47,7 @@ namespace fc::vm::message {
                     uint64_t nonce,
                     BigInt value,
                     BigInt gasPrice,
-                    BigInt gasLimit,
+                    GasAmount gasLimit,
                     MethodNumber method,
                     MethodParams params)
         : to{std::move(to)},
@@ -65,7 +67,7 @@ namespace fc::vm::message {
     BigInt value{};
 
     BigInt gasPrice{};
-    BigInt gasLimit{};
+    GasAmount gasLimit{};
 
     MethodNumber method{};
     MethodParams params{};

core/vm/runtime/env.hpp

@@ -7,6 +7,7 @@
 #define FILECOIN_CORE_VM_RUNTIME_ENV_HPP
 
 #include "crypto/randomness/randomness_provider.hpp"
+#include "primitives/types.hpp"
 #include "vm/actor/invoker.hpp"
 #include "vm/indices/indices.hpp"
 #include "vm/state/state_tree.hpp"
@@ -35,7 +36,7 @@ namespace fc::vm::runtime {
     outcome::result<MessageReceipt> applyMessage(
         const UnsignedMessage &message);
 
-    outcome::result<InvocationOutput> send(BigInt &gas_used,
+    outcome::result<InvocationOutput> send(GasAmount &gas_used,
                                            const Address &origin,
                                            const UnsignedMessage &message);