@yz-social/kdht 0.1.0

package/dht/nodeStorage.js

@@ -0,0 +1,23 @@
+import { NodeRefresh } from './nodeRefresh.js';
+
+// Keeping application data.
+export class NodeStorage extends NodeRefresh {
+  storage = new Map(); // keys must be preserved as bigint, not converted to string.
+  // TODO: store across sessions
+  storeLocally(key, value) { // Store in memory by a BigInt key (must be already hashed). Not persistent.
+    this.storage.set(key, value);
+    // TODO: The paper says this can be optimized.
+    // Claude.ai suggests just writing to the next in line, but that doesn't work.
+    this.schedule(key, 'storage', () => this.storeValue(key, value));
+  }
+  retrieveLocally(key) {     // Retrieve from memory.
+    return this.storage.get(key);
+  }
+  async replicateCloserStorage(contact) { // Replicate to new contact any of our data for which contact is closer than us.
+    for (const key in this.storage.keys()) {
+      if (contact.distance(key) <= this.distance(key)) { //fixme define distance on contact
+	await contact.store(key, this.retrieveLocally(key));
+      }
+    }
+  }
+}

package/dht/nodeTransports.js

@@ -0,0 +1,59 @@
+import { NodeStorage } from './nodeStorage.js';
+
+// Management of Contacts that have a limited number of connections that can transport messages.
+export class NodeTransports extends NodeStorage {
+  looseTransports = [];
+  get nTransports() {
+    let count = this.looseTransports.length;
+    this.forEachBucket(bucket => (count += bucket.nTransports, true));
+    return count;
+  }
+  removeLooseTransport(key) { // Remove the contact for key from looseTransports, and return boolean indicating whether it had been present.
+    const looseIndex = this.looseTransports.findIndex(c => c.key === key);
+    if (looseIndex >= 0) {
+      this.looseTransports.splice(looseIndex, 1);
+      return true;
+    }
+    return false;
+  }
+  static maxTransports = 32;
+  noteContactForTransport(contact) { // We're about to use this contact for a message, so keep track of it.
+    // Requires: if we later addToRoutingTable successfully, it should be removed from looseTransports.
+    // Requires: if we later remove contact because of a failed send, it should be removed from looseTransports.
+    const assert = this.constructor.assert;
+    assert(contact.key !== this.key, 'noting contact for self transport', this, contact);
+    assert(contact.host.key === this.key, 'Contact', contact.report, 'is not hosted by', this.contact.report);
+    let existing = this.findContactByKey(contact.key);
+    if (existing) return existing;
+    
+    if (this.nTransports >= this.constructor.maxTransports) { // Determine if we have to drop one first, and do so.
+      //console.log(this.name, 'needs to drop a transport');
+      function removeLast(list) { // Remove and return the last element of list that has connction and is NOT sponsor.
+	const index = list.findLastIndex(element => element.connection && !contact.hasSponsor(element.key));
+	if (index < 0) return null;
+	const sub = list.splice(index, 1);
+	return sub[0];
+      }
+      let dropped = removeLast(this.looseTransports);
+      if (dropped) {
+	console.log('dropping loose transport', dropped.name, 'in', this.name);
+      } else { // Find the bucket with the most connections.
+	let bestBucket = null, bestCount = 0;
+	this.forEachBucket(bucket => {
+	  const count = bucket.nTransports;
+	  if (count < bestCount) return true;
+	  bestBucket = bucket;
+	  bestCount = count;
+	  return true;
+	});
+	dropped = removeLast(bestBucket.contacts);
+	if (!dropped) console.log('Unable to find something to drop in', this.report(null));
+	else console.log('dropping transport', dropped.name, 'in', this.name, bestBucket.index, 'among', bestCount);
+      }
+      dropped.disconnectTransport();
+    }
+
+    this.looseTransports.push(contact); // Now add it as loose. If we later addToRoutingTable, it will then be moved from looseTransports.
+    return contact;
+  }
+}

