feat: implemented NodeManager.refreshBucket()

This method preforms the kademlia `refreshBucket` operation. It selects a random node within the bucket and preforms a search for that node. The process exchanges node information with any nodes it connects to.

#345

src/nodes/NodeManager.ts

@@ -5,11 +5,17 @@ import type KeyManager from '../keys/KeyManager';
 import type { PublicKeyPem } from '../keys/types';
 import type Sigchain from '../sigchain/Sigchain';
 import type { ChainData, ChainDataEncoded } from '../sigchain/types';
-import type { NodeId, NodeAddress, NodeBucket } from '../nodes/types';
+import type {
+  NodeId,
+  NodeAddress,
+  NodeBucket,
+  NodeBucketIndex,
+} from '../nodes/types';
 import type { ClaimEncoded } from '../claims/types';
 import type { Timer } from '../types';
 import Logger from '@matrixai/logger';
 import { StartStop, ready } from '@matrixai/async-init/dist/StartStop';
+import { IdInternal } from '@matrixai/id';
 import * as nodesErrors from './errors';
 import * as nodesUtils from './utils';
 import * as networkUtils from '../network/utils';
@@ -514,7 +520,7 @@ class NodeManager {
   //   return await this.nodeGraph.getAllBuckets(tran);
   // }
 
-  // FIXME
+  // FIXME potentially confusing name, should we rename this to renewBuckets?
   /**
    * To be called on key renewal. Re-orders all nodes in all buckets with respect
    * to the new node ID.
@@ -609,6 +615,24 @@ class NodeManager {
   public async queueDrained(): Promise<void> {
     await this.setNodeQueueEmpty;
   }
+
+  /**
+   * Kademlia refresh bucket operation.
+   * It picks a random node within a bucket and does a search for that node.
+   * Connections during the search will will share node information with other
+   * nodes.
+   * @param bucketIndex
+   */
+  private async refreshBucket(bucketIndex: NodeBucketIndex) {
+    // We need to generate a random nodeId for this bucket
+    const nodeId = this.keyManager.getNodeId();
+    const bucketRandomNodeId = nodesUtils.generateRandomNodeIdForBucket(
+      nodeId,
+      bucketIndex,
+    );
+    // We then need to start a findNode procedure
+    await this.nodeConnectionManager.findNode(bucketRandomNodeId);
+  }
 }
 
 export default NodeManager;

src/nodes/utils.ts

@@ -7,6 +7,7 @@ import type {
 import { IdInternal } from '@matrixai/id';
 import lexi from 'lexicographic-integer';
 import { bytes2BigInt, bufferSplit } from '../utils';
+import * as keysUtils from '../keys/utils';
 
 // FIXME:
 const prefixBuffer = Buffer.from([33]);
@@ -283,6 +284,44 @@ function bucketSortByDistance(
   }
 }
 
+function generateRandomDistanceForBucket(bucketIndex: NodeBucketIndex): NodeId {
+  const buffer = keysUtils.getRandomBytesSync(32);
+  // Calculate the most significant byte for bucket
+  const base = bucketIndex / 8;
+  const mSigByte = Math.floor(base);
+  const mSigBit = (base - mSigByte) * 8 + 1;
+  const mSigByteIndex = buffer.length - mSigByte - 1;
+  // Creating masks
+  // AND mask should look like 0b00011111
+  // OR mask should look like  0b00010000
+  const shift = 8 - mSigBit;
+  const andMask = 0b11111111 >>> shift;
+  const orMask = 0b10000000 >>> shift;
+  let byte = buffer[mSigByteIndex];
+  byte = byte & andMask; // Forces 0 for bits above bucket bit
+  byte = byte | orMask; // Forces 1 in the desired bucket bit
+  buffer[mSigByteIndex] = byte;
+  // Zero out byte 'above' mSigByte
+  for (let byteIndex = 0; byteIndex < mSigByteIndex; byteIndex++) {
+    buffer[byteIndex] = 0;
+  }
+  return IdInternal.fromBuffer<NodeId>(buffer);
+}
+
+function xOrNodeId(node1: NodeId, node2: NodeId): NodeId {
+  const xOrNodeArray = node1.map((byte, i) => byte ^ node2[i]);
+  const xOrNodeBuffer = Buffer.from(xOrNodeArray);
+  return IdInternal.fromBuffer<NodeId>(xOrNodeBuffer);
+}
+
+function generateRandomNodeIdForBucket(
+  nodeId: NodeId,
+  bucket: NodeBucketIndex,
+): NodeId {
+  const randomDistanceForBucket = generateRandomDistanceForBucket(bucket);
+  return xOrNodeId(nodeId, randomDistanceForBucket);
+}
+
 export {
   prefixBuffer,
   encodeNodeId,
@@ -299,4 +338,7 @@ export {
   parseLastUpdatedBucketDbKey,
   nodeDistance,
   bucketSortByDistance,
+  generateRandomDistanceForBucket,
+  xOrNodeId,
+  generateRandomNodeIdForBucket,
 };

tests/nodes/utils.test.ts

@@ -171,4 +171,22 @@ describe('nodes/utils', () => {
       i++;
     }
   });
+  test('should generate random distance for a bucket', async () => {
+    // Const baseNodeId = testNodesUtils.generateRandomNodeId();
+    const zeroNodeId = IdInternal.fromBuffer<NodeId>(Buffer.alloc(32, 0));
+    for (let i = 0; i < 255; i++) {
+      const randomDistance = nodesUtils.generateRandomDistanceForBucket(i);
+      expect(nodesUtils.bucketIndex(zeroNodeId, randomDistance)).toEqual(i);
+    }
+  });
+  test('should generate random NodeId for a bucket', async () => {
+    const baseNodeId = testNodesUtils.generateRandomNodeId();
+    for (let i = 0; i < 255; i++) {
+      const randomDistance = nodesUtils.generateRandomNodeIdForBucket(
+        baseNodeId,
+        i,
+      );
+      expect(nodesUtils.bucketIndex(baseNodeId, randomDistance)).toEqual(i);
+    }
+  });
 });