Struct Peer

pub struct Peer<T: AsyncWrite + Unpin + Send + Sync> {

    mempool: Arc<Mutex<Mempool>>,
    blocks_only: bool,
    services: ServiceFlags,
    user_agent: String,
    messages: u64,
    start_time: Instant,
    last_message: Instant,
    last_addrv2: Instant,
    last_inv: Instant,
    current_best_block: i32,
    last_ping: Option<Instant>,
    id: u32,
    node_tx: UnboundedSender<NodeNotification>,
    state: State,
    send_headers: bool,
    node_requests: UnboundedReceiver<NodeRequest>,
    address: LocalAddress,
    kind: ConnectionKind,
    wants_addrv2: bool,
    shutdown: bool,
    actor_receiver: UnboundedReceiver<ReaderMessage>,
    writer: WriteTransport<T>,
    our_user_agent: String,
    our_best_block: u32,
    cancellation_sender: Option<Sender<()>>,
    transport_protocol: TransportProtocol,
}

Fields

mempool: Arc<Mutex<Mempool>>

blocks_only: bool

services: ServiceFlags

user_agent: String

messages: u64

start_time: Instant

last_message: Instant

last_addrv2: Instant

last_inv: Instant

current_best_block: i32

last_ping: Option<Instant>

id: u32

node_tx: UnboundedSender<NodeNotification>

state: State

send_headers: bool

node_requests: UnboundedReceiver<NodeRequest>

address: LocalAddress

kind: ConnectionKind

wants_addrv2: bool

shutdown: bool

actor_receiver: UnboundedReceiver<ReaderMessage>

writer: WriteTransport<T>

our_user_agent: String

our_best_block: u32

cancellation_sender: Option<Sender<()>>

transport_protocol: TransportProtocol

Implementations

impl<T: AsyncWrite + Unpin + Send + Sync> Peer<T>

pub async fn read_loop(self) -> Result<Self, PeerError>

async fn peer_loop_inner(&mut self) -> Result<(), PeerError>

pub async fn handle_node_request( &mut self, request: NodeRequest, ) -> Result<(), PeerError>

pub async fn handle_peer_message( &mut self, message: NetworkMessage, time: Instant, ) -> Result<(), PeerError>

impl<T: AsyncWrite + Unpin + Send + Sync> Peer<T>

pub async fn write(&mut self, msg: NetworkMessage) -> Result<(), PeerError>

pub async fn handle_get_data(&mut self, inv: Inventory) -> Result<(), PeerError>

pub fn create_peer<W: AsyncWrite + Unpin + Send + Sync + 'static>( id: u32, address: LocalAddress, mempool: Arc<Mutex<Mempool>>, node_tx: UnboundedSender<NodeNotification>, node_requests: UnboundedReceiver<NodeRequest>, kind: ConnectionKind, actor_receiver: UnboundedReceiver<ReaderMessage>, writer: WriteTransport<W>, our_user_agent: String, our_best_block: u32, cancellation_sender: Sender<()>, transport_protocol: TransportProtocol, )

async fn handle_ping(&mut self, nonce: u64) -> Result<(), PeerError>

async fn handle_version( &mut self, version: VersionMessage, ) -> Result<(), PeerError>

fn send_to_node(&self, message: PeerMessages, time: Instant)

Trait Implementations

impl<T: AsyncWrite + Unpin + Send + Sync> Debug for Peer<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.