react-native-ble-mesh 1.0.1

package/src/index.mjs

@@ -0,0 +1,62 @@
+/**
+ * @fileoverview BLE Mesh Network Library - ESM Entry Point
+ * @module rn-ble-mesh
+ * @description Production-ready BLE Mesh Network with Noise Protocol security
+ */
+
+// Import CJS module and re-export as ESM
+import cjs from './index.js';
+
+// Named exports
+export const {
+  // Factory functions
+  createMeshService,
+  createNodeMesh,
+  createTestMesh,
+
+  // Main service class
+  MeshService,
+
+  // Transport classes
+  BLETransport,
+  MockTransport,
+  Transport,
+
+  // Storage classes
+  MemoryStorage,
+  AsyncStorageAdapter,
+  Storage,
+  MessageStore,
+
+  // Constants
+  PROTOCOL_VERSION,
+  MESSAGE_TYPE,
+  MESSAGE_FLAGS,
+  CONNECTION_STATE,
+  SERVICE_STATE,
+  POWER_MODE,
+  BLE_SERVICE_UUID,
+  BLE_CHARACTERISTIC_TX,
+  BLE_CHARACTERISTIC_RX,
+  MESH_CONFIG,
+  CRYPTO_CONFIG,
+
+  // Error classes
+  MeshError,
+  CryptoError,
+  ConnectionError,
+  HandshakeError,
+  MessageError,
+  ValidationError,
+
+  // Module namespaces
+  crypto,
+  protocol,
+  mesh,
+  transport,
+  storage,
+  utils
+} = cjs;
+
+// Default export for convenience
+export default cjs;

package/src/mesh/dedup/BloomFilter.js

