dignity.js 0.5.3 → 0.6.0

package/src/gossip/peer-group.js

@@ -0,0 +1,64 @@
+const PEER_GROUP_SCOPE_PREFIX = 'gossip:';
+
+const DEFAULT_PEER_GROUP_OPTIONS = {
+  fanout: 3,
+  maxActivePeers: 8,
+  maxHops: 6,
+  relayEnabled: true
+};
+
+function peerGroupScope(groupId) {
+  if (!groupId) {
+    throw new Error('peerGroupScope requires groupId');
+  }
+  return `${PEER_GROUP_SCOPE_PREFIX}${groupId}`;
+}
+
+function parsePeerGroupScope(scope) {
+  if (!scope || !scope.startsWith(PEER_GROUP_SCOPE_PREFIX)) {
+    return null;
+  }
+  return scope.slice(PEER_GROUP_SCOPE_PREFIX.length);
+}
+
+function shufflePeerIds(peerIds, randomFn = Math.random) {
+  const list = [...peerIds];
+  for (let i = list.length - 1; i > 0; i -= 1) {
+    const j = Math.floor(randomFn() * (i + 1));
+    [list[i], list[j]] = [list[j], list[i]];
+  }
+  return list;
+}
+
+function selectFanoutPeers({
+  peers,
+  count,
+  excludePeerIds = [],
+  connectedPeerIds = [],
+  randomFn = Math.random
+}) {
+  const excluded = new Set(excludePeerIds.filter(Boolean));
+  const candidates = peers
+    .map((entry) => entry.peerId || entry)
+    .filter((peerId) => peerId && !excluded.has(peerId));
+
+  const connected = new Set(connectedPeerIds.filter(Boolean));
+  const preferred = candidates.filter((peerId) => connected.has(peerId));
+  const others = candidates.filter((peerId) => !connected.has(peerId));
+
+  const ordered = [
+    ...shufflePeerIds(preferred, randomFn),
+    ...shufflePeerIds(others, randomFn)
+  ];
+
+  return ordered.slice(0, Math.max(0, count));
+}
+
+module.exports = {
+  PEER_GROUP_SCOPE_PREFIX,
+  DEFAULT_PEER_GROUP_OPTIONS,
+  peerGroupScope,
+  parsePeerGroupScope,
+  shufflePeerIds,
+  selectFanoutPeers
+};

package/src/index.js

@@ -30,6 +30,13 @@ const {
   MessageSecurityService,
   DEFAULT_SECURITY_OPTIONS
 } = require('./security/message-security-service');
+const {
+  PEER_GROUP_SCOPE_PREFIX,
+  DEFAULT_PEER_GROUP_OPTIONS,
+  peerGroupScope,
+  parsePeerGroupScope,
+  selectFanoutPeers
+} = require('./gossip/peer-group');
 
 module.exports = {
   DignityP2P,
@@ -47,5 +54,10 @@ module.exports = {
   VDF,
   SlothPermutation,
   MessageSecurityService,
-  DEFAULT_SECURITY_OPTIONS
+  DEFAULT_SECURITY_OPTIONS,
+  PEER_GROUP_SCOPE_PREFIX,
+  DEFAULT_PEER_GROUP_OPTIONS,
+  peerGroupScope,
+  parsePeerGroupScope,
+  selectFanoutPeers
 };

package/src/network/in-memory-network.js

@@ -20,6 +20,19 @@ class InMemoryNetworkHub {
     }
     await Promise.all(deliveries);
   }
