@vailix/mask 0.2.4 → 0.2.6

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @vailix/mask
 
+## 0.2.6
+
+### Patch Changes
+
+- 36836bb: Fix BLE error handling: verify initialization, emit async errors properly, and add connection timeout.
+
+## 0.2.5
+
+### Patch Changes
+
+- a48760e: Fix master key generation to use cryptographically secure random bytes
+
+  Changed master key generation from `randomUUID()` to `randomBytes(32).toString('hex')`.
+  This fixes the "Invalid master key format" error caused by UUID hyphens failing hex validation,
+  and provides proper 256-bit cryptographic randomness following security best practices.
+
 ## 0.2.4
 
 ### Patch Changes

package/__tests__/ble-error-handling.test.ts

@@ -0,0 +1,355 @@
+/**
+ * Tests for BleService error handling improvements.
+ * 
+ * Tests cover:
+ * - EventEmitter pattern for error propagation
+ * - BLE state check before scanning (initialize() call)
+ * - Timeout behavior in initialize()
+ * - Error emission from scan callback
+ * 
+ * NOTE: These tests use a simplified TestBleService that mirrors the actual
+ * BleService implementation logic without importing react-native-ble-plx.
+ */
+
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { EventEmitter } from 'eventemitter3';
+
+// ============================================================================
+// Mock BLE State enum
+// ============================================================================
+const State = {
+    PoweredOn: 'PoweredOn',
+    PoweredOff: 'PoweredOff',
+    Unauthorized: 'Unauthorized',
+    Unsupported: 'Unsupported',
+};
+
+// Mock BleManager that tracks calls
+class MockBleManager {
+    onStateChange = vi.fn();
+    startDeviceScan = vi.fn();
+    stopDeviceScan = vi.fn();
+    destroy = vi.fn();
+}
+
+/**
+ * Simplified BleService implementation for testing the logic patterns.
+ * This mirrors the actual BleService but without the react-native-ble-plx import.
+ * 
+ * Key difference from actual code: uses setImmediate/setTimeout(0) to defer
+ * synchronous callbacks, avoiding temporal dead zone issues in tests.
+ */
+class TestBleService extends EventEmitter {
+    private manager: MockBleManager;
+    private isScanning = false;
+
+    constructor(mockManager: MockBleManager) {
+        super();
+        this.manager = mockManager;
+    }
+
+    async initialize(): Promise<boolean> {
+        const INIT_TIMEOUT_MS = 5000;
+
+        return new Promise((resolve) => {
+            let resolved = false;
+            let subscriptionRef: { remove: () => void } | null = null;
+
+            const timeout = setTimeout(() => {
+                if (!resolved) {
+                    resolved = true;
+                    subscriptionRef?.remove();
+                    resolve(false);
+                }
+            }, INIT_TIMEOUT_MS);
+
+            const handleState = (state: string) => {
+                if (resolved) return;
+
+                if (state === State.PoweredOn) {
+                    resolved = true;
+                    clearTimeout(timeout);
+                    subscriptionRef?.remove();
+                    resolve(true);
+                } else if (state === State.PoweredOff || state === State.Unauthorized) {
+                    resolved = true;
+                    clearTimeout(timeout);
+                    subscriptionRef?.remove();
+                    resolve(false);
+                }
+            };
+
+            subscriptionRef = this.manager.onStateChange(handleState, true);
+        });
+    }
+
+    async startDiscovery(myRpi: string, myMetadataKey: string): Promise<void> {
+        if (this.isScanning) return;
+
+        const isReady = await this.initialize();
+        if (!isReady) {
+            throw new Error('Bluetooth is not available or not enabled');
+        }
+
+        this.isScanning = true;
+        this.startScanning();
+    }
+
+    private startScanning(): void {
+        this.manager.startDeviceScan(
+            ['service-uuid'],
+            { allowDuplicates: true },
+            (error: any, device: any) => {
+                if (error) {
+                    console.warn('BLE scan error:', error);
+                    this.emit('error', error);
+                    return;
+                }
+            }
+        );
+    }
+
+    stopDiscovery(): void {
+        this.isScanning = false;
+        this.manager.stopDeviceScan();
+    }
+
+    destroy(): void {
+        this.stopDiscovery();
+        this.manager.destroy();
+    }
+}
+
+describe('BleService Error Handling', () => {
+    let mockManager: MockBleManager;
+    let bleService: TestBleService;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.useFakeTimers();
+        mockManager = new MockBleManager();
+        bleService = new TestBleService(mockManager);
+    });
+
+    afterEach(() => {
+        vi.useRealTimers();
+        bleService.destroy();
+    });
+
+    describe('EventEmitter pattern', () => {
+        it('should extend EventEmitter and support on/off/emit', () => {
+            const errorHandler = vi.fn();
+
+            bleService.on('error', errorHandler);
+            bleService.emit('error', new Error('test error'));
+
+            expect(errorHandler).toHaveBeenCalledTimes(1);
+            expect(errorHandler).toHaveBeenCalledWith(expect.any(Error));
+        });
+
+        it('should allow removing listeners', () => {
+            const errorHandler = vi.fn();
+
+            bleService.on('error', errorHandler);
+            bleService.off('error', errorHandler);
+            bleService.emit('error', new Error('test error'));
+
+            expect(errorHandler).not.toHaveBeenCalled();
+        });
+    });
+
+    describe('initialize()', () => {
+        it('should resolve true when BLE state is PoweredOn', async () => {
+            mockManager.onStateChange.mockImplementation((callback: Function, immediate: boolean) => {
+                // Defer the immediate callback to next tick to avoid TDZ
+                if (immediate) {
+                    Promise.resolve().then(() => callback(State.PoweredOn));
+                }
+                return { remove: vi.fn() };
+            });
+
+            const result = await bleService.initialize();
+            expect(result).toBe(true);
+        });
+
+        it('should resolve false when BLE state is PoweredOff', async () => {
+            mockManager.onStateChange.mockImplementation((callback: Function, immediate: boolean) => {
+                if (immediate) {
+                    Promise.resolve().then(() => callback(State.PoweredOff));
+                }
+                return { remove: vi.fn() };
+            });
+
+            const result = await bleService.initialize();
+            expect(result).toBe(false);
+        });
+
+        it('should resolve false when BLE state is Unauthorized', async () => {
+            mockManager.onStateChange.mockImplementation((callback: Function, immediate: boolean) => {
+                if (immediate) {
+                    Promise.resolve().then(() => callback(State.Unauthorized));
+                }
+                return { remove: vi.fn() };
+            });
+
+            const result = await bleService.initialize();
+            expect(result).toBe(false);
+        });
+
+        it('should timeout after 5 seconds and resolve false', async () => {
+            const removeSubscription = vi.fn();
+            mockManager.onStateChange.mockImplementation(() => {
+                // Never call the callback - simulate hanging
+                return { remove: removeSubscription };
+            });
+
+            const initPromise = bleService.initialize();
+
+            // Fast-forward 5 seconds
+            await vi.advanceTimersByTimeAsync(5000);
+
+            const result = await initPromise;
+            expect(result).toBe(false);
+            expect(removeSubscription).toHaveBeenCalled();
+        });
+
+        it('should clear timeout when state resolves before timeout', async () => {
+            const removeSubscription = vi.fn();
+            mockManager.onStateChange.mockImplementation((callback: Function) => {
+                // Resolve after 1 second
+                setTimeout(() => callback(State.PoweredOn), 1000);
+                return { remove: removeSubscription };
+            });
+
+            const initPromise = bleService.initialize();
+
+            // Fast-forward 1 second (before 5s timeout)
+            await vi.advanceTimersByTimeAsync(1000);
+
+            const result = await initPromise;
+            expect(result).toBe(true);
+            expect(removeSubscription).toHaveBeenCalled();
+        });
+    });
+
+    describe('startDiscovery()', () => {
+        it('should call initialize() before starting scan', async () => {
+            mockManager.onStateChange.mockImplementation((callback: Function, immediate: boolean) => {
+                if (immediate) {
+                    Promise.resolve().then(() => callback(State.PoweredOn));
+                }
+                return { remove: vi.fn() };
+            });
+
+            await bleService.startDiscovery('testrpi', 'testkey');
+
+            expect(mockManager.onStateChange).toHaveBeenCalled();
+            expect(mockManager.startDeviceScan).toHaveBeenCalled();
+        });
+
+        it('should throw error if BLE is not available', async () => {
+            mockManager.onStateChange.mockImplementation((callback: Function, immediate: boolean) => {
+                if (immediate) {
+                    Promise.resolve().then(() => callback(State.PoweredOff));
+                }
+                return { remove: vi.fn() };
+            });
+
+            await expect(bleService.startDiscovery('testrpi', 'testkey'))
+                .rejects.toThrow('Bluetooth is not available or not enabled');
+        });
+
+        it('should throw error if BLE times out', async () => {
+            mockManager.onStateChange.mockImplementation(() => {
+                // Never resolve - simulate timeout
+                return { remove: vi.fn() };
+            });
+
+            const discoveryPromise = bleService.startDiscovery('testrpi', 'testkey');
+
+            // Prevent unhandled rejection by attaching catch handler immediately
+            const caughtPromise = discoveryPromise.catch(e => e);
+
+            // Fast-forward past timeout
+            await vi.advanceTimersByTimeAsync(5000);
+
+            // Verify the error was caught
+            const result = await caughtPromise;
+            expect(result).toBeInstanceOf(Error);
+            expect(result.message).toBe('Bluetooth is not available or not enabled');
+        });
+
+        it('should not start scan if already scanning', async () => {
+            mockManager.onStateChange.mockImplementation((callback: Function, immediate: boolean) => {
+                if (immediate) {
+                    Promise.resolve().then(() => callback(State.PoweredOn));
+                }
+                return { remove: vi.fn() };
+            });
+
+            await bleService.startDiscovery('testrpi', 'testkey');
+            await bleService.startDiscovery('testrpi2', 'testkey2');
+
+            // startDeviceScan should only be called once
+            expect(mockManager.startDeviceScan).toHaveBeenCalledTimes(1);
+        });
+    });
+
+    describe('scan error emission', () => {
+        it('should emit error event when scan encounters error', async () => {
+            const errorHandler = vi.fn();
+            bleService.on('error', errorHandler);
+
+            mockManager.onStateChange.mockImplementation((callback: Function, immediate: boolean) => {
+                if (immediate) {
+                    Promise.resolve().then(() => callback(State.PoweredOn));
+                }
+                return { remove: vi.fn() };
+            });
+
+            // Capture the scan callback when startDeviceScan is called
+            mockManager.startDeviceScan.mockImplementation(
+                (uuids: string[], options: any, callback: Function) => {
+                    // Simulate an error occurring during scan
+                    const mockError = { message: 'Unknown error occurred', reason: 'bug' };
+                    callback(mockError, null);
+                }
+            );
+
+            await bleService.startDiscovery('testrpi', 'testkey');
+
+            expect(errorHandler).toHaveBeenCalledTimes(1);
+            expect(errorHandler).toHaveBeenCalledWith(
+                expect.objectContaining({ message: 'Unknown error occurred' })
+            );
+        });
+
+        it('should continue emitting errors for subsequent scan errors', async () => {
+            const errorHandler = vi.fn();
+            bleService.on('error', errorHandler);
+
+            mockManager.onStateChange.mockImplementation((callback: Function, immediate: boolean) => {
+                if (immediate) {
+                    Promise.resolve().then(() => callback(State.PoweredOn));
+                }
+                return { remove: vi.fn() };
+            });
+
+            let scanCallback: Function;
+            mockManager.startDeviceScan.mockImplementation(
+                (uuids: string[], options: any, callback: Function) => {
+                    scanCallback = callback;
+                }
+            );
+
+            await bleService.startDiscovery('testrpi', 'testkey');
+
+            // Simulate multiple errors
+            scanCallback!({ message: 'Error 1' }, null);
+            scanCallback!({ message: 'Error 2' }, null);
+            scanCallback!({ message: 'Error 3' }, null);
+
+            expect(errorHandler).toHaveBeenCalledTimes(3);
+        });
+    });
+});

