signable.hpp

Go to the documentation of this file.

#ifndef IROHA_SIGNABLE_HPP
#define IROHA_SIGNABLE_HPP

#include "interfaces/base/model_primitive.hpp"

#include <boost/functional/hash.hpp>
#include <optional>
#include <unordered_set>
#include "cryptography/default_hash_provider.hpp"
#include "interfaces/common_objects/range_types.hpp"
#include "interfaces/common_objects/signature.hpp"
#include "interfaces/common_objects/string_view_types.hpp"
#include "interfaces/common_objects/types.hpp"
#include "utils/string_builder.hpp"

namespace shared_model {

  namespace interface {

    template <typename Model,
              typename HashProvider = shared_model::crypto::Sha3_256>
    class Signable : public ModelPrimitive<Model> {
     public:
      virtual types::SignatureRangeType signatures() const = 0;

      virtual bool addSignature(types::SignedHexStringView signed_blob,
                                types::PublicKeyHexStringView public_key) = 0;

      virtual types::TimestampType createdTime() const = 0;

      virtual const types::BlobType &payload() const = 0;

      virtual const types::BlobType &blob() const = 0;

      bool operator==(const Model &rhs) const override {
        return equalsByValue(rhs)
            // is_permutation consumes ~O(N^2)
            and std::is_permutation(signatures().begin(),
                                    signatures().end(),
                                    rhs.signatures().begin(),
                                    rhs.signatures().end());
      }

      bool equalsByValue(const Model &rhs) const {
        return this->hash() == rhs.hash();
      }

      virtual const types::HashType &hash() const = 0;

      // ------------------------| Primitive override |-------------------------

      std::string toString() const override {
        return detail::PrettyStringBuilder()
            .init("Signable")
            .appendNamed("created_time", std::to_string(createdTime()))
            .append(signatures())
            .finalize();
      }

     protected:
     protected:
      class SignatureSetTypeOps {
       public:
        template <typename T>
        size_t operator()(const T &sig) const {
          return std::hash<std::string>{}(sig.publicKey());
        }

        template <typename T>
        bool operator()(const T &lhs, const T &rhs) const {
          return lhs.publicKey() == rhs.publicKey();
        }
      };

      template <typename T>
      using SignatureSetType =
          std::unordered_set<T, SignatureSetTypeOps, SignatureSetTypeOps>;

     protected:
      static auto makeHash(const types::BlobType &payload) {
        return HashProvider::makeHash(payload);
      }
    };

  }  // namespace interface
}  // namespace shared_model

#endif  // IROHA_SIGNABLE_HPP