Source file parameters_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.                                                 *)
(*                                                                           *)
(*****************************************************************************)

type bootstrap_account = {
  public_key_hash : Signature.Public_key_hash.t ;
  public_key : Signature.Public_key.t option ;
  amount : Tez_repr.t ;
}

type bootstrap_contract = {
  delegate : Signature.Public_key_hash.t ;
  amount : Tez_repr.t ;
  script : Script_repr.t ;
}

type t = {
  bootstrap_accounts : bootstrap_account list ;
  bootstrap_contracts : bootstrap_contract list ;
  commitments : Commitment_repr.t list ;
  constants : Constants_repr.parametric ;
  security_deposit_ramp_up_cycles : int option ;
  no_reward_cycles : int option ;
}

let bootstrap_account_encoding =
  let open Data_encoding in
  union
    [ case (Tag 0) ~title:"Public_key_known"
        (tup2
           Signature.Public_key.encoding
           Tez_repr.encoding)
        (function
          | { public_key_hash ; public_key = Some public_key ; amount } ->
              assert (Signature.Public_key_hash.equal
                        (Signature.Public_key.hash public_key)
                        public_key_hash) ;
              Some (public_key, amount)
          | { public_key = None }  -> None)
        (fun (public_key, amount) ->
           { public_key = Some public_key ;
             public_key_hash = Signature.Public_key.hash public_key ;
             amount }) ;
      case (Tag 1) ~title:"Public_key_unknown"
        (tup2
           Signature.Public_key_hash.encoding
           Tez_repr.encoding)
        (function
          | { public_key_hash ; public_key = None ; amount } ->
              Some (public_key_hash, amount)
          | { public_key = Some _ }  -> None)
        (fun (public_key_hash, amount) ->
           { public_key = None ;
             public_key_hash ;
             amount }) ]

let bootstrap_contract_encoding =
  let open Data_encoding in
  conv
    (fun { delegate ; amount ; script } -> (delegate, amount, script))
    (fun (delegate, amount, script) -> { delegate ; amount ; script })
    (obj3
       (req "delegate" Signature.Public_key_hash.encoding)
       (req "amount" Tez_repr.encoding)
       (req "script" Script_repr.encoding))

let encoding =
  let open Data_encoding in
  conv
    (fun { bootstrap_accounts ; bootstrap_contracts ; commitments ; constants ;
           security_deposit_ramp_up_cycles ; no_reward_cycles } ->
      ((bootstrap_accounts, bootstrap_contracts, commitments,
        security_deposit_ramp_up_cycles, no_reward_cycles),
       constants))
    (fun ( (bootstrap_accounts, bootstrap_contracts, commitments,
            security_deposit_ramp_up_cycles, no_reward_cycles),
           constants) ->
      { bootstrap_accounts ; bootstrap_contracts ; commitments ; constants ;
        security_deposit_ramp_up_cycles ; no_reward_cycles })
    (merge_objs
       (obj5
          (req "bootstrap_accounts" (list bootstrap_account_encoding))
          (dft "bootstrap_contracts" (list bootstrap_contract_encoding) [])
          (dft "commitments" (list Commitment_repr.encoding) [])
          (opt "security_deposit_ramp_up_cycles" int31)
          (opt "no_reward_cycles" int31))
       Constants_repr.parametric_encoding)


(* Only for migration from 004 to 005 *)

