p2p_dart #

Serverless peer-to-peer networking for Dart.
Direct, encrypted connections between Dart applications — no central server required.

✨ Features #

🚀 Quick Start #

1. Add to pubspec.yaml #

dependencies:
  p2p_dart: ^1.0.0

2. Minimal example #

import 'package:p2p_dart/p2p_dart.dart';

void main() async {
  // Create a node with bootstrap peers.
  final node = P2PNode(
    config: P2PConfig(
      bootstrapPeers: ['<known-peer-id>'],
    ),
  );

  // Start the node — initialises DHT & WebRTC.
  await node.initialize();
  print('Online: ${node.peerId}');

  // Listen for incoming messages.
  node.eventBus.on<MessageReceivedEvent>((event) {
    print('[${event.senderId.substring(0, 8)}]: ${event.data}');
  });

  // Connect and send.
  await node.connect('<remote-peer-id>');
  await node.send('<remote-peer-id>', {'hello': 'world'});

  // Store a value in the DHT.
  await node.dhtPut('my-key', 'my-value');

  // Retrieve it later (from any node in the network).
  final value = await node.dhtGet('my-key');
  print(value); // 'my-value'
}

📖 API Overview #

P2PNode #

The central class — creates, manages, and tears down the P2P node.

P2PConfig #

P2PConfig(
  peerId: null,                   // auto-generated if null
  bootstrapPeers: [...],          // shorthand for dht.bootstrapPeers
  dht: DHTConfig(
    bootstrapPeers: [...],
    bucketSize: 20,               // Kademlia k
    alpha: 3,                     // lookup parallelism
    replicationFactor: 3,
    valueTtl: Duration(hours: 24),
  ),
  webrtc: WebRTCConfig(
    stunServers: [StunServerConfig('stun.l.google.com')],
    turnServers: [TurnServerConfig(host: '…', username: '…', credential: '…')],
    connectionTimeout: Duration(seconds: 30),
  ),
  security: SecurityConfig(
    enforceEncryption: true,
    requireAuthentication: false,
  ),
  performance: PerformanceConfig(
    maxConnections: 100,
    maxMessageSize: 65536,
    heartbeatInterval: Duration(seconds: 30),
    enableCompression: false,
  ),
  logging: LoggingConfig(verbose: false),
)

EventBus #

Type-safe publish/subscribe:

// Subscribe
final sub = node.eventBus.on<MessageReceivedEvent>((event) { … });

// One-shot
node.eventBus.once<PeerConnectedEvent>((event) { … });

// Await next event
final event = await node.eventBus.next<NodeStartedEvent>();

// As a stream
node.eventBus.stream<PeerLeftEvent>().listen((event) { … });

// Cancel
sub.cancel();

Available Events

Connection #

Individual connection object returned by node.connect():

final conn = await node.connect(remotePeerId);

// Send
await conn.send({'key': 'value'});
await conn.sendText('raw string');
await conn.sendBinary(Uint8List.fromList([…]));

// Receive
conn.onData.listen((msg) => print(msg.payload));
conn.onStateChange.listen((state) => print(state));

// Stats
print(conn.stats());

// Close
await conn.close();

🔐 Security #

All connections are secured by default:

1. DTLS — DTLS 1.2 (handled by WebRTC engine) with certificate fingerprint exchange.
2. ECDH Key Exchange — Ephemeral P-256 key pairs; shared secret derived per-session.
3. AES-256-GCM — All application messages encrypted end-to-end.
4. HMAC-SHA256 — Each encrypted envelope is authenticated.
5. Challenge-Response Auth — Optional peer identity verification.

P2PConfig(
  security: SecurityConfig(
    enforceEncryption: true,
    requireAuthentication: true,
    trustedPeers: ['<trusted-peer-id>', …],
  ),
)

💾 Distributed Hash Table #

p2p_dart includes a full Kademlia DHT:

// Store any JSON value.
await node.dhtPut('user:alice', jsonEncode({'name': 'Alice', 'score': 100}));

// Retrieve from anywhere in the network.
final raw = await node.dhtGet('user:alice');
final user = jsonDecode(raw!);

// Content-addressable (key = SHA-1 of value).
final storage = DecentralisedStorage();
final casKey = await storage.putCas({'data': 'important'});
final doc = await storage.getCas(casKey);

📁 Project Structure #

lib/
├── p2p_dart.dart              # Public exports
└── src/
    ├── core/
    │   ├── p2p_node.dart      # ⭐ Main entry point
    │   ├── connection.dart    # Individual peer connection
    │   ├── channel_manager.dart
    │   ├── peer_info.dart
    │   ├── p2p_config.dart
    │   ├── enums.dart
    │   └── exceptions.dart
    ├── dht/
    │   ├── dht_network.dart   # Kademlia DHT
    │   ├── routing_table.dart
    │   ├── kademlia.dart      # XOR metric + ID utilities
    │   ├── bucket.dart
    │   └── dht_config.dart
    ├── webrtc/
    │   ├── webrtc_manager.dart
    │   ├── webrtc_config.dart
    │   ├── ice_configuration.dart
    │   ├── stun_client.dart
    │   └── data_channel_wrapper.dart
    ├── networking/
    │   ├── message.dart
    │   ├── message_handler.dart
    │   ├── packet.dart
    │   └── transport.dart
    ├── security/
    │   ├── encryption.dart    # AES-256-GCM
    │   ├── key_exchange.dart  # ECDH P-256
    │   ├── dtls_handler.dart
    │   ├── crypto_utils.dart
    │   └── auth_manager.dart
    ├── discovery/
    │   ├── peer_discovery.dart
    │   ├── local_network.dart # mDNS
    │   └── peer_cache.dart
    ├── events/
    │   ├── event_bus.dart
    │   └── events.dart
    ├── utils/
    │   ├── logger.dart
    │   ├── async_utils.dart
    │   ├── buffer_manager.dart
    │   └── validators.dart
    └── extensions/
        ├── stream_extensions.dart
        ├── future_extensions.dart
        └── string_extensions.dart

example/
├── simple_chat.dart           # CLI chat application
├── file_sharing.dart          # Chunked file transfer
├── multiplayer_game.dart      # Real-time game state sync
└── decentralized_storage.dart # DHT key-value store

test/
├── unit/                      # Unit tests (Kademlia, crypto, events…)
├── integration/               # Node lifecycle tests
└── performance/               # Throughput benchmarks

🧪 Running Tests #

dart pub get
dart test                          # All tests
dart test test/unit/               # Unit tests only
dart test test/performance/        # Benchmarks
dart test --coverage=coverage/     # With coverage

📚 Examples #

# P2P Chat (terminal A)
dart run example/simple_chat.dart

# P2P Chat (terminal B — paste peer ID from A)
dart run example/simple_chat.dart <peer-id-from-A>

# File sharing
dart run example/file_sharing.dart <target-peer-id> /path/to/file.txt

# Decentralised storage demo
dart run example/decentralized_storage.dart

# Multiplayer game demo
dart run example/multiplayer_game.dart

⚡ Performance #

🗺️ Roadmap #

• ❌ Flutter WebRTC integration (flutter_webrtc / dart_webrtc)
• ❌ mDNS via multicast_dns package
• ❌ Noise protocol upgrade for handshake
• ❌ QUIC transport support
• ❌ Pub.dev publication
• ❌ GitHub Actions CI workflow

🤝 Contributing #

1. Fork the repo.
2. Create a feature branch: git checkout -b feat/my-feature.
3. Run tests: dart test.
4. Open a PR against main.

📄 License #

MIT © 2026 p2p_dart contributors — see LICENSE.