@yz-social/kdht 0.1.3 → 0.1.4

package/spec/dhtInternalsSpec.js

@@ -1,14 +1,15 @@
-import { Node, KBucket, Contact, SimulatedContact, Helper } from '../index.js';
+import { Node, KBucket, SimulatedContact, Helper } from '../index.js';
 const { describe, it, expect, beforeAll, afterAll, BigInt} = globalThis; // For linters.
 
 describe("DHT internals", function () {
   beforeAll(function () {
-    //Node.distinguisher = 0;
-  });
-  afterAll(function () {
+    // Subtle: None of these tests depend on automatic refresh (of buckets or storage), but some
+    // of the tests trigger the refresh. By doing this before we start, the nodes will not schedule any refresh.
+    // If we failed to do that, then the refreshes would continue to happen after the test, when other
+    // tests might be running.
+    // Note: Do not fail to set Node.refreshTimeIntervalMS in such other tests that need it.
     Node.stopRefresh();
   });
-
   describe("structure", function () {
     let example;
     beforeAll(async function () {
@@ -32,7 +33,7 @@ describe("DHT internals", function () {
 	expect(retrieved).toBeUndefined();
       });
     });
-      
+
     describe("report", function () {
       beforeAll(async function () { // Add some data for which we know the expected internal structure.
 	example.storeLocally(await Node.key("foo"), 17); // May or may not have already been set to same value, depending on test order.
@@ -64,12 +65,12 @@ describe("DHT internals", function () {
       });
     });
   });
-  
+
   describe("operations", function () {
     const one = 1n;
     const two = 2n;
     const three = 3n;
-    const max = Node.one << BigInt(Node.keySize);
+    const max = one << BigInt(Node.keySize);
     describe("commonPrefixLength", function () {
       it("is keySize for 0n.", function () {
 	expect(Node.commonPrefixLength(Node.zero)).toBe(Node.keySize);
@@ -87,7 +88,7 @@ describe("DHT internals", function () {
     describe("getBucketIndex", function () {
       let node;
       beforeAll(function () {
-	node = Node.fromKey(Node.zero); 
+	node = Node.fromKey(Node.zero);
       });
       it("bucket keySize -1 is farthest.", function () {
 	const distance = max - Node.one; // max distance within nTagBits. All bits on.
@@ -112,6 +113,7 @@ describe("DHT internals", function () {
 	node = await Node.create();
       });
       function test(bucketIndex) {
+// console.log(`[dhtInternalsSpec:index=${bucketIndex}]`);
 	it(`computes random of ${bucketIndex}.`, function () {
 	  const random = node.ensureBucket(bucketIndex).randomTarget;
 	  const computedBucket = node.getBucketIndex(random);
@@ -131,7 +133,7 @@ describe("DHT internals", function () {
 	const bucket0 = new KBucket(node, 0);
 	const bucket10 = new KBucket(node, 10);
 	const bucket60 = new KBucket(node, 60);
-	const bucket90 = new KBucket(node, 90);	
+	const bucket90 = new KBucket(node, 90);
 	const addTo = async bucket => {
 	  const key = bucket.randomTarget;
 	  keys.push(key);
@@ -142,9 +144,9 @@ describe("DHT internals", function () {
 	await addTo(bucket60);
 	await addTo(bucket90);
 	node.routingTable.set(0, bucket0);
-	node.routingTable.set(10, bucket10);	
+	node.routingTable.set(10, bucket10);
 	node.routingTable.set(60, bucket60);
-	node.routingTable.set(90, bucket90);	
+	node.routingTable.set(90, bucket90);
       });
       it("is initially empty.", async function () {
 	const node = await Node.create();
@@ -170,7 +172,7 @@ describe("DHT internals", function () {
   0: ${node.routingTable.get(0).contacts.map(c => c.key.toString() + 'n').join(', ')}
   10: ${node.routingTable.get(10).contacts.map(c => c.key.toString() + 'n').join(', ')}
   60: ${node.routingTable.get(60).contacts.map(c => c.key.toString() + 'n').join(', ')}
-  90: ${node.routingTable.get(90).contacts.map(c => c.key.toString() + 'n').join(', ')}`;	
+  90: ${node.routingTable.get(90).contacts.map(c => c.key.toString() + 'n').join(', ')}`;
 	expect(report).toBe(expected);
       });
     });
@@ -198,8 +200,9 @@ describe("DHT internals", function () {
 	  node = host.node;
 	  // These others are all constructed to have distances that increase by one from node.
 	  for (let i = 1; i <= nOthers; i++) {
-	    let other = SimulatedContact.fromKey(BigInt(i), host.host);
-	    await node.addToRoutingTable(other);
+	    let other = SimulatedContact.fromKey(BigInt(i));
+	    let ourViewOfIt = node.ensureContact(other);
+	    await node.addToRoutingTable(ourViewOfIt);
 	  }
 	  //node.report();
 	}, 20e3);
@@ -250,4 +253,290 @@ describe("DHT internals", function () {
       });
     });
   });
+
+  describe("lookup performance with laggy nodes", function() {
+    // Test to demonstrate blocking behavior with slow nodes
+    // After implementing racing, this will show the improvement
+    let network;
+    const nNodes = 10;
+
+    beforeAll(async function() {
+      // Create a small network
+      network = [];
+      for (let i = 0; i < nNodes; i++) {
+        const contact = await SimulatedContact.create(i);
+        network.push(contact);
+      }
+
+      // Make 6 out of 10 nodes laggy with varying delays
+      network[4].node.delayMs = 200;
+      network[5].node.delayMs = 200;
+      network[6].node.delayMs = 400;
+      network[7].node.delayMs = 400;
+      network[8].node.delayMs = 600;
+      network[9].node.delayMs = 600;
+
+      console.log('Network setup: nodes 0-3 are fast (40ms), nodes 4-9 are laggy (200/400/600ms)');
+
+      // Build network: each node knows about all others
+      for (let i = 0; i < nNodes; i++) {
+        const node = network[i].node;
+        for (let j = 0; j < nNodes; j++) {
+          if (i !== j) {
+            await node.addToRoutingTable(network[j].clone(node));
+          }
+        }
+      }
+    }, 30e3);
+
+    afterAll(function() {
+      network.forEach(contact => contact.disconnect());
+    });
+
+    it("completes lookup without blocking on all laggy nodes", async function() {
+      // Tests that the continuous-flow algorithm (keeping alpha requests in flight)
+      // makes progress without waiting for ALL slow nodes to respond.
+      // With 6/10 nodes being laggy (200-600ms), the lookup must contact some slow nodes,
+      // but shouldn't need to wait for every single slow response.
+      const searcher = network[0].node;
+      const targetKey = await Node.key("test-value");
+
+      // Perform a findNodes lookup with timing enabled
+      const startTime = Date.now();
+      const result = await searcher.iterate(targetKey, 'findNodes', Node.k, false, true);
+      const elapsed = Date.now() - startTime;
+
+      console.log(`Lookup: ${elapsed}ms, ${result.length} nodes found`);
+
+      // If we had to wait for ALL 6 slow nodes sequentially, it would take 2400ms+.
+      // The continuous flow should allow faster completion by not blocking on stragglers.
+      expect(elapsed).toBeLessThan(1500);
+      expect(result.length).toBeGreaterThan(0);
+      expect(result.length).toBeLessThanOrEqual(Node.k);
+    }, 30e3);
+
+    it("completes lookup despite some nodes timing out", async function() {
+      // Temporarily set some nodes to have delays exceeding the 10s timeout
+      const originalDelays = network.map(c => c.node.delayMs);
+      network[8].node.delayMs = 12000; // Will timeout
+      network[9].node.delayMs = 15000; // Will timeout
+
+      const searcher = network[0].node;
+      const targetKey = await Node.key("timeout-test");
+
+      const startTime = Date.now();
+      const result = await searcher.iterate(targetKey, 'findNodes', Node.k, true, true);
+      const elapsed = Date.now() - startTime;
+
+      // Restore original delays
+      network.forEach((c, i) => c.node.delayMs = originalDelays[i]);
+
+      console.log(`Timeout test: ${elapsed}ms, ${result.length} nodes found`);
+
+      // Should complete around 10s (the timeout), not 15s (waiting for slowest)
+      expect(elapsed).toBeGreaterThan(9000); // At least one timeout triggered
+      expect(elapsed).toBeLessThan(12000); // Didn't wait for 15s node
+      expect(result.length).toBeGreaterThan(0); // Still found some nodes
+    }, 20e3);
+
+    // Verbose diagnostic test - disabled by default. Change xit to it to enable.
+    it("can store and retrieve values with diagnostic tracing", async function() {
+      // Enable diagnostic tracing to see store/read details
+      Node.diagnosticTrace = true;
+
+      const storer = network[0].node;
+      const reader = network[3].node; // Different node reads
+      const targetKey = await Node.key("diagnostic-test-key");
+      const testValue = "diagnostic-test-value";
+
+      console.log('\n--- Store/Read Diagnostic Test ---');
+      console.log(`Storing "${testValue}" from node ${storer.name}`);
+
+      const storeCount = await storer.storeValue(targetKey, testValue);
+      console.log(`Store completed: ${storeCount} copies`);
+
+      console.log(`\nReading from node ${reader.name}`);
+      const retrieved = await reader.locateValue(targetKey);
+
+      console.log(`\n--- Store/Read Summary ---`);
+      console.log(`Stored to ${storeCount} nodes`);
+      console.log(`Retrieved: ${retrieved}`);
+      console.log(`Match: ${retrieved === testValue}`);
+
+      Node.diagnosticTrace = false; // Clean up
+
+      expect(storeCount).toBeGreaterThan(0);
+      expect(retrieved).toBe(testValue);
+    }, 30e3);
+  });
+
+  // Randomized store/read tests - disabled by default. Change xdescribe to describe to enable.
+  describe("store/read with randomized networks", function() {
+    // Track results across all tests for summary
+    const testResults = [];
+
+    afterAll(function() {
+      // Print summary of all test results
+      console.log('\n========== STORE/READ TEST SUMMARY ==========');
+      console.log(`Total tests: ${testResults.length}`);
+      const successes = testResults.filter(r => r.found);
+      const failures = testResults.filter(r => !r.found);
+      console.log(`Successes: ${successes.length}, Failures: ${failures.length}`);
+
+      if (successes.length > 0) {
+        const ranks = successes.map(r => r.rank);
+        const avgRank = ranks.reduce((a, b) => a + b, 0) / ranks.length;
+        const maxRank = Math.max(...ranks);
+        const storeCounts = successes.map(r => r.storedToCount);
+        const avgStoreCount = storeCounts.reduce((a, b) => a + b, 0) / storeCounts.length;
+        console.log(`Average rank of responder: ${avgRank.toFixed(2)} (1 = closest)`);
+        console.log(`Worst rank: ${maxRank}`);
+        console.log(`Average nodes stored to: ${avgStoreCount.toFixed(1)}`);
+
+        // Distribution of ranks
+        const rankDist = {};
+        ranks.forEach(r => rankDist[r] = (rankDist[r] || 0) + 1);
+        console.log('Rank distribution:', rankDist);
+      }
+
+      if (failures.length > 0) {
+        console.log('\nFailed tests:');
+        failures.forEach(f => console.log(`  Test ${f.testId}: stored to ${f.storedToCount} nodes, queried ${f.queriedCount} nodes`));
+      }
+      console.log('==============================================\n');
+    });
+
+    // Helper to create a randomized network
+    async function createRandomNetwork(nNodes, connectivityFactor = 0.5) {
+      const network = [];
+      for (let i = 0; i < nNodes; i++) {
+        const contact = await SimulatedContact.create(i);
+        network.push(contact);
+      }
+
+      // Randomly connect nodes based on connectivity factor
+      for (let i = 0; i < nNodes; i++) {
+        const node = network[i].node;
+        for (let j = 0; j < nNodes; j++) {
+          if (i !== j && Math.random() < connectivityFactor) {
+            await node.addToRoutingTable(network[j].clone(node));
+          }
+        }
+      }
+
+      return network;
+    }
+
+    // Helper to run a store/read test and track where value was found
+    async function runStoreReadTest(testId, network, storerIdx, readerIdx, keyString) {
+      const storer = network[storerIdx].node;
+      const reader = network[readerIdx].node;
+      const targetKey = await Node.key(keyString);
+      const testValue = `value-${testId}`;
+
+      // Perform store and track recipients (sorted by distance from targetKey)
+      const k = storer.constructor.k;
+      let helpers = await storer.locateNodes(targetKey, k * 2);
+      helpers = [...helpers].sort(Helper.compare); // Ensure sorted by distance
+
+      const storedTo = [];
+      for (const helper of helpers.slice(0, k)) {
+        const stored = await helper.contact.store(targetKey, testValue);
+        if (stored) {
+          storedTo.push({
+            name: helper.name,
+            key: helper.key,
+            distance: helper.distance
+          });
+        }
+      }
+
+      // Now read - iterate now returns { value, responder } when found
+      const result = await reader.iterate(targetKey, 'findValue', k, false); // trace=false for cleaner output
+
+      const found = Node.isValueResult(result);
+      let rank = -1;
+      let responderName = 'unknown';
+      let responderDistance = null;
+
+      if (found && result.responder) {
+        // Find the rank of the responder in the storedTo list
+        const responderKey = result.responder.key;
+        responderName = result.responder.name;
+        responderDistance = result.responder.distance;
+
+        for (let i = 0; i < storedTo.length; i++) {
+          if (storedTo[i].key === responderKey) {
+            rank = i + 1;
+            break;
+          }
+        }
+
+        // If responder not in storedTo list, it might have gotten the value via cache propagation
+        if (rank === -1) {
+          responderName = `${result.responder.name} (not in store list!)`;
+          rank = storedTo.length + 1; // Worse than any stored node
+        }
+      }
+
+      const testResult = {
+        testId,
+        found,
+        rank: found ? rank : -1,
+        responderName,
+        responderDistance,
+        storedToCount: storedTo.length,
+        storedToNames: storedTo.map(s => s.name),
+        queriedCount: found ? 0 : (Array.isArray(result) ? result.length : 0),
+        value: found ? result.value : undefined
+      };
+
+      testResults.push(testResult);
+      return testResult;
+    }
+
+    // Generate 20 randomized store/read tests
+    for (let testNum = 1; testNum <= 20; testNum++) {
+      it(`randomized store/read test ${testNum}`, async function() {
+        // Randomize network parameters
+        const nNodes = 8 + Math.floor(Math.random() * 8); // 8-15 nodes
+        const connectivity = 0.4 + Math.random() * 0.4; // 40-80% connectivity
+
+        const network = await createRandomNetwork(nNodes, connectivity);
+
+        // Random storer and reader (different nodes)
+        const storerIdx = Math.floor(Math.random() * nNodes);
+        let readerIdx = Math.floor(Math.random() * nNodes);
+        while (readerIdx === storerIdx) {
+          readerIdx = Math.floor(Math.random() * nNodes);
+        }
+
+        const result = await runStoreReadTest(
+          testNum,
+          network,
+          storerIdx,
+          readerIdx,
+          `test-key-${testNum}-${Date.now()}`
+        );
+
+        // Log individual test result
+        if (result.found) {
+          const distStr = result.responderDistance ? ` dist=${String(result.responderDistance).length}digits` : '';
+          console.log(`Test ${testNum}: FOUND at rank ${result.rank}/${result.storedToCount} (${result.responderName}${distStr}) - ${nNodes} nodes, ${(connectivity*100).toFixed(0)}% connectivity`);
+          if (result.rank > 3) {
+            console.log(`  ⚠ WARNING: Value found at rank ${result.rank} (not among top 3 closest to key)`);
+            console.log(`    Stored to: ${result.storedToNames.slice(0, 5).join(', ')}${result.storedToNames.length > 5 ? '...' : ''}`);
+          }
+        } else {
+          console.log(`Test ${testNum}: NOT FOUND - stored to ${result.storedToCount}, queried ${result.queriedCount} - ${nNodes} nodes, ${(connectivity*100).toFixed(0)}% connectivity`);
+          console.log(`    Stored to: ${result.storedToNames.join(', ')}`);
+        }
+
+        // Clean up network
+        network.forEach(contact => contact.disconnect());
+
+        expect(result.found).toBe(true);
+      }, 60e3);
+    }
+  });
 });

package/spec/dhtKeySpec.js

@@ -2,9 +2,6 @@ import { Node } from '../index.js';
 const { describe, it, expect, BigInt, afterAll } = globalThis; // For linters.
 
 describe("DHT Keys", function () {
-  afterAll(function () {
-    Node.stopRefresh();
-  });
 
   describe("Node creation", function () {
 

package/spec/dhtWriteReadSpec.js

@@ -0,0 +1,85 @@
+#!/usr/bin/env npx jasmine
+const { describe, it, expect, beforeAll, afterAll, beforeEach, afterEach } = globalThis; // For linters.
+import process from 'node:process';
+import { spawn, exec } from 'node:child_process';
+import {cpus, availableParallelism } from 'node:os';
+import { v4 as uuidv4 } from 'uuid';
+import { WebContact, Node } from '../index.js';
+import { fileURLToPath } from 'url';
+import path from 'path';
+
+describe("DHT write/read", function () {
+  let contact, portalProcess, botProcess;
+  const verbose = false;
+  const baseURL = 'http://localhost:3000/kdht';
+  const logicalCores = availableParallelism();
+  console.log(`Model description "${cpus()[0].model}", ${logicalCores} logical cores.`);
+  const maxPerCluster = logicalCores / 2; // Why half? Because we have at least two processes.
+  const nPortals = maxPerCluster;
+  const nBots = maxPerCluster;
+  const fixedSpacing  = 2; // Between portals.
+  const variableSpacing = 5; // Additional random between portals.
+  const nWrites = 40;
+  const waitBeforeRead = 15e3;
+  const thrash = true;
+  const showPortals = true;
+  const showBots = true;
+
+  
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = path.dirname(__filename);
+  const portalSeconds = fixedSpacing * nPortals + 1.5 * variableSpacing;
+  const botsMilliseconds = 2 * Node.refreshTimeIntervalMS;
+  
+  beforeAll(async function () {
+    function echo(data) { data = data.slice(0, -1); console.log(data.toString()); }
+
+    console.log(new Date(), 'starting', nPortals, 'portals over', portalSeconds, 'seconds');
+    portalProcess = spawn('node', [path.resolve(__dirname, 'portal.js'), '--nPortals', nPortals, '--verbose', verbose.toString()]);
+    if (showPortals) {
+      portalProcess.stdout.on('data', echo);
+      portalProcess.stderr.on('data', echo);
+    }
+    await Node.delay(portalSeconds * 1e3);
+
+    if (nBots) {
+      for (let launched = 0, round = Math.min(nBots, maxPerCluster); launched < nBots; round = Math.min(nBots - launched, maxPerCluster), launched += round) {
+	console.log(new Date(), 'starting', round, 'bots over', botsMilliseconds/1e3, 'seconds');
+	botProcess = spawn('node', [path.resolve(__dirname, 'bots.js'), '--nBots', round, '--thrash', thrash.toString(), '--verbose', verbose.toString()]);
+	if (showBots) {
+	  botProcess.stdout.on('data', echo);
+	  botProcess.stderr.on('data', echo);
+	}
+	await Node.delay(botsMilliseconds);
+      }
+    }
+
+    contact = await WebContact.create({name: uuidv4(), debug: verbose});
+    const bootstrapName = await contact.fetchBootstrap(baseURL);
+    const bootstrapContact = await contact.ensureRemoteContact(bootstrapName, baseURL);
+    console.log(new Date(), contact.sname, 'joining', bootstrapContact.sname);
+    await contact.join(bootstrapContact);
+    console.log(new Date(), contact.sname, 'joined');    
+    for (let index = 0; index < nWrites; index++) {
+      const wrote = await contact.storeValue(index, index);
+      console.log('Wrote', index);
+    }
+    if (waitBeforeRead) {
+      console.log(new Date(), `Written. Waiting ${waitBeforeRead.toLocaleString()} ms before reading.`);
+      await Node.delay(waitBeforeRead);
+    }
+    console.log(new Date(), 'Reading');
+  }, 5e3 * nWrites + (1 + Math.ceil(nBots / maxPerCluster)) * Node.refreshTimeIntervalMS);
+  afterAll(async function () {
+    contact.disconnect();
+    console.log(new Date(), 'killing portals and bots');
+    exec('pkill kdht-');
+  });
+  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);
+    }, 10e3); // Can take longer to re-establish multiple connections.
+  }
+});

package/spec/portal.js

@@ -6,19 +6,22 @@ import { launchWriteRead } from './writes.js';
 import express from 'express';
 import logger from 'morgan';
 import path from 'path';
+import {cpus, availableParallelism } from 'node:os';
 import { fileURLToPath } from 'url';
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
 import { Node } from '../index.js';
 
+const logicalCores = availableParallelism();
+
 // TODO: Allow a remote portal to be specified that this portal will hook with, forming one big network.
 const argv = yargs(hideBin(process.argv))
-      .usage("Start an http post server through which nodes can connect to set of nPortals stable nodes.")
+      .usage(`Start an http post server through which nodes can connect to set of nPortals stable nodes. Model description "${cpus()[0].model}", ${logicalCores} logical cores.`)
       .option('nPortals', {
 	alias: 'nportals',	
 	alias: 'p',
 	type: 'number',
-	default: 20,
+	default: Math.min(logicalCores / 2, 2),
 	description: "The number of steady nodes that handle initial connections."
       })
       .option('nBots', {

package/transports/contact.js

@@ -1,3 +1,4 @@
+import { v4 as uuidv4 } from 'uuid';
 import { Node } from '../dht/node.js';
 
 export class Contact {
@@ -31,7 +32,8 @@ export class Contact {
     return this.fromNode(node, host || node);
   }
   clone(hostNode, searchHost = true) { // Answer a Contact that is set up for hostNode - either this instance or a new one.
-    // Unless searchHost is null, any existing contact on hostNode will be returned.
+    // I.e., a Contact with node: this.node and host: hostNode.
+    // Unless searchHost is null, a matching existing contact on hostNode will be returned.
     if (this.host === hostNode) return this; // All good.
 
     // Reuse existing contact in hostNode -- if still running.
@@ -57,41 +59,108 @@ export class Contact {
   store(key, value) {
     return this.sendRPC('store', key, value);
   }
-  disconnect() { // Simulate a disconnection of node, marking as such and rejecting any RPCs in flight.
+  async disconnect() { // Simulate a disconnection of node, marking as such and rejecting any RPCs in flight.
     Node.assert(this.host === this.node, "Disconnect", this.name, "not invoked on home contact", this.host.name);
-    this.host.isRunning = false;
+    // Attempt to ensure that there are other copies.
+    if (!this.host.isStopped()) {
+      await Promise.all(this.host.storage.entries().map(([key, value]) => this.storeValue(key, value)));
+    }
     this.host.stopRefresh();
-    this.host.contacts.forEach(async contact => {
+    for (const contact of this.host.contacts) {
       const far = contact.connection;
       if (!far) return;
-      contact.disconnectTransport();
-    });
+      contact.synchronousSend(['-', 'bye']); // May have already been closed by other side.
+      await contact.disconnectTransport(false);
+    }
+    this.host.isRunning = false;
+  }
+  disconnectTransport(andNotify = true) { // There are asynchronous things that happen, but they each get triggered synchronously
+    if (andNotify) this.synchronousSend(['-', 'close']);  // May have already send "bye" and closed.
+  }
+  close() { // The sender is closing their connection, but not necessarilly disconnected entirely (e.g., maybe maxTransports)
+    this.host.log('closing disconnected contact', this.sname, this.xxx++);
+    this.disconnectTransport(false);
+    this.host.removeLooseTransport(this.key); // If any.
+  }
+  bye() { // The sender is disconnecting from the network
+    this.host.log('removing disconnected contact', this.sname);
+    this.host.removeContact(this).then(bucket => bucket?.resetRefresh('now')); // Accelerate the bucket refresh
   }
   distance(key) { return this.host.constructor.distance(this.key, key); }
 
   // RPC
-  sendRPC(method, ...rest) { // Promise the result of a nework call to node. Rejects if we get disconnected along the way.
+  static maxPingMs = 330; // Not including connect time. These are single-hop WebRTC data channels.
+  serializeRequest(...rest) { // Return the composite datum suitable for transport over the wire.
+    return rest; // Non-simulation subclases must override.
+  }
+  async deserializeRequest(...rest) { // Inverse of serializeRequest. Response object will be spread for Node receiveRPC.
+    return rest; // Non-simulation subclases must override.
+  }
+  serializeResponse(response) { // Like serializeRequest, but specifically for a probe response.
+    return response;
+  }
+  async deserializeResponse(result) { // Inverse of serializeResponse.
+    return result;
+  }
+  rpcTimeout(method) { // Promise to resolve to null at appriate timeout for RPC method
+    let hops = 15; // recursive calls
+    if (method === 'signals') hops = 2;
+    else if (['ping', 'findNodes', 'findValue', 'store'].includes(method)) hops = 1;
+    return Node.delay(hops * this.constructor.maxPingMs, null);
+  }
+  async sendRPC(method, ...rest) { // Promise the result of a network call to node, or null if not possible.
     const sender = this.host.contact;
-    //this.host.log('sendRPC', method, rest, sender.isRunning ? 'running' : 'stopped', 'sender key:', sender.key, 'to node:', this.sname, this.key);
-    if (!sender.isRunning) {this.host.log('not running'); return null;  }// sender closed before call.
-    if (sender.key === this.key) {
-      const result = this.receiveRPC(method, sender, ...rest);
+
+    if (!sender.isRunning) return null; // sender closed before call.
+    if (sender.key === this.key) { // self-send short-circuit
+      const result = this.host.receiveRPC(method, sender, ...rest);
       if (!result) this.host.xlog('no local result');
       return result;
     }
+    if (!await this.connect()) return null;
+    // 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.
+    let messageTag = uuidv4();
+    // if (method === 'signals') {
+    //   messageTag = 'X' + messageTag;
+    //   this.host.xlog(this.counter, 'requesting', messageTag, method, 'of', this.sname);
+    // }
+    const message = this.serializeRequest(messageTag, method, sender, ...rest);
 
     const start = Date.now();
-    return this.transmitRPC(method, ...rest) // The main event.
+    return this.transmitRPC(...message)
       .then(result => {
-	if (!sender.isRunning) {this.host.log('sender closed'); return null; } // Sender closed after call.
+	if (!sender.isRunning) return null; // Sender closed after call.
 	return result;
       })
       .finally(() => Node.noteStatistic(start, 'rpc'));
   }
-  async receiveRPC(method, sender, ...rest) { // Call the message method to act on the 'to' node side.
-    Node.assert(typeof(method)==='string', 'no method', method);
-    Node.assert(sender instanceof Contact, 'no sender', sender);
-    return this.host.receiveRPC(method, sender, ...rest);
+  getResponsePromise(messageTag) { // Get a promise that will resolve when a response comes in as messageTag.
+    return new Promise(resolve => this.host.messageResolvers.set(messageTag, resolve));
+  }
+  async receiveRPC(messageTag, ...data) { // Call the message method to act on the 'to' node side.
+    const responder = this.host.messageResolvers.get(messageTag);
+    if (responder) { // A response to something we sent and are waiting for.
+      let [result] = data;
+      this.host.messageResolvers.delete(messageTag);
+      result = await this.deserializeResponse(result);
+      responder(result);
+    } else if (!this.host.isRunning) {
+      this.disconnectTransport();
+      // Kludge: In testing, it is possible for a disconnecting node to send a request that will respond to a new session of the same id.
+    } else if (typeof(data[0]) !== 'string' || data[0] === 'pong') {
+      ; //this.host.xlog(this.counter, 'received result without responder', messageTag, data, 'at', this.sname);
+    } else if (data[0] === 'close') {
+      this.close();
+    } else if (data[0] === 'bye') {
+      this.bye();
+    } else { // An incoming request.
+      const deserialized = await this.deserializeRequest(...data);
+      let response = await this.host.receiveRPC(...deserialized);
+      response = this.serializeResponse(response);
+      //if (messageTag.startsWith('X')) this.host.xlog(this.counter, 'responding', messageTag, response, 'to', this.sname);
+      await this.send([messageTag, response]);
+    }
   }
   // Sponsorship
   _sponsors = new Map(); // maps key => contact
@@ -115,13 +184,12 @@ export class Contact {
     //return `${this.connection ? '_' : ''}${this.sname}v${this.counter}${this.isRunning ? '' : '*'}`;
     return `${this.connection ? '_' : ''}${this.sname}${this.isRunning ? '' : '*'}`; // simpler version
   }
-  static pingTimeMS = 30; // ms
+  static pingTimeMS = 40; // ms
   static async ensureTime(thunk, ms = this.pingTimeMS) { // Promise that thunk takes at least ms to execute.
     const start = Date.now();
     const result = await thunk();
     const elapsed = Date.now() - start;
-    if (elapsed > ms) return result;
-    await new Promise(resolve => setTimeout(resolve, ms - elapsed));
+    await Node.delay(ms - elapsed);
     return result;
   }
 }