package/dht/nodeUtilities.js

@@ -0,0 +1,81 @@
+// Some scaffolding for development and debugging.
+export class NodeUtilities {
+  constructor(properties) {
+    Object.assign(this, properties);
+  }
+  isRunning = true;
+  static delay(ms, value) { // Promise to resolve (to nothing) after a given number of milliseconds
+    return new Promise(resolve => setTimeout(resolve, ms, value));
+  }
+  static randomInteger(max) { // Return a random number between 0 (inclusive) and max (exclusive).
+    return Math.floor(Math.random() * max);
+  }
+  
+  debug = false;
+  get sname() { // The home contact sname, or just name if no contact
+    return this.contact?.sname || this.name;
+  }
+  log(...rest) { if (this.debug) console.log(new Date(), this.sname, ...rest); }
+  xlog(...rest) { console.log(new Date(), this.sname, ...rest); }
+  static assert(ok, ...rest) { // If !ok, log rests and exit.
+    if (ok) return;
+    console.error(...rest, new Error("Assert failure").stack); // Not throwing error, because we want to exit. But we are grabbing stack.
+    globalThis.process?.exit(1);
+  }
+  // TODO: Instead of a global collector (which won't work when distributed across devices), 
+  static _stats = {};
+  static get statistics() { // Return {bucket, storage, rpc}, where each value is [elapsedInSeconds, count, averageInMSToNearestTenth].
+    // If Nodes.contacts is populated, also report average number of buckets and contacts.
+    const { _stats } = this;
+    if (this.contacts?.length) {
+      let buckets = 0, contacts = 0, stored = 0;
+      for (const {node} of this.contacts) {
+	stored += node.storage.size;
+	node.forEachBucket(bucket => {
+	  buckets++;
+	  contacts += bucket.contacts.length;
+	  return true;
+	});
+      }
+      _stats.contacts = Math.round(contacts/this.contacts.length);
+      _stats.stored = Math.round(stored/this.contacts.length);
+      _stats.buckets = Math.round(buckets/this.contacts.length);
+    }
+    return _stats;
+  }
+  static resetStatistics() { // Reset statistics to zero.
+    const stat = {count:0, elapsed:0, lag:0};
+    this._stats = {
+      bucket: Object.assign({}, stat), // copy the model
+      storage: Object.assign({}, stat),
+      rpc: Object.assign({}, stat)
+    };
+  }
+  static noteStatistic(startTimeMS, name) { // Given a startTimeMS, update statistics bucket for name.
+    const stat = this._stats?.[name];
+    if (!stat) return;
+    stat.count++;
+    stat.elapsed += Date.now() - startTimeMS;
+  }
+  report(logger = console.log) { // return logger( a string description of node )
+    let report = `Node: ${this.contact?.report || this.name}, ${this.nTransports} transports`;
+    function contactsString(contacts) { return contacts.map(contact => contact.report).join(', '); }
+    if (this.storage.size) {
+      report += `\n  storing ${this.storage.size}: ` +
+	Array.from(this.storage.entries()).map(([k, v]) => `${k}n: ${JSON.stringify(v)}`).join(', ');
+    }
+    if (this.looseTransports.length) {
+      report += `\n  transports ${this.looseTransports.map(contact => contact.report).join(', ')}`;
+    }
+    for (let index = 0; index < this.constructor.keySize; index++) {
+      const bucket = this.routingTable.get(index);
+      if (!bucket) continue;
+      report += `\n  ${index}: ` + (contactsString(bucket.contacts) || '-');
+    }
+    return logger ? logger(report) : report;
+  }
+  static reportAll() {
+    this.contacts?.forEach(contact => contact.node.report());
+  }
+}
+

package/index.js

