(**************************************************************************) (* *) (* Copyright (c) 2014 - 2017. *) (* Dynamic Ledger Solutions, Inc. *) (* *) (* All rights reserved. No warranty, explicit or implicit, provided. *) (* *) (**************************************************************************) (** Generic interface for a datatype with comparison, pretty-printer and serialization functions. *) module type T = sig type t val compare: t -> t -> int val equal: t -> t -> bool val (=): t -> t -> bool val (<>): t -> t -> bool val (<): t -> t -> bool val (<=): t -> t -> bool val (>=): t -> t -> bool val (>): t -> t -> bool val min: t -> t -> t val max: t -> t -> t val pp: Format.formatter -> t -> unit val encoding: t Data_encoding.t val to_bytes: t -> MBytes.t val of_bytes: MBytes.t -> t option end (** Generic interface for a datatype with comparison, pretty-printer, serialization functions and a hashing function. *) module type HASHABLE = sig include T type hash val hash: t -> hash val hash_raw: MBytes.t -> hash end (** {2 Hash Types} ************************************************************) (** The signature of an abstract hash type, as produced by functor {!Make_SHA256}. The {!t} type is abstracted for separating the various kinds of hashes in the system at typing time. Each type is equipped with functions to use it as is of as keys in the database or in memory sets and maps. *) module type MINIMAL_HASH = sig type t val name: string val title: string val hash_bytes: MBytes.t list -> t val hash_string: string list -> t val size: int (* in bytes *) val compare: t -> t -> int val equal: t -> t -> bool val to_hex: t -> string val of_hex: string -> t option val of_hex_exn: string -> t val to_string: t -> string val of_string: string -> t option val of_string_exn: string -> t val to_bytes: t -> MBytes.t val of_bytes: MBytes.t -> t option val of_bytes_exn: MBytes.t -> t val read: MBytes.t -> int -> t val write: MBytes.t -> int -> t -> unit val to_path: t -> string list -> string list val of_path: string list -> t option val of_path_exn: string list -> t val prefix_path: string -> string list val path_length: int end module type HASH = sig include MINIMAL_HASH val of_b58check_exn: string -> t val of_b58check_opt: string -> t option val to_b58check: t -> string val to_short_b58check: t -> string val encoding: t Data_encoding.t val pp: Format.formatter -> t -> unit val pp_short: Format.formatter -> t -> unit type Base58.data += Hash of t val b58check_encoding: t Base58.encoding val rpc_arg: t RPC_arg.t module Set : sig include Set.S with type elt = t val encoding: t Data_encoding.t end module Map : sig include Map.S with type key = t val encoding: 'a Data_encoding.t -> 'a t Data_encoding.t end end module type MERKLE_TREE = sig type elt include HASH val compute: elt list -> t val empty: t type path = | Left of path * t | Right of t * path | Op val compute_path: elt list -> int -> path val check_path: path -> elt -> t * int val path_encoding: path Data_encoding.t end