Method handle_swarm_event

p2p/src/node.rs:490–582

(
        &mut self,
        event: NodeSwarmEvent<P, M, S>,
    )

    // TODO fix skip_all
    #[tracing::instrument(skip_all)]
    async fn handle_swarm_event(
        &mut self,
        event: NodeSwarmEvent<P, M, S>,
    ) -> Result<Option<SwarmEventResult>> {
        libp2p_metrics().record(&event);
        match event {
            // outbound events
            SwarmEvent::Behaviour(event) => self.handle_node_event(event).await,
            SwarmEvent::ConnectionEstablished {
                peer_id,
                num_established,
                ..
            } => {
                if let Some(channels) = self.dial_queries.get_mut(&peer_id) {
                    while let Some(channel) = channels.pop() {
                        channel.send(Ok(())).ok();
                    }
                }

                if num_established == 1.try_into().unwrap() {
                    self.emit_network_event(NetworkEvent::PeerConnected(peer_id));
                }
                trace!("ConnectionEstablished: {:}", peer_id);
                Ok(None)
            }
            SwarmEvent::ConnectionClosed {
                peer_id,
                num_established,
                ..
            } => {
                if num_established == 0 {
                    self.emit_network_event(NetworkEvent::PeerDisconnected(peer_id));
                }

                trace!("ConnectionClosed: {:}", peer_id);
                Ok(None)
            }
            SwarmEvent::OutgoingConnectionError { peer_id, error, .. } => {
                trace!("failed to dial: {:?}, {:?}", peer_id, error);

                if let Some(peer_id) = peer_id {
                    if let Some(channels) = self.dial_queries.get_mut(&peer_id) {
                        while let Some(channel) = channels.pop() {
                            channel
                                .send(Err(anyhow!("Error dialing peer {:?}: {}", peer_id, error)))
                                .ok();
                        }
                    }
                }
                Ok(None)
            }
            SwarmEvent::ExternalAddrConfirmed { address } => {
                if let Err(err) = self
                    .peers_tx
                    .send(peers::Message::NewLocalAddresses(vec![address]))
                    .await
                {
                    warn!(