block_header_repr.ml
(*****************************************************************************)
(* *)
(* Open Source License *)
(* Copyright (c) 2018 Dynamic Ledger Solutions, Inc. <contact@tezos.com> *)
(* *)
(* Permission is hereby granted, free of charge, to any person obtaining a *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *)
(* and/or sell copies of the Software, and to permit persons to whom the *)
(* Software is furnished to do so, subject to the following conditions: *)
(* *)
(* The above copyright notice and this permission notice shall be included *)
(* in all copies or substantial portions of the Software. *)
(* *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *)
(* DEALINGS IN THE SOFTWARE. *)
(* *)
(*****************************************************************************)
(** Block header *)
type contents = {
payload_hash : Block_payload_hash.t;
payload_round : Round_repr.t;
seed_nonce_hash : Nonce_hash.t option;
proof_of_work_nonce : bytes;
liquidity_baking_escape_vote : bool;
}
type protocol_data = {contents : contents; signature : Signature.t}
type t = {shell : Block_header.shell_header; protocol_data : protocol_data}
type block_header = t
type raw = Block_header.t
type shell_header = Block_header.shell_header
let raw_encoding = Block_header.encoding
let shell_header_encoding = Block_header.shell_header_encoding
type block_watermark = Block_header of Chain_id.t
let bytes_of_block_watermark = function
| Block_header chain_id ->
Bytes.cat (Bytes.of_string "\x11") (Chain_id.to_bytes chain_id)
let to_watermark b = Signature.Custom (bytes_of_block_watermark b)
let of_watermark = function
| Signature.Custom b ->
if Compare.Int.(Bytes.length b > 0) then
match Bytes.get b 0 with
| '\x11' ->
Option.map
(fun chain_id -> Block_header chain_id)
(Chain_id.of_bytes_opt (Bytes.sub b 1 (Bytes.length b - 1)))
| _ -> None
else None
| _ -> None
let contents_encoding =
let open Data_encoding in
def "block_header.alpha.unsigned_contents"
@@ conv
(fun {
payload_hash;
payload_round;
seed_nonce_hash;
proof_of_work_nonce;
liquidity_baking_escape_vote;
} ->
( payload_hash,
payload_round,
proof_of_work_nonce,
seed_nonce_hash,
liquidity_baking_escape_vote ))
(fun ( payload_hash,
payload_round,
proof_of_work_nonce,
seed_nonce_hash,
liquidity_baking_escape_vote ) ->
{
payload_hash;
payload_round;
seed_nonce_hash;
proof_of_work_nonce;
liquidity_baking_escape_vote;
})
(obj5
(req "payload_hash" Block_payload_hash.encoding)
(req "payload_round" Round_repr.encoding)
(req
"proof_of_work_nonce"
(Fixed.bytes Constants_repr.proof_of_work_nonce_size))
(opt "seed_nonce_hash" Nonce_hash.encoding)
(req "liquidity_baking_escape_vote" Data_encoding.bool))
let protocol_data_encoding =
let open Data_encoding in
def "block_header.alpha.signed_contents"
@@ conv
(fun {contents; signature} -> (contents, signature))
(fun (contents, signature) -> {contents; signature})
(merge_objs
contents_encoding
(obj1 (req "signature" Signature.encoding)))
let raw {shell; protocol_data} =
let protocol_data =
Data_encoding.Binary.to_bytes_exn protocol_data_encoding protocol_data
in
{Block_header.shell; protocol_data}
let unsigned_encoding =
let open Data_encoding in
merge_objs Block_header.shell_header_encoding contents_encoding
let encoding =
let open Data_encoding in
def "block_header.alpha.full_header"
@@ conv
(fun {shell; protocol_data} -> (shell, protocol_data))
(fun (shell, protocol_data) -> {shell; protocol_data})
(merge_objs Block_header.shell_header_encoding protocol_data_encoding)
(** Constants *)
let max_header_length =
let fake_level = Raw_level_repr.root in
let fake_round = Round_repr.zero in
let fake_fitness =
Fitness_repr.create_without_locked_round
~level:fake_level
~predecessor_round:fake_round
~round:fake_round
in
let fake_shell =
{
Block_header.level = 0l;
proto_level = 0;
predecessor = Block_hash.zero;
timestamp = Time.of_seconds 0L;
validation_passes = 0;
operations_hash = Operation_list_list_hash.zero;
fitness = Fitness_repr.to_raw fake_fitness;
context = Context_hash.zero;
}
and fake_contents =
{
payload_hash = Block_payload_hash.zero;
payload_round = Round_repr.zero;
proof_of_work_nonce =
Bytes.make Constants_repr.proof_of_work_nonce_size '0';
seed_nonce_hash = Some Nonce_hash.zero;
liquidity_baking_escape_vote = false;
}
in
Data_encoding.Binary.length
encoding
{
shell = fake_shell;
protocol_data = {contents = fake_contents; signature = Signature.zero};
}
(** Header parsing entry point *)
let hash_raw = Block_header.hash
let hash {shell; protocol_data} =
Block_header.hash
{
shell;
protocol_data =
Data_encoding.Binary.to_bytes_exn protocol_data_encoding protocol_data;
}
type locked_round_evidence = {
preendorsement_round : Round_repr.t;
preendorsement_count : int;
}
type error +=
| (* Permanent *)
Invalid_block_signature of
Block_hash.t * Signature.Public_key_hash.t
| (* Permanent *) Invalid_stamp
| (* Permanent *)
Invalid_payload_hash of {
expected : Block_payload_hash.t;
provided : Block_payload_hash.t;
}
| (* Permanent *)
Locked_round_after_block_round of {
locked_round : Round_repr.t;
round : Round_repr.t;
}
| (* Permanent *)
Invalid_payload_round of {
payload_round : Round_repr.t;
round : Round_repr.t;
}
| (* Permanent *)
Insufficient_locked_round_evidence of {
voting_power : int;
consensus_threshold : int;
}
| (* Permanent *) Invalid_commitment of {expected : bool}
| (* Permanent *) Wrong_timestamp of Time.t * Time.t
let () =
register_error_kind
`Permanent
~id:"block_header.invalid_block_signature"
~title:"Invalid block signature"
~description:"A block was not signed with the expected private key."
~pp:(fun ppf (block, pkh) ->
Format.fprintf
ppf
"Invalid signature for block %a. Expected: %a."
Block_hash.pp_short
block
Signature.Public_key_hash.pp_short
pkh)
Data_encoding.(
obj2
(req "block" Block_hash.encoding)
(req "expected" Signature.Public_key_hash.encoding))
(function
| Invalid_block_signature (block, pkh) -> Some (block, pkh) | _ -> None)
(fun (block, pkh) -> Invalid_block_signature (block, pkh)) ;
register_error_kind
`Permanent
~id:"block_header.invalid_stamp"
~title:"Insufficient block proof-of-work stamp"
~description:"The block's proof-of-work stamp is insufficient"
~pp:(fun ppf () -> Format.fprintf ppf "Insufficient proof-of-work stamp")
Data_encoding.empty
(function Invalid_stamp -> Some () | _ -> None)
(fun () -> Invalid_stamp) ;
register_error_kind
`Permanent
~id:"block_header.invalid_payload_hash"
~title:"Invalid payload hash"
~description:"Invalid payload hash."
~pp:(fun ppf (expected, provided) ->
Format.fprintf
ppf
"Invalid payload hash (expected: %a, provided: %a)."
Block_payload_hash.pp_short
expected
Block_payload_hash.pp_short
provided)
Data_encoding.(
obj2
(req "expected" Block_payload_hash.encoding)
(req "provided" Block_payload_hash.encoding))
(function
| Invalid_payload_hash {expected; provided} -> Some (expected, provided)
| _ -> None)
(fun (expected, provided) -> Invalid_payload_hash {expected; provided}) ;
() ;
register_error_kind
`Permanent
~id:"block_header.locked_round_after_block_round"
~title:"Locked round after block round"
~description:"Locked round after block round."
~pp:(fun ppf (locked_round, round) ->
Format.fprintf
ppf
"Locked round (%a) is after the block round (%a)."
Round_repr.pp
locked_round
Round_repr.pp
round)
Data_encoding.(
obj2
(req "locked_round" Round_repr.encoding)
(req "round" Round_repr.encoding))
(function
| Locked_round_after_block_round {locked_round; round} ->
Some (locked_round, round)
| _ -> None)
(fun (locked_round, round) ->
Locked_round_after_block_round {locked_round; round}) ;
() ;
register_error_kind
`Permanent
~id:"block_header.invalid_payload_round"
~title:"Invalid payload round"
~description:"The given payload round is invalid."
~pp:(fun ppf (payload_round, round) ->
Format.fprintf
ppf
"The provided payload round (%a) is after the block round (%a)."
Round_repr.pp
payload_round
Round_repr.pp
round)
Data_encoding.(
obj2
(req "payload_round" Round_repr.encoding)
(req "round" Round_repr.encoding))
(function
| Invalid_payload_round {payload_round; round} ->
Some (payload_round, round)
| _ -> None)
(fun (payload_round, round) -> Invalid_payload_round {payload_round; round}) ;
register_error_kind
`Permanent
~id:"block_header.insufficient_locked_round_evidence"
~title:"Insufficient locked round evidence"
~description:"Insufficient locked round evidence."
~pp:(fun ppf (voting_power, consensus_threshold) ->
Format.fprintf
ppf
"The provided locked round evidence is not sufficient: provided %d \
voting power but was expecting at least %d."
voting_power
consensus_threshold)
Data_encoding.(
obj2 (req "voting_power" int31) (req "consensus_threshold" int31))
(function
| Insufficient_locked_round_evidence {voting_power; consensus_threshold}
->
Some (voting_power, consensus_threshold)
| _ -> None)
(fun (voting_power, consensus_threshold) ->
Insufficient_locked_round_evidence {voting_power; consensus_threshold}) ;
register_error_kind
`Permanent
~id:"block_header.invalid_commitment"
~title:"Invalid commitment in block header"
~description:"The block header has invalid commitment."
~pp:(fun ppf expected ->
if expected then
Format.fprintf ppf "Missing seed's nonce commitment in block header."
else
Format.fprintf ppf "Unexpected seed's nonce commitment in block header.")
Data_encoding.(obj1 (req "expected" bool))
(function Invalid_commitment {expected} -> Some expected | _ -> None)
(fun expected -> Invalid_commitment {expected}) ;
register_error_kind
`Permanent
~id:"block_header.wrong_timestamp"
~title:"Wrong timestamp"
~description:"Block timestamp not the expected one."
~pp:(fun ppf (block_ts, expected_ts) ->
Format.fprintf
ppf
"Wrong timestamp: block timestamp (%a) not the expected one (%a)"
Time.pp_hum
block_ts
Time.pp_hum
expected_ts)
Data_encoding.(
obj2
(req "block_timestamp" Time.encoding)
(req "expected_timestamp" Time.encoding))
(function Wrong_timestamp (t1, t2) -> Some (t1, t2) | _ -> None)
(fun (t1, t2) -> Wrong_timestamp (t1, t2))
let check_signature (block : t) (chain_id : Chain_id.t)
(key : Signature.Public_key.t) =
let check_signature key ({shell; protocol_data = {contents; signature}} : t) =
let unsigned_header =
Data_encoding.Binary.to_bytes_exn unsigned_encoding (shell, contents)
in
Signature.check
~watermark:(to_watermark (Block_header chain_id))
key
signature
unsigned_header
in
if check_signature key block then ok ()
else
error (Invalid_block_signature (hash block, Signature.Public_key.hash key))
let check_payload_round ~round ~payload_round =
error_when
Round_repr.(payload_round > round)
(Invalid_payload_round {payload_round; round})
let check_timestamp round_durations ~timestamp ~round ~predecessor_timestamp
~predecessor_round =
Round_repr.timestamp_of_round
round_durations
~predecessor_timestamp
~predecessor_round
~round
>>? fun expected_timestamp ->
if Time_repr.(expected_timestamp = timestamp) then Error_monad.ok ()
else error (Wrong_timestamp (timestamp, expected_timestamp))
module Proof_of_work = struct
let check_hash hash stamp_threshold =
let bytes = Block_hash.to_bytes hash in
let word = TzEndian.get_int64 bytes 0 in
Compare.Uint64.(word <= stamp_threshold)
let check_header_proof_of_work_stamp shell contents stamp_threshold =
let hash =
hash {shell; protocol_data = {contents; signature = Signature.zero}}
in
check_hash hash stamp_threshold
let check_proof_of_work_stamp ~proof_of_work_threshold block =
if
check_header_proof_of_work_stamp
block.shell
block.protocol_data.contents
proof_of_work_threshold
then ok ()
else error Invalid_stamp
end
let begin_validate_block_header ~(block_header : t) ~(chain_id : Chain_id.t)
~(predecessor_timestamp : Time.t) ~(predecessor_round : Round_repr.t)
~(fitness : Fitness_repr.t) ~(timestamp : Time.t)
~(delegate_pk : Signature.Public_key.t)
~(round_durations : Round_repr.Durations.t)
~(proof_of_work_threshold : int64) ~(expected_commitment : bool) =
(* Level relationship between current node and the predecessor is
done by the shell. We know that level is predecessor level + 1.
The predecessor block hash is guaranteed by the shell to be the
one in the shell header. The operations are guaranteed to
correspond to the shell_header.operations_hash by the shell *)
let {payload_round; seed_nonce_hash; _} =
block_header.protocol_data.contents
in
let raw_level = block_header.shell.level in
Proof_of_work.check_proof_of_work_stamp ~proof_of_work_threshold block_header
>>? fun () ->
Raw_level_repr.of_int32 raw_level >>? fun level ->
check_signature block_header chain_id delegate_pk >>? fun () ->
let round = Fitness_repr.round fitness in
check_payload_round ~round ~payload_round >>? fun () ->
check_timestamp
round_durations
~predecessor_timestamp
~predecessor_round
~timestamp
~round
>>? fun () ->
Fitness_repr.check_except_locked_round fitness ~level ~predecessor_round
>>? fun () ->
let has_commitment =
match seed_nonce_hash with None -> false | Some _ -> true
in
error_unless
Compare.Bool.(has_commitment = expected_commitment)
(Invalid_commitment {expected = expected_commitment})
type checkable_payload_hash =
| No_check
| Expected_payload_hash of Block_payload_hash.t
let finalize_validate_block_header ~(block_header_contents : contents)
~(round : Round_repr.t)
~(* We have to check the round because in the construction case it was
deduced from the time *)
(fitness : Fitness_repr.t)
~(checkable_payload_hash : checkable_payload_hash)
~(locked_round_evidence : locked_round_evidence option)
~(consensus_threshold : int) =
let {
payload_hash = actual_payload_hash;
seed_nonce_hash = _;
proof_of_work_nonce = _;
_;
} =
block_header_contents
in
(match checkable_payload_hash with
| No_check -> Result.return_unit
| Expected_payload_hash bph ->
error_unless
(Block_payload_hash.equal actual_payload_hash bph)
(Invalid_payload_hash {expected = bph; provided = actual_payload_hash}))
>>? fun () ->
(match locked_round_evidence with
| None -> ok None
| Some {preendorsement_count; preendorsement_round} ->
error_when
Round_repr.(preendorsement_round >= round)
(Locked_round_after_block_round
{locked_round = preendorsement_round; round})
>>? fun () ->
error_when
Compare.Int.(preendorsement_count < consensus_threshold)
(Insufficient_locked_round_evidence
{voting_power = preendorsement_count; consensus_threshold})
>>? fun () -> ok (Some preendorsement_round))
>>? fun locked_round -> Fitness_repr.check_locked_round fitness ~locked_round