Mina_networking (mina_networking.Mina

exception No_initial_peers

type Structured_log_events.t +=

| Gossip_new_state of {

state_hash : Mina_base.State_hash.t;

}

| Gossip_transaction_pool_diff of {

txns : Network_pool.Transaction_pool.Resource_pool.Diff.t;

}

| Gossip_snark_pool_diff of {

work : Network_pool.Snark_pool.Resource_pool.Diff.compact;

}

val gossip_new_state_structured_events_id : Structured_log_events.id

val gossip_new_state_structured_events_repr : Structured_log_events.repr

val gossip_transaction_pool_diff_structured_events_id : 
  Structured_log_events.id

val gossip_transaction_pool_diff_structured_events_repr : 
  Structured_log_events.repr

val gossip_snark_pool_diff_structured_events_id : Structured_log_events.id

val gossip_snark_pool_diff_structured_events_repr : Structured_log_events.repr

val refused_answer_query_string : string

module Rpcs : sig ... end

module Sinks : module type of Sinks

module Gossip_net : Gossip_net.S with module Rpc_intf := Rpcs

module Config : sig ... end

type t

val peers : t -> Network_peer.Peer.t list Async.Deferred.t

val bandwidth_info : 
  t ->
  ([ `Input of float ] * [ `Output of float ] * [ `Cpu_usage of float ])
    Async.Deferred.Or_error.t

val get_peer_node_status : 
  t ->
  Network_peer.Peer.t ->
  Rpcs.Get_node_status.Node_status.t Async.Deferred.Or_error.t

val add_peer : 
  t ->
  Network_peer.Peer.t ->
  is_seed:bool ->
  unit Async.Deferred.Or_error.t

val on_first_connect : t -> f:( unit -> 'a ) -> 'a Async.Deferred.t

val on_first_high_connectivity : t -> f:( unit -> 'a ) -> 'a Async.Deferred.t

val random_peers : t -> int -> Network_peer.Peer.t list Async.Deferred.t

val get_ancestry : 
  t ->
  Network_peer.Peer.Id.t ->
  ( Consensus.Data.Consensus_state.Value.t, Mina_base.State_hash.t )
    With_hash.t ->
  ( Mina_block.t, Mina_base.State_body_hash.t list * Mina_block.t )
    Proof_carrying_data.t
    Network_peer.Envelope.Incoming.t
    Async.Deferred.Or_error.t

val get_best_tip : 
  ?heartbeat_timeout:Core.Time_ns.Span.t ->
  ?timeout:Core.Time.Span.t ->
  t ->
  Network_peer.Peer.t ->
  ( Mina_block.t, Mina_base.State_body_hash.t list * Mina_block.t )
    Proof_carrying_data.t
    Async.Deferred.Or_error.t

val get_transition_chain_proof : 
  ?heartbeat_timeout:Core.Time_ns.Span.t ->
  ?timeout:Core.Time.Span.t ->
  t ->
  Network_peer.Peer.t ->
  Mina_base.State_hash.t ->
  (Mina_base.State_hash.t * Mina_base.State_body_hash.t Core.List.t)
    Async.Deferred.Or_error.t

val get_transition_chain : 
  ?heartbeat_timeout:Core.Time_ns.Span.t ->
  ?timeout:Core.Time.Span.t ->
  t ->
  Network_peer.Peer.t ->
  Mina_base.State_hash.t list ->
  Mina_block.t list Async.Deferred.Or_error.t

val get_staged_ledger_aux_and_pending_coinbases_at_hash : 
  t ->
  Network_peer.Peer.Id.t ->
  Mina_base.State_hash.t ->
  (Staged_ledger.Scan_state.t
   * Mina_base.Ledger_hash.t
   * Mina_base.Pending_coinbase.t
   * Mina_state.Protocol_state.value list)
    Async.Deferred.Or_error.t

val ban_notify : 
  t ->
  Network_peer.Peer.t ->
  Core.Time.t ->
  unit Async.Deferred.Or_error.t

val broadcast_state : 
  t ->
  Mina_block.t Mina_base.State_hash.With_state_hashes.t ->
  unit Async.Deferred.t

val broadcast_snark_pool_diff : 
  t ->
  Network_pool.Snark_pool.Resource_pool.Diff.t ->
  unit Async.Deferred.t

val broadcast_transaction_pool_diff : 
  t ->
  Network_pool.Transaction_pool.Resource_pool.Diff.t ->
  unit Async.Deferred.t

val glue_sync_ledger : 
  t ->
  preferred:Network_peer.Peer.t list ->
  (Mina_base.Ledger_hash.t * Mina_ledger.Sync_ledger.Query.t)
    Pipe_lib.Linear_pipe.Reader.t ->
  (Mina_base.Ledger_hash.t
   * Mina_ledger.Sync_ledger.Query.t
   * Mina_ledger.Sync_ledger.Answer.t Network_peer.Envelope.Incoming.t)
    Pipe_lib.Linear_pipe.Writer.t ->
  unit

val query_peer : 
  ?heartbeat_timeout:Core.Time_ns.Span.t ->
  ?timeout:Core.Time.Span.t ->
  t ->
  Network_peer.Peer.Id.t ->
  ( 'q, 'r ) Rpcs.rpc ->
  'q ->
  'r Network_peer.Rpc_intf.rpc_response Async.Deferred.t

val restart_helper : t -> unit

val initial_peers : t -> Mina_net2.Multiaddr.t list

val connection_gating_config : 
  t ->
  Mina_net2.connection_gating Async.Deferred.t

val set_connection_gating_config : 
  t ->
  Mina_net2.connection_gating ->
  Mina_net2.connection_gating Async.Deferred.t

val ban_notification_reader : 
  t ->
  Gossip_net.ban_notification Pipe_lib.Linear_pipe.Reader.t

val create : 
  Config.t ->
  sinks:Sinks.t ->
  get_some_initial_peers:
    ( Rpcs.Get_some_initial_peers.query Network_peer.Envelope.Incoming.t ->
      Rpcs.Get_some_initial_peers.response Async.Deferred.t ) ->
  get_staged_ledger_aux_and_pending_coinbases_at_hash:
    ( Rpcs.Get_staged_ledger_aux_and_pending_coinbases_at_hash.query
        Network_peer.Envelope.Incoming.t ->
      Rpcs.Get_staged_ledger_aux_and_pending_coinbases_at_hash.response
        Async.Deferred.t ) ->
  answer_sync_ledger_query:
    ( Rpcs.Answer_sync_ledger_query.query Network_peer.Envelope.Incoming.t ->
      Rpcs.Answer_sync_ledger_query.response Async.Deferred.t ) ->
  get_ancestry:
    ( Rpcs.Get_ancestry.query Network_peer.Envelope.Incoming.t ->
      Rpcs.Get_ancestry.response Async.Deferred.t ) ->
  get_best_tip:
    ( Rpcs.Get_best_tip.query Network_peer.Envelope.Incoming.t ->
      Rpcs.Get_best_tip.response Async.Deferred.t ) ->
  get_node_status:
    ( Rpcs.Get_node_status.query Network_peer.Envelope.Incoming.t ->
      Rpcs.Get_node_status.response Async.Deferred.t ) ->
  get_transition_chain_proof:
    ( Rpcs.Get_transition_chain_proof.query Network_peer.Envelope.Incoming.t ->
      Rpcs.Get_transition_chain_proof.response Async.Deferred.t ) ->
  get_transition_chain:
    ( Rpcs.Get_transition_chain.query Network_peer.Envelope.Incoming.t ->
      Rpcs.Get_transition_chain.response Async.Deferred.t ) ->
  get_transition_knowledge:
    ( Rpcs.Get_transition_knowledge.query Network_peer.Envelope.Incoming.t ->
      Rpcs.Get_transition_knowledge.response Async.Deferred.t ) ->
  t Async.Deferred.t