1391 lines
34 KiB
OCaml
1391 lines
34 KiB
OCaml
(*****************************************************************************)
|
|
(* *)
|
|
(* 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. *)
|
|
(* *)
|
|
(*****************************************************************************)
|
|
|
|
module type BASIC_DATA = sig
|
|
type t
|
|
|
|
include Compare.S with type t := t
|
|
|
|
val encoding : t Data_encoding.t
|
|
|
|
val pp : Format.formatter -> t -> unit
|
|
end
|
|
|
|
type t = Raw_context.t
|
|
|
|
type context = t
|
|
|
|
type public_key = Signature.Public_key.t
|
|
|
|
type public_key_hash = Signature.Public_key_hash.t
|
|
|
|
type signature = Signature.t
|
|
|
|
module Tez : sig
|
|
include BASIC_DATA
|
|
|
|
type tez = t
|
|
|
|
val zero : tez
|
|
|
|
val one_mutez : tez
|
|
|
|
val one_cent : tez
|
|
|
|
val fifty_cents : tez
|
|
|
|
val one : tez
|
|
|
|
val ( -? ) : tez -> tez -> tez tzresult
|
|
|
|
val ( +? ) : tez -> tez -> tez tzresult
|
|
|
|
val ( *? ) : tez -> int64 -> tez tzresult
|
|
|
|
val ( /? ) : tez -> int64 -> tez tzresult
|
|
|
|
val of_string : string -> tez option
|
|
|
|
val to_string : tez -> string
|
|
|
|
val of_mutez : int64 -> tez option
|
|
|
|
val to_mutez : tez -> int64
|
|
end
|
|
|
|
module Period : sig
|
|
include BASIC_DATA
|
|
|
|
type period = t
|
|
|
|
val rpc_arg : period RPC_arg.arg
|
|
|
|
val of_seconds : int64 -> period tzresult
|
|
|
|
val to_seconds : period -> int64
|
|
|
|
val mult : int32 -> period -> period tzresult
|
|
|
|
val zero : period
|
|
|
|
val one_second : period
|
|
|
|
val one_minute : period
|
|
|
|
val one_hour : period
|
|
end
|
|
|
|
module Timestamp : sig
|
|
include BASIC_DATA with type t = Time.t
|
|
|
|
type time = t
|
|
|
|
val ( +? ) : time -> Period.t -> time tzresult
|
|
|
|
val ( -? ) : time -> time -> Period.t tzresult
|
|
|
|
val of_notation : string -> time option
|
|
|
|
val to_notation : time -> string
|
|
|
|
val of_seconds : string -> time option
|
|
|
|
val to_seconds_string : time -> string
|
|
|
|
val current : context -> time
|
|
end
|
|
|
|
module Raw_level : sig
|
|
include BASIC_DATA
|
|
|
|
type raw_level = t
|
|
|
|
val rpc_arg : raw_level RPC_arg.arg
|
|
|
|
val diff : raw_level -> raw_level -> int32
|
|
|
|
val root : raw_level
|
|
|
|
val succ : raw_level -> raw_level
|
|
|
|
val pred : raw_level -> raw_level option
|
|
|
|
val to_int32 : raw_level -> int32
|
|
|
|
val of_int32 : int32 -> raw_level tzresult
|
|
end
|
|
|
|
module Cycle : sig
|
|
include BASIC_DATA
|
|
|
|
type cycle = t
|
|
|
|
val rpc_arg : cycle RPC_arg.arg
|
|
|
|
val root : cycle
|
|
|
|
val succ : cycle -> cycle
|
|
|
|
val pred : cycle -> cycle option
|
|
|
|
val add : cycle -> int -> cycle
|
|
|
|
val sub : cycle -> int -> cycle option
|
|
|
|
val to_int32 : cycle -> int32
|
|
|
|
module Map : S.MAP with type key = cycle
|
|
end
|
|
|
|
module Gas : sig
|
|
type t = private Unaccounted | Limited of {remaining : Z.t}
|
|
|
|
val encoding : t Data_encoding.encoding
|
|
|
|
val pp : Format.formatter -> t -> unit
|
|
|
|
type cost
|
|
|
|
val cost_encoding : cost Data_encoding.encoding
|
|
|
|
val pp_cost : Format.formatter -> cost -> unit
|
|
|
|
type error += Block_quota_exceeded (* `Temporary *)
|
|
|
|
type error += Operation_quota_exceeded (* `Temporary *)
|
|
|
|
type error += Gas_limit_too_high (* `Permanent *)
|
|
|
|
val free : cost
|
|
|
|
val atomic_step_cost : int -> cost
|
|
|
|
val step_cost : int -> cost
|
|
|
|
val alloc_cost : int -> cost
|
|
|
|
val alloc_bytes_cost : int -> cost
|
|
|
|
val alloc_mbytes_cost : int -> cost
|
|
|
|
val alloc_bits_cost : int -> cost
|
|
|
|
val read_bytes_cost : Z.t -> cost
|
|
|
|
val write_bytes_cost : Z.t -> cost
|
|
|
|
val ( *@ ) : int -> cost -> cost
|
|
|
|
val ( +@ ) : cost -> cost -> cost
|
|
|
|
val check_limit : context -> Z.t -> unit tzresult
|
|
|
|
val set_limit : context -> Z.t -> context
|
|
|
|
val set_unlimited : context -> context
|
|
|
|
val consume : context -> cost -> context tzresult
|
|
|
|
val check_enough : context -> cost -> unit tzresult
|
|
|
|
val level : context -> t
|
|
|
|
val consumed : since:context -> until:context -> Z.t
|
|
|
|
val block_level : context -> Z.t
|
|
end
|
|
|
|
module Script_int : module type of Script_int_repr
|
|
|
|
module Script_timestamp : sig
|
|
open Script_int
|
|
|
|
type t
|
|
|
|
val compare : t -> t -> int
|
|
|
|
val to_string : t -> string
|
|
|
|
val to_notation : t -> string option
|
|
|
|
val to_num_str : t -> string
|
|
|
|
val of_string : string -> t option
|
|
|
|
val diff : t -> t -> z num
|
|
|
|
val add_delta : t -> z num -> t
|
|
|
|
val sub_delta : t -> z num -> t
|
|
|
|
val now : context -> t
|
|
|
|
val to_zint : t -> Z.t
|
|
|
|
val of_zint : Z.t -> t
|
|
end
|
|
|
|
module Script : sig
|
|
type prim = Michelson_v1_primitives.prim =
|
|
| K_parameter
|
|
| K_storage
|
|
| K_code
|
|
| D_False
|
|
| D_Elt
|
|
| D_Left
|
|
| D_None
|
|
| D_Pair
|
|
| D_Right
|
|
| D_Some
|
|
| D_True
|
|
| D_Unit
|
|
| I_PACK
|
|
| I_UNPACK
|
|
| I_BLAKE2B
|
|
| I_SHA256
|
|
| I_SHA512
|
|
| I_ABS
|
|
| I_ADD
|
|
| I_AMOUNT
|
|
| I_AND
|
|
| I_BALANCE
|
|
| I_CAR
|
|
| I_CDR
|
|
| I_CHAIN_ID
|
|
| I_CHECK_SIGNATURE
|
|
| I_COMPARE
|
|
| I_CONCAT
|
|
| I_CONS
|
|
| I_CREATE_ACCOUNT
|
|
| I_CREATE_CONTRACT
|
|
| I_IMPLICIT_ACCOUNT
|
|
| I_DIP
|
|
| I_DROP
|
|
| I_DUP
|
|
| I_EDIV
|
|
| I_EMPTY_BIG_MAP
|
|
| I_EMPTY_MAP
|
|
| I_EMPTY_SET
|
|
| I_EQ
|
|
| I_EXEC
|
|
| I_APPLY
|
|
| I_FAILWITH
|
|
| I_GE
|
|
| I_GET
|
|
| I_GT
|
|
| I_HASH_KEY
|
|
| I_IF
|
|
| I_IF_CONS
|
|
| I_IF_LEFT
|
|
| I_IF_NONE
|
|
| I_INT
|
|
| I_LAMBDA
|
|
| I_LE
|
|
| I_LEFT
|
|
| I_LOOP
|
|
| I_LSL
|
|
| I_LSR
|
|
| I_LT
|
|
| I_MAP
|
|
| I_MEM
|
|
| I_MUL
|
|
| I_NEG
|
|
| I_NEQ
|
|
| I_NIL
|
|
| I_NONE
|
|
| I_NOT
|
|
| I_NOW
|
|
| I_OR
|
|
| I_PAIR
|
|
| I_PUSH
|
|
| I_RIGHT
|
|
| I_SIZE
|
|
| I_SOME
|
|
| I_SOURCE
|
|
| I_SENDER
|
|
| I_SELF
|
|
| I_SLICE
|
|
| I_STEPS_TO_QUOTA
|
|
| I_SUB
|
|
| I_SWAP
|
|
| I_TRANSFER_TOKENS
|
|
| I_SET_DELEGATE
|
|
| I_UNIT
|
|
| I_UPDATE
|
|
| I_XOR
|
|
| I_ITER
|
|
| I_LOOP_LEFT
|
|
| I_ADDRESS
|
|
| I_CONTRACT
|
|
| I_ISNAT
|
|
| I_CAST
|
|
| I_RENAME
|
|
| I_DIG
|
|
| I_DUG
|
|
| T_bool
|
|
| T_contract
|
|
| T_int
|
|
| T_key
|
|
| T_key_hash
|
|
| T_lambda
|
|
| T_list
|
|
| T_map
|
|
| T_big_map
|
|
| T_nat
|
|
| T_option
|
|
| T_or
|
|
| T_pair
|
|
| T_set
|
|
| T_signature
|
|
| T_string
|
|
| T_bytes
|
|
| T_mutez
|
|
| T_timestamp
|
|
| T_unit
|
|
| T_operation
|
|
| T_address
|
|
| T_chain_id
|
|
|
|
type location = Micheline.canonical_location
|
|
|
|
type annot = Micheline.annot
|
|
|
|
type expr = prim Micheline.canonical
|
|
|
|
type lazy_expr = expr Data_encoding.lazy_t
|
|
|
|
val lazy_expr : expr -> lazy_expr
|
|
|
|
type node = (location, prim) Micheline.node
|
|
|
|
type t = {code : lazy_expr; storage : lazy_expr}
|
|
|
|
val location_encoding : location Data_encoding.t
|
|
|
|
val expr_encoding : expr Data_encoding.t
|
|
|
|
val prim_encoding : prim Data_encoding.t
|
|
|
|
val encoding : t Data_encoding.t
|
|
|
|
val lazy_expr_encoding : lazy_expr Data_encoding.t
|
|
|
|
val deserialized_cost : expr -> Gas.cost
|
|
|
|
val serialized_cost : MBytes.t -> Gas.cost
|
|
|
|
val traversal_cost : node -> Gas.cost
|
|
|
|
val node_cost : node -> Gas.cost
|
|
|
|
val int_node_cost : Z.t -> Gas.cost
|
|
|
|
val int_node_cost_of_numbits : int -> Gas.cost
|
|
|
|
val string_node_cost : string -> Gas.cost
|
|
|
|
val string_node_cost_of_length : int -> Gas.cost
|
|
|
|
val bytes_node_cost : MBytes.t -> Gas.cost
|
|
|
|
val bytes_node_cost_of_length : int -> Gas.cost
|
|
|
|
val prim_node_cost_nonrec : expr list -> annot -> Gas.cost
|
|
|
|
val prim_node_cost_nonrec_of_length : int -> annot -> Gas.cost
|
|
|
|
val seq_node_cost_nonrec : expr list -> Gas.cost
|
|
|
|
val seq_node_cost_nonrec_of_length : int -> Gas.cost
|
|
|
|
val minimal_deserialize_cost : lazy_expr -> Gas.cost
|
|
|
|
val force_decode : context -> lazy_expr -> (expr * context) tzresult Lwt.t
|
|
|
|
val force_bytes : context -> lazy_expr -> (MBytes.t * context) tzresult Lwt.t
|
|
|
|
val unit_parameter : lazy_expr
|
|
|
|
module Legacy_support : sig
|
|
val manager_script_code : lazy_expr
|
|
|
|
val add_do :
|
|
manager_pkh:Signature.Public_key_hash.t ->
|
|
script_code:lazy_expr ->
|
|
script_storage:lazy_expr ->
|
|
(lazy_expr * lazy_expr) tzresult Lwt.t
|
|
|
|
val add_set_delegate :
|
|
manager_pkh:Signature.Public_key_hash.t ->
|
|
script_code:lazy_expr ->
|
|
script_storage:lazy_expr ->
|
|
(lazy_expr * lazy_expr) tzresult Lwt.t
|
|
|
|
val has_default_entrypoint : lazy_expr -> bool
|
|
|
|
val add_root_entrypoint : script_code:lazy_expr -> lazy_expr tzresult Lwt.t
|
|
end
|
|
end
|
|
|
|
module Constants : sig
|
|
(** Fixed constants *)
|
|
type fixed = {
|
|
proof_of_work_nonce_size : int;
|
|
nonce_length : int;
|
|
max_revelations_per_block : int;
|
|
max_operation_data_length : int;
|
|
max_proposals_per_delegate : int;
|
|
}
|
|
|
|
val fixed_encoding : fixed Data_encoding.t
|
|
|
|
val fixed : fixed
|
|
|
|
val proof_of_work_nonce_size : int
|
|
|
|
val nonce_length : int
|
|
|
|
val max_revelations_per_block : int
|
|
|
|
val max_operation_data_length : int
|
|
|
|
val max_proposals_per_delegate : int
|
|
|
|
(** Constants parameterized by context *)
|
|
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.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.t;
|
|
michelson_maximum_type_size : int;
|
|
seed_nonce_revelation_tip : Tez.t;
|
|
origination_size : int;
|
|
block_security_deposit : Tez.t;
|
|
endorsement_security_deposit : Tez.t;
|
|
baking_reward_per_endorsement : Tez.t list;
|
|
endorsement_reward : Tez.t list;
|
|
cost_per_byte : Tez.t;
|
|
hard_storage_limit_per_operation : Z.t;
|
|
test_chain_duration : int64;
|
|
quorum_min : int32;
|
|
quorum_max : int32;
|
|
min_proposal_quorum : int32;
|
|
initial_endorsers : int;
|
|
delay_per_missing_endorsement : Period.t;
|
|
}
|
|
|
|
val parametric_encoding : parametric Data_encoding.t
|
|
|
|
val parametric : context -> parametric
|
|
|
|
val preserved_cycles : context -> int
|
|
|
|
val blocks_per_cycle : context -> int32
|
|
|
|
val blocks_per_commitment : context -> int32
|
|
|
|
val blocks_per_roll_snapshot : context -> int32
|
|
|
|
val blocks_per_voting_period : context -> int32
|
|
|
|
val time_between_blocks : context -> Period.t list
|
|
|
|
val endorsers_per_block : context -> int
|
|
|
|
val initial_endorsers : context -> int
|
|
|
|
val delay_per_missing_endorsement : context -> Period.t
|
|
|
|
val hard_gas_limit_per_operation : context -> Z.t
|
|
|
|
val hard_gas_limit_per_block : context -> Z.t
|
|
|
|
val cost_per_byte : context -> Tez.t
|
|
|
|
val hard_storage_limit_per_operation : context -> Z.t
|
|
|
|
val proof_of_work_threshold : context -> int64
|
|
|
|
val tokens_per_roll : context -> Tez.t
|
|
|
|
val michelson_maximum_type_size : context -> int
|
|
|
|
val baking_reward_per_endorsement : context -> Tez.t list
|
|
|
|
val endorsement_reward : context -> Tez.t list
|
|
|
|
val seed_nonce_revelation_tip : context -> Tez.t
|
|
|
|
val origination_size : context -> int
|
|
|
|
val block_security_deposit : context -> Tez.t
|
|
|
|
val endorsement_security_deposit : context -> Tez.t
|
|
|
|
val test_chain_duration : context -> int64
|
|
|
|
val quorum_min : context -> int32
|
|
|
|
val quorum_max : context -> int32
|
|
|
|
val min_proposal_quorum : context -> int32
|
|
|
|
(** All constants: fixed and parametric *)
|
|
type t = {fixed : fixed; parametric : parametric}
|
|
|
|
val encoding : t Data_encoding.t
|
|
end
|
|
|
|
module Voting_period : sig
|
|
include BASIC_DATA
|
|
|
|
type voting_period = t
|
|
|
|
val rpc_arg : voting_period RPC_arg.arg
|
|
|
|
val root : voting_period
|
|
|
|
val succ : voting_period -> voting_period
|
|
|
|
type kind = Proposal | Testing_vote | Testing | Promotion_vote
|
|
|
|
val kind_encoding : kind Data_encoding.encoding
|
|
|
|
val to_int32 : voting_period -> int32
|
|
end
|
|
|
|
module Level : sig
|
|
type t = private {
|
|
level : Raw_level.t;
|
|
level_position : int32;
|
|
cycle : Cycle.t;
|
|
cycle_position : int32;
|
|
voting_period : Voting_period.t;
|
|
voting_period_position : int32;
|
|
expected_commitment : bool;
|
|
}
|
|
|
|
include BASIC_DATA with type t := t
|
|
|
|
val pp_full : Format.formatter -> t -> unit
|
|
|
|
type level = t
|
|
|
|
val root : context -> level
|
|
|
|
val succ : context -> level -> level
|
|
|
|
val pred : context -> level -> level option
|
|
|
|
val from_raw : context -> ?offset:int32 -> Raw_level.t -> level
|
|
|
|
val diff : level -> level -> int32
|
|
|
|
val current : context -> level
|
|
|
|
val last_level_in_cycle : context -> Cycle.t -> level
|
|
|
|
val levels_in_cycle : context -> Cycle.t -> level list
|
|
|
|
val levels_in_current_cycle : context -> ?offset:int32 -> unit -> level list
|
|
|
|
val last_allowed_fork_level : context -> Raw_level.t
|
|
end
|
|
|
|
module Fitness : sig
|
|
include module type of Fitness
|
|
|
|
type fitness = t
|
|
|
|
val increase : ?gap:int -> context -> context
|
|
|
|
val current : context -> int64
|
|
|
|
val to_int64 : fitness -> int64 tzresult
|
|
end
|
|
|
|
module Nonce : sig
|
|
type t
|
|
|
|
type nonce = t
|
|
|
|
val encoding : nonce Data_encoding.t
|
|
|
|
type unrevealed = {
|
|
nonce_hash : Nonce_hash.t;
|
|
delegate : public_key_hash;
|
|
rewards : Tez.t;
|
|
fees : Tez.t;
|
|
}
|
|
|
|
val record_hash : context -> unrevealed -> context tzresult Lwt.t
|
|
|
|
val reveal : context -> Level.t -> nonce -> context tzresult Lwt.t
|
|
|
|
type status = Unrevealed of unrevealed | Revealed of nonce
|
|
|
|
val get : context -> Level.t -> status tzresult Lwt.t
|
|
|
|
val of_bytes : MBytes.t -> nonce tzresult
|
|
|
|
val hash : nonce -> Nonce_hash.t
|
|
|
|
val check_hash : nonce -> Nonce_hash.t -> bool
|
|
end
|
|
|
|
module Seed : sig
|
|
type seed
|
|
|
|
type error +=
|
|
| Unknown of {oldest : Cycle.t; cycle : Cycle.t; latest : Cycle.t}
|
|
|
|
val for_cycle : context -> Cycle.t -> seed tzresult Lwt.t
|
|
|
|
val cycle_end :
|
|
context -> Cycle.t -> (context * Nonce.unrevealed list) tzresult Lwt.t
|
|
|
|
val seed_encoding : seed Data_encoding.t
|
|
end
|
|
|
|
module Big_map : sig
|
|
type id = Z.t
|
|
|
|
val fresh : context -> (context * id) tzresult Lwt.t
|
|
|
|
val fresh_temporary : context -> context * id
|
|
|
|
val mem :
|
|
context -> id -> Script_expr_hash.t -> (context * bool) tzresult Lwt.t
|
|
|
|
val get_opt :
|
|
context ->
|
|
id ->
|
|
Script_expr_hash.t ->
|
|
(context * Script.expr option) tzresult Lwt.t
|
|
|
|
val rpc_arg : id RPC_arg.t
|
|
|
|
val cleanup_temporary : context -> context Lwt.t
|
|
|
|
val exists :
|
|
context ->
|
|
id ->
|
|
(context * (Script.expr * Script.expr) option) tzresult Lwt.t
|
|
end
|
|
|
|
module Contract : sig
|
|
include BASIC_DATA
|
|
|
|
type contract = t
|
|
|
|
val rpc_arg : contract RPC_arg.arg
|
|
|
|
val to_b58check : contract -> string
|
|
|
|
val of_b58check : string -> contract tzresult
|
|
|
|
val implicit_contract : public_key_hash -> contract
|
|
|
|
val is_implicit : contract -> public_key_hash option
|
|
|
|
val exists : context -> contract -> bool tzresult Lwt.t
|
|
|
|
val must_exist : context -> contract -> unit tzresult Lwt.t
|
|
|
|
val allocated : context -> contract -> bool tzresult Lwt.t
|
|
|
|
val must_be_allocated : context -> contract -> unit tzresult Lwt.t
|
|
|
|
val list : context -> contract list Lwt.t
|
|
|
|
val get_manager_key : context -> public_key_hash -> public_key tzresult Lwt.t
|
|
|
|
val is_manager_key_revealed :
|
|
context -> public_key_hash -> bool tzresult Lwt.t
|
|
|
|
val reveal_manager_key :
|
|
context -> public_key_hash -> public_key -> context tzresult Lwt.t
|
|
|
|
val get_script_code :
|
|
context -> contract -> (context * Script.lazy_expr option) tzresult Lwt.t
|
|
|
|
val get_script :
|
|
context -> contract -> (context * Script.t option) tzresult Lwt.t
|
|
|
|
val get_storage :
|
|
context -> contract -> (context * Script.expr option) tzresult Lwt.t
|
|
|
|
val get_counter : context -> public_key_hash -> Z.t tzresult Lwt.t
|
|
|
|
val get_balance : context -> contract -> Tez.t tzresult Lwt.t
|
|
|
|
val init_origination_nonce : context -> Operation_hash.t -> context
|
|
|
|
val unset_origination_nonce : context -> context
|
|
|
|
val fresh_contract_from_current_nonce :
|
|
context -> (context * t) tzresult Lwt.t
|
|
|
|
val originated_from_current_nonce :
|
|
since:context -> until:context -> contract list tzresult Lwt.t
|
|
|
|
type big_map_diff_item =
|
|
| Update of {
|
|
big_map : Big_map.id;
|
|
diff_key : Script.expr;
|
|
diff_key_hash : Script_expr_hash.t;
|
|
diff_value : Script.expr option;
|
|
}
|
|
| Clear of Big_map.id
|
|
| Copy of Big_map.id * Big_map.id
|
|
| Alloc of {
|
|
big_map : Big_map.id;
|
|
key_type : Script.expr;
|
|
value_type : Script.expr;
|
|
}
|
|
|
|
type big_map_diff = big_map_diff_item list
|
|
|
|
val big_map_diff_encoding : big_map_diff Data_encoding.t
|
|
|
|
val originate :
|
|
context ->
|
|
contract ->
|
|
balance:Tez.t ->
|
|
script:Script.t * big_map_diff option ->
|
|
delegate:public_key_hash option ->
|
|
context tzresult Lwt.t
|
|
|
|
type error += Balance_too_low of contract * Tez.t * Tez.t
|
|
|
|
val spend : context -> contract -> Tez.t -> context tzresult Lwt.t
|
|
|
|
val credit : context -> contract -> Tez.t -> context tzresult Lwt.t
|
|
|
|
val update_script_storage :
|
|
context ->
|
|
contract ->
|
|
Script.expr ->
|
|
big_map_diff option ->
|
|
context tzresult Lwt.t
|
|
|
|
val used_storage_space : context -> t -> Z.t tzresult Lwt.t
|
|
|
|
val increment_counter : context -> public_key_hash -> context tzresult Lwt.t
|
|
|
|
val check_counter_increment :
|
|
context -> public_key_hash -> Z.t -> unit tzresult Lwt.t
|
|
|
|
(**/**)
|
|
|
|
(* Only for testing *)
|
|
type origination_nonce
|
|
|
|
val initial_origination_nonce : Operation_hash.t -> origination_nonce
|
|
|
|
val originated_contract : origination_nonce -> contract
|
|
end
|
|
|
|
module Delegate : sig
|
|
type balance =
|
|
| Contract of Contract.t
|
|
| Rewards of Signature.Public_key_hash.t * Cycle.t
|
|
| Fees of Signature.Public_key_hash.t * Cycle.t
|
|
| Deposits of Signature.Public_key_hash.t * Cycle.t
|
|
|
|
type balance_update = Debited of Tez.t | Credited of Tez.t
|
|
|
|
type balance_updates = (balance * balance_update) list
|
|
|
|
val balance_updates_encoding : balance_updates Data_encoding.t
|
|
|
|
val cleanup_balance_updates : balance_updates -> balance_updates
|
|
|
|
val get : context -> Contract.t -> public_key_hash option tzresult Lwt.t
|
|
|
|
val set :
|
|
context -> Contract.t -> public_key_hash option -> context tzresult Lwt.t
|
|
|
|
val fold :
|
|
context -> init:'a -> f:(public_key_hash -> 'a -> 'a Lwt.t) -> 'a Lwt.t
|
|
|
|
val list : context -> public_key_hash list Lwt.t
|
|
|
|
val freeze_deposit :
|
|
context -> public_key_hash -> Tez.t -> context tzresult Lwt.t
|
|
|
|
val freeze_rewards :
|
|
context -> public_key_hash -> Tez.t -> context tzresult Lwt.t
|
|
|
|
val freeze_fees :
|
|
context -> public_key_hash -> Tez.t -> context tzresult Lwt.t
|
|
|
|
val cycle_end :
|
|
context ->
|
|
Cycle.t ->
|
|
Nonce.unrevealed list ->
|
|
(context * balance_updates * Signature.Public_key_hash.t list) tzresult
|
|
Lwt.t
|
|
|
|
type frozen_balance = {deposit : Tez.t; fees : Tez.t; rewards : Tez.t}
|
|
|
|
val punish :
|
|
context ->
|
|
public_key_hash ->
|
|
Cycle.t ->
|
|
(context * frozen_balance) tzresult Lwt.t
|
|
|
|
val full_balance : context -> public_key_hash -> Tez.t tzresult Lwt.t
|
|
|
|
val has_frozen_balance :
|
|
context -> public_key_hash -> Cycle.t -> bool tzresult Lwt.t
|
|
|
|
val frozen_balance : context -> public_key_hash -> Tez.t tzresult Lwt.t
|
|
|
|
val frozen_balance_encoding : frozen_balance Data_encoding.t
|
|
|
|
val frozen_balance_by_cycle_encoding :
|
|
frozen_balance Cycle.Map.t Data_encoding.t
|
|
|
|
val frozen_balance_by_cycle :
|
|
context -> Signature.Public_key_hash.t -> frozen_balance Cycle.Map.t Lwt.t
|
|
|
|
val staking_balance :
|
|
context -> Signature.Public_key_hash.t -> Tez.t tzresult Lwt.t
|
|
|
|
val delegated_contracts :
|
|
context -> Signature.Public_key_hash.t -> Contract_repr.t list Lwt.t
|
|
|
|
val delegated_balance :
|
|
context -> Signature.Public_key_hash.t -> Tez.t tzresult Lwt.t
|
|
|
|
val deactivated :
|
|
context -> Signature.Public_key_hash.t -> bool tzresult Lwt.t
|
|
|
|
val grace_period :
|
|
context -> Signature.Public_key_hash.t -> Cycle.t tzresult Lwt.t
|
|
end
|
|
|
|
module Vote : sig
|
|
type proposal = Protocol_hash.t
|
|
|
|
val record_proposal :
|
|
context -> Protocol_hash.t -> public_key_hash -> context tzresult Lwt.t
|
|
|
|
val get_proposals : context -> int32 Protocol_hash.Map.t tzresult Lwt.t
|
|
|
|
val clear_proposals : context -> context Lwt.t
|
|
|
|
val recorded_proposal_count_for_delegate :
|
|
context -> public_key_hash -> int tzresult Lwt.t
|
|
|
|
val listings_encoding :
|
|
(Signature.Public_key_hash.t * int32) list Data_encoding.t
|
|
|
|
val freeze_listings : context -> context tzresult Lwt.t
|
|
|
|
val clear_listings : context -> context tzresult Lwt.t
|
|
|
|
val listing_size : context -> int32 tzresult Lwt.t
|
|
|
|
val in_listings : context -> public_key_hash -> bool Lwt.t
|
|
|
|
val get_listings : context -> (public_key_hash * int32) list Lwt.t
|
|
|
|
type ballot = Yay | Nay | Pass
|
|
|
|
val ballot_encoding : ballot Data_encoding.t
|
|
|
|
type ballots = {yay : int32; nay : int32; pass : int32}
|
|
|
|
val ballots_encoding : ballots Data_encoding.t
|
|
|
|
val has_recorded_ballot : context -> public_key_hash -> bool Lwt.t
|
|
|
|
val record_ballot :
|
|
context -> public_key_hash -> ballot -> context tzresult Lwt.t
|
|
|
|
val get_ballots : context -> ballots tzresult Lwt.t
|
|
|
|
val get_ballot_list :
|
|
context -> (Signature.Public_key_hash.t * ballot) list Lwt.t
|
|
|
|
val clear_ballots : context -> context Lwt.t
|
|
|
|
val get_current_period_kind : context -> Voting_period.kind tzresult Lwt.t
|
|
|
|
val set_current_period_kind :
|
|
context -> Voting_period.kind -> context tzresult Lwt.t
|
|
|
|
val get_current_quorum : context -> int32 tzresult Lwt.t
|
|
|
|
val get_participation_ema : context -> int32 tzresult Lwt.t
|
|
|
|
val set_participation_ema : context -> int32 -> context tzresult Lwt.t
|
|
|
|
val get_current_proposal : context -> proposal tzresult Lwt.t
|
|
|
|
val init_current_proposal : context -> proposal -> context tzresult Lwt.t
|
|
|
|
val clear_current_proposal : context -> context tzresult Lwt.t
|
|
end
|
|
|
|
module Block_header : sig
|
|
type t = {shell : Block_header.shell_header; protocol_data : protocol_data}
|
|
|
|
and protocol_data = {contents : contents; signature : Signature.t}
|
|
|
|
and contents = {
|
|
priority : int;
|
|
seed_nonce_hash : Nonce_hash.t option;
|
|
proof_of_work_nonce : MBytes.t;
|
|
}
|
|
|
|
type block_header = t
|
|
|
|
type raw = Block_header.t
|
|
|
|
type shell_header = Block_header.shell_header
|
|
|
|
val raw : block_header -> raw
|
|
|
|
val hash : block_header -> Block_hash.t
|
|
|
|
val hash_raw : raw -> Block_hash.t
|
|
|
|
val encoding : block_header Data_encoding.encoding
|
|
|
|
val raw_encoding : raw Data_encoding.t
|
|
|
|
val contents_encoding : contents Data_encoding.t
|
|
|
|
val unsigned_encoding : (shell_header * contents) Data_encoding.t
|
|
|
|
val protocol_data_encoding : protocol_data Data_encoding.encoding
|
|
|
|
val shell_header_encoding : shell_header Data_encoding.encoding
|
|
|
|
(** The maximum size of block headers in bytes *)
|
|
val max_header_length : int
|
|
end
|
|
|
|
module Kind : sig
|
|
type seed_nonce_revelation = Seed_nonce_revelation_kind
|
|
|
|
type double_endorsement_evidence = Double_endorsement_evidence_kind
|
|
|
|
type double_baking_evidence = Double_baking_evidence_kind
|
|
|
|
type activate_account = Activate_account_kind
|
|
|
|
type endorsement = Endorsement_kind
|
|
|
|
type proposals = Proposals_kind
|
|
|
|
type ballot = Ballot_kind
|
|
|
|
type reveal = Reveal_kind
|
|
|
|
type transaction = Transaction_kind
|
|
|
|
type origination = Origination_kind
|
|
|
|
type delegation = Delegation_kind
|
|
|
|
type 'a manager =
|
|
| Reveal_manager_kind : reveal manager
|
|
| Transaction_manager_kind : transaction manager
|
|
| Origination_manager_kind : origination manager
|
|
| Delegation_manager_kind : delegation manager
|
|
end
|
|
|
|
type 'kind operation = {
|
|
shell : Operation.shell_header;
|
|
protocol_data : 'kind protocol_data;
|
|
}
|
|
|
|
and 'kind protocol_data = {
|
|
contents : 'kind contents_list;
|
|
signature : Signature.t option;
|
|
}
|
|
|
|
and _ contents_list =
|
|
| Single : 'kind contents -> 'kind contents_list
|
|
| Cons :
|
|
'kind Kind.manager contents * 'rest Kind.manager contents_list
|
|
-> ('kind * 'rest) Kind.manager contents_list
|
|
|
|
and _ contents =
|
|
| Endorsement : {level : Raw_level.t} -> Kind.endorsement contents
|
|
| Seed_nonce_revelation : {
|
|
level : Raw_level.t;
|
|
nonce : Nonce.t;
|
|
}
|
|
-> Kind.seed_nonce_revelation contents
|
|
| Double_endorsement_evidence : {
|
|
op1 : Kind.endorsement operation;
|
|
op2 : Kind.endorsement operation;
|
|
}
|
|
-> Kind.double_endorsement_evidence contents
|
|
| Double_baking_evidence : {
|
|
bh1 : Block_header.t;
|
|
bh2 : Block_header.t;
|
|
}
|
|
-> Kind.double_baking_evidence contents
|
|
| Activate_account : {
|
|
id : Ed25519.Public_key_hash.t;
|
|
activation_code : Blinded_public_key_hash.activation_code;
|
|
}
|
|
-> Kind.activate_account contents
|
|
| Proposals : {
|
|
source : Signature.Public_key_hash.t;
|
|
period : Voting_period.t;
|
|
proposals : Protocol_hash.t list;
|
|
}
|
|
-> Kind.proposals contents
|
|
| Ballot : {
|
|
source : Signature.Public_key_hash.t;
|
|
period : Voting_period.t;
|
|
proposal : Protocol_hash.t;
|
|
ballot : Vote.ballot;
|
|
}
|
|
-> Kind.ballot contents
|
|
| Manager_operation : {
|
|
source : Signature.Public_key_hash.t;
|
|
fee : Tez.tez;
|
|
counter : counter;
|
|
operation : 'kind manager_operation;
|
|
gas_limit : Z.t;
|
|
storage_limit : Z.t;
|
|
}
|
|
-> 'kind Kind.manager contents
|
|
|
|
and _ manager_operation =
|
|
| Reveal : Signature.Public_key.t -> Kind.reveal manager_operation
|
|
| Transaction : {
|
|
amount : Tez.tez;
|
|
parameters : Script.lazy_expr;
|
|
entrypoint : string;
|
|
destination : Contract.contract;
|
|
}
|
|
-> Kind.transaction manager_operation
|
|
| Origination : {
|
|
delegate : Signature.Public_key_hash.t option;
|
|
script : Script.t;
|
|
credit : Tez.tez;
|
|
preorigination : Contract.t option;
|
|
}
|
|
-> Kind.origination manager_operation
|
|
| Delegation :
|
|
Signature.Public_key_hash.t option
|
|
-> Kind.delegation manager_operation
|
|
|
|
and counter = Z.t
|
|
|
|
type 'kind internal_operation = {
|
|
source : Contract.contract;
|
|
operation : 'kind manager_operation;
|
|
nonce : int;
|
|
}
|
|
|
|
type packed_manager_operation =
|
|
| Manager : 'kind manager_operation -> packed_manager_operation
|
|
|
|
type packed_contents = Contents : 'kind contents -> packed_contents
|
|
|
|
type packed_contents_list =
|
|
| Contents_list : 'kind contents_list -> packed_contents_list
|
|
|
|
type packed_protocol_data =
|
|
| Operation_data : 'kind protocol_data -> packed_protocol_data
|
|
|
|
type packed_operation = {
|
|
shell : Operation.shell_header;
|
|
protocol_data : packed_protocol_data;
|
|
}
|
|
|
|
type packed_internal_operation =
|
|
| Internal_operation : 'kind internal_operation -> packed_internal_operation
|
|
|
|
val manager_kind : 'kind manager_operation -> 'kind Kind.manager
|
|
|
|
module Fees : sig
|
|
val origination_burn : context -> (context * Tez.t) tzresult Lwt.t
|
|
|
|
val record_paid_storage_space :
|
|
context -> Contract.t -> (context * Z.t * Z.t * Tez.t) tzresult Lwt.t
|
|
|
|
val start_counting_storage_fees : context -> context
|
|
|
|
val burn_storage_fees :
|
|
context -> storage_limit:Z.t -> payer:Contract.t -> context tzresult Lwt.t
|
|
|
|
type error += Cannot_pay_storage_fee (* `Temporary *)
|
|
|
|
type error += Operation_quota_exceeded (* `Temporary *)
|
|
|
|
type error += Storage_limit_too_high (* `Permanent *)
|
|
|
|
val check_storage_limit : context -> storage_limit:Z.t -> unit tzresult
|
|
end
|
|
|
|
module Operation : sig
|
|
type nonrec 'kind contents = 'kind contents
|
|
|
|
type nonrec packed_contents = packed_contents
|
|
|
|
val contents_encoding : packed_contents Data_encoding.t
|
|
|
|
type nonrec 'kind protocol_data = 'kind protocol_data
|
|
|
|
type nonrec packed_protocol_data = packed_protocol_data
|
|
|
|
val protocol_data_encoding : packed_protocol_data Data_encoding.t
|
|
|
|
val unsigned_encoding :
|
|
(Operation.shell_header * packed_contents_list) Data_encoding.t
|
|
|
|
type raw = Operation.t = {shell : Operation.shell_header; proto : MBytes.t}
|
|
|
|
val raw_encoding : raw Data_encoding.t
|
|
|
|
val contents_list_encoding : packed_contents_list Data_encoding.t
|
|
|
|
type 'kind t = 'kind operation = {
|
|
shell : Operation.shell_header;
|
|
protocol_data : 'kind protocol_data;
|
|
}
|
|
|
|
type nonrec packed = packed_operation
|
|
|
|
val encoding : packed Data_encoding.t
|
|
|
|
val raw : _ operation -> raw
|
|
|
|
val hash : _ operation -> Operation_hash.t
|
|
|
|
val hash_raw : raw -> Operation_hash.t
|
|
|
|
val hash_packed : packed_operation -> Operation_hash.t
|
|
|
|
val acceptable_passes : packed_operation -> int list
|
|
|
|
type error += Missing_signature (* `Permanent *)
|
|
|
|
type error += Invalid_signature (* `Permanent *)
|
|
|
|
val check_signature :
|
|
public_key -> Chain_id.t -> _ operation -> unit tzresult Lwt.t
|
|
|
|
val check_signature_sync :
|
|
public_key -> Chain_id.t -> _ operation -> unit tzresult
|
|
|
|
val internal_operation_encoding : packed_internal_operation Data_encoding.t
|
|
|
|
val pack : 'kind operation -> packed_operation
|
|
|
|
type ('a, 'b) eq = Eq : ('a, 'a) eq
|
|
|
|
val equal : 'a operation -> 'b operation -> ('a, 'b) eq option
|
|
|
|
module Encoding : sig
|
|
type 'b case =
|
|
| Case : {
|
|
tag : int;
|
|
name : string;
|
|
encoding : 'a Data_encoding.t;
|
|
select : packed_contents -> 'b contents option;
|
|
proj : 'b contents -> 'a;
|
|
inj : 'a -> 'b contents;
|
|
}
|
|
-> 'b case
|
|
|
|
val endorsement_case : Kind.endorsement case
|
|
|
|
val seed_nonce_revelation_case : Kind.seed_nonce_revelation case
|
|
|
|
val double_endorsement_evidence_case :
|
|
Kind.double_endorsement_evidence case
|
|
|
|
val double_baking_evidence_case : Kind.double_baking_evidence case
|
|
|
|
val activate_account_case : Kind.activate_account case
|
|
|
|
val proposals_case : Kind.proposals case
|
|
|
|
val ballot_case : Kind.ballot case
|
|
|
|
val reveal_case : Kind.reveal Kind.manager case
|
|
|
|
val transaction_case : Kind.transaction Kind.manager case
|
|
|
|
val origination_case : Kind.origination Kind.manager case
|
|
|
|
val delegation_case : Kind.delegation Kind.manager case
|
|
|
|
module Manager_operations : sig
|
|
type 'b case =
|
|
| MCase : {
|
|
tag : int;
|
|
name : string;
|
|
encoding : 'a Data_encoding.t;
|
|
select :
|
|
packed_manager_operation -> 'kind manager_operation option;
|
|
proj : 'kind manager_operation -> 'a;
|
|
inj : 'a -> 'kind manager_operation;
|
|
}
|
|
-> 'kind case
|
|
|
|
val reveal_case : Kind.reveal case
|
|
|
|
val transaction_case : Kind.transaction case
|
|
|
|
val origination_case : Kind.origination case
|
|
|
|
val delegation_case : Kind.delegation case
|
|
end
|
|
end
|
|
|
|
val of_list : packed_contents list -> packed_contents_list
|
|
|
|
val to_list : packed_contents_list -> packed_contents list
|
|
end
|
|
|
|
module Roll : sig
|
|
type t = private int32
|
|
|
|
type roll = t
|
|
|
|
val encoding : roll Data_encoding.t
|
|
|
|
val snapshot_rolls : context -> context tzresult Lwt.t
|
|
|
|
val cycle_end : context -> Cycle.t -> context tzresult Lwt.t
|
|
|
|
val baking_rights_owner :
|
|
context -> Level.t -> priority:int -> public_key tzresult Lwt.t
|
|
|
|
val endorsement_rights_owner :
|
|
context -> Level.t -> slot:int -> public_key tzresult Lwt.t
|
|
|
|
val delegate_pubkey : context -> public_key_hash -> public_key tzresult Lwt.t
|
|
|
|
val get_rolls :
|
|
context -> Signature.Public_key_hash.t -> roll list tzresult Lwt.t
|
|
|
|
val get_change :
|
|
context -> Signature.Public_key_hash.t -> Tez.t tzresult Lwt.t
|
|
end
|
|
|
|
module Commitment : sig
|
|
type t = {
|
|
blinded_public_key_hash : Blinded_public_key_hash.t;
|
|
amount : Tez.tez;
|
|
}
|
|
|
|
val get_opt :
|
|
context -> Blinded_public_key_hash.t -> Tez.t option tzresult Lwt.t
|
|
|
|
val delete : context -> Blinded_public_key_hash.t -> context tzresult Lwt.t
|
|
end
|
|
|
|
module Bootstrap : sig
|
|
val cycle_end : context -> Cycle.t -> context tzresult Lwt.t
|
|
end
|
|
|
|
module Global : sig
|
|
val get_block_priority : context -> int tzresult Lwt.t
|
|
|
|
val set_block_priority : context -> int -> context tzresult Lwt.t
|
|
end
|
|
|
|
val prepare_first_block :
|
|
Context.t ->
|
|
typecheck:(context ->
|
|
Script.t ->
|
|
((Script.t * Contract.big_map_diff option) * context) tzresult
|
|
Lwt.t) ->
|
|
level:Int32.t ->
|
|
timestamp:Time.t ->
|
|
fitness:Fitness.t ->
|
|
context tzresult Lwt.t
|
|
|
|
val prepare :
|
|
Context.t ->
|
|
level:Int32.t ->
|
|
predecessor_timestamp:Time.t ->
|
|
timestamp:Time.t ->
|
|
fitness:Fitness.t ->
|
|
context tzresult Lwt.t
|
|
|
|
val finalize : ?commit_message:string -> context -> Updater.validation_result
|
|
|
|
val activate : context -> Protocol_hash.t -> context Lwt.t
|
|
|
|
val fork_test_chain : context -> Protocol_hash.t -> Time.t -> context Lwt.t
|
|
|
|
val record_endorsement : context -> Signature.Public_key_hash.t -> context
|
|
|
|
val allowed_endorsements :
|
|
context ->
|
|
(Signature.Public_key.t * int list * bool) Signature.Public_key_hash.Map.t
|
|
|
|
val init_endorsements :
|
|
context ->
|
|
(Signature.Public_key.t * int list * bool) Signature.Public_key_hash.Map.t ->
|
|
context
|
|
|
|
val included_endorsements : context -> int
|
|
|
|
val reset_internal_nonce : context -> context
|
|
|
|
val fresh_internal_nonce : context -> (context * int) tzresult
|
|
|
|
val record_internal_nonce : context -> int -> context
|
|
|
|
val internal_nonce_already_recorded : context -> int -> bool
|
|
|
|
val add_fees : context -> Tez.t -> context tzresult Lwt.t
|
|
|
|
val add_rewards : context -> Tez.t -> context tzresult Lwt.t
|
|
|
|
val add_deposit :
|
|
context -> Signature.Public_key_hash.t -> Tez.t -> context tzresult Lwt.t
|
|
|
|
val get_fees : context -> Tez.t
|
|
|
|
val get_rewards : context -> Tez.t
|
|
|
|
val get_deposits : context -> Tez.t Signature.Public_key_hash.Map.t
|
|
|
|
val description : context Storage_description.t
|