tezos-protocol-012-Psithaca 12.3

Tezos Protocol Implementation - Low level Repr. of Operations

Defines kinds of operations that can be performed on chain:

preendorsement
endorsement
double baking evidence
double preendorsing evidence
double endorsing evidence
seed nonce revelation
account activation
proposal (see: Voting_repr)
ballot (see: Voting_repr)
failing noop
manager operation (which in turn has several types):
revelation
transaction
origination
delegation
set deposits limitation

Each of them can be encoded as raw bytes. Operations are distinguished at type level using phantom type parameters. packed_operation type allows for unifying them when required, for instance to put them on a single list.

module Kind : sig ... end

type 'a consensus_operation_type =

| Endorsement : Kind.endorsement consensus_operation_type
| Preendorsement : Kind.preendorsement consensus_operation_type

val pp_operation_kind : 
  Stdlib.Format.formatter ->
  'kind consensus_operation_type ->
  unit

type consensus_content = {

slot : Slot_repr.t;
level : Raw_level_repr.t;
round : Round_repr.t;
block_payload_hash : Block_payload_hash.t;

}

val consensus_content_encoding : consensus_content Data_encoding.t

val pp_consensus_content : Stdlib.Format.formatter -> consensus_content -> unit

type consensus_watermark =

| Endorsement of Tezos_crypto.Chain_id.t
| Preendorsement of Tezos_crypto.Chain_id.t

val to_watermark : consensus_watermark -> Tezos_crypto.Signature.watermark

val of_watermark : 
  Tezos_crypto.Signature.watermark ->
  consensus_watermark option

type raw = Tezos_base.Operation.t = {

shell : Tezos_base.Operation.shell_header;
proto : bytes;

}

val raw_encoding : raw Data_encoding.t

type 'kind operation = {

shell : Tezos_base.Operation.shell_header;
protocol_data : 'kind protocol_data;

}

and 'kind protocol_data = {

contents : 'kind contents_list;
signature : Tezos_crypto.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 =

| Preendorsement : consensus_content -> Kind.preendorsement contents
| Endorsement : consensus_content -> Kind.endorsement contents
| Seed_nonce_revelation : {
1. level : Raw_level_repr.t;
2. nonce : Seed_repr.nonce;
} -> Kind.seed_nonce_revelation contents
| Double_preendorsement_evidence : {
1. op1 : Kind.preendorsement operation;
2. op2 : Kind.preendorsement operation;
} -> Kind.double_preendorsement_evidence contents
| Double_endorsement_evidence : {
1. op1 : Kind.endorsement operation;
2. op2 : Kind.endorsement operation;
} -> Kind.double_endorsement_evidence contents
| Double_baking_evidence : {
1. bh1 : Block_header_repr.t;
2. bh2 : Block_header_repr.t;
} -> Kind.double_baking_evidence contents
| Activate_account : {
1. id : Tezos_crypto.Ed25519.Public_key_hash.t;
2. activation_code : Blinded_public_key_hash.activation_code;
} -> Kind.activate_account contents
| Proposals : {
1. source : Tezos_crypto.Signature.public_key_hash;
2. period : int32;
3. proposals : Tezos_crypto.Protocol_hash.t list;
} -> Kind.proposals contents
| Ballot : {
1. source : Tezos_crypto.Signature.public_key_hash;
2. period : int32;
3. proposal : Tezos_crypto.Protocol_hash.t;
4. ballot : Vote_repr.ballot;
} -> Kind.ballot contents
| Failing_noop : string -> Kind.failing_noop contents
| Manager_operation : {
1. source : Tezos_crypto.Signature.public_key_hash;
2. fee : Tez_repr.tez;
3. counter : counter;
4. operation : 'kind manager_operation;
5. gas_limit : Gas_limit_repr.Arith.integral;
6. storage_limit : Z.t;
} -> 'kind Kind.manager contents

and _ manager_operation =

| Reveal : Tezos_crypto.Signature.public_key -> Kind.reveal manager_operation
| Transaction : {
1. amount : Tez_repr.tez;
2. parameters : Script_repr.lazy_expr;
3. entrypoint : string;
4. destination : Contract_repr.contract;
} -> Kind.transaction manager_operation
| Origination : {
1. delegate : Tezos_crypto.Signature.public_key_hash option;
2. script : Script_repr.t;
3. credit : Tez_repr.tez;
4. preorigination : Contract_repr.t option;
} -> Kind.origination manager_operation
| Delegation : Tezos_crypto.Signature.public_key_hash option -> Kind.delegation manager_operation
| Register_global_constant : {
1. value : Script_repr.lazy_expr;
} -> Kind.register_global_constant manager_operation
| Set_deposits_limit : Tez_repr.t option -> Kind.set_deposits_limit manager_operation

and counter = Z.t

type 'kind internal_operation = {

source : Contract_repr.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

val of_list : 
  packed_contents list ->
  (packed_contents_list,
    Tezos_protocol_environment_012_Psithaca__Environment.Error_monad.error
      Tezos_protocol_environment_012_Psithaca__Environment.Error_monad.trace)
    Stdlib.result

val to_list : packed_contents_list -> packed_contents list

type packed_protocol_data =

| Operation_data : 'kind protocol_data -> packed_protocol_data

type packed_operation = {

shell : Tezos_base.Operation.shell_header;
protocol_data : packed_protocol_data;

}

val pack : 'kind operation -> packed_operation

type packed_internal_operation =

| Internal_operation : 'kind internal_operation -> packed_internal_operation

val manager_kind : 'kind manager_operation -> 'kind Kind.manager

val encoding : packed_operation Data_encoding.t

val contents_encoding : packed_contents Data_encoding.t

val contents_list_encoding : packed_contents_list Data_encoding.t

val protocol_data_encoding : packed_protocol_data Data_encoding.t

val unsigned_operation_encoding : 
  (Tezos_base.Operation.shell_header * packed_contents_list) Data_encoding.t

val raw : _ operation -> raw

val hash_raw : raw -> Tezos_crypto.Operation_hash.t

val hash : _ operation -> Tezos_crypto.Operation_hash.t

val hash_packed : packed_operation -> Tezos_crypto.Operation_hash.t

val acceptable_passes : packed_operation -> int list

type Tezos_protocol_environment_012_Psithaca__Environment.Error_monad.error +=

| Missing_signature

type Tezos_protocol_environment_012_Psithaca__Environment.Error_monad.error +=

| Invalid_signature

val check_signature : 
  Tezos_crypto.Signature.public_key ->
  Tezos_crypto.Chain_id.t ->
  _ operation ->
  (unit,
    Tezos_protocol_environment_012_Psithaca__Environment.Error_monad.error
      Tezos_protocol_environment_012_Psithaca__Environment.Error_monad.trace)
    Stdlib.result

val internal_operation_encoding : packed_internal_operation Data_encoding.t

type ('a, 'b) eq =

| Eq : ('a, 'a) eq

val equal : 'a operation -> 'b operation -> ('a, 'b) eq option

val packed_internal_operation_in_memory_size : 
  packed_internal_operation ->
  Cache_memory_helpers.nodes_and_size

module Encoding : sig ... end

package tezos-protocol-012-Psithaca