High-Performance P2P Networking for Modern Applications

#include "node/node.h"
#include "subsystems/dht_discovery.h"
#include <iostream>
#include <thread>
#include <chrono>

using namespace librats;

int main() {
    NodeConfig config;
    config.listen_port = 8080;
    // The protocol is bound into the handshake: only peers with the exact same
    // (name/version) can complete a connection.
    config.protocol = "my_app/1.0";

    Node node(config);

    // DHT discovery announces + searches under a discovery key and dials any
    // peers it finds. An empty key defaults to config.protocol, so peers of the
    // same app/version discover each other automatically.
    node.add_subsystem(std::make_unique<DhtDiscovery>(DhtDiscovery::Config{}));

    node.on_peer_connected([](const Peer& peer) {
        std::cout << "Discovered peer: " << peer.id().short_hex() << std::endl;
    });

    std::cout << "Protocol: " << node.protocol() << std::endl;

    // start() brings up the DHT; announcing + searching runs on its own thread.
    node.start();

    std::this_thread::sleep_for(std::chrono::minutes(5));  // let discovery run
    node.stop();
    return 0;
}

#include "node/node.h"
#include "subsystems/message_json.h"
#include <iostream>
#include <string>

using namespace librats;

int main() {
    Node node(NodeConfig{/*listen_port=*/8080});
    node.add_subsystem(std::make_unique<MessageJson>());  // reached via node.json()

    // Typed JSON handlers. The sender is the AUTHENTICATED PeerId from the
    // handshake — it cannot be spoofed by a field in the payload.
    node.json()->on("chat", [](const PeerId& from, const librats::Json& data) {
        std::cout << "[CHAT] " << from.short_hex() << ": "
                  << data.value("message", "") << std::endl;
    });

    node.json()->on("user_join", [](const PeerId& from, const librats::Json& data) {
        std::cout << "[JOIN] " << data.value("username", "") << " joined" << std::endl;
    });

    // Announce ourselves whenever a peer connects.
    node.on_peer_connected([&](const Peer& peer) {
        std::cout << "✅ Peer connected: " << peer.id().short_hex() << std::endl;
        node.json()->send("user_join",
            librats::Json{{"username", "User_" + node.local_id().short_hex()}});
    });

    node.start();

    // Broadcast a chat message to all connected peers.
    node.json()->send("chat", librats::Json{{"message", "Hello, P2P chat!"}});

    return 0;
}

#include "node/node.h"
#include "subsystems/pubsub.h"
#include "subsystems/dht_discovery.h"
#include <iostream>

using namespace librats;

int main() {
    Node node(NodeConfig{/*listen_port=*/8080});
    auto* pubsub = node.add_subsystem(std::make_unique<PubSub>());
    node.add_subsystem(std::make_unique<DhtDiscovery>(DhtDiscovery::Config{}));  // find peers to gossip with

    // Optional: validate inbound messages before they are delivered or forwarded.
    pubsub->set_validator("chat", [](const PeerId& from, const std::string& topic, ByteView data) {
        // Only accept messages shorter than 1000 bytes.
        return data.size() <= 1000 ? ValidationResult::Accept : ValidationResult::Reject;
    });

    // Subscribe: installs the delivery handler and joins the topic mesh.
    pubsub->subscribe("chat", [](const PeerId& from, const std::string& topic, ByteView data) {
        std::cout << "Chat from " << from.short_hex() << ": "
                  << std::string(reinterpret_cast<const char*>(data.data()), data.size()) << std::endl;
    });

    node.start();

    // Publish along the mesh — relayed to every subscriber, even several hops away.
    std::string msg = "Hello, GossipSub world!";
    pubsub->publish("chat", ByteView(msg));

    return 0;
}

#include "node/node.h"
#include "subsystems/file_transfer.h"
#include <iostream>

using namespace librats;

int main() {
    Node node(NodeConfig{/*listen_port=*/8080});

    // Stage in-progress downloads in ./downloads; chunk size, window and
    // integrity verification are set through FileTransfer::Config if needed.
    auto* files = node.add_subsystem(std::make_unique<FileTransfer>("./downloads"));

    files->on_progress([](const FileTransfer::Progress& p) {
        std::cout << "\ud83d\udcc1 Transfer " << p.id
                  << ": " << (int)p.percent() << "% complete"
                  << " (" << (p.transfer_rate_bps / 1024) << " KB/s)" << std::endl;
    });

    files->on_complete([](uint64_t id, bool success, const std::string& path) {
        if (success) {
            std::cout << "\u2705 Transfer completed: " << path << std::endl;
        } else {
            std::cout << "\u274c Transfer failed: " << path << std::endl;
        }
    });

    // Auto-accept incoming offers into ./downloads. Per-chunk CRC32 and a
    // whole-file SHA-256 are verified before each file is moved into place.
    files->on_offer([&](const FileTransfer::Offer& offer) {
        std::cout << "\ud83d\udce5 Incoming: " << offer.name
                  << " from " << offer.from.short_hex() << std::endl;
        files->accept(offer.from, offer.id, "./downloads/" + offer.name);
    });

    node.start();

    std::cout << "File transfer ready. Connect peers and exchange files!" << std::endl;

    // With a peer's id (e.g. from on_peer_connected), send a file or a directory:
    // files->send_file(peer_id, "my_file.txt");
    // files->send_directory(peer_id, "./my_folder");

    return 0;
}