@@ -0,0 +1,7 @@
+export { Contact } from './transports/contact.js';
+export { SimulatedContact, SimulatedConnectionContact } from './transports/simulations.js';
+//export { InProcessWebContact } from './transports/inProcessWebrtc.js';
+export { WebContact } from './transports/webrtc.js';
+export { Helper } from './dht/helper.js';
+export { KBucket } from './dht/kbucket.js';
+export { Node } from './dht/node.js';

package/junx.js

@@ -0,0 +1,17 @@
+async function bar() {
+  throw new Error("synchronously thrown from bar (asynchronous from foo)");
+}
+async function foo() {
+  try {
+    bar();
+  } catch (e) {
+    console.log('foo caught', e);
+  }
+  throw new Error('synchronously thrown from foo');
+}
+
+try {
+  await foo();
+} catch (e) {
+  console.log('outer caught', e);
+}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@yz-social/kdht",
+  "version": "0.1.0",
+  "description": "Pure Kademlia base, for testing variations.",
+  "exports": {
+    ".": "./index.js",
+    "./router": "./portals/router.js",
+    "./portal": "./portals/node.js"
+  },
+  "type": "module",
+  "scripts": {
+    "serverTest": "node spec/portal.js --nPortals 20 --nWrites 40",
+    "serverTestLight": "node spec/portal.js --nPortals 10 --nWrites 40",
+    "smoke": "node spec/portal.js --nPortals 5 --nBots 5 --thrash --nWrites 10",
+    "smoke20": "node spec/portal.js --nPortals 10 --nBots 10 --thrash --nWrites 10",
+    "load30": "node spec/portal.js --nPortals 10 --nBots 20 --nWrites 100",
+    "load50": "node spec/portal.js --nPortals 10 --nBots 65 --nWrites 100",
+    "load75": "node spec/portal.js --nPortals 10 --nBots 40 --nWrites 100",
+    "load100": "node spec/portal.js --nPortals 10 --nBots 90 --nWrites 100",
+    "load150": "node spec/portal.js --nPortals 15 --nBots 135 --nWrites 100",
+    "load200": "node spec/portal.js --nPortals 20 --nBots 180 --nWrites 100",
+    "thrash30": "node spec/portal.js --nPortals 10 --nBots 20 --thrash true --nWrites 100",
+    "thrash50": "node spec/portal.js --nPortals 10 --nBots 40 --thrash true --nWrites 100",
+    "thrash100": "node spec/portal.js --nPortals 10 --nBots 90 --thrash true --nWrites 100",
+    "thrash150": "node spec/portal.js --nPortals 15 --nBots 135 --thrash true --nWrites 100",
+    "thrash200": "node spec/portal.js --nPortals 20 --nBots 180 --thrash true --nWrites 100",
+    "test": "npx jasmine"
+  },
+  "dependencies": {
+    "@yz-social/webrtc": "^0.1.0",
+    "uuid": "^13.0.0"
+  },
+  "devDependencies": {
+    "express": "^5.2.1",
+    "jasmine": "^5.12.0",
+    "morgan": "^1.10.1",
+    "yargs": "^18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/YZ-social/kdht.git"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org"
+  }
+}

package/portals/node.js

@@ -0,0 +1,31 @@
+import process from 'node:process';
+import cluster from 'node:cluster';
+import { v4 as uuidv4 } from 'uuid';
+import { WebContact, Node } from '../index.js';
+
+export async function setup({baseURL, externalBaseURL = '', verbose, fixedSpacing, variableSpacing}) {
+  const hostName = uuidv4();
+  process.title = 'kdht-portal-' + hostName;
+  // For debugging:
+  // process.on('uncaughtException', error => console.error(hostName, 'Global uncaught exception:', error));
+  // process.on('unhandledRejection', error => console.error(hostName, 'Global unhandled promise rejection:', error));
+
+  const contact = await WebContact.create({name: hostName, isServerNode: true, debug: verbose});
+  // Handle signaling that comes as a message from the server.
+  process.on('message', async ([senderSname, ...incomingSignals]) => { // Signals from a sender through the server.
+    const response = await contact.signals(senderSname, ...incomingSignals);
+    process.send([senderSname, ...response]);
+  });
+
+  await Node.delay(fixedSpacing * 1e3 * cluster.worker.id - 1);
+
+  const isFirst = cluster.worker.id === 1; // The primary/server is 0.
+  const joinURL = isFirst ? externalBaseURL : baseURL;
+
+  if (!isFirst) await Node.delay(Node.fuzzyInterval(variableSpacing * 1e3));
+  // Determine boostrap BEFORE we send in our own name.
+  const bootstrapName = joinURL && await contact.fetchBootstrap(joinURL);
+  const bootstrap = joinURL && await contact.ensureRemoteContact(bootstrapName, joinURL);
+  process.send(contact.sname); // Report in to server as available for others to bootstrap through.
+  if (bootstrap) await contact.join(bootstrap);
+}