@@ -0,0 +1,207 @@
+'use strict';
+
+/**
+ * @fileoverview Bloom filter for efficient duplicate detection
+ * @module mesh/dedup/BloomFilter
+ */
+
+/**
+ * FNV-1a hash parameters
+ * @constant
+ * @private
+ */
+const FNV_PRIME = 0x01000193;
+const FNV_OFFSET = 0x811c9dc5;
+
+/**
+ * Bloom filter for probabilistic set membership testing
+ * @class BloomFilter
+ */
+class BloomFilter {
+  /**
+   * Creates a new BloomFilter
+   * @param {number} [size=2048] - Size of the bit array in bits
+   * @param {number} [hashCount=7] - Number of hash functions to use
+   */
+  constructor(size = 2048, hashCount = 7) {
+    if (!Number.isInteger(size) || size <= 0) {
+      throw new Error('Size must be a positive integer');
+    }
+    if (!Number.isInteger(hashCount) || hashCount <= 0) {
+      throw new Error('Hash count must be a positive integer');
+    }
+
+    /**
+     * Size of the bit array in bits
+     * @type {number}
+     */
+    this.size = size;
+
+    /**
+     * Number of hash functions
+     * @type {number}
+     */
+    this.hashCount = hashCount;
+
+    /**
+     * Bit array storage (using Uint8Array for efficiency)
+     * @type {Uint8Array}
+     * @private
+     */
+    this._bits = new Uint8Array(Math.ceil(size / 8));
+
+    /**
+     * Number of items added
+     * @type {number}
+     * @private
+     */
+    this._count = 0;
+  }
+
+  /**
+   * Computes FNV-1a hash of input data
+   * @param {Uint8Array} data - Data to hash
+   * @param {number} seed - Seed for variation
+   * @returns {number} Hash value
+   * @private
+   */
+  _fnv1a(data, seed) {
+    let hash = FNV_OFFSET ^ seed;
+    // Handle empty data by mixing in the seed and length
+    if (data.length === 0) {
+      hash ^= seed;
+      hash = Math.imul(hash, FNV_PRIME) >>> 0;
+    }
+    for (let i = 0; i < data.length; i++) {
+      hash ^= data[i];
+      hash = Math.imul(hash, FNV_PRIME) >>> 0;
+    }
+    return hash;
+  }
+
+  /**
+   * Converts input to Uint8Array
+   * @param {string|Uint8Array} item - Item to convert
+   * @returns {Uint8Array} Byte array
+   * @private
+   */
+  _toBytes(item) {
+    if (item instanceof Uint8Array) {
+      return item;
+    }
+    if (typeof item === 'string') {
+      const encoder = new TextEncoder();
+      return encoder.encode(item);
+    }
+    throw new Error('Item must be string or Uint8Array');
+  }
+
+  /**
+   * Computes hash positions for an item
+   * @param {string|Uint8Array} item - Item to hash
+   * @returns {number[]} Array of bit positions
+   * @private
+   */
+  _getPositions(item) {
+    const data = this._toBytes(item);
+    const positions = [];
+    for (let i = 0; i < this.hashCount; i++) {
+      const hash = this._fnv1a(data, i);
+      positions.push(hash % this.size);
+    }
+    return positions;
+  }
+
+  /**
+   * Sets a bit at the given position
+   * @param {number} position - Bit position
+   * @private
+   */
+  _setBit(position) {
+    const byteIndex = Math.floor(position / 8);
+    const bitIndex = position % 8;
+    this._bits[byteIndex] |= (1 << bitIndex);
+  }
+
+  /**
+   * Gets a bit at the given position
+   * @param {number} position - Bit position
+   * @returns {boolean} True if bit is set
+   * @private
+   */
+  _getBit(position) {
+    const byteIndex = Math.floor(position / 8);
+    const bitIndex = position % 8;
+    return (this._bits[byteIndex] & (1 << bitIndex)) !== 0;
+  }
+
+  /**
+   * Adds an item to the filter
+   * @param {string|Uint8Array} item - Item to add
+   */
+  add(item) {
+    const positions = this._getPositions(item);
+    for (const pos of positions) {
+      this._setBit(pos);
+    }
+    this._count++;
+  }
+
+  /**
+   * Tests if an item might be in the filter
+   * @param {string|Uint8Array} item - Item to test
+   * @returns {boolean} True if item might be present, false if definitely absent
+   */
+  mightContain(item) {
+    const positions = this._getPositions(item);
+    for (const pos of positions) {
+      if (!this._getBit(pos)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  /**
+   * Clears all items from the filter
+   */
+  clear() {
+    this._bits.fill(0);
+    this._count = 0;
+  }
+
+  /**
+   * Gets the fill ratio of the filter
+   * @returns {number} Ratio of set bits to total bits (0-1)
+   */
+  getFillRatio() {
+    let setBits = 0;
+    for (let i = 0; i < this._bits.length; i++) {
+      let byte = this._bits[i];
+      while (byte) {
+        setBits += byte & 1;
+        byte >>>= 1;
+      }
+    }
+    return setBits / this.size;
+  }
+
+  /**
+   * Gets the number of items added
+   * @returns {number} Count of items added
+   */
+  getCount() {
+    return this._count;
+  }
+
+  /**
+   * Estimates false positive rate based on current fill
+   * @returns {number} Estimated false positive probability
+   */
+  getEstimatedFalsePositiveRate() {
+    const fillRatio = this.getFillRatio();
+    return Math.pow(fillRatio, this.hashCount);
+  }
+}
+
+module.exports = BloomFilter;

package/src/mesh/dedup/DedupManager.js

@@ -0,0 +1,212 @@
+'use strict';
+
+/**
+ * @fileoverview Combined deduplication manager using Bloom filter and LRU cache
+ * @module mesh/dedup/DedupManager
+ */
+
+const BloomFilter = require('./BloomFilter');
+const MessageCache = require('./MessageCache');
+const { MESH_CONFIG } = require('../../constants');
+
+/**
+ * Default configuration for deduplication
+ * @constant
+ * @private
+ */
+const DEFAULT_CONFIG = {
+  bloomFilterSize: MESH_CONFIG.BLOOM_FILTER_SIZE,
+  bloomHashCount: MESH_CONFIG.BLOOM_HASH_COUNT,
+  cacheSize: 1024,
+  autoResetThreshold: 0.75
+};
+
+/**
+ * Deduplication manager combining Bloom filter and LRU cache
+ * Uses Bloom filter for fast probabilistic checks with LRU cache as backup
+ * @class DedupManager
+ */
+class DedupManager {
+  /**
+   * Creates a new DedupManager
+   * @param {Object} [options] - Configuration options
+   * @param {number} [options.bloomFilterSize] - Size of Bloom filter in bits
+   * @param {number} [options.bloomHashCount] - Number of hash functions
+   * @param {number} [options.cacheSize] - Maximum LRU cache entries
+   * @param {number} [options.autoResetThreshold] - Fill ratio for auto reset
+   */
+  constructor(options = {}) {
+    const config = { ...DEFAULT_CONFIG, ...options };
+
+    /**
+     * Bloom filter for fast duplicate detection
+     * @type {BloomFilter}
+     * @private
+     */
+    this._bloomFilter = new BloomFilter(
+      config.bloomFilterSize,
+      config.bloomHashCount
+    );
+
+    /**
+     * LRU cache for precise duplicate detection
+     * @type {MessageCache}
+     * @private
+     */
+    this._cache = new MessageCache(config.cacheSize);
+
+    /**
+     * Auto-reset threshold for Bloom filter
+     * @type {number}
+     * @private
+     */
+    this._autoResetThreshold = config.autoResetThreshold;
+
+    /**
+     * Statistics for monitoring
+     * @type {Object}
+     * @private
+     */
+    this._stats = {
+      checks: 0,
+      bloomPositives: 0,
+      cacheHits: 0,
+      duplicates: 0,
+      added: 0,
+      resets: 0
+    };
+  }
+
+  /**
+   * Checks if a message ID has been seen before
+   * @param {string} messageId - Message ID to check
+   * @returns {boolean} True if message is a duplicate
+   */
+  isDuplicate(messageId) {
+    this._stats.checks++;
+
+    // Quick check with Bloom filter
+    if (!this._bloomFilter.mightContain(messageId)) {
+      return false;
+    }
+    this._stats.bloomPositives++;
+
+    // Confirm with exact cache lookup (handles false positives)
+    if (this._cache.has(messageId)) {
+      this._stats.cacheHits++;
+      this._stats.duplicates++;
+      return true;
+    }
+
+    // Bloom filter false positive
+    return false;
+  }
+
+  /**
+   * Marks a message ID as seen
+   * @param {string} messageId - Message ID to mark
+   */
+  markSeen(messageId) {
+    this._bloomFilter.add(messageId);
+    this._cache.add(messageId);
+    this._stats.added++;
+
+    // Auto-reset Bloom filter if too full
+    if (this._bloomFilter.getFillRatio() >= this._autoResetThreshold) {
+      this._resetBloomFilter();
+    }
+  }
+
+  /**
+   * Checks and marks a message in one operation
+   * @param {string} messageId - Message ID to check and mark
+   * @returns {boolean} True if message was a duplicate
+   */
+  checkAndMark(messageId) {
+    if (this.isDuplicate(messageId)) {
+      return true;
+    }
+    this.markSeen(messageId);
+    return false;
+  }
+
+  /**
+   * Resets the Bloom filter while preserving cache entries
+   * @private
+   */
+  _resetBloomFilter() {
+    this._bloomFilter.clear();
+    this._stats.resets++;
+
+    // Re-add all cached entries to Bloom filter
+    const entries = this._cache.getAll();
+    for (const messageId of entries) {
+      this._bloomFilter.add(messageId);
+    }
+  }
+
+  /**
+   * Resets both the Bloom filter and cache
+   */
+  reset() {
+    this._bloomFilter.clear();
+    this._cache.clear();
+    this._stats.resets++;
+  }
+
+  /**
+   * Gets deduplication statistics
+   * @returns {Object} Statistics object
+   */
+  getStats() {
+    return {
+      ...this._stats,
+      bloomFillRatio: this._bloomFilter.getFillRatio(),
+      bloomCount: this._bloomFilter.getCount(),
+      cacheSize: this._cache.size,
+      estimatedFalsePositiveRate: this._bloomFilter.getEstimatedFalsePositiveRate()
+    };
+  }
+
+  /**
+   * Resets statistics counters
+   */
+  resetStats() {
+    this._stats = {
+      checks: 0,
+      bloomPositives: 0,
+      cacheHits: 0,
+      duplicates: 0,
+      added: 0,
+      resets: 0
+    };
+  }
+
+  /**
+   * Gets the number of unique messages seen
+   * @returns {number} Count of unique messages in cache
+   */
+  getUniqueCount() {
+    return this._cache.size;
+  }
+
+  /**
+   * Checks if a specific message ID is in the exact cache
+   * @param {string} messageId - Message ID to check
+   * @returns {boolean} True if in cache
+   */
+  isInCache(messageId) {
+    return this._cache.has(messageId);
+  }
+
+  /**
+   * Gets when a message was first seen
+   * @param {string} messageId - Message ID to look up
+   * @returns {number|null} Timestamp or null if not found
+   */
+  getSeenTimestamp(messageId) {
+    return this._cache.getTimestamp(messageId);
+  }
+}
+
+module.exports = DedupManager;

package/src/mesh/dedup/MessageCache.js

@@ -0,0 +1,219 @@
+'use strict';
+
+/**
+ * @fileoverview LRU message cache for duplicate detection backup
+ * @module mesh/dedup/MessageCache
+ */
+
+/**
+ * LRU Cache node for doubly-linked list
+ * @class CacheNode
+ * @private
+ */
+class CacheNode {
+  /**
+   * Creates a new CacheNode
+   * @param {string} key - Message ID
+   * @param {number} timestamp - When the message was seen
+   */
+  constructor(key, timestamp) {
+    this.key = key;
+    this.timestamp = timestamp;
+    this.prev = null;
+    this.next = null;
+  }
+}
+
+/**
+ * LRU message cache for storing recently seen message IDs
+ * Uses doubly-linked list for O(1) operations
+ * @class MessageCache
+ */
+class MessageCache {
+  /**
+   * Creates a new MessageCache
+   * @param {number} maxSize - Maximum number of message IDs to store
+   */
+  constructor(maxSize) {
+    if (!Number.isInteger(maxSize) || maxSize <= 0) {
+      throw new Error('Max size must be a positive integer');
+    }
+
+    /**
+     * Maximum number of entries
+     * @type {number}
+     */
+    this.maxSize = maxSize;
+
+    /**
+     * Map of message IDs to cache nodes
+     * @type {Map<string, CacheNode>}
+     * @private
+     */
+    this._map = new Map();
+
+    /**
+     * Head of the LRU list (most recently used)
+     * @type {CacheNode|null}
+     * @private
+     */
+    this._head = null;
+
+    /**
+     * Tail of the LRU list (least recently used)
+     * @type {CacheNode|null}
+     * @private
+     */
+    this._tail = null;
+  }
+
+  /**
+   * Moves a node to the head of the list
+   * @param {CacheNode} node - Node to move
+   * @private
+   */
+  _moveToHead(node) {
+    if (node === this._head) { return; }
+
+    // Remove from current position
+    if (node.prev) { node.prev.next = node.next; }
+    if (node.next) { node.next.prev = node.prev; }
+    if (node === this._tail) { this._tail = node.prev; }
+
+    // Move to head
+    node.prev = null;
+    node.next = this._head;
+    if (this._head) { this._head.prev = node; }
+    this._head = node;
+    if (!this._tail) { this._tail = node; }
+  }
+
+  /**
+   * Removes the tail node (least recently used)
+   * @returns {string|null} Removed message ID or null
+   * @private
+   */
+  _removeTail() {
+    if (!this._tail) { return null; }
+
+    const key = this._tail.key;
+    this._map.delete(key);
+
+    if (this._head === this._tail) {
+      this._head = null;
+      this._tail = null;
+    } else {
+      this._tail = this._tail.prev;
+      if (this._tail) { this._tail.next = null; }
+    }
+
+    return key;
+  }
+
+  /**
+   * Adds a message ID to the cache
+   * @param {string} messageId - Message ID to add
+   * @returns {boolean} True if newly added, false if already present
+   */
+  add(messageId) {
+    if (typeof messageId !== 'string' || messageId.length === 0) {
+      throw new Error('Message ID must be a non-empty string');
+    }
+
+    // Check if already exists
+    const existing = this._map.get(messageId);
+    if (existing) {
+      existing.timestamp = Date.now();
+      this._moveToHead(existing);
+      return false;
+    }
+
+    // Create new node
+    const node = new CacheNode(messageId, Date.now());
+    this._map.set(messageId, node);
+
+    // Add to head
+    node.next = this._head;
+    if (this._head) { this._head.prev = node; }
+    this._head = node;
+    if (!this._tail) { this._tail = node; }
+
+    // Evict if over capacity
+    if (this._map.size > this.maxSize) {
+      this._removeTail();
+    }
+
+    return true;
+  }
+
+  /**
+   * Checks if a message ID is in the cache
+   * @param {string} messageId - Message ID to check
+   * @returns {boolean} True if present
+   */
+  has(messageId) {
+    return this._map.has(messageId);
+  }
+
+  /**
+   * Gets the timestamp when a message was first seen
+   * @param {string} messageId - Message ID to look up
+   * @returns {number|null} Timestamp or null if not found
+   */
+  getTimestamp(messageId) {
+    const node = this._map.get(messageId);
+    return node ? node.timestamp : null;
+  }
+
+  /**
+   * Removes a message ID from the cache
+   * @param {string} messageId - Message ID to remove
+   * @returns {boolean} True if removed, false if not found
+   */
+  delete(messageId) {
+    const node = this._map.get(messageId);
+    if (!node) { return false; }
+
+    // Update linked list
+    if (node.prev) { node.prev.next = node.next; }
+    if (node.next) { node.next.prev = node.prev; }
+    if (node === this._head) { this._head = node.next; }
+    if (node === this._tail) { this._tail = node.prev; }
+
+    this._map.delete(messageId);
+    return true;
+  }
+
+  /**
+   * Clears all entries from the cache
+   */
+  clear() {
+    this._map.clear();
+    this._head = null;
+    this._tail = null;
+  }
+
+  /**
+   * Gets the current number of entries
+   * @returns {number} Number of cached message IDs
+   */
+  get size() {
+    return this._map.size;
+  }
+
+  /**
+   * Gets all message IDs in the cache (most recent first)
+   * @returns {string[]} Array of message IDs
+   */
+  getAll() {
+    const result = [];
+    let node = this._head;
+    while (node) {
+      result.push(node.key);
+      node = node.next;
+    }
+    return result;
+  }
+}
+
+module.exports = MessageCache;

package/src/mesh/dedup/index.js

@@ -0,0 +1,16 @@
+'use strict';
+
+/**
+ * @fileoverview Deduplication module exports
+ * @module mesh/dedup
+ */
+
+const BloomFilter = require('./BloomFilter');
+const MessageCache = require('./MessageCache');
+const DedupManager = require('./DedupManager');
+
+module.exports = {
+  BloomFilter,
+  MessageCache,
+  DedupManager
+};