Small, Fast P2P Networking for Real Applications

#include <librats/node/node.h>
#include <librats/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 <librats/node/node.h>
#include <librats/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();
    node.connect("127.0.0.1", 8081);   // or let a discovery subsystem find peers

    // Every line typed becomes a chat message to all connected peers.
    std::string line;
    while (std::getline(std::cin, line))
        node.json()->send("chat", librats::Json{{"message", line}});

    node.stop();
    return 0;
}

#include <librats/node/node.h>
#include <librats/subsystems/pubsub.h>
#include <librats/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 line;
    while (std::getline(std::cin, line))
        pubsub->publish("chat", ByteView(line));

    node.stop();
    return 0;
}

#include <librats/node/node.h>
#include <librats/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 << "📁 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 << "✅ Transfer completed: " << path << std::endl;
        } else {
            std::cout << "❌ 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 << "📥 Incoming: " << offer.name
                  << " from " << offer.from.short_hex() << std::endl;
        files->accept(offer.from, offer.id, "./downloads/" + offer.name);
    });

    node.start();
    node.connect("127.0.0.1", 8081);

    // Once a peer is connected, push a file or a whole directory to it.
    std::cout << "type a path to send it to every peer\n";
    std::string path;
    while (std::getline(std::cin, path))
        for (const auto& p : node.peers())
            files->send_file(p.id, path);          // or files->send_directory(p.id, path)

    node.stop();
    return 0;
}

#include <librats/node/node.h>
#include <librats/subsystems/dht_discovery.h>
#include <librats/subsystems/peer_exchange.h>
#include <librats/subsystems/port_mapping_service.h>
#include <librats/subsystems/hole_punch.h>
#include <librats/subsystems/relay.h>
#include <iostream>
#include <thread>
#include <chrono>

using namespace librats;

int main() {
    NodeConfig config;
    config.listen_port = 8080;
    config.protocol    = "my_app/1.0";
    Node node(config);

    // Find peers: wide-area over the DHT, then grow the mesh by peer exchange.
    node.add_subsystem(std::make_unique<DhtDiscovery>(DhtDiscovery::Config{}));
    node.add_subsystem(std::make_unique<PeerExchange>());

    // Rung 1: ask the router to forward the port (UPnP IGD + NAT-PMP, in parallel).
    node.add_subsystem(std::make_unique<PortMappingService>());

    // Rung 2: UDP hole punching. A peer that PEX learned but could not dial is
    // punched automatically; the rendezvous goes through a peer both sides share.
    node.add_subsystem(std::make_unique<HolePunch>());

    // Rung 3: relay. Carries the connection through a common peer when a punch
    // cannot work (e.g. symmetric NAT). Still Noise-encrypted end to end; the
    // relay only moves ciphertext. Serving *other* peers' circuits is opt-in.
    Relay::Config relay;
    relay.serve = false;
    node.add_subsystem(std::make_unique<Relay>(relay));

    node.start();

    // Peers arrive through on_peer_connected() whichever rung got them there;
    // PeerInfo::transport says whether a link is direct or relayed.
    std::this_thread::sleep_for(std::chrono::seconds(30));

    // What the mesh has learned about our own side of the NAT:
    // Open, EndpointIndependent (punchable), EndpointDependent (needs a relay), Unknown.
    if (node.nat_status().udp_mapping() == NatMapping::EndpointDependent)
        std::cout << "symmetric NAT: direct links to other NATed peers will go via relay\n";

    node.stop();
    return 0;
}

import { createNode, encodeUtf8, decodeUtf8 } from 'react-native-librats'

// One C++ implementation drives both iOS and Android -- no JNI bridge,
// no Swift wrapper. `protocol` is bound into the Noise handshake, so it
// must be identical on every platform of your app.
const node = createNode({
  listenPort: 8080,
  protocol: 'myapp/1.0',
  dataDir: appWritablePath,   // keeps a stable identity across restarts
})

// Handlers go on before start(): librats stores them without a lock and
// reads them from reactor threads, so registering later throws.
node.onPeerConnected((peerId) => console.log('connected', peerId))
node.onMessage('chat', (peerId, data) => {
  console.log(peerId, decodeUtf8(data))   // Hermes has no TextDecoder
})

node.start()
node.connect('192.168.1.42', 8080)
node.broadcast('chat', encodeUtf8('hello from React Native'))

// A node owns live sockets and threads, and iOS tears them down when the
// app suspends. Stop on background, start on resume.
AppState.addEventListener('change', (state) => {
  if (state === 'active') node.start()
  else node.stop()
})