package/portals/router.js

@@ -0,0 +1,67 @@
+import cluster from 'node:cluster';
+import express from 'express';
+import { Node } from '../index.js';
+
+export const router = express.Router();
+
+const portals = {}; // Maps worker sname => worker, for the full lifetime of the program. NOTE: MAY get filed in out of order from workers.
+const workers = Object.values(cluster.workers);
+for (const worker of workers) {
+  worker.on('message', message => { // Message from a worker, in response to a POST.
+    if (!worker.tag) {  // The very first message from a worker (during setup) will identify its tag.
+      portals[message] = worker;
+      worker.tag = message;
+      worker.requestResolvers = {}; // Maps sender sname => resolve function of a waiting promise in flight.
+      console.log(worker.id - 1, message);
+    } else {
+      // Each worker can have several simultaneous conversations going. We need to get the message to the correct
+      // conversation promise, which we do by calling the resolver that the POST handler is waiting on.
+      // Note that requestResolvers are per worker: there can only be one requestResolver pending per worker
+      // for each sender.
+      const [senderSname, ...signals] = message;
+      worker.requestResolvers[senderSname]?.(signals);
+    }
+  });
+}
+cluster.on('exit', (worker, code, signal) => { // Tell us about dead workers.
+  console.error(`\n\n*** Crashed worker ${worker.id}:${worker.tag} received code: ${code} signal: ${signal}. ***\n`);
+});
+
+router.get('/name/:label', (req, res, next) => { // Answer the actual sname corresponding to label.
+  const label = req.params.label;
+  // label can be a worker id, which alas starts from 1.
+  const isRandom = label === 'random';
+  let list = isRandom ? Object.values(portals) : workers;
+  const index = isRandom ? Node.randomInteger(list.length) : label - 1;
+  const worker =  list[index];
+  if (!worker) return res.sendStatus(isRandom ? 403 : 404);
+  return res.json(worker.tag);
+});
+
+router.post('/join/:from/:to', async (req, res, next) => { // Handler for JSON POST requests that provide an array of signals and get signals back.
+  // Our WebRTC send [['offer', ...], ['icecandidate', ...], ...]
+  // and accept responses of [['answer', ...], ['icecandidate', ...], ...]
+  // through multiple POSTS.
+  const {params, body} = req;
+  // Find the specifed worker, or pick one at random. TODO CLEANUP: Remove. We now use as separate /name/:label to pick one.
+  const worker = portals[params.to];
+  if (!worker) {
+    console.warn('no worker', params.to);
+    return res.sendStatus(404);
+  }
+  if (!worker.tag) {
+    console.warn('worker', params.to, 'not signed in yet');
+    return res.sendStatus(403);
+  }
+
+  // Each kdht worker node can handle connections from multiple clients. Specify which one.
+  body.unshift(params.from); // Adds sender sname at front of body.
+
+  // Pass the POST body to the worker and await the response.
+  const promise = new Promise(resolve => worker.requestResolvers[params.from] = resolve);
+  worker.send(body, undefined, undefined, error => error && console.log(`Error communicating with portal worker ${worker.id}:${worker.tag} ${worker.isConnected() ? 'connected' : 'disconnected'} ${worker.isDead() ? 'dead' : 'running'}:`, error));
+  let response = await promise;
+  delete worker.requestResolvers[params.from]; // Now that we have the response.
+
+  return res.send(response);
+});

