walletpair-sdk 1.0.2 → 1.0.5

package/src/ble/web-ble-transport.test.ts

@@ -1,42 +1,47 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { WebBleCentralTransport, isWebBleSupported } from './web-ble-transport.js';
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type { ProtocolMessage } from '../types.js'
+import { isWebBleSupported, WebBleCentralTransport } from './web-ble-transport.js'
 
 // ── Mock Web Bluetooth API ──────────────────────────────────────────
 
 function createMockCharacteristic() {
-  const listeners = new Map<string, Function>();
+  const listeners = new Map<string, (...args: unknown[]) => unknown>()
   return {
     writeValueWithoutResponse: vi.fn().mockResolvedValue(undefined),
     startNotifications: vi.fn().mockResolvedValue(undefined),
-    addEventListener: vi.fn((evt: string, fn: Function) => { listeners.set(evt, fn); }),
-    removeEventListener: vi.fn((evt: string) => { listeners.delete(evt); }),
-    _fire: (evt: string, data: any) => listeners.get(evt)?.(data),
+    addEventListener: vi.fn((evt: string, fn: (...args: unknown[]) => unknown) => {
+      listeners.set(evt, fn)
+    }),
+    removeEventListener: vi.fn((evt: string) => {
+      listeners.delete(evt)
+    }),
+    _fire: (evt: string, data: unknown) => listeners.get(evt)?.(data),
     value: null as DataView | null,
-  };
+  }
 }
 
 function createMockBleDevice() {
-  const listeners = new Map<string, Function>();
-  const writeChar = createMockCharacteristic();
-  const notifyChar = createMockCharacteristic();
+  const listeners = new Map<string, (...args: unknown[]) => unknown>()
+  const writeChar = createMockCharacteristic()
+  const notifyChar = createMockCharacteristic()
 
   const service = {
     getCharacteristic: vi.fn((uuid: string) => {
       // BLE_WRITE_CHAR_UUID = 'e3a10002-...'
-      if (uuid.includes('10002')) return Promise.resolve(writeChar);
-      if (uuid.includes('10003')) return Promise.resolve(notifyChar);
-      return Promise.reject(new Error('unknown characteristic'));
+      if (uuid.includes('10002')) return Promise.resolve(writeChar)
+      if (uuid.includes('10003')) return Promise.resolve(notifyChar)
+      return Promise.reject(new Error('unknown characteristic'))
     }),
-  };
+  }
 
   const server = {
     connect: vi.fn().mockResolvedValue(undefined),
     getPrimaryService: vi.fn().mockResolvedValue(service),
     connected: true,
-  };
+  }
 
   // Make connect() return the server with getPrimaryService
-  server.connect.mockResolvedValue(server);
+  server.connect.mockResolvedValue(server)
 
   const device = {
     gatt: {
@@ -44,15 +49,19 @@ function createMockBleDevice() {
       connected: true,
       disconnect: vi.fn(),
     },
-    addEventListener: vi.fn((evt: string, fn: Function) => { listeners.set(evt, fn); }),
-    removeEventListener: vi.fn((evt: string) => { listeners.delete(evt); }),
+    addEventListener: vi.fn((evt: string, fn: (...args: unknown[]) => unknown) => {
+      listeners.set(evt, fn)
+    }),
+    removeEventListener: vi.fn((evt: string) => {
+      listeners.delete(evt)
+    }),
     _fireDisconnect: () => listeners.get('gattserverdisconnected')?.({} as Event),
-  };
+  }
 
-  return { device, writeChar, notifyChar, server };
+  return { device, writeChar, notifyChar, server }
 }
 
