libp2p

package main

import (
    "context"
    "fmt"
    "github.com/libp2p/go-libp2p"
    "github.com/libp2p/go-libp2p/core/host"
    "github.com/libp2p/go-libp2p/core/peer"
    dht "github.com/libp2p/go-libp2p-kad-dht"
    pubsub "github.com/libp2p/go-libp2p-pubsub"
    "github.com/libp2p/go-libp2p/p2p/security/noise"
    "github.com/libp2p/go-libp2p/p2p/muxer/yamux"
    quic "github.com/libp2p/go-libp2p/p2p/transport/quic"
    "github.com/libp2p/go-libp2p/p2p/transport/tcp"
)

func main() {
    ctx := context.Background()

    // libp2p 호스트 생성
    host, err := libp2p.New(
        // 전송 계층: TCP + QUIC
        libp2p.Transport(tcp.NewTCPTransport),
        libp2p.Transport(quic.NewTransport),

        // 리스닝 주소
        libp2p.ListenAddrStrings(
            "/ip4/0.0.0.0/tcp/9000",
            "/ip4/0.0.0.0/udp/9000/quic-v1",
        ),

        // 보안: Noise 프로토콜
        libp2p.Security(noise.ID, noise.New),

        // 멀티플렉싱: yamux
        libp2p.Muxer("/yamux/1.0.0", yamux.DefaultTransport),

        // NAT 홀펀칭 활성화
        libp2p.EnableHolePunching(),
        libp2p.EnableAutoRelay(),
    )
    if err != nil {
        panic(err)
    }
    defer host.Close()

    fmt.Printf("PeerID: %s\n", host.ID())
    fmt.Printf("Addresses: %v\n", host.Addrs())

    // Kademlia DHT 초기화
    kademliaDHT, err := dht.New(ctx, host,
        dht.Mode(dht.ModeServer),  // 풀 DHT 노드
        dht.BootstrapPeers(dht.GetDefaultBootstrapPeerAddrInfos()...),
    )
    if err != nil {
        panic(err)
    }

    // DHT 부트스트랩
    if err := kademliaDHT.Bootstrap(ctx); err != nil {
        panic(err)
    }

    // GossipSub PubSub 생성
    ps, err := pubsub.NewGossipSub(ctx, host,
        pubsub.WithPeerExchange(true),
        pubsub.WithFloodPublish(true),
    )
    if err != nil {
        panic(err)
    }

    // 토픽 조인
    topic, err := ps.Join("filecoin/blocks")
    if err != nil {
        panic(err)
    }

    // 구독
    sub, err := topic.Subscribe()
    if err != nil {
        panic(err)
    }

    // 메시지 수신 고루틴
    go func() {
        for {
            msg, err := sub.Next(ctx)
            if err != nil {
                return
            }
            fmt.Printf("From: %s, Data: %s\n", msg.GetFrom(), msg.Data)
        }
    }()

    // 블록 대기
    select {}
}

use libp2p::{
    core::upgrade,
    gossipsub, identity, kad, noise,
    swarm::{NetworkBehaviour, SwarmEvent},
    tcp, yamux, PeerId, Swarm, Transport,
};
use std::time::Duration;
use tokio::select;

// 커스텀 네트워크 동작 정의
#[derive(NetworkBehaviour)]
struct MyBehaviour {
    kademlia: kad::Behaviour,
    gossipsub: gossipsub::Behaviour,
}

#[tokio::main]
async fn main() -> Result<(), Box> {
    // 키페어 생성 (PeerID 결정)
    let local_key = identity::Keypair::generate_ed25519();
    let local_peer_id = PeerId::from(local_key.public());
    println!("PeerID: {}", local_peer_id);

    // 전송 계층 구성: TCP + Noise + Yamux
    let transport = tcp::tokio::Transport::default()
        .upgrade(upgrade::Version::V1)
        .authenticate(noise::Config::new(&local_key)?)
        .multiplex(yamux::Config::default())
        .boxed();

    // Kademlia DHT 설정
    let store = kad::store::MemoryStore::new(local_peer_id);
    let kademlia = kad::Behaviour::new(local_peer_id, store);

    // GossipSub 설정
    let gossipsub_config = gossipsub::ConfigBuilder::default()
        .heartbeat_interval(Duration::from_secs(1))
        .validation_mode(gossipsub::ValidationMode::Strict)
        .build()
        .expect("Valid config");

    let gossipsub = gossipsub::Behaviour::new(
        gossipsub::MessageAuthenticity::Signed(local_key.clone()),
        gossipsub_config,
    )?;

    // Swarm 생성
    let behaviour = MyBehaviour { kademlia, gossipsub };
    let mut swarm = Swarm::new(
        transport,
        behaviour,
        local_peer_id,
        libp2p::swarm::Config::with_tokio_executor(),
    );

    // 리스닝 시작
    swarm.listen_on("/ip4/0.0.0.0/tcp/0".parse()?)?;

    // 토픽 구독
    let topic = gossipsub::IdentTopic::new("polkadot/transactions");
    swarm.behaviour_mut().gossipsub.subscribe(&topic)?;

    // 이벤트 루프
    loop {
        select! {
            event = swarm.select_next_some() => match event {
                SwarmEvent::NewListenAddr { address, .. } => {
                    println!("Listening on: {}", address);
                }
                SwarmEvent::Behaviour(MyBehaviourEvent::Gossipsub(
                    gossipsub::Event::Message { message, .. }
                )) => {
                    println!(
                        "Received: {} from {:?}",
                        String::from_utf8_lossy(&message.data),
                        message.source
                    );
                }
                SwarmEvent::Behaviour(MyBehaviourEvent::Kademlia(
                    kad::Event::RoutingUpdated { peer, .. }
                )) => {
                    println!("DHT: Added peer {}", peer);
                }
                _ => {}
            }
        }
    }
}