module Proto_004 = struct

  type parametric = {
    preserved_cycles: int ;
    blocks_per_cycle: int32 ;
    blocks_per_commitment: int32 ;
    blocks_per_roll_snapshot: int32 ;
    blocks_per_voting_period: int32 ;
    time_between_blocks: Period_repr.t list ;
    endorsers_per_block: int ;
    hard_gas_limit_per_operation: Z.t ;
    hard_gas_limit_per_block: Z.t ;
    proof_of_work_threshold: int64 ;
    tokens_per_roll: Tez_repr.t ;
    michelson_maximum_type_size: int;
    seed_nonce_revelation_tip: Tez_repr.t ;
    origination_size: int ;
    block_security_deposit: Tez_repr.t ;
    endorsement_security_deposit: Tez_repr.t ;
    block_reward: Tez_repr.t ;
    endorsement_reward: Tez_repr.t ;
    cost_per_byte: Tez_repr.t ;
    hard_storage_limit_per_operation: Z.t ;
    test_chain_duration: int64 ;  (* in seconds *)
  }

  let default = {
    preserved_cycles = 5 ;
    blocks_per_cycle = 4096l ;
    blocks_per_commitment = 32l ;
    blocks_per_roll_snapshot = 256l ;
    blocks_per_voting_period = 32768l ;
    time_between_blocks =
      List.map Period_repr.of_seconds_exn [ 60L ; 75L ] ;
    endorsers_per_block = 32 ;
    hard_gas_limit_per_operation = Z.of_int 800_000 ;
    hard_gas_limit_per_block = Z.of_int 8_000_000 ;
    proof_of_work_threshold =
      Int64.(sub (shift_left 1L 46) 1L) ;
    tokens_per_roll =
      Tez_repr.(mul_exn one 8_000) ;
    michelson_maximum_type_size = 1000 ;
    seed_nonce_revelation_tip = begin
      match Tez_repr.(one /? 8L) with
      | Ok c -> c
      | Error _ -> assert false
    end ;
    origination_size = 257 ;
    block_security_deposit = Tez_repr.(mul_exn one 512) ;
    endorsement_security_deposit = Tez_repr.(mul_exn one 64) ;
    block_reward = Tez_repr.(mul_exn one 16) ;
    endorsement_reward = Tez_repr.(mul_exn one 2) ;
    hard_storage_limit_per_operation = Z.of_int 60_000 ;
    cost_per_byte = Tez_repr.of_mutez_exn 1_000L ;
    test_chain_duration = Int64.mul 32768L 60L;
  }

  (* This encoding is used to read configuration files (e.g. sandbox.json)
     where some fields can be missing, in that case they are replaced by
     the default. *)
  let constants_encoding =
    let open Data_encoding in
    conv
      (fun (c : parametric) ->
         let module Compare_time_between_blocks = Compare.List (Period_repr) in
         let module Compare_keys = Compare.List (Ed25519.Public_key) in
         let opt (=) def v = if def = v then None else Some v in
         let preserved_cycles =
           opt Compare.Int.(=)
             default.preserved_cycles c.preserved_cycles
         and blocks_per_cycle =
           opt Compare.Int32.(=)
             default.blocks_per_cycle c.blocks_per_cycle
         and blocks_per_commitment =
           opt Compare.Int32.(=)
             default.blocks_per_commitment c.blocks_per_commitment
         and blocks_per_roll_snapshot =
           opt Compare.Int32.(=)
             default.blocks_per_roll_snapshot c.blocks_per_roll_snapshot
         and blocks_per_voting_period =
           opt Compare.Int32.(=)
             default.blocks_per_voting_period c.blocks_per_voting_period
         and time_between_blocks =
           opt Compare_time_between_blocks.(=)
             default.time_between_blocks c.time_between_blocks
         and endorsers_per_block =
           opt Compare.Int.(=)
             default.endorsers_per_block c.endorsers_per_block
         and hard_gas_limit_per_operation =
           opt Compare.Z.(=)
             default.hard_gas_limit_per_operation c.hard_gas_limit_per_operation
         and hard_gas_limit_per_block =
           opt Compare.Z.(=)
             default.hard_gas_limit_per_block c.hard_gas_limit_per_block
         and proof_of_work_threshold =
           opt Compare.Int64.(=)
             default.proof_of_work_threshold c.proof_of_work_threshold
         and tokens_per_roll =
           opt Tez_repr.(=)
             default.tokens_per_roll c.tokens_per_roll
         and michelson_maximum_type_size =
           opt Compare.Int.(=)
             default.michelson_maximum_type_size c.michelson_maximum_type_size
         and seed_nonce_revelation_tip =
           opt Tez_repr.(=)
             default.seed_nonce_revelation_tip c.seed_nonce_revelation_tip
         and origination_size =
           opt Compare.Int.(=)
             default.origination_size c.origination_size
         and block_security_deposit =
           opt Tez_repr.(=)
             default.block_security_deposit c.block_security_deposit
         and endorsement_security_deposit =
           opt Tez_repr.(=)
             default.endorsement_security_deposit c.endorsement_security_deposit
         and block_reward =
           opt Tez_repr.(=)
             default.block_reward c.block_reward
         and endorsement_reward =
           opt Tez_repr.(=)
             default.endorsement_reward c.endorsement_reward
         and cost_per_byte =
           opt Tez_repr.(=)
             default.cost_per_byte c.cost_per_byte
         and hard_storage_limit_per_operation =
           opt Compare.Z.(=)
             default.hard_storage_limit_per_operation c.hard_storage_limit_per_operation
         and test_chain_duration =
           opt Compare.Int64.(=)
             default.test_chain_duration c.test_chain_duration
         in
         (( preserved_cycles,
            blocks_per_cycle,
            blocks_per_commitment,
            blocks_per_roll_snapshot,
            blocks_per_voting_period,
            time_between_blocks,
            endorsers_per_block,
            hard_gas_limit_per_operation,
            hard_gas_limit_per_block),
          ((proof_of_work_threshold,
            tokens_per_roll,
            michelson_maximum_type_size,
            seed_nonce_revelation_tip,
            origination_size,
            block_security_deposit,
            endorsement_security_deposit,
            block_reward),
           (endorsement_reward,
            cost_per_byte,
            hard_storage_limit_per_operation,
            test_chain_duration))))
      (fun (( preserved_cycles,
              blocks_per_cycle,
              blocks_per_commitment,
              blocks_per_roll_snapshot,
              blocks_per_voting_period,
              time_between_blocks,
              endorsers_per_block,
              hard_gas_limit_per_operation,
              hard_gas_limit_per_block),
            ((proof_of_work_threshold,
              tokens_per_roll,
              michelson_maximum_type_size,
              seed_nonce_revelation_tip,
              origination_size,
              block_security_deposit,
              endorsement_security_deposit,
              block_reward),
             (endorsement_reward,
              cost_per_byte,
              hard_storage_limit_per_operation,
              test_chain_duration))) ->
        let unopt def = function None -> def | Some v -> v in
        { preserved_cycles =
            unopt default.preserved_cycles preserved_cycles ;
          blocks_per_cycle =
            unopt default.blocks_per_cycle blocks_per_cycle ;
          blocks_per_commitment =
            unopt default.blocks_per_commitment blocks_per_commitment ;
          blocks_per_roll_snapshot =
            unopt default.blocks_per_roll_snapshot blocks_per_roll_snapshot ;
          blocks_per_voting_period =
            unopt default.blocks_per_voting_period blocks_per_voting_period ;
          time_between_blocks =
            unopt default.time_between_blocks @@
            time_between_blocks ;
          endorsers_per_block =
            unopt default.endorsers_per_block endorsers_per_block ;
          hard_gas_limit_per_operation =
            unopt default.hard_gas_limit_per_operation hard_gas_limit_per_operation ;
          hard_gas_limit_per_block =
            unopt default.hard_gas_limit_per_block hard_gas_limit_per_block ;
          proof_of_work_threshold =
            unopt default.proof_of_work_threshold proof_of_work_threshold ;
          tokens_per_roll =
            unopt default.tokens_per_roll tokens_per_roll ;
          michelson_maximum_type_size =
            unopt default.michelson_maximum_type_size michelson_maximum_type_size ;
          seed_nonce_revelation_tip =
            unopt default.seed_nonce_revelation_tip seed_nonce_revelation_tip ;
          origination_size =
            unopt default.origination_size origination_size ;
          block_security_deposit =
            unopt default.block_security_deposit block_security_deposit ;
          endorsement_security_deposit =
            unopt default.endorsement_security_deposit endorsement_security_deposit ;
          block_reward =
            unopt default.block_reward block_reward ;
          endorsement_reward =
            unopt default.endorsement_reward endorsement_reward ;
          cost_per_byte =
            unopt default.cost_per_byte cost_per_byte ;
          hard_storage_limit_per_operation =
            unopt default.hard_storage_limit_per_operation hard_storage_limit_per_operation ;
          test_chain_duration =
            unopt default.test_chain_duration test_chain_duration ;
        } )
      (merge_objs
         (obj9
            (opt "preserved_cycles" uint8)
            (opt "blocks_per_cycle" int32)
            (opt "blocks_per_commitment" int32)
            (opt "blocks_per_roll_snapshot" int32)
            (opt "blocks_per_voting_period" int32)
            (opt "time_between_blocks" (list Period_repr.encoding))
            (opt "endorsers_per_block" uint16)
            (opt "hard_gas_limit_per_operation" z)
            (opt "hard_gas_limit_per_block" z))
         (merge_objs
            (obj8
               (opt "proof_of_work_threshold" int64)
               (opt "tokens_per_roll" Tez_repr.encoding)
               (opt "michelson_maximum_type_size" uint16)
               (opt "seed_nonce_revelation_tip" Tez_repr.encoding)
               (opt "origination_size" int31)
               (opt "block_security_deposit" Tez_repr.encoding)
               (opt "endorsement_security_deposit" Tez_repr.encoding)
               (opt "block_reward" Tez_repr.encoding))
            (obj4
               (opt "endorsement_reward" Tez_repr.encoding)
               (opt "cost_per_byte" Tez_repr.encoding)
               (opt "hard_storage_limit_per_operation" z)
               (opt "test_chain_duration" int64))))

end