-function mockNavigatorBluetooth(device: any) {
+function mockNavigatorBluetooth(device: unknown) {
   Object.defineProperty(globalThis, 'navigator', {
     value: {
       bluetooth: {
@@ -61,7 +70,7 @@ function mockNavigatorBluetooth(device: any) {
     },
     writable: true,
     configurable: true,
-  });
+  })
 }
 
 function clearNavigatorBluetooth() {
@@ -69,124 +78,124 @@ function clearNavigatorBluetooth() {
     value: undefined,
     writable: true,
     configurable: true,
-  });
+  })
 }
 
 // ── isWebBleSupported ───────────────────────────────────────────────
 
 describe('isWebBleSupported', () => {
   it('returns false when navigator is undefined', () => {
-    clearNavigatorBluetooth();
-    expect(isWebBleSupported()).toBe(false);
-  });
+    clearNavigatorBluetooth()
+    expect(isWebBleSupported()).toBe(false)
+  })
 
   it('returns false when navigator.bluetooth is missing', () => {
     Object.defineProperty(globalThis, 'navigator', {
       value: {},
       writable: true,
       configurable: true,
-    });
-    expect(isWebBleSupported()).toBe(false);
-  });
+    })
+    expect(isWebBleSupported()).toBe(false)
+  })
 
   it('returns true when navigator.bluetooth exists', () => {
     Object.defineProperty(globalThis, 'navigator', {
       value: { bluetooth: {} },
       writable: true,
       configurable: true,
-    });
-    expect(isWebBleSupported()).toBe(true);
-  });
-});
+    })
+    expect(isWebBleSupported()).toBe(true)
+  })
+})
 
 // ── WebBleCentralTransport ──────────────────────────────────────────
 
 describe('WebBleCentralTransport', () => {
-  let transport: WebBleCentralTransport;
+  let transport: WebBleCentralTransport
 
   beforeEach(() => {
-    transport = new WebBleCentralTransport();
-    clearNavigatorBluetooth();
-  });
+    transport = new WebBleCentralTransport()
+    clearNavigatorBluetooth()
+  })
 
   it('starts in disconnected state', () => {
-    expect(transport.state).toBe('disconnected');
-  });
+    expect(transport.state).toBe('disconnected')
+  })
 
   it('connect() throws when Web Bluetooth is not supported', async () => {
-    await expect(transport.connect()).rejects.toThrow('Web Bluetooth is not supported');
-  });
+    await expect(transport.connect()).rejects.toThrow('Web Bluetooth is not supported')
+  })
 
   it('connect() transitions through connecting to connected', async () => {
-    const { device } = createMockBleDevice();
-    mockNavigatorBluetooth(device);
+    const { device } = createMockBleDevice()
+    mockNavigatorBluetooth(device)
 
-    const openHandler = vi.fn();
-    transport.onOpen(openHandler);
+    const openHandler = vi.fn()
+    transport.onOpen(openHandler)
 
-    await transport.connect();
+    await transport.connect()
 
-    expect(transport.state).toBe('connected');
-    expect(openHandler).toHaveBeenCalledTimes(1);
-  });
+    expect(transport.state).toBe('connected')
+    expect(openHandler).toHaveBeenCalledTimes(1)
+  })
 
   it('connect() sets up GATT characteristics', async () => {
-    const { device, notifyChar } = createMockBleDevice();
-    mockNavigatorBluetooth(device);
+    const { device, notifyChar } = createMockBleDevice()
+    mockNavigatorBluetooth(device)
 
-    await transport.connect();
+    await transport.connect()
 
-    expect(notifyChar.startNotifications).toHaveBeenCalled();
+    expect(notifyChar.startNotifications).toHaveBeenCalled()
     expect(notifyChar.addEventListener).toHaveBeenCalledWith(
       'characteristicvaluechanged',
       expect.any(Function),
-    );
-  });
+    )
+  })
 
   it('disconnect() calls gatt.disconnect and cleans up', async () => {
-    const { device } = createMockBleDevice();
-    mockNavigatorBluetooth(device);
+    const { device } = createMockBleDevice()
+    mockNavigatorBluetooth(device)
 
-    await transport.connect();
-    transport.disconnect();
+    await transport.connect()
+    transport.disconnect()
 
-    expect(device.gatt.disconnect).toHaveBeenCalled();
-    expect(transport.state).toBe('disconnected');
-  });
+    expect(device.gatt.disconnect).toHaveBeenCalled()
+    expect(transport.state).toBe('disconnected')
+  })
 
   it('disconnect() is safe to call when not connected', () => {
-    expect(() => transport.disconnect()).not.toThrow();
-    expect(transport.state).toBe('disconnected');
-  });
+    expect(() => transport.disconnect()).not.toThrow()
+    expect(transport.state).toBe('disconnected')
+  })
 
   it('send() does nothing when not connected', () => {
-    transport.send({ v: 1, t: 'ping', ch: 'abc' } as any);
+    transport.send({ v: 1, t: 'ping', ch: 'abc' } as unknown as ProtocolMessage)
     // Should not throw
-  });
+  })
 
   it('onClose handler fires on GATT disconnect', async () => {
-    const { device } = createMockBleDevice();
-    mockNavigatorBluetooth(device);
+    const { device } = createMockBleDevice()
+    mockNavigatorBluetooth(device)
 
-    const closeHandler = vi.fn();
-    transport.onClose(closeHandler);
+    const closeHandler = vi.fn()
+    transport.onClose(closeHandler)
 
-    await transport.connect();
-    device._fireDisconnect();
+    await transport.connect()
+    device._fireDisconnect()
 
-    expect(closeHandler).toHaveBeenCalledTimes(1);
-    expect(transport.state).toBe('disconnected');
-  });
+    expect(closeHandler).toHaveBeenCalledTimes(1)
+    expect(transport.state).toBe('disconnected')
+  })
 
   it('handler registration methods work', () => {
-    const msgHandler = vi.fn();
-    const closeHandler = vi.fn();
-    const openHandler = vi.fn();
+    const msgHandler = vi.fn()
+    const closeHandler = vi.fn()
+    const openHandler = vi.fn()
 
-    transport.onMessage(msgHandler);
-    transport.onClose(closeHandler);
-    transport.onOpen(openHandler);
+    transport.onMessage(msgHandler)
+    transport.onClose(closeHandler)
+    transport.onOpen(openHandler)
 
     // No throws — handlers registered
-  });
-});
+  })
+})

