Mina中的genesis

1. 引言

前序博客见：

Mina如何实现22KB？

genesis_proof结构比genesis_proof.Inputs结构多一个proof_data字段，少一个blockchain_proof_system_id字段。
但是，proof_data字段中更包含了blockchain_proof_system_id字段。
且Precomputed_values类型等价为genesis_proof结构。

(* genesis_proof.ml中有： *)
module T = struct
  type t =
    { runtime_config : Runtime_config.t
    ; constraint_constants : Genesis_constants.Constraint_constants.t
    ; genesis_constants : Genesis_constants.t
    ; proof_level : Genesis_constants.Proof_level.t
    ; genesis_ledger : Genesis_ledger.Packed.t
    ; genesis_epoch_data : Consensus.Genesis_epoch_data.t
    ; consensus_constants : Consensus.Constants.t
    ; protocol_state_with_hashes :
        Protocol_state.value State_hash.With_state_hashes.t
    ; constraint_system_digests : (string * Md5_lib.t) list Lazy.t
    ; proof_data : Proof_data.t option
    }
   
module Proof_data = struct
  type t =
    { blockchain_proof_system_id : Pickles.Verification_key.Id.t
    ; genesis_proof : Proof.t
    }
end
module Inputs = struct
  type t =
    { runtime_config : Runtime_config.t
    ; constraint_constants : Genesis_constants.Constraint_constants.t
    ; proof_level : Genesis_constants.Proof_level.t
    ; genesis_constants : Genesis_constants.t
    ; genesis_ledger : Genesis_ledger.Packed.t
    ; genesis_epoch_data : Consensus.Genesis_epoch_data.t
    ; consensus_constants : Consensus.Constants.t
    ; protocol_state_with_hashes :
        Protocol_state.value State_hash.With_state_hashes.t
    ; constraint_system_digests : (string * Md5_lib.t) list option
    ; blockchain_proof_system_id :
        (* This is only used for calculating the hash to lookup the genesis
           proof with. It is re-calculated when building the blockchain prover,
           so it is always okay -- if less efficient at startup -- to pass
           [None] here.
        *)
        Pickles.Verification_key.Id.t option
    }

Proof类型为：

type t = (Nat.N2.n, Nat.N2.n) Pickles.Proof.t 

(* Pickles.Proof结构为： *)
module Make (W : Nat.Intf) (MLMB : Nat.Intf) : sig
    type nonrec t = (W.n, MLMB.n) t [@@deriving sexp, compare, yojson, hash]
  end

type t =
          (Verification_key.Max_width.n, Verification_key.Max_width.n) Proof.t

type ('max_width, 'mlmb) t

State_hash.With_state_hashes类型为：

type 'a t = ('a, State_hashes.t) With_hash.t

(* State_hash结构为： *)
type t = Field.t