package/routes/index.js

@@ -0,0 +1,39 @@
+import express from 'express';
+import { TrickleWebRTC } from '@yz-social/webrtc';
+import { WebContact as Contact } from '../index.js';
+export const router = express.Router();
+
+
+
+router.post('/join/:key', async (req, res, next) => {
+
+  const {params, body} = req;
+  const tag = params.tag;
+  const incomingSignals = body;
+  let connection = testConnections[tag];
+  console.log('post connection:', !!connection, 'incoming:', incomingSignals.map(s => s[0]));
+  if (!connection) {
+    connection = testConnections[tag] = TrickleWebRTC.ensure({serviceLabel: tag});
+    const timer = setTimeout(() => connection.close(), 15e3);
+    console.log('created connection and applying', incomingSignals.map(s => s[0]));
+    connection.next = connection.signals;
+    const dataPromise = connection.dataChannelPromise = connection.ensureDataChannel('echo', {}, incomingSignals);
+    dataPromise.then(dataChannel => {
+      connection.reportConnection(true);
+      dataChannel.onclose = () => {
+	clearTimeout(timer);
+	connection.close();
+	delete testConnections[tag];
+      };
+      dataChannel.onmessage = event => dataChannel.send(event.data); // Just echo what we are given.
+    });
+  } else {
+    console.log('applying incoming signals');
+    connection.signals = incomingSignals;
+  }
+  console.log('awaiting response');
+  const responseSignals = await Promise.race([connection.next, connection.dataChannelPromise]);
+  connection.next = connection.signals;
+  console.log('responding', responseSignals.map(s => s[0]));
+  res.send(responseSignals); // Send back our signalling answer+ice.
+});

package/save/dhtWriteRead.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env npx jasmine
+const { describe, it, expect, beforeAll, afterAll, beforeEach, afterEach } = globalThis; // For linters.
+import process from 'node:process';
+import { exec } from 'node:child_process';
+import { v4 as uuidv4 } from 'uuid';
+import { WebContact, Node } from '../index.js';
+
+// I cannot get yargs to work properly within jasmine. Get args by hand.
+// Note: jasmine will treat --options as arguments to itself. To pass them to the script, you need to separate with '--'.
+const nWritesIndex = process.argv.indexOf('--nWrites');
+const verboseIndex = process.argv.indexOf('--verbose');
+const shutdownIndex = process.argv.indexOf('--shutdown');
+const nWrites = nWritesIndex >= 0 ? JSON.parse(process.argv[nWritesIndex + 1]) : 10;
+const verbose = verboseIndex >= 0 ? JSON.parse( process.argv[verboseIndex + 1] || 'true' ) : false;
+const shutdown = shutdownIndex >= 0 ? JSON.parse( process.argv[shutdownIndex + 1] || 'true' ) : true;
+
+describe("DHT write/read", function () {
+  let contact;
+  beforeAll(async function () {
+    contact = await WebContact.create({name: uuidv4(), debug: verbose});
+    const bootstrapName = await contact.fetchBootstrap();
+    const bootstrapContact = await contact.ensureRemoteContact(bootstrapName, 'http://localhost:3000/kdht');
+    console.log(new Date(), contact.sname, 'joining', bootstrapContact.sname);
+    await contact.join(bootstrapContact);
+    console.log('joined');
+    for (let index = 0; index < nWrites; index++) {
+      const wrote = await contact.store(index, index);
+      console.log('Wrote', index);
+    }
+    console.log(new Date(), 'Written. Waiting two refresh periods before reading.', 2 * Node.refreshTimeIntervalMS / 1e3, 'seconds');
+    await Node.delay(2 * Node.refreshTimeIntervalMS);
+    console.log(new Date(), 'Reading');
+  }, 5e3 * nWrites + 2 * Node.refreshTimeIntervalMS);
+  afterAll(function () {
+    if (shutdown) {
+      exec('pkill kdht-bot');
+      Node.delay(2e3);
+      exec('pkill kdht-portal-server');
+    }
+  });
+  for (let index = 0; index < nWrites; index++) {
+    it(`reads ${index}.`, async function () {
+      const read = await contact.node.locateValue(index);
+      console.log('read', read);
+      expect(read).toBe(index);
+    });
+  }
+});

