swift-libp2p

dependencies: [
    .package(url: "https://github.com/example/swift-libp2p.git", from: "0.1.0")
]

.target(
    name: "YourApp",
    dependencies: [
        "P2P",
        "P2PTransportTCP",
        "P2PSecurityNoise",
        "P2PMuxYamux"
    ]
)

import P2P
import P2PTransportTCP
import P2PSecurityNoise
import P2PMuxYamux

// Create a node
let keyPair = KeyPair.generateEd25519()
let config = NodeConfiguration(
    keyPair: keyPair,
    listenAddresses: [Multiaddr("/ip4/0.0.0.0/tcp/4001")!],
    transports: [TCPTransport()],
    security: [NoiseUpgrader()],
    muxers: [YamuxMuxer()],
    limits: ConnectionLimits(maxConnections: 100)
)

let node = Node(configuration: config)

// Register protocol handler
await node.handle("/chat/1.0.0") { stream in
    // Handle incoming chat messages
    let data = try await stream.read()
    print("Received: \(String(data: data, encoding: .utf8)!)")
}

// Start the node
try await node.start()
print("Node started with PeerID: \(await node.peerID)")

// Connect to a peer
let remotePeer = try await node.connect(
    to: Multiaddr("/ip4/192.168.1.100/tcp/4001/p2p/12D3KooW...")!
)

// Open a stream
let stream = try await node.newStream(to: remotePeer, protocol: "/chat/1.0.0")
try await stream.write(Data("Hello!".utf8))

// Services implement EventEmitting protocol
public final class MyService: EventEmitting, Sendable {
    public var events: AsyncStream<MyEvent> { ... }
    public func shutdown() { ... }  // Required: terminates event stream
}

// Safe usage with automatic cleanup
try await withEventEmitter(myService) { service in
    for await event in service.events {
        // Handle events
    }
}
// shutdown() called automatically

let node = Node(configuration: NodeConfiguration(
    keyPair: myKeyPair,
    transports: [TCPTransport()],      // Injectable
    security: [NoiseUpgrader()],       // Injectable
    muxers: [YamuxMuxer()]             // Injectable
))

let limits = ConnectionLimits(
    maxConnections: 100,
    maxConnectionsPerPeer: 2,
    idleTimeout: .seconds(60)
)

let policy = ReconnectionPolicy(
    enabled: true,
    maxAttempts: 5,
    backoff: .exponential(base: .seconds(1), factor: 2.0, maxDelay: .seconds(60))
)

let gater = ConnectionGater(
    allowlist: [trustedPeerID],
    denylist: [blockedPeerID],
    customFilter: { peer, direction in
        // Custom filtering logic
        return true
    }
)

// Node events
for await event in await node.events {
    switch event {
    case .peerConnected(let peer):
        print("Connected to \(peer)")
    case .peerDisconnected(let peer):
        print("Disconnected from \(peer)")
    case .listenError(let addr, let error):
        print("Listen error on \(addr): \(error)")
    case .connectionError(let peer, let error):
        print("Connection error: \(error)")
    }
}

// Service events (e.g., GossipSub)
let gossipsub = GossipSubService(...)
Task {
    for await event in gossipsub.events {
        switch event {
        case .messageReceived(let topic, let message):
            print("Received on \(topic): \(message)")
        case .peerJoined(let topic, let peer):
            print("\(peer) joined \(topic)")
        default: break
        }
    }
}

// Don't forget to shutdown when done!
gossipsub.shutdown()

import P2PTransportQUIC

// QUIC transport with libp2p certificate
let quicTransport = QUICTransport(configuration: .init(
    certificateProvider: .libp2p(keyPair: keyPair)
))

// Listen on QUIC
let listener = try await quicTransport.listen(
    Multiaddr("/ip4/0.0.0.0/udp/4001/quic-v1")!
)

// Dial with QUIC
let connection = try await quicTransport.dial(
    Multiaddr("/ip4/192.168.1.100/udp/4001/quic-v1/p2p/12D3KooW...")!
)

import P2PTransportWebRTC

let webrtcTransport = WebRTCTransport()

// Listen on WebRTC Direct
let listener = try await webrtcTransport.listenSecured(
    Multiaddr("/ip4/0.0.0.0/udp/4001/webrtc-direct")!,
    localKeyPair: keyPair
)

// Dial with WebRTC Direct (certhash from listener's address)
let connection = try await webrtcTransport.dialSecured(
    Multiaddr("/ip4/127.0.0.1/udp/4001/webrtc-direct/certhash/<hash>")!,
    localKeyPair: keyPair
)

import P2PCircuitRelay

let client = RelayClient()
await client.registerHandler(registry: node)

// Reserve a slot on the relay
let reservation = try await client.reserve(on: relayPeerID, using: node)
print("Reserved until: \(reservation.expiration)")
print("Relay addresses: \(reservation.addresses)")

// Connect to target through relay
let connection = try await client.connectThrough(
    relay: relayPeerID,
    to: targetPeerID,
    using: node
)

// Use the relayed connection
try await connection.write(Data("Hello through relay!".utf8))

let server = RelayServer(configuration: .init(
    maxReservations: 128,
    maxCircuitsPerPeer: 16,
    reservationDuration: .seconds(3600)
))

await server.registerHandler(
    registry: node,
    opener: node,
    localPeer: node.peerID,
    getLocalAddresses: { node.listenAddresses }
)