(* State_hashes结构为： *)
module State_hashes = struct
  [%%versioned
  module Stable = struct
    module V1 = struct
      type t =
        { mutable state_body_hash : State_body_hash.Stable.V1.t option
        ; state_hash : T.Stable.V1.t
        }

1.1 Genesis_ledger.Packed结构

  type t = (module Intf.S)
  let t ((module L) : t) = L.t

val t : Mina_ledger.Ledger.t Lazy.t

include
  Merkle_mask.Maskable_merkle_tree_intf.S
    with module Location := Location
    with module Addr = Location.Addr
    with type root_hash := Ledger_hash.t
     and type hash := Ledger_hash.t
     and type account := Account.t
     and type key := Public_key.Compressed.t
     and type token_id := Token_id.t
     and type token_id_set := Token_id.Set.t
     and type account_id := Account_id.t
     and type account_id_set := Account_id.Set.t
     and type t = Mask.Attached.t
     and type attached_mask = Mask.Attached.t
     and type unattached_mask = Mask.t

1.2 Constraint_constants结构

Genesis_constants.Constraint_constants结构为：

type t =
    { sub_windows_per_window : int
    ; ledger_depth : int
    ; work_delay : int
    ; block_window_duration_ms : int
    ; transaction_capacity_log_2 : int
    ; pending_coinbase_depth : int
    ; coinbase_amount : Currency.Amount.Stable.Latest.t
    ; supercharged_coinbase_factor : int
    ; account_creation_fee : Currency.Fee.Stable.Latest.t
    ; fork : Fork_constants.t option
    }

(* 赋值为： *)
	let compiled =
        { sub_windows_per_window
        ; ledger_depth
        ; work_delay
        ; block_window_duration_ms
        ; transaction_capacity_log_2
        ; pending_coinbase_depth
        ; coinbase_amount =
            Currency.Amount.of_formatted_string coinbase_amount_string
        ; supercharged_coinbase_factor
        ; account_creation_fee =
            Currency.Fee.of_formatted_string account_creation_fee_string
        ; fork
        }

而Snark_keys_header.Constraint_constants结构为：【为用于constraint system的常量，Mina主网中未定义fork_previous_length，因此fork=None】

(** The constants used in the constraint system.  *)
  type t =
    { sub_windows_per_window : int
    ; ledger_depth : int
    ; work_delay : int
    ; block_window_duration_ms : int
    ; transaction_capacity : Transaction_capacity.t
    ; pending_coinbase_depth : int
    ; coinbase_amount : UInt64.t
    ; supercharged_coinbase_factor : int
    ; account_creation_fee : UInt64.t
    ; fork :
        (Fork_config.t option
        [@to_yojson Fork_config.opt_to_yojson]
        [@of_yojson Fork_config.opt_of_yojson])
    }

1.3 Transition frontier 之 full_frontier结构

(* Invariant: The path from the root to the tip inclusively, will be max_length *)
type t =
  { root_ledger : Ledger.Any_ledger.witness
  ; mutable root : State_hash.t
  ; mutable best_tip : State_hash.t
  ; logger : Logger.t
  ; table : Node.t State_hash.Table.t
  ; mutable protocol_states_for_root_scan_state :
      Protocol_states_for_root_scan_state.t
  ; consensus_local_state : Consensus.Data.Local_state.t
  ; max_length : int
  ; precomputed_values : Precomputed_values.t
  ; time_controller : Block_time.Controller.t
  ; persistent_root_instance : Persistent_root.Instance.t
  }

module Node = struct
  type t =
    { breadcrumb : Breadcrumb.t
    ; successor_hashes : State_hash.t list
    ; length : int
    }

2. Snark transition

snark transition结构为：

(* snark_transition结构为： *)
type t =
        ( Blockchain_state.Value.Stable.V2.t (* 字段名为blockchain_state *)
        , Consensus.Data.Consensus_transition.Value.Stable.V1.t (* 字段名为consensus_transition *)
        , Pending_coinbase.Update.Stable.V1.t ) (* 字段名为pending_coinbase_update *)
        Poly.Stable.V1.t

type ('blockchain_state, 'consensus_transition, 'pending_coinbase_update) t =
    { blockchain_state : 'blockchain_state
    ; consensus_transition : 'consensus_transition
    ; pending_coinbase_update : 'pending_coinbase_update
    }

2.1 Blockchain_state结构

Blockchain_state结构为：

(* Blockchain_state.value结构为： *)
type t =
        ( Staged_ledger_hash.Stable.V1.t (* 字段名为staged_ledger_hash *)
        , Frozen_ledger_hash.Stable.V1.t (* 字段名为snarked_ledger_hash *)
        , Local_state.Stable.V1.t (* 字段名为local_state *)
        , Block_time.Stable.V1.t ) (* 字段名为timestamp *)
        Poly.Stable.V2.t

type ('staged_ledger_hash, 'snarked_ledger_hash, 'local_state, 'time) t =
        { staged_ledger_hash : 'staged_ledger_hash
        ; genesis_ledger_hash : 'snarked_ledger_hash (* 字段名为genesis_ledger_hash，又名snarked_ledger_hash *)
        ; registers : (* 字段名registers中封装了genesis_ledger_hash、unit、local_state 以及Registers*)
            ('snarked_ledger_hash, unit, 'local_state) Registers.Stable.V1.t
        ; timestamp : 'time
        }

Local_state结构为：

(* mina_transaction_logic.ml中： *)
module Local_state = struct
      type t =
        ( Parties.t
        , Call_stack.t
        , Token_id.t
        , Amount.t
        , Ledger.t
        , Bool.t
        , Transaction_commitment.t
        , Bool.failure_status_tbl )
        Parties_logic.Local_state.t

(* Parties_logic.Local_data结构为： *)
type ( 'parties
           , 'call_stack
           , 'token_id
           , 'excess
           , 'ledger
           , 'bool
           , 'comm
           , 'failure_status_tbl )
           t =
        { parties : 'parties (* parties字段为Parties类型 *)
        ; call_stack : 'call_stack (* call_stack字段为Call_stack类型 *)
        ; transaction_commitment : 'comm (* transaction_commitment字段为Transaction_commitment类型 *)
        ; full_transaction_commitment : 'comm (* full_transaction_commitment字段为Transaction_commitment类型 *)
        ; token_id : 'token_id (* token_id字段为Token_id类型 *)
        ; excess : 'excess (* excess字段为Amount类型 *)
        ; ledger : 'ledger (* ledger字段为Ledger类型 *)
        ; success : 'bool (* success字段为Bool类型 *)
        ; failure_status_tbl : 'failure_status_tbl (* failure_status_tbl字段为Bool.failure_status_tbl类型 *)
        }

Registers结构为：

 (* Registers结构为： *)
 type t =
    ( Frozen_ledger_hash.t
    , Pending_coinbase.Stack.t
    , Local_state.t )
    Stable.Latest.t

 type ('ledger, 'pending_coinbase_stack, 'local_state) t =
      { ledger : 'ledger (* ledger字段为Frozen_ledger_hash类型 *)
      ; pending_coinbase_stack : 'pending_coinbase_stack (* pending_coinbase_stack字段为Pending_coinbase.Stack类型 *)
      ; local_state : 'local_state (* local_state字段为Local_state类型 *)
      }

Pending_coinbase.Stack结构为：

(* Pending_coinbase.Stack结构为： *)
type t =
        (Coinbase_stack.Stable.V1.t,  (* 为Field.t *)
        State_stack.Stable.V1.t) 
        Poly.Stable.V1.t
        
module V1 = struct
        type ('data_stack, 'state_stack) t =
          { data : 'data_stack; state : 'state_stack }

(* State_stack类型为： *)
type t = Stack_hash.Stable.V1.t  (* 为Field.t *)
             Poly.Stable.V1.t

 module V1 = struct
        type 'stack_hash t = { init : 'stack_hash; (* init字段为Stack_hash字段 *)
        curr : 'stack_hash } (* curr字段为Stack_hash字段 *)

2.2 Consensus.Data.Consensus_transition结构

Consensus.Data.Consensus_transition结构为：【就是global slot数字】

(* Consensus.Data.Consensus_transition结构为： *)
module Consensus_transition = struct
    include Mina_numbers.Global_slot
    module Value = Mina_numbers.Global_slot

    type var = Checked.t

    let genesis = zero
  end

3）Pending_coinbase.Update结构为：

(* Pending_coinbase.Update结构为：*)
type t = (Action.Stable.V1.t,
            Amount.Stable.V1.t) (* 为unsigned类型 *)
            Poly.Stable.V1.t

type ('action, 'coinbase_amount) t =
            { action : 'action;  (* action字段为Action类型 *)
            coinbase_amount : 'coinbase_amount } (* coinbase_amount字段为Amount类型 *)

(* Actiion为枚举类型： *)
		type t =
            | Update_none
            | Update_one
            | Update_two_coinbase_in_first
            | Update_two_coinbase_in_second

3. Internal transition

internal transition结构为：

(* internal transition结构为： *)
type t = Stable.Latest.t =
  { snark_transition : Snark_transition.Value.t (* 见上一节Snark transition内容 *)
  ; ledger_proof : Ledger_proof.t option
  ; prover_state : Consensus.Data.Prover_state.t
  ; staged_ledger_diff : Staged_ledger_diff.t
  }

3.1 Snark_transition结构

Snark_transition结构：见上一节Snark transition内容。

3.2 Ledger_proof结构

Ledger_proof结构：【等价为Transaction_snark结构】

(* Ledger_proof结构为： *)
module Prod : Ledger_proof_intf.S with type t = Transaction_snark.t = struct
  [%%versioned
  module Stable = struct
    module V2 = struct
      type t = Transaction_snark.Stable.V2.t

2.1）Transaction_snark结构为：

(* transaction_snark/transaction_snark.ml中有Transaction_snark结构为：： *)
module Stable = struct
  module V2 = struct
    type t =
      { statement : Statement.With_sok.Stable.V2.t; proof : Proof.Stable.V2.t }

Statement.With_sok结构为：

(* Statement.With_sok结构为： *)
  module With_sok = struct
   [%%versioned
   module Stable = struct
     module V2 = struct
       type t =
         ( Frozen_ledger_hash.Stable.V1.t
         , Currency.Amount.Stable.V1.t
         , Pending_coinbase.Stack_versioned.Stable.V1.t (* 见上面的 Pending_coinbase.Stack结构 *)
         , Fee_excess.Stable.V1.t
         , Sok_message.Digest.Stable.V1.t (* 为string类型 *)
         , Local_state.Stable.V1.t ) (* 见上面Local_state结构 *)

(* Fee_excess结构为： *)
type t =
     ( Token_id.Stable.V1.t
     , (Fee.Stable.V1.t, (* 为uint64 *)
     	Sgn.Stable.V1.t) (* Sgn为枚举：Pos或Neg，即代表极性。 *)
     		Signed_poly.Stable.V1.t ) 
     Poly.Stable.V1.t

(* Signed_poly中字段有： *)
type ('magnitude, 'sgn) t = { magnitude : 'magnitude; (* magnitude字段为Fee类型 *)
   											sgn : 'sgn } (* sgn字段为Sgn枚举类型，Pos或Neg *)

(* Poly中字段有： *)
type ('token, 'fee) t =
       { fee_token_l : 'token (* fee_token_l字段为Token_id类型 *)
       ; fee_excess_l : 'fee (* fee_excess_l字段为Sgined_poly类型，包含magnitude和sgn这2个字段。 *)
       ; fee_token_r : 'token (* fee_token_r字段为Token_id类型 *)
       ; fee_excess_r : 'fee (* fee_excess_r字段为Sgined_poly类型，包含magnitude和sgn这2个字段。 *)
       }

2.2）Proof结构为：

module Proof = struct
 [%%versioned
 module Stable = struct
   module V2 = struct
     type t = Pickles.Proof.Branching_2.Stable.V2.t

Pickles.Proof.Branching_2结构为：

(* Pickles.Proof.Branching_2结构为： *)
type t =
      ( ( Tock.Inner_curve.Affine.t
        , Reduced_me_only.Wrap.Challenges_vector.t MLMB_vec.t )
        Types.Wrap.Proof_state.Me_only.t
      , ( unit
        , Tock.Curve.Affine.t Max_branching_at_most.t
        , Challenge.Constant.t Scalar_challenge.t Bulletproof_challenge.t
          Step_bp_vec.t
          Max_branching_at_most.t )
        Base.Me_only.Step.t )
      Base.Wrap.t

3.3 Consensus.Data.Prover_state结构

Consensus.Data.Prover_state结构为：【等同为Stake_proof结构】

(* Consensus.Data.Prover_state结构为： *)
type t =
      { delegator : Account.Index.Stable.V1.t (* 为int类型，即delegator在Account tree中的位置？ *)
      ; delegator_pk : Public_key.Compressed.Stable.V1.t (* 为压缩公钥 *)
      ; coinbase_receiver_pk : Public_key.Compressed.Stable.V1.t (* 为压缩公钥 *)
      ; ledger : Mina_ledger.Sparse_ledger.Stable.V2.t
      ; producer_private_key : Private_key.Stable.V1.t (* 为产块者私钥 *)
      ; producer_public_key : Public_key.Stable.V1.t (* 为产块者公钥 *)
      }

Mina_ledger.Sparse_ledger结构为：

(* Mina_ledger.Sparse_ledger结构为： *)
type t =
      ( Ledger_hash.Stable.V1.t (* 为Field.t类型 *)
      , Account_id.Stable.V2.t (* 类型为Public_key.Compressed.Stable.V1.t * Digest.Stable.V1.t *)
      , Account.Stable.V2.t )
      Sparse_ledger_lib.Sparse_ledger.T.Stable.V2.t

type ('hash, 'key, 'account) t =
        { indexes : ('key * int) list
        ; depth : int
        ; tree : ('hash, 'account) Tree.Stable.V1.t
        }

Account结构为：【具有的字段为：public_key、token_id、token_permissions、token_symbol、balance、balance、nonce、receipt_chain_hash、delegate、voting_for、timing、permissions、zkapp、zkapp_url。】

type t =
        ( Public_key.Compressed.Stable.V1.t
        , Token_id.Stable.V1.t
        , Token_permissions.Stable.V1.t
        , Token_symbol.Stable.V1.t
        , Balance.Stable.V1.t
        , Nonce.Stable.V1.t
        , Receipt.Chain_hash.Stable.V1.t
        , Public_key.Compressed.Stable.V1.t option
        , State_hash.Stable.V1.t
        , Timing.Stable.V1.t
        , Permissions.Stable.V2.t
        , Zkapp_account.Stable.V2.t option
        , string )
        (* TODO: Cache the digest of this? *)
        Poly.Stable.V2.t

type ( 'pk
           , 'id
           , 'token_permissions
           , 'token_symbol
           , 'amount
           , 'nonce
           , 'receipt_chain_hash
           , 'delegate
           , 'state_hash
           , 'timing
           , 'permissions
           , 'zkapp_opt
           , 'zkapp_uri )
           t =
        { public_key : 'pk
        ; token_id : 'id
        ; token_permissions : 'token_permissions
        ; token_symbol : 'token_symbol
        ; balance : 'amount
        ; nonce : 'nonce
        ; receipt_chain_hash : 'receipt_chain_hash
        ; delegate : 'delegate
        ; voting_for : 'state_hash
        ; timing : 'timing
        ; permissions : 'permissions
        ; zkapp : 'zkapp_opt
        ; zkapp_uri : 'zkapp_uri
        }

3.4 Staged_ledger_diff结构

Staged_ledger_diff结构为：

type t =
    Pre_diff_with_at_most_two_coinbase.t
    * Pre_diff_with_at_most_one_coinbase.t option

(* Pre_diff_with_at_most_two_coinbase结构为： *)
module Pre_diff_with_at_most_two_coinbase : sig
  type t =
    (Transaction_snark_work.t, 
    	User_command.t With_status.t) 
    	Pre_diff_two.t
(* With_status中字段有： *)
type 'a t = { data : 'a;  (* data字段为User_command类型 *)
				status : Transaction_status.Stable.V2.t }
(* Pre_diff_two中字段有： *)
type ('a, 'b) t =
        { completed_works : 'a list (* completed_works为数组，元素均为Transaction_snark_work类型 *)
        ; commands : 'b list (* commands为数组，元素均为With_status类型 *)
        ; coinbase : Ft.Stable.V1.t At_most_two.Stable.V1.t
        ; internal_command_balances :
            Transaction_status.Internal_command_balance_data.Stable.V1.t list (* 数组 *)
        }

(* Transaction_status为枚举类型： *)
type t = Applied | Failed of Failure.Collection.Stable.V1.t
(* User_command *)
type t =
        ( Signed_command.With_valid_signature.Stable.V2.t
        , Parties.Valid.Stable.V1.t )
        Poly.Stable.V2.t (* 为枚举类型：type ('u, 's) t = Signed_command of 'u | Parties of 's *)
(* Signed_command： *)
type t =
      ( Payload.Stable.V2.t
      , Public_key.Stable.V1.t
      , Signature.Stable.V1.t )
      Poly.Stable.V1.t
type ('payload, 'pk, 'signature) t =
        { payload : 'payload; signer : 'pk; signature : 'signature }

(* Pre_diff_with_at_most_one_coinbase结构为： *)
type t =
        ( Transaction_snark_work.Stable.V2.t
        , User_command.Stable.V2.t With_status.Stable.V2.t )
        Pre_diff_one.Stable.V1.t
(* Pre_diff_one中字段有： *)
type ('a, 'b) t =
        { completed_works : 'a list
        ; commands : 'b list
        ; coinbase : Ft.Stable.V1.t At_most_one.Stable.V1.t
        ; internal_command_balances :
            Transaction_status.Internal_command_balance_data.Stable.V1.t list
        }

4. External transition

external transition结构为：【等价为Block结构】

(* external transition结构为： *)
type t = Block.t

type t = { header : Header.Stable.V1.t; body : Body.Stable.V1.t }

4.1 Header结构

Header结构为：

type t =
      { protocol_state : Protocol_state.Value.Stable.V2.t
      ; protocol_state_proof : Proof.Stable.V2.t [@sexp.opaque]
      ; delta_block_chain_proof :
          (* TODO: abstract *)
          State_hash.Stable.V1.t * State_body_hash.Stable.V1.t list
      ; current_protocol_version : Protocol_version.Stable.V1.t
      ; proposed_protocol_version_opt : Protocol_version.Stable.V1.t option
      ; body_reference : Body_reference.Stable.V1.t
      }

其中：

（1）protocol_state、protocol_state_proof内容见：Mina概览 第5节“Mina区块结构”。（2）delta_block_chain_proof内容见： Mina中的delta_transition_chain_proof/delta_block_chain_proof（3）current_protocol_version结构为：

type t = { major : int; minor : int; patch : int }

（4）Body_reference结构为：

(* type t = State_body_hash.Stable.V1.t *)
    type t = unit [@@deriving compare, sexp, yojson]

4.2 Body结构

Body结构为：

type t = { staged_ledger_diff : Staged_ledger_diff.Stable.V2.t }

Staged_ledger_diff结构见上面。

5. Breadcrumb

Transition Frontier：为本地data store中包含的网络中的最新 k k k个区块。为rose tree-type数据结构，该tree中的每个节点可能有多个children，即分叉。该tree中的每个节点都可称为breadcrumb。其实就是已验证通过的区块。

Breadcrumb结构为：

type t =
    { validated_transition : Mina_block.Validated.t
    ; staged_ledger : Staged_ledger.t [@sexp.opaque]
    ; just_emitted_a_proof : bool
    ; transition_receipt_time : Time.t option
    }

5.1 Mina_block.Validated结构

Mina_block.Validated结构，即为validated_block结构：【其实就是一个结构体，其data字段为External_transition结构，其hash字段为State_hashes结构（包含state_body_hash和state_hash字段）。以及，一个State_hash*State_hash数组。】

type t = Block.t State_hash.With_state_hashes.t * State_hash.t Non_empty_list.t

1）State_hash.With_state_hashes结构为：【在上面的代码语境中，'a表示的是Block.t结构】

type 'a t = ('a, State_hashes.t) With_hash.t

(* State_hashes.t结构为： *)
type t =
        { mutable state_body_hash : State_body_hash.Stable.V1.t option (* 均为Field.t *)
        ; state_hash : T.Stable.V1.t (* 均为Field.t *)
        }

(* With_hash结构为：【此语境下，'a表示的是Block.t结构，'h表示的是State_hashes结构】*)
type ('a, 'h) t = ('a, 'h) Stable.Latest.t = { data : 'a; hash : 'h }

2）State_hash.t为Field.t，而Non_empty_list结构为：【其实表示的就是State_hash*State_hash数组。此代码语境下，'a表示的State_hash结构。为a tuple of the head and the rest (as a list)】

type 'a t = 'a * 'a list 

5.2 Staged_ledger结构

Staged_ledger结构为：

type t =
    { scan_state : Scan_state.t
    ; ledger :
        ((* Invariant: this is the ledger after having applied all the
            transactions in the above state. *)
         Ledger.attached_mask
        [@sexp.opaque])
    ; constraint_constants : Genesis_constants.Constraint_constants.t
    ; pending_coinbase_collection : Pending_coinbase.t
    }

5.2.1 Scan_state结构

Scan_state结构为：【等价为Transaction_snark_scan_state】

type t =
      ( Ledger_proof_with_sok_message.Stable.V2.t
      , Transaction_with_witness.Stable.V2.t )
      Parallel_scan.State.Stable.V1.t

type ('merge, 'base) t = ('merge, 'base) Binable_arg.Stable.V1.t =
        { trees :
            ('merge Merge.Stable.V1.t, 'base Base.Stable.V1.t) Tree.Stable.V1.t
            Non_empty_list.Stable.V1.t
              (*use non empty list*)
        ; acc : ('merge * 'base list) option
              (*last emitted proof and the corresponding transactions*)
        ; curr_job_seq_no : int
              (*Sequence number for the jobs added every block*)
        ; max_base_jobs : int (*transaction_capacity_log_2*)
        ; delay : int
        }

1）Ledger_proof_with_sok_message结构为：【其中Ledger_proof结构见上面3.2节。】

type t = Ledger_proof.Stable.V2.t * Sok_message.Stable.V1.t

(* Sok_message结构为： *)
type t =
      { fee : Currency.Fee.Stable.V1.t
      ; prover : Public_key.Compressed.Stable.V1.t
      }

2）Transaction_with_witness结构为：

(* TODO: The statement is redundant here - it can be computed from the
     witness and the transaction
  *)
  type t =
    { transaction_with_info :
        Mina_transaction_logic.Transaction_applied.Stable.V2.t
    ; state_hash : State_hash.Stable.V1.t * State_body_hash.Stable.V1.t
    ; statement : Transaction_snark.Statement.Stable.V2.t
    ; init_stack :
        Transaction_snark.Pending_coinbase_stack_state.Init_stack.Stable.V1
        .t
    ; ledger_witness : Mina_ledger.Sparse_ledger.Stable.V2.t [@sexp.opaque]
    }

2.1）Mina_transaction_logic.Transaction_applied结构为：

type t =
    { previous_hash : Ledger_hash.Stable.V1.t (* 为Field.t结构 *)
    ; varying : Varying.Stable.V2.t
    }
(* Varying为枚举结构： *)
type t =
      | Command of Command_applied.Stable.V2.t
      | Fee_transfer of Fee_transfer_applied.Stable.V2.t
      | Coinbase of Coinbase_applied.Stable.V2.t
(* Command_applied结构为： *)
type t =
      | Signed_command of Signed_command_applied.Stable.V2.t
      | Parties of Parties_applied.Stable.V1.t
(* Signed_command_applied结构为： *)
type t = { common : Common.Stable.V2.t; body : Body.Stable.V2.t }
(* Parties_applied结构为： *)
type t =
      { accounts :
          (Account_id.Stable.V2.t * Account.Stable.V2.t option) list
      ; command : Parties.Stable.V1.t With_status.Stable.V2.t
      ; previous_empty_accounts : Account_id.Stable.V2.t list
      }
      
(* Fee_transfer_applied结构为： *)
type t =
      { fee_transfer : Fee_transfer.Stable.V2.t
      ; previous_empty_accounts : Account_id.Stable.V2.t list
      ; receiver_timing : Account.Timing.Stable.V1.t
      }
 (* Coinbase_applied结构为： *)
 type t =
      { coinbase : Coinbase.Stable.V1.t
      ; previous_empty_accounts : Account_id.Stable.V2.t list
      ; receiver_timing : Account.Timing.Stable.V1.t
      }

2.2）Transaction_snark.Statement结构为：

type t =
    ( Frozen_ledger_hash.Stable.V1.t
    , Currency.Amount.Stable.V1.t
    , Pending_coinbase.Stack_versioned.Stable.V1.t
    , Fee_excess.Stable.V1.t
    , unit
    , Local_state.Stable.V1.t )
    Poly.Stable.V2.t

    type ( 'ledger_hash
         , 'amount
         , 'pending_coinbase
         , 'fee_excess
         , 'sok_digest
         , 'local_state )
         t =
      { source :
          ( 'ledger_hash
          , 'pending_coinbase
          , 'local_state )
          Registers.Stable.V1.t
      ; target :
          ( 'ledger_hash
          , 'pending_coinbase
          , 'local_state )
          Registers.Stable.V1.t
      ; supply_increase : 'amount
      ; fee_excess : 'fee_excess
      ; sok_digest : 'sok_digest
      }

Pending_coinbase.Stack_versioned结构为：

type t =
    (Coinbase_stack.Stable.V1.t, (* 为Field.t *)
    State_stack.Stable.V1.t) 
    Poly.Stable.V1.t
    
type ('data_stack, 'state_stack) t =
      { data : 'data_stack; 
      state : 'state_stack }
      
(* State_stack结构为： *)
type t = Stack_hash.Stable.V1.t (* 为Field.t *)
              Poly.Stable.V1.t
type 'stack_hash t = { init : 'stack_hash; curr : 'stack_hash }

2.3） Transaction_snark.Pending_coinbase_stack_state.Init_stack结构为：【为Pending_coinbase.Stack_versioned】

type t = Base of Pending_coinbase.Stack_versioned.Stable.V1.t | Merge

5.2.2 Ledger.attached_mask结构

Ledger.attached_mask结构为：【等效为Mask.Attached.t，见masking_merkle_tree.ml】

type t =
    { uuid : Uuid.Stable.V1.t
    ; account_tbl : Account.t Location_binable.Table.t
    ; token_owners : Account_id.Stable.Latest.t Token_id.Table.t
    ; mutable parent : Parent.t
    ; detached_parent_signal : Detached_parent_signal.t
    ; hash_tbl : Hash.t Addr.Table.t
    ; location_tbl : Location.t Account_id.Table.t
    ; mutable current_location : Location.t option
    ; depth : int
    }

5.2.3 Genesis_constants.Constraint_constants结构

Genesis_constants.Constraint_constants结构为：

(** Constants that affect the constraint systems for proofs (and thus also key
    generation).

    Care must be taken to ensure that these match against the proving/
    verification keys when [proof_level=Full], otherwise generated proofs will
    be invalid.
*)
module Constraint_constants = struct
  type t =
    { sub_windows_per_window : int
    ; ledger_depth : int
    ; work_delay : int
    ; block_window_duration_ms : int
    ; transaction_capacity_log_2 : int
    ; pending_coinbase_depth : int
    ; coinbase_amount : Currency.Amount.Stable.Latest.t
    ; supercharged_coinbase_factor : int
    ; account_creation_fee : Currency.Fee.Stable.Latest.t
    ; fork : Fork_constants.t option
    }

5.2.4 Pending_coinbase结构

Pending_coinbase结构为：

(* A pending coinbase is basically a Merkle tree of "stacks", each of which contains two hashes. The first hash
   is computed from the components in the coinbase via a "push" operation. The second hash, a protocol
   state hash, is computed from the state *body* hash in the coinbase.
   The "add_coinbase" operation takes a coinbase, retrieves the latest stack, or creates a new one, and does
   a push.

   A pending coinbase also contains a stack id, used to determine the chronology of stacks, so we can know
   which is the oldest, and which is the newest stack.

   The name "stack" here is a misnomer: see issue #3226
 *)
type t =
      ( Merkle_tree_versioned.Stable.V2.t
      , Stack_id.Stable.V1.t )  (* 为int *)
      Poly_versioned.Stable.V1.t

type ('tree, 'stack_id) t = ('tree, 'stack_id) T.Poly.t =
        { tree : 'tree; pos_list : 'stack_id list; new_pos : 'stack_id }

Merkle_tree_versioned结构为：

type t =
        ( Hash_versioned.Stable.V1.t (* 为Field.t *)
        , Stack_id.Stable.V1.t (* 为int *)
        , Stack_versioned.Stable.V1.t ) (* 见上面Stack_versioned *)
        Sparse_ledger_lib.Sparse_ledger.T.Stable.V2.t

type ('hash, 'key, 'account) t =
        { indexes : ('key * int) list
        ; depth : int
        ; tree : ('hash, 'account) Tree.Stable.V1.t
        }

附录1. Mina系列博客

Mina系列博客有：

Mina概览Mina的支付流程Mina的zkAppMina中的Pasta（Pallas和Vesta）曲线Mina中的Schnorr signatureMina中的Pickles SNARKMina中的Kimchi SNARKMina Kimchi SNARK 代码解析Mina Berkeley QANet测试网zkApp初体验Mina中的Poseidon hashMina中的多项式承诺方案Recursive SNARKs总览Mina技术白皮书Mina代码解析Mina中的Snark WorkerMina中的Scan StateMina中的VRFMina中的delta_transition_chain_proof/delta_block_chain_proofMina中的stake delegationMina如何实现22KB？Mina中的stake_proof