package/save/webrtc.js

@@ -0,0 +1,212 @@
+import { v4 as uuidv4 } from 'uuid';
+import { Node } from '../dht/node.js';
+import { Helper } from '../dht/helper.js';
+import { Contact } from './contact.js';
+import { WebRTC } from '@yz-social/webrtc';
+const { BigInt } = globalThis; // For linters.
+
+
+export class WebContact extends Contact {
+  // Can this set all be done more simply?
+  get name() { return this.node.name; }
+  get key() { return this.node.key; }
+  get isServerNode() { return this.node.isServerNode; }
+  get isRunning() { return this.node.isRunning; }
+
+  checkResponse(response) {
+    if (!response.ok) throw new Error(`${this.sname} fetch ${response.url} failed ${response.status}: ${response.statusText}.`);
+  }
+  async fetchSignals(url, signalsToSend) {
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(signalsToSend)
+    });
+    this.checkResponse(response);
+    return await response.json();
+  }
+  async fetchBootstrap(label = 'random') {
+    const url = `http://localhost:3000/kdht/name/${label}`;
+    const response = await fetch(url);
+    this.checkResponse(response);
+    return await response.json();
+  }
+  get webrtcLabel() {
+    return `@${this.host.contact.sname} ==> ${this.sname}`;
+  }
+  // Within a process, there is only one WebContact.serializer, so each process can only complete one  connection at a time.
+  // (It can maintain Node.maxTransports open connections. The serialization is a limit on the connection/signal process.)
+  static serializer = Promise.resolve();
+  channelName = 'kdht';
+
+  ensureWebRTC(initialSignals) { // If not already configured, sets up contact to have properties:
+    // - connection - a promise for an open webrtc data channel:
+    //   send(string) puts data on the channel
+    //   incomming messages are dispatched to receiveWebRTC(string)
+    // - closed - resolves when webrtc closes.
+    // - webrtc - an instance of WebRTC (which may be used for webrtc.respond()
+    // initialSignals should be a list, or null for the creator of the offer.
+    if (this.webrtc) return this.webrtc;
+
+    const webrtc = this.webrtc = new WebRTC({label: this.webrtcLabel});
+    let {promise, resolve} = Promise.withResolvers();
+    this.closed = promise;
+    const dataChannelPromise = webrtc.ensureDataChannel(this.channelName, {}, initialSignals);
+    dataChannelPromise.then(dataChannel => {
+      webrtc.reportConnection(true);
+      dataChannel.addEventListener('close', () => {
+	console.log(webrtc.label, 'connection closed');
+	this.connection = this.webrtc = null;
+	resolve(null);
+      });
+      dataChannel.addEventListener('message', event => this.receiveWebRTC(event.data));
+    });
+    return dataChannelPromise;
+  }
+  connect() { // Connect from host to node, promising a possibly cloned contact that has been noted.
+    // Creates a WebRTC instance and uses it's connectVia to to signal.
+    const contact = this.host.noteContactForTransport(this);
+    //this.host.log('ensuring connection for', contact.sname, contact.connection ? 'exists' : 'must create');
+    if (contact.connection) return contact.connection;
+    contact.initiating = true;
+    //console.log('setting client contact connection promise');
+    return contact.connection = contact.constructor.serializer = contact.constructor.serializer.then(async () => { // TODO: do we need this serialization?
+      const { host, node, isServerNode, bootstrapHost } = contact;
+      // Anyone can connect to a server node using the server's connect endpoint.
+      // Anyone in the DHT can connect to another DHT node through a sponsor.
+      const dataChannelPromise = contact.ensureWebRTC(null);
+      await this.webrtc.signalsReady;      
+      let sponsor = contact.findSponsor(candidate => candidate.connection) ||
+	  contact.findSponsor(candidate => candidate.isServerNode);
+      try {
+	if (sponsor) {
+	  await contact.webrtc.connectVia(async signals => sponsor.sendRPC('forwardSignals', contact.key, host.contact.sname, ...signals));
+	} else if (bootstrapHost || !contact.isServerNode) {
+	  const url = `${bootstrapHost || 'http://localhost:3000/kdht'}/join/${this.host.contact.sname}/${this.sname}`;
+	  await contact.webrtc.connectVia(signals => this.fetchSignals(url, signals));
+	} else {
+	  console.error(`Cannot reach unsponsored contact ${contact.sname}.`);
+	  await contact.host.removeContact(contact);
+	  return contact.connection = contact.webrtc = null;
+	}
+      } catch (error) {
+	console.error(`${contact.webrtc.label} failed to connect through ${sponsor ? `sponsor ${sponsor.sname}` : `bootstrap ${bootstrapHost || contact.sname}`}`);
+	console.error(error);
+	return null;
+      }
+      return await dataChannelPromise;
+    });
+  }
+  async signals(senderSname, ...signals) { // Accept directed WebRTC signals from a sender sname, creating if necessary the new contact on
+    // host to receive them, and promising a response.
+    let contact = await this.ensureRemoteContact(senderSname);
+    if (contact.initiating) return []; // TODO: is this the right response?
+    if (contact.webrtc) return await contact.webrtc.respond(signals); // TODO: move this and its counterpart on connect to ensureWebRTC?
+    this.host.noteContactForTransport(contact);
+    contact.connection = contact.ensureWebRTC(signals);
+    return await contact.webrtc.respond([]);
+  }
+  async send(message) { // Promise to send through previously opened connection promise.
+    return this.connection   // Connection could be reset to null  
+      ?.then(channel => channel?.send(JSON.stringify(message)))
+      .catch(error => console.error(this.host.contact.sname, error, error.stack)); 
+  }
+  getName(sname) { // Answer name from sname.
+    if (sname.startsWith(this.constructor.serverSignifier)) return sname.slice(1);
+    return sname;
+  }
+  async ensureRemoteContact(sname, sponsor = null) {
+    let contact;
+    if (sname === this.host.contact.sname) {
+      contact = this.host.contact; // ok, not remote, but contacts can send back us in a list of closest nodes.
+    }
+    const name = this.getName(sname);
+    if (!contact) {
+      // Not the final answer. Just an optimization to avoid hashing name.
+      contact = this.host.existingContact(name);
+    }
+    if (!contact) {
+      const isServerNode = name !== sname;
+      contact = await this.constructor.create({name, isServerNode}, this.host); // checks for existence AFTER creating Node.
+    }
+    if (sponsor instanceof Contact) contact.noteSponsor(sponsor);
+    else if (typeof(sponsor) === 'string') contact.bootstrapHost = sponsor;
+    return contact;
+  }
+  receiveRPC(method, sender, key, ...rest) { // Receive an RPC from sender, dispatch, and return that value, which will be awaited and sent back to sender.
+    if (method === 'forwardSignals') { // Can't be handled by Node, because 'forwardSignals' is specific to WebContact.
+      const [sendingSname, ...signals] = rest;
+      //console.log(this.host.contact.sname, this.host.key, 'received forwardingSignals from', sender.sname, 'on contact', this.sname, this.key, 'concerning', key);
+      if (key === this.host.key) { // for us!
+	//console.log(this.host.contact.sname, 'processing signals from', sendingSname, signals.map(s => s[0]));
+	return this.signals(...rest);
+      } else { // Forard to the target.
+	const target = this.host.findContactByKey(key);
+	if (!target) {
+	  //console.log(this.host.contact.same, 'does not have contact to', sendingSname);
+	  return null;
+	}
+	//if (this.debugCounter++ > 3) process.exit(1);
+	//console.log(this.host.contact.sname, 'forwarding signals from', sendingSname, signals.map(s => s[0]), 'to target', target.sname, key);
+	return target.sendRPC('forwardSignals', key, ...rest);
+      }
+    }
+    return super.receiveRPC(method, sender, key, ...rest);
+  }
+  //debugCounter = 0;
+  inFlight = new Map();
+  async transmitRPC(method, key, ...rest) { // Must return a promise.
+    // this.host.log('transmit to', this.sname, this.connection ? 'with connection' : 'WITHOUT connection');
+    if (!await this.connect()) return null;
+    const sender = this.host.contact.sname;
+    // uuid so that the two sides don't send a request with the same id to each other.
+    // Alternatively, we could concatenate a counter to our host.name.
+    const messageTag = uuidv4();
+    const responsePromise = new Promise(resolve => this.inFlight.set(messageTag, resolve));
+    // this.host.log('sending to', this.sname);
+    //console.log(this.host.contact.sname, 'sending', method, key, rest.map(s => Array.isArray(s) ? s[0] : s), 'to', this.sname);
+    this.send([messageTag, method, sender, key.toString(), ...rest]);
+    const response = await Promise.race([responsePromise, this.closed]);
+    // this.host.log('got response from', this.sname);
+    return response;
+  }
+  async receiveWebRTC(dataString) { // Handle receipt of a WebRTC data channel message that was sent to this contact.
+    // The message could the start of an RPC sent from the peer, or it could be a response to an RPC that we made.
+    // As we do the latter, we generate and note (in transmitRPC) a message tag included in the message.
+    // If we find that in our inFlight tags, then the message is a response.
+    const [messageTag, ...data] = JSON.parse(dataString);
+    const responder = this.inFlight.get(messageTag);
+    if (responder) { // A response to something we sent and are waiting for.
+      let [result] = data;
+      this.inFlight.delete(messageTag);
+      //this.host.log('received response', result);
+      if (Array.isArray(result)) {
+	if (!result.length) responder(result);
+	const first = result[0];
+	const isSignal = Array.isArray(first) && ['offer', 'answer', 'icecandidate'].includes(first[0]);
+	//console.log(this.host.contact.sname, 'got rpc response on contact', this.sname, isSignal, result.map(s => Array.isArray(s) ? s[0] : s));
+	if (isSignal) {
+	  responder(result); // This could be the sponsor or the original sender. Either way, it will know what to do.
+	} else {
+	  responder(await Promise.all(result.map(async ([sname, distance]) =>
+	    new Helper(await this.ensureRemoteContact(sname, this), BigInt(distance)))));
+	}
+      } else {
+	responder(result);
+      }
+    } else { // An incoming request.
+      const [method, senderLabel, key, ...rest] = data;
+      const sender = await this.ensureRemoteContact(senderLabel);
+      //this.host.log('dispatched', method, 'from', sender.sname);
+      let response = await this.receiveRPC(method, sender, BigInt(key), ...rest);
+      //if (method === 'forwardSignals') console.log(this.host.contact.sname, 'incoming signals through', this.sname, 'originating from', rest[0]);
+      if ((method !== 'forwardSignals') && this.host.constructor.isContactsResult(response)) {
+	response = response.map(helper => [helper.contact.sname, helper.distance.toString()]);
+      }
+      this.send([messageTag, response]);
+    }
+  }
+  disconnectTransport() {
+    this.webrtc?.close();
+  }
+}