+
+  async sendToPeers(senderId, message, peerIds = []) {
+    const targets = new Set((peerIds || []).filter((peerId) => peerId && peerId !== senderId));
+    const deliveries = [];
+
+    for (const [nodeId, adapter] of this.adapters.entries()) {
+      if (nodeId !== senderId && targets.has(nodeId)) {
+        deliveries.push(adapter.receive(message));
+      }
+    }
+
+    await Promise.all(deliveries);
+  }
 }
 
 class InMemoryNetworkAdapter {
@@ -31,6 +44,7 @@ class InMemoryNetworkAdapter {
     this.hub = hub;
     this.nodeId = null;
     this.messageHandlers = new Set();
+    this.connectedPeers = new Set();
   }
 
   async start(nodeId) {
@@ -44,6 +58,14 @@ class InMemoryNetworkAdapter {
     }
 
     this.nodeId = null;
+    this.connectedPeers.clear();
+  }
+
+  async connectToPeer(remotePeerId) {
+    if (!remotePeerId || remotePeerId === this.nodeId) {
+      return;
+    }
+    this.connectedPeers.add(remotePeerId);
   }
 
   async broadcast(message) {
@@ -54,6 +76,26 @@ class InMemoryNetworkAdapter {
     await this.hub.broadcast(this.nodeId, message);
   }
 
+  async sendToPeers(message, peerIds = []) {
+    if (!this.nodeId) {
+      throw new Error('Network adapter has not been started');
+    }
+
+    await this.hub.sendToPeers(this.nodeId, message, peerIds);
+  }
+
+  listOpenPeerIds() {
+    return [...this.connectedPeers];
+  }
+
+  getOpenConnectionCount() {
+    return this.connectedPeers.size;
+  }
+
+  isConnectedTo(remotePeerId) {
+    return this.connectedPeers.has(remotePeerId);
+  }
+
   onMessage(handler) {
     this.messageHandlers.add(handler);
   }

package/src/network/peerjs-network.js

@@ -185,6 +185,34 @@ class PeerJSNetworkAdapter {
     await Promise.all(deliveries);
   }
 
+  async sendToPeers(message, peerIds = []) {
+    if (!this.peer) {
+      throw new Error('PeerJS network adapter has not been started');
+    }
+
+    const targets = new Set((peerIds || []).filter(Boolean));
+    if (targets.size === 0) {
+      return;
+    }
+
+    const deliveries = [];
+    for (const [peerId, connection] of this.connections.entries()) {
+      if (targets.has(peerId) && connection.open) {
+        deliveries.push(connection.send(message));
+      }
+    }
+
+    await Promise.all(deliveries);
+  }
+
+  async disconnectPeer(remotePeerId) {
+    const connection = this.connections.get(remotePeerId);
+    if (connection && typeof connection.close === 'function') {
+      connection.close();
+    }
+    this.connections.delete(remotePeerId);
+  }
+
   getOpenConnectionCount() {
     return this.listOpenPeerIds().length;
   }

package/src/persistence/indexeddb-persistence.js

@@ -73,6 +73,7 @@ class IndexedDBPersistence {
       ownerId: record.ownerId,
       collaboratorIds: Array.isArray(record.collaboratorIds) ? [...record.collaboratorIds] : [],
       data: { ...record.data },
+      hash: record.hash || null,
       createdAt: record.createdAt,
       updatedAt: record.updatedAt,
       deletedAt: record.deletedAt,
@@ -143,6 +144,7 @@ class IndexedDBPersistence {
         ownerId: stored.ownerId,
         collaboratorIds: stored.collaboratorIds,
         data: stored.data,
+        hash: stored.hash || null,
         createdAt: stored.createdAt,
         updatedAt: stored.updatedAt,
         deletedAt: stored.deletedAt,

package/src/security/message-security-service.js

@@ -387,8 +387,16 @@ class MessageSecurityService {
 
       let key;
       if (encryption.kdf === 'pbkdf2') {
-        const iterations = encryption.kdfIterations || DEFAULT_SECURITY_OPTIONS.kdfIterations;
-        key = await deriveBroadcastKey(password, salt, iterations);
+        const configuredIterations = this.options.kdfIterations || DEFAULT_SECURITY_OPTIONS.kdfIterations;
+        const requestedIterations = encryption.kdfIterations || configuredIterations;
+        const minIterations = Math.max(1000, Math.floor(configuredIterations * 0.1));
+        const maxIterations = configuredIterations * 2;
+
+        if (requestedIterations < minIterations || requestedIterations > maxIterations) {
+          throw new Error(`Invalid kdfIterations: ${requestedIterations}`);
+        }
+
+        key = await deriveBroadcastKey(password, salt, requestedIterations);
       } else {
         key = legacyBroadcastKey(password, salt);
       }

package/src/security/sloth-vdf.js

@@ -6,6 +6,12 @@ class SlothPermutation {
   static p = BigInt(
     '170082004324204494273811327264862981553264701145937538369570764779791492622392118654022654452947093285873855529044371650895045691292912712699015605832276411308653107069798639938826015099738961427172366594187783204437869906954750443653318078358839409699824714551430573905637228307966826784684174483831608534979'
   );
+  // precompute values for optimization:
+  // (p - 1) / 2
+  static pHalf = (SlothPermutation.p - BigInt(1)) >> BigInt(1);
+  // (p + 1) / 4
+  // p ≡ 3 (mod 4) ⇒ (p+1) divisible by 4
+  static pQuarter = (SlothPermutation.p + BigInt(1)) >> BigInt(2);
 
   fastPow(base, exponent, modulus) {
     if (modulus === BigInt(1)) {
@@ -17,11 +23,11 @@ class SlothPermutation {
     let powExponent = exponent;
 
     while (powExponent > 0) {
-      if (powExponent % BigInt(2) === BigInt(1)) {
+      if ((powExponent & BigInt(1)) === BigInt(1)) {
         result = (result * powBase) % modulus;
       }
 
-      powExponent = powExponent / BigInt(2);
+      powExponent = powExponent >> BigInt(1);
       powBase = (powBase * powBase) % modulus;
     }
 
@@ -29,7 +35,7 @@ class SlothPermutation {
   }
 
   quadRes(x) {
-    return this.fastPow(x, (SlothPermutation.p - BigInt(1)) / BigInt(2), SlothPermutation.p) === BigInt(1);
+    return this.fastPow(x, SlothPermutation.pHalf, SlothPermutation.p) === BigInt(1);
   }
 
   modSqrtOp(x) {
@@ -37,10 +43,10 @@ class SlothPermutation {
     let value = x;
 
     if (this.quadRes(value)) {
-      y = this.fastPow(value, (SlothPermutation.p + BigInt(1)) / BigInt(4), SlothPermutation.p);
+      y = this.fastPow(value, SlothPermutation.pQuarter, SlothPermutation.p);
     } else {
       value = (-value + SlothPermutation.p) % SlothPermutation.p;
-      y = this.fastPow(value, (SlothPermutation.p + BigInt(1)) / BigInt(4), SlothPermutation.p);
+      y = this.fastPow(value, SlothPermutation.pQuarter, SlothPermutation.p);
     }
 
     return y;

package/src/signaling/websocket-signaling-provider.js

@@ -1,3 +1,12 @@
+function randomBase36(length) {
+  let value = '';
+  while (value.length < length) {
+    const chunk = Math.random().toString(36).slice(2);
+    value += chunk.length > 0 ? chunk : '0';
+  }
+  return value.slice(0, length);
+}
+
 class WebSocketSignalingProvider {
   constructor({ id, url, WebSocketImpl, priority = 0 }) {
     if (!url) {
@@ -50,8 +59,8 @@ class WebSocketSignalingProvider {
       return this.url;
     }
 
-    const connectionId = `dignityjs_${Math.random().toString(36).slice(2, 12)}`;
-    const token = Math.random().toString(36).slice(2, 12);
+    const connectionId = `dignityjs_${randomBase36(10)}`;
+    const token = randomBase36(10);
     const hasQuery = this.url.includes('?');
     const hasId = /[?&]id=/.test(this.url);
     const hasToken = /[?&]token=/.test(this.url);