dignity.js 0.5.4 → 0.6.0

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/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);
       }