package/__tests__/singleton.test.ts

@@ -66,6 +66,10 @@ vi.mock('../src/ble', () => {
             onNearbyUsersChanged = vi.fn().mockReturnValue(() => { });
             pairWithUser = vi.fn().mockResolvedValue({ success: true });
             unpairUser = vi.fn().mockResolvedValue(undefined);
+            // EventEmitter methods (BleService now extends EventEmitter)
+            on = vi.fn();
+            off = vi.fn();
+            emit = vi.fn();
         },
     };
 });

package/dist/index.js

@@ -73,7 +73,7 @@ var IdentityManager = class {
     try {
       let key = await this.keyStorage.getKey();
       if (!key) {
-        key = (0, import_react_native_quick_crypto.randomUUID)();
+        key = (0, import_react_native_quick_crypto.randomBytes)(32).toString("hex");
         await this.keyStorage.setKey(key);
       }
       this.masterKey = key;
@@ -370,6 +370,7 @@ var MatcherService = class extends import_eventemitter3.EventEmitter {
 
 // src/ble.ts
 var import_react_native_ble_plx = require("react-native-ble-plx");
+var import_eventemitter32 = require("eventemitter3");
 var VAILIX_SERVICE_UUID = "a1b2c3d4-e5f6-7890-abcd-ef1234567890";
 var RPI_OUT_CHAR_UUID = "a1b2c3d4-e5f6-7890-abcd-ef1234567891";
 var RPI_IN_CHAR_UUID = "a1b2c3d4-e5f6-7890-abcd-ef1234567892";
@@ -391,7 +392,7 @@ function extractRpiPrefix(device, serviceUUID) {
   }
   return null;
 }
-var BleService = class {
+var BleService = class extends import_eventemitter32.EventEmitter {
   manager;
   isScanning = false;
   nearbyUsers = /* @__PURE__ */ new Map();
@@ -411,6 +412,7 @@ var BleService = class {
   // Storage reference for persisting pairs
   storage;
   constructor(config = {}) {
+    super();
     this.manager = new import_react_native_ble_plx.BleManager();
     this.discoveryTimeoutMs = config.discoveryTimeoutMs ?? DEFAULT_DISCOVERY_TIMEOUT_MS;
     this.proximityThreshold = config.proximityThreshold ?? DEFAULT_PROXIMITY_THRESHOLD;
@@ -427,12 +429,19 @@ var BleService = class {
    * Check if BLE is available and enabled
    */
   async initialize() {
+    const INIT_TIMEOUT_MS = 5e3;
     return new Promise((resolve) => {
+      const timeout = setTimeout(() => {
+        subscription.remove();
+        resolve(false);
+      }, INIT_TIMEOUT_MS);
       const subscription = this.manager.onStateChange((state) => {
         if (state === import_react_native_ble_plx.State.PoweredOn) {
+          clearTimeout(timeout);
           subscription.remove();
           resolve(true);
         } else if (state === import_react_native_ble_plx.State.PoweredOff || state === import_react_native_ble_plx.State.Unauthorized) {
+          clearTimeout(timeout);
           subscription.remove();
           resolve(false);
         }
@@ -458,6 +467,10 @@ var BleService = class {
    */
   async startDiscovery(myRpi, myMetadataKey) {
     if (this.isScanning) return;
+    const isReady = await this.initialize();
+    if (!isReady) {
+      throw new Error("Bluetooth is not available or not enabled");
+    }
     this.myRpi = myRpi;
     this.myMetadataKey = myMetadataKey;
     this.isScanning = true;
@@ -559,6 +572,7 @@ var BleService = class {
       (error, device) => {
         if (error) {
           console.warn("BLE scan error:", error);
+          this.emit("error", error);
           return;
         }
         if (device) {
@@ -901,6 +915,9 @@ var VailixSDK = class _VailixSDK {
       serviceUUID: config.serviceUUID
     });
     ble.setStorage(storage);
+    ble.on("error", (error) => {
+      matcher.emit("error", error);
+    });
     await storage.cleanupOldScans();
     return new _VailixSDK(
       identity,

package/dist/index.mjs

@@ -1,8 +1,8 @@
 // src/index.ts
-import { createCipheriv, randomBytes } from "react-native-quick-crypto";
+import { createCipheriv, randomBytes as randomBytes2 } from "react-native-quick-crypto";
 
 // src/identity.ts
-import { createHmac, randomUUID } from "react-native-quick-crypto";
+import { createHmac, randomBytes } from "react-native-quick-crypto";
 import * as SecureStore from "expo-secure-store";
 
 // src/utils.ts
@@ -37,7 +37,7 @@ var IdentityManager = class {
     try {
       let key = await this.keyStorage.getKey();
       if (!key) {
-        key = randomUUID();
+        key = randomBytes(32).toString("hex");
         await this.keyStorage.setKey(key);
       }
       this.masterKey = key;
@@ -89,7 +89,7 @@ var IdentityManager = class {
 // src/storage.ts
 import { sqliteTable, text, integer, index } from "drizzle-orm/sqlite-core";
 import { lt, gt, inArray } from "drizzle-orm";
-import { randomUUID as randomUUID2 } from "react-native-quick-crypto";
+import { randomUUID } from "react-native-quick-crypto";
 import AsyncStorage from "@react-native-async-storage/async-storage";
 var SCAN_HISTORY_KEY = "vailix_scan_history";
 var scannedEvents = sqliteTable("scanned_events", {
@@ -123,7 +123,7 @@ var StorageService = class _StorageService {
     return Date.now() - lastScan >= this.rescanIntervalMs;
   }
   async logScan(rpi, metadataKey, timestamp) {
-    await this.db.insert(scannedEvents).values({ id: randomUUID2(), rpi, metadataKey, timestamp });
+    await this.db.insert(scannedEvents).values({ id: randomUUID(), rpi, metadataKey, timestamp });
     this.lastScanByRpi.set(rpi, Date.now());
     if (this.lastScanByRpi.size > _StorageService.MAX_SCAN_HISTORY_SIZE) {
       const entries2 = Array.from(this.lastScanByRpi.entries());
@@ -334,6 +334,7 @@ var MatcherService = class extends EventEmitter {
 
 // src/ble.ts
 import { BleManager, State } from "react-native-ble-plx";
+import { EventEmitter as EventEmitter2 } from "eventemitter3";
 var VAILIX_SERVICE_UUID = "a1b2c3d4-e5f6-7890-abcd-ef1234567890";
 var RPI_OUT_CHAR_UUID = "a1b2c3d4-e5f6-7890-abcd-ef1234567891";
 var RPI_IN_CHAR_UUID = "a1b2c3d4-e5f6-7890-abcd-ef1234567892";
@@ -355,7 +356,7 @@ function extractRpiPrefix(device, serviceUUID) {
   }
   return null;
 }
-var BleService = class {
+var BleService = class extends EventEmitter2 {
   manager;
   isScanning = false;
   nearbyUsers = /* @__PURE__ */ new Map();
@@ -375,6 +376,7 @@ var BleService = class {
   // Storage reference for persisting pairs
   storage;
   constructor(config = {}) {
+    super();
     this.manager = new BleManager();
     this.discoveryTimeoutMs = config.discoveryTimeoutMs ?? DEFAULT_DISCOVERY_TIMEOUT_MS;
     this.proximityThreshold = config.proximityThreshold ?? DEFAULT_PROXIMITY_THRESHOLD;
@@ -391,12 +393,19 @@ var BleService = class {
    * Check if BLE is available and enabled
    */
   async initialize() {
+    const INIT_TIMEOUT_MS = 5e3;
     return new Promise((resolve) => {
+      const timeout = setTimeout(() => {
+        subscription.remove();
+        resolve(false);
+      }, INIT_TIMEOUT_MS);
       const subscription = this.manager.onStateChange((state) => {
         if (state === State.PoweredOn) {
+          clearTimeout(timeout);
           subscription.remove();
           resolve(true);
         } else if (state === State.PoweredOff || state === State.Unauthorized) {
+          clearTimeout(timeout);
           subscription.remove();
           resolve(false);
         }
@@ -422,6 +431,10 @@ var BleService = class {
    */
   async startDiscovery(myRpi, myMetadataKey) {
     if (this.isScanning) return;
+    const isReady = await this.initialize();
+    if (!isReady) {
+      throw new Error("Bluetooth is not available or not enabled");
+    }
     this.myRpi = myRpi;
     this.myMetadataKey = myMetadataKey;
     this.isScanning = true;
@@ -523,6 +536,7 @@ var BleService = class {
       (error, device) => {
         if (error) {
           console.warn("BLE scan error:", error);
+          this.emit("error", error);
           return;
         }
         if (device) {
@@ -865,6 +879,9 @@ var VailixSDK = class _VailixSDK {
       serviceUUID: config.serviceUUID
     });
     ble.setStorage(storage);
+    ble.on("error", (error) => {
+      matcher.emit("error", error);
+    });
     await storage.cleanupOldScans();
     return new _VailixSDK(
       identity,
@@ -1055,7 +1072,7 @@ var VailixSDK = class _VailixSDK {
       throw new Error(`Metadata exceeds maximum size of ${_VailixSDK.MAX_METADATA_SIZE} bytes`);
     }
     const key = Buffer.from(keyHex, "hex");
-    const iv = randomBytes(12);
+    const iv = randomBytes2(12);
     const cipher = createCipheriv("aes-256-gcm", key, iv);
     let encrypted = cipher.update(jsonStr, "utf8", "base64");
     encrypted += cipher.final("base64");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vailix/mask",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "Privacy-preserving proximity tracing SDK for React Native & Expo",
   "author": "Gil Eyni",
   "keywords": [

package/src/ble.ts

@@ -1,4 +1,5 @@
 import { BleManager, Device, State, BleError } from 'react-native-ble-plx';
+import { EventEmitter } from 'eventemitter3';
 import type { NearbyUser, PairResult } from './types';
 import type { StorageService } from './storage';
 
@@ -92,7 +93,7 @@ function extractRpiPrefix(device: Device, serviceUUID: string): string | null {
 // BleService Class
 // ============================================================================
 
-export class BleService {
+export class BleService extends EventEmitter {
     private manager: BleManager;
     private isScanning: boolean = false;
     private nearbyUsers: Map<string, InternalNearbyUser> = new Map();
@@ -118,6 +119,7 @@ export class BleService {
     private storage?: StorageService;
 
     constructor(config: BleServiceConfig = {}) {
+        super();  // Initialize EventEmitter
         this.manager = new BleManager();
         this.discoveryTimeoutMs = config.discoveryTimeoutMs ?? DEFAULT_DISCOVERY_TIMEOUT_MS;
         this.proximityThreshold = config.proximityThreshold ?? DEFAULT_PROXIMITY_THRESHOLD;
@@ -136,12 +138,21 @@ export class BleService {
      * Check if BLE is available and enabled
      */
     async initialize(): Promise<boolean> {
+        const INIT_TIMEOUT_MS = 5000;  // 5 second timeout
+
         return new Promise((resolve) => {
+            const timeout = setTimeout(() => {
+                subscription.remove();
+                resolve(false);  // Timed out waiting for BLE state
+            }, INIT_TIMEOUT_MS);
+
             const subscription = this.manager.onStateChange((state: typeof State[keyof typeof State]) => {
                 if (state === State.PoweredOn) {
+                    clearTimeout(timeout);
                     subscription.remove();
                     resolve(true);
                 } else if (state === State.PoweredOff || state === State.Unauthorized) {
+                    clearTimeout(timeout);
                     subscription.remove();
                     resolve(false);
                 }
@@ -170,6 +181,12 @@ export class BleService {
     async startDiscovery(myRpi: string, myMetadataKey: string): Promise<void> {
         if (this.isScanning) return;
 
+        // Ensure BLE is powered on before scanning
+        const isReady = await this.initialize();
+        if (!isReady) {
+            throw new Error('Bluetooth is not available or not enabled');
+        }
+
         this.myRpi = myRpi;
         this.myMetadataKey = myMetadataKey;
         this.isScanning = true;
@@ -299,6 +316,7 @@ export class BleService {
             (error: BleError | null, device: Device | null) => {
                 if (error) {
                     console.warn('BLE scan error:', error);
+                    this.emit('error', error);  // Propagate to listeners
                     return;
                 }
                 if (device) {

package/src/identity.ts

@@ -1,4 +1,4 @@
-import { createHmac, randomUUID } from 'react-native-quick-crypto';
+import { createHmac, randomBytes } from 'react-native-quick-crypto';
 import * as SecureStore from 'expo-secure-store';
 import type { KeyStorage } from './types';
 import { generateDisplayName } from './utils';
@@ -30,7 +30,7 @@ export class IdentityManager {
         try {
             let key = await this.keyStorage.getKey();
             if (!key) {
-                key = randomUUID();
+                key = randomBytes(32).toString('hex');
                 await this.keyStorage.setKey(key);
             }
             this.masterKey = key;

package/src/index.ts

@@ -122,6 +122,12 @@ export class VailixSDK {
         });
         ble.setStorage(storage);
 
+        // Forward BLE errors to SDK error stream
+        // Consumers receive via sdk.onError()
+        ble.on('error', (error) => {
+            matcher.emit('error', error);
+        });
+
         // Cleanup old scans on init
         await storage.cleanupOldScans();