package/src/ble/web-ble-transport.ts

@@ -7,110 +7,123 @@
 
 /// <reference path="./web-bluetooth.d.ts" />
 
-import type { Transport, TransportState, ProtocolMessage } from '../types.js';
+import type { ProtocolMessage, Transport, TransportState } from '../types.js'
 import {
+  BLE_NOTIFY_CHAR_UUID,
   BLE_SERVICE_UUID,
   BLE_WRITE_CHAR_UUID,
-  BLE_NOTIFY_CHAR_UUID,
-  frameMessage,
   Defragmenter,
-} from './framing.js';
+  frameMessage,
+} from './framing.js'
 
 export function isWebBleSupported(): boolean {
-  return typeof navigator !== 'undefined' && !!navigator.bluetooth;
+  return typeof navigator !== 'undefined' && !!navigator.bluetooth
 }
 
 export class WebBleCentralTransport implements Transport {
-  state: TransportState = 'disconnected';
+  state: TransportState = 'disconnected'
 
-  private device: BluetoothDevice | null = null;
-  private writeChar: BluetoothRemoteGATTCharacteristic | null = null;
-  private notifyChar: BluetoothRemoteGATTCharacteristic | null = null;
-  private defrag = new Defragmenter();
-  private mtuPayload = 509;
+  private device: BluetoothDevice | null = null
+  private writeChar: BluetoothRemoteGATTCharacteristic | null = null
+  private notifyChar: BluetoothRemoteGATTCharacteristic | null = null
+  private defrag = new Defragmenter()
+  private mtuPayload = 509
 
-  private messageHandler: ((msg: ProtocolMessage) => void) | null = null;
-  private closeHandler: (() => void) | null = null;
-  private openHandler: (() => void) | null = null;
+  private messageHandler: ((msg: ProtocolMessage) => void) | null = null
+  private closeHandler: (() => void) | null = null
+  private openHandler: (() => void) | null = null
 
-  onMessage(handler: (msg: ProtocolMessage) => void): void { this.messageHandler = handler; }
-  onClose(handler: () => void): void { this.closeHandler = handler; }
-  onOpen(handler: () => void): void { this.openHandler = handler; }
+  onMessage(handler: (msg: ProtocolMessage) => void): void {
+    this.messageHandler = handler
+  }
+  onClose(handler: () => void): void {
+    this.closeHandler = handler
+  }
+  onOpen(handler: () => void): void {
+    this.openHandler = handler
+  }
 
   async connect(): Promise<void> {
     if (!isWebBleSupported()) {
-      throw new Error('Web Bluetooth is not supported in this environment');
+      throw new Error('Web Bluetooth is not supported in this environment')
     }
 
-    this.state = 'connecting';
+    this.state = 'connecting'
 
-    const device = await navigator.bluetooth!.requestDevice({
-      filters: [
-        { namePrefix: 'WalletPair' },
-        { services: [BLE_SERVICE_UUID] },
-      ],
+    const device = await navigator.bluetooth?.requestDevice({
+      filters: [{ namePrefix: 'WalletPair' }, { services: [BLE_SERVICE_UUID] }],
       optionalServices: [BLE_SERVICE_UUID],
-    });
+    })
+
+    if (!device) throw new Error('No BLE device selected')
 
-    this.device = device;
-    device.addEventListener('gattserverdisconnected', this.onDisconnect);
+    this.device = device
+    device.addEventListener('gattserverdisconnected', this.onDisconnect)
 
-    const server = await device.gatt!.connect();
-    const service = await server.getPrimaryService(BLE_SERVICE_UUID);
+    const server = await device.gatt?.connect()
+    if (!server) throw new Error('Failed to connect to GATT server')
+    const service = await server.getPrimaryService(BLE_SERVICE_UUID)
 
-    this.writeChar = await service.getCharacteristic(BLE_WRITE_CHAR_UUID);
-    this.notifyChar = await service.getCharacteristic(BLE_NOTIFY_CHAR_UUID);
+    this.writeChar = await service.getCharacteristic(BLE_WRITE_CHAR_UUID)
+    this.notifyChar = await service.getCharacteristic(BLE_NOTIFY_CHAR_UUID)
 
-    await this.notifyChar.startNotifications();
-    this.notifyChar.addEventListener('characteristicvaluechanged', this.onNotification);
+    await this.notifyChar.startNotifications()
+    this.notifyChar.addEventListener('characteristicvaluechanged', this.onNotification)
 
-    this.state = 'connected';
-    this.openHandler?.();
+    this.state = 'connected'
+    this.openHandler?.()
   }
 
   send(msg: ProtocolMessage): void {
-    if (!this.writeChar || this.state !== 'connected') return;
-    const frames = frameMessage(JSON.stringify(msg), this.mtuPayload);
+    if (!this.writeChar || this.state !== 'connected') return
+    const frames = frameMessage(JSON.stringify(msg), this.mtuPayload)
     // Send frames sequentially
-    let chain = Promise.resolve();
+    let chain = Promise.resolve()
     for (const frame of frames) {
-      chain = chain.then(() => this.writeChar!.writeValueWithoutResponse(frame as unknown as ArrayBuffer));
+      chain = chain.then(() =>
+        this.writeChar?.writeValueWithoutResponse(frame as unknown as ArrayBuffer),
+      )
     }
   }
 
   disconnect(): void {
     if (this.device?.gatt?.connected) {
-      this.device.gatt.disconnect();
+      this.device.gatt.disconnect()
     }
-    this.cleanup();
+    this.cleanup()
   }
 
   private onNotification = (event: Event): void => {
-    const target = event.target as BluetoothRemoteGATTCharacteristic;
-    const dv = target.value!;
-    const data = new Uint8Array(dv.buffer, dv.byteOffset, dv.byteLength);
-    const json = this.defrag.push(data);
+    const target = event.target as BluetoothRemoteGATTCharacteristic
+    const dv = target.value
+    if (!dv) return
+    const data = new Uint8Array(dv.buffer, dv.byteOffset, dv.byteLength)
+    const json = this.defrag.push(data)
     if (json && this.messageHandler) {
-      try { this.messageHandler(JSON.parse(json)); } catch { /* bad json */ }
+      try {
+        this.messageHandler(JSON.parse(json))
+      } catch {
+        /* bad json */
+      }
     }
-  };
+  }
 
   private onDisconnect = (): void => {
-    this.cleanup();
-    this.closeHandler?.();
-  };
+    this.cleanup()
+    this.closeHandler?.()
+  }
 
   private cleanup(): void {
     if (this.notifyChar) {
-      this.notifyChar.removeEventListener('characteristicvaluechanged', this.onNotification);
+      this.notifyChar.removeEventListener('characteristicvaluechanged', this.onNotification)
     }
     if (this.device) {
-      this.device.removeEventListener('gattserverdisconnected', this.onDisconnect);
+      this.device.removeEventListener('gattserverdisconnected', this.onDisconnect)
     }
-    this.device = null;
-    this.writeChar = null;
-    this.notifyChar = null;
-    this.defrag.reset();
-    this.state = 'disconnected';
+    this.device = null
+    this.writeChar = null
+    this.notifyChar = null
+    this.defrag.reset()
+    this.state = 'disconnected'
   }
 }

package/src/ble/web-bluetooth.d.ts

@@ -4,44 +4,44 @@
  */
 
 interface BluetoothDevice extends EventTarget {
-  readonly id: string;
-  readonly name?: string | undefined;
-  readonly gatt?: BluetoothRemoteGATTServer | undefined;
+  readonly id: string
+  readonly name?: string | undefined
+  readonly gatt?: BluetoothRemoteGATTServer | undefined
 }
 
 interface BluetoothRemoteGATTServer {
-  readonly device: BluetoothDevice;
-  readonly connected: boolean;
-  connect(): Promise<BluetoothRemoteGATTServer>;
-  disconnect(): void;
-  getPrimaryService(service: string): Promise<BluetoothRemoteGATTService>;
+  readonly device: BluetoothDevice
+  readonly connected: boolean
+  connect(): Promise<BluetoothRemoteGATTServer>
+  disconnect(): void
+  getPrimaryService(service: string): Promise<BluetoothRemoteGATTService>
 }
 
 interface BluetoothRemoteGATTService {
-  getCharacteristic(characteristic: string): Promise<BluetoothRemoteGATTCharacteristic>;
+  getCharacteristic(characteristic: string): Promise<BluetoothRemoteGATTCharacteristic>
 }
 
 interface BluetoothRemoteGATTCharacteristic extends EventTarget {
-  readonly value: DataView | null;
-  startNotifications(): Promise<BluetoothRemoteGATTCharacteristic>;
-  stopNotifications(): Promise<BluetoothRemoteGATTCharacteristic>;
-  writeValueWithoutResponse(value: BufferSource): Promise<void>;
+  readonly value: DataView | null
+  startNotifications(): Promise<BluetoothRemoteGATTCharacteristic>
+  stopNotifications(): Promise<BluetoothRemoteGATTCharacteristic>
+  writeValueWithoutResponse(value: BufferSource): Promise<void>
 }
 
 interface BluetoothRequestDeviceFilter {
-  namePrefix?: string;
-  services?: string[];
+  namePrefix?: string
+  services?: string[]
 }
 
 interface RequestDeviceOptions {
-  filters?: BluetoothRequestDeviceFilter[];
-  optionalServices?: string[];
+  filters?: BluetoothRequestDeviceFilter[]
+  optionalServices?: string[]
 }
 
 interface Bluetooth {
-  requestDevice(options: RequestDeviceOptions): Promise<BluetoothDevice>;
+  requestDevice(options: RequestDeviceOptions): Promise<BluetoothDevice>
 }
 
 interface Navigator {
-  bluetooth?: Bluetooth | undefined;
+  bluetooth?: Bluetooth | undefined
 }