walletpair-sdk 1.0.2 → 1.0.5

package/src/ble/framing.test.ts

@@ -1,196 +1,204 @@
-import { describe, it, expect } from 'vitest';
-import { frameMessage, Defragmenter, DEFAULT_FRAME_PAYLOAD, MIN_FRAME_PAYLOAD } from './framing.js';
+import { describe, expect, it } from 'vitest'
+import { DEFAULT_FRAME_PAYLOAD, Defragmenter, frameMessage, MIN_FRAME_PAYLOAD } from './framing.js'
 
 describe('frameMessage', () => {
   it('frames empty string as single frame with both flags', () => {
-    const frames = frameMessage('');
-    expect(frames).toHaveLength(1);
-    expect(frames[0]![0]).toBe(0x03); // first + last
-    expect(frames[0]).toHaveLength(3); // header only
-  });
+    const frames = frameMessage('')
+    expect(frames).toHaveLength(1)
+    const f0 = frames[0]
+    expect(f0).toBeDefined()
+    expect(f0?.[0]).toBe(0x03) // first + last
+    expect(f0).toHaveLength(3) // header only
+  })
 
   it('frames short message as single frame', () => {
-    const msg = '{"v":1,"t":"ping"}';
-    const frames = frameMessage(msg);
-    expect(frames).toHaveLength(1);
-    expect(frames[0]![0]).toBe(0x03); // first + last
+    const msg = '{"v":1,"t":"ping"}'
+    const frames = frameMessage(msg)
+    expect(frames).toHaveLength(1)
+    const f0 = frames[0]
+    expect(f0).toBeDefined()
+    expect(f0?.[0]).toBe(0x03) // first + last
 
     // Verify total length in header
-    const payload = new TextEncoder().encode(msg);
-    const totalLen = (frames[0]![1]! << 8) | frames[0]![2]!;
-    expect(totalLen).toBe(payload.length);
+    const payload = new TextEncoder().encode(msg)
+    const totalLen = ((f0?.[1] ?? 0) << 8) | (f0?.[2] ?? 0)
+    expect(totalLen).toBe(payload.length)
 
     // Verify payload
-    const extracted = frames[0]!.subarray(3);
-    expect(new TextDecoder().decode(extracted)).toBe(msg);
-  });
+    const extracted = f0?.subarray(3)
+    expect(new TextDecoder().decode(extracted)).toBe(msg)
+  })
 
   it('fragments message exceeding maxPayload', () => {
-    const longMsg = 'A'.repeat(100);
-    const frames = frameMessage(longMsg, 30);
+    const longMsg = 'A'.repeat(100)
+    const frames = frameMessage(longMsg, 30)
 
-    expect(frames.length).toBeGreaterThan(1);
+    expect(frames.length).toBeGreaterThan(1)
 
     // First frame: flag=0x01 (first only)
-    expect(frames[0]![0]! & 0x01).toBe(0x01); // first bit set
-    expect(frames[0]![0]! & 0x02).toBe(0x00); // last bit not set
+    const f0 = frames[0]
+    expect(f0).toBeDefined()
+    expect((f0?.[0] ?? 0) & 0x01).toBe(0x01) // first bit set
+    expect((f0?.[0] ?? 0) & 0x02).toBe(0x00) // last bit not set
 
     // Last frame: flag=0x02 (last only)
-    const lastFrame = frames[frames.length - 1]!;
-    expect(lastFrame[0]! & 0x01).toBe(0x00); // first bit not set
-    expect(lastFrame[0]! & 0x02).toBe(0x02); // last bit set
+    const lastFrame = frames[frames.length - 1]
+    expect(lastFrame).toBeDefined()
+    expect((lastFrame?.[0] ?? 0) & 0x01).toBe(0x00) // first bit not set
+    expect((lastFrame?.[0] ?? 0) & 0x02).toBe(0x02) // last bit set
 
     // Middle frames (if any): flag=0x00
     for (let i = 1; i < frames.length - 1; i++) {
-      expect(frames[i]![0]).toBe(0x00);
+      expect(frames[i]?.[0]).toBe(0x00)
     }
-  });
+  })
 
   it('first frame contains total length in header', () => {
-    const msg = 'X'.repeat(200);
-    const frames = frameMessage(msg, 50);
-    const totalLen = (frames[0]![1]! << 8) | frames[0]![2]!;
-    expect(totalLen).toBe(new TextEncoder().encode(msg).length);
-  });
+    const msg = 'X'.repeat(200)
+    const frames = frameMessage(msg, 50)
+    const f0 = frames[0]
+    const totalLen = ((f0?.[1] ?? 0) << 8) | (f0?.[2] ?? 0)
+    expect(totalLen).toBe(new TextEncoder().encode(msg).length)
+  })
 
   it('respects MIN_FRAME_PAYLOAD even when maxPayload is smaller', () => {
-    const msg = 'A'.repeat(100);
-    const frames = frameMessage(msg, 5); // smaller than MIN_FRAME_PAYLOAD
+    const msg = 'A'.repeat(100)
+    const frames = frameMessage(msg, 5) // smaller than MIN_FRAME_PAYLOAD
     // Each payload chunk should be at least MIN_FRAME_PAYLOAD
     for (const frame of frames) {
-      const payloadSize = frame.length - 3;
+      const payloadSize = frame.length - 3
       if (payloadSize > 0) {
         // Last frame might be shorter
-        if ((frame[0]! & 0x02) === 0) {
-          expect(payloadSize).toBeGreaterThanOrEqual(MIN_FRAME_PAYLOAD);
+        if (((frame[0] ?? 0) & 0x02) === 0) {
+          expect(payloadSize).toBeGreaterThanOrEqual(MIN_FRAME_PAYLOAD)
         }
       }
     }
-  });
+  })
 
   it('uses DEFAULT_FRAME_PAYLOAD when no maxPayload specified', () => {
-    const msg = 'B'.repeat(DEFAULT_FRAME_PAYLOAD + 100);
-    const frames = frameMessage(msg);
-    expect(frames.length).toBe(2); // slightly over one full frame
-  });
-});
+    const msg = 'B'.repeat(DEFAULT_FRAME_PAYLOAD + 100)
+    const frames = frameMessage(msg)
+    expect(frames.length).toBe(2) // slightly over one full frame
+  })
+})
 
 describe('Defragmenter', () => {
   it('reassembles single-frame message', () => {
-    const defrag = new Defragmenter();
-    const msg = '{"hello":"world"}';
-    const frames = frameMessage(msg);
+    const defrag = new Defragmenter()
+    const msg = '{"hello":"world"}'
+    const frames = frameMessage(msg)
 
-    expect(frames).toHaveLength(1);
-    const result = defrag.push(frames[0]!);
-    expect(result).toBe(msg);
-  });
+    expect(frames).toHaveLength(1)
+    const result = defrag.push(frames[0] ?? new Uint8Array())
+    expect(result).toBe(msg)
+  })
 
   it('reassembles multi-frame message', () => {
-    const defrag = new Defragmenter();
-    const msg = 'A'.repeat(200);
-    const frames = frameMessage(msg, 50);
+    const defrag = new Defragmenter()
+    const msg = 'A'.repeat(200)
+    const frames = frameMessage(msg, 50)
 
-    expect(frames.length).toBeGreaterThan(1);
+    expect(frames.length).toBeGreaterThan(1)
 
     for (let i = 0; i < frames.length - 1; i++) {
-      const result = defrag.push(frames[i]!);
-      expect(result).toBeNull(); // not complete yet
+      const result = defrag.push(frames[i] ?? new Uint8Array())
+      expect(result).toBeNull() // not complete yet
     }
 
-    const result = defrag.push(frames[frames.length - 1]!);
-    expect(result).toBe(msg);
-  });
+    const result = defrag.push(frames[frames.length - 1] ?? new Uint8Array())
+    expect(result).toBe(msg)
+  })
 
   it('handles multiple messages in sequence', () => {
-    const defrag = new Defragmenter();
+    const defrag = new Defragmenter()
 
-    const msg1 = '{"first":true}';
-    const msg2 = '{"second":true}';
+    const msg1 = '{"first":true}'
+    const msg2 = '{"second":true}'
 
-    const frames1 = frameMessage(msg1);
-    const frames2 = frameMessage(msg2);
+    const frames1 = frameMessage(msg1)
+    const frames2 = frameMessage(msg2)
 
-    expect(defrag.push(frames1[0]!)).toBe(msg1);
-    expect(defrag.push(frames2[0]!)).toBe(msg2);
-  });
+    expect(defrag.push(frames1[0] ?? new Uint8Array())).toBe(msg1)
+    expect(defrag.push(frames2[0] ?? new Uint8Array())).toBe(msg2)
+  })
 
   it('handles interleaved fragmented messages correctly via reset', () => {
-    const defrag = new Defragmenter();
+    const defrag = new Defragmenter()
 
     // Start a message
-    const longMsg = 'X'.repeat(100);
-    const frames = frameMessage(longMsg, 30);
-    defrag.push(frames[0]!); // first fragment
+    const longMsg = 'X'.repeat(100)
+    const frames = frameMessage(longMsg, 30)
+    defrag.push(frames[0] ?? new Uint8Array()) // first fragment
 
     // Reset and start new message
-    defrag.reset();
-    const shortMsg = '{"ok":true}';
-    const shortFrames = frameMessage(shortMsg);
-    expect(defrag.push(shortFrames[0]!)).toBe(shortMsg);
-  });
+    defrag.reset()
+    const shortMsg = '{"ok":true}'
+    const shortFrames = frameMessage(shortMsg)
+    expect(defrag.push(shortFrames[0] ?? new Uint8Array())).toBe(shortMsg)
+  })
 
   it('ignores frames shorter than 3 bytes', () => {
-    const defrag = new Defragmenter();
-    expect(defrag.push(new Uint8Array([0x03, 0x00]))).toBeNull();
-    expect(defrag.push(new Uint8Array([0x03]))).toBeNull();
-    expect(defrag.push(new Uint8Array([]))).toBeNull();
-  });
+    const defrag = new Defragmenter()
+    expect(defrag.push(new Uint8Array([0x03, 0x00]))).toBeNull()
+    expect(defrag.push(new Uint8Array([0x03]))).toBeNull()
+    expect(defrag.push(new Uint8Array([]))).toBeNull()
+  })
 
   it('reassembles unicode content correctly', () => {
-    const defrag = new Defragmenter();
-    const msg = '{"text":"你好世界🌍"}';
-    const frames = frameMessage(msg, 20);
+    const defrag = new Defragmenter()
+    const msg = '{"text":"你好世界🌍"}'
+    const frames = frameMessage(msg, 20)
 
-    let result: string | null = null;
+    let result: string | null = null
     for (const frame of frames) {
-      result = defrag.push(frame);
+      result = defrag.push(frame)
     }
-    expect(result).toBe(msg);
-  });
+    expect(result).toBe(msg)
+  })
 
   it('handles large messages (> 64KB total length)', () => {
-    const defrag = new Defragmenter();
+    const defrag = new Defragmenter()
     // total_length field is 2 bytes, so max representable is 65535
     // But the code handles growth beyond that via the safety check
-    const msg = 'Z'.repeat(1000);
-    const frames = frameMessage(msg, 100);
+    const msg = 'Z'.repeat(1000)
+    const frames = frameMessage(msg, 100)
 
-    let result: string | null = null;
+    let result: string | null = null
     for (const frame of frames) {
-      result = defrag.push(frame);
+      result = defrag.push(frame)
     }
-    expect(result).toBe(msg);
-  });
+    expect(result).toBe(msg)
+  })
 
   it('reset() clears internal state', () => {
-    const defrag = new Defragmenter();
-    const longMsg = 'Y'.repeat(100);
-    const frames = frameMessage(longMsg, 30);
+    const defrag = new Defragmenter()
+    const longMsg = 'Y'.repeat(100)
+    const frames = frameMessage(longMsg, 30)
 
     // Push first frame
-    defrag.push(frames[0]!);
-    defrag.reset();
+    defrag.push(frames[0] ?? new Uint8Array())
+    defrag.reset()
 
     // After reset, pushing a complete single-frame message should work
-    const shortMsg = '{"reset":true}';
-    const shortFrames = frameMessage(shortMsg);
-    expect(defrag.push(shortFrames[0]!)).toBe(shortMsg);
-  });
+    const shortMsg = '{"reset":true}'
+    const shortFrames = frameMessage(shortMsg)
+    expect(defrag.push(shortFrames[0] ?? new Uint8Array())).toBe(shortMsg)
+  })
 
   it('frame/defrag round-trip preserves exact content for various sizes', () => {
-    const defrag = new Defragmenter();
+    const defrag = new Defragmenter()
     for (const size of [0, 1, 19, 20, 21, 50, 100, 509, 510, 1000]) {
-      defrag.reset();
+      defrag.reset()
       // Size 0 frame has no payload text, skip
-      if (size === 0) continue;
-      const msg = JSON.stringify({ data: 'x'.repeat(size) });
-      const frames = frameMessage(msg, 50);
-      let result: string | null = null;
+      if (size === 0) continue
+      const msg = JSON.stringify({ data: 'x'.repeat(size) })
+      const frames = frameMessage(msg, 50)
+      let result: string | null = null
       for (const frame of frames) {
-        result = defrag.push(frame);
+        result = defrag.push(frame)
       }
-      expect(result).toBe(msg);
+      expect(result).toBe(msg)
     }
-  });
-});
+  })
+})

package/src/ble/framing.ts

@@ -7,94 +7,91 @@
  *   flags bit 1: last fragment
  */
 
-const FLAG_FIRST = 0x01;
-const FLAG_LAST = 0x02;
+const FLAG_FIRST = 0x01
+const FLAG_LAST = 0x02
 
-export const DEFAULT_FRAME_PAYLOAD = 509;
-export const MIN_FRAME_PAYLOAD = 20;
+export const DEFAULT_FRAME_PAYLOAD = 509
+export const MIN_FRAME_PAYLOAD = 20
 
-export const BLE_SERVICE_UUID = 'e3a10001-7770-4270-8000-000077700001';
-export const BLE_WRITE_CHAR_UUID = 'e3a10002-7770-4270-8000-000077700001';
-export const BLE_NOTIFY_CHAR_UUID = 'e3a10003-7770-4270-8000-000077700001';
+export const BLE_SERVICE_UUID = 'e3a10001-7770-4270-8000-000077700001'
+export const BLE_WRITE_CHAR_UUID = 'e3a10002-7770-4270-8000-000077700001'
+export const BLE_NOTIFY_CHAR_UUID = 'e3a10003-7770-4270-8000-000077700001'
 
 /** Split a JSON string into BLE frames. */
-export function frameMessage(
-  jsonStr: string,
-  maxPayload = DEFAULT_FRAME_PAYLOAD,
-): Uint8Array[] {
-  const payload = new TextEncoder().encode(jsonStr);
-  const frames: Uint8Array[] = [];
+export function frameMessage(jsonStr: string, maxPayload = DEFAULT_FRAME_PAYLOAD): Uint8Array[] {
+  const payload = new TextEncoder().encode(jsonStr)
+  const frames: Uint8Array[] = []
 
   if (payload.length === 0) {
-    const frame = new Uint8Array(3);
-    frame[0] = FLAG_FIRST | FLAG_LAST;
-    return [frame];
+    const frame = new Uint8Array(3)
+    frame[0] = FLAG_FIRST | FLAG_LAST
+    return [frame]
   }
 
-  const chunkSize = Math.max(maxPayload, MIN_FRAME_PAYLOAD);
+  const chunkSize = Math.max(maxPayload, MIN_FRAME_PAYLOAD)
 
   for (let offset = 0; offset < payload.length; offset += chunkSize) {
-    const isFirst = offset === 0;
-    const end = Math.min(offset + chunkSize, payload.length);
-    const isLast = end === payload.length;
-    const fragment = payload.subarray(offset, end);
+    const isFirst = offset === 0
+    const end = Math.min(offset + chunkSize, payload.length)
+    const isLast = end === payload.length
+    const fragment = payload.subarray(offset, end)
 
-    const frame = new Uint8Array(3 + fragment.length);
-    frame[0] = (isFirst ? FLAG_FIRST : 0) | (isLast ? FLAG_LAST : 0);
+    const frame = new Uint8Array(3 + fragment.length)
+    frame[0] = (isFirst ? FLAG_FIRST : 0) | (isLast ? FLAG_LAST : 0)
     if (isFirst) {
-      frame[1] = (payload.length >> 8) & 0xff;
-      frame[2] = payload.length & 0xff;
+      frame[1] = (payload.length >> 8) & 0xff
+      frame[2] = payload.length & 0xff
     }
-    frame.set(fragment, 3);
-    frames.push(frame);
+    frame.set(fragment, 3)
+    frames.push(frame)
   }
 
-  return frames;
+  return frames
 }
 
 /** Accumulates BLE frames and emits complete JSON strings. */
 export class Defragmenter {
-  private buffer: Uint8Array | null = null;
-  private offset = 0;
+  private buffer: Uint8Array | null = null
+  private offset = 0
 
   push(data: Uint8Array): string | null {
-    if (data.length < 3) return null;
+    if (data.length < 3) return null
 
-    const flags = data[0]!;
-    const isFirst = !!(flags & FLAG_FIRST);
-    const isLast = !!(flags & FLAG_LAST);
-    const fragment = data.subarray(3);
+    const flags = data[0] ?? 0
+    const isFirst = !!(flags & FLAG_FIRST)
+    const isLast = !!(flags & FLAG_LAST)
+    const fragment = data.subarray(3)
 
     if (isFirst) {
-      const totalLength = (data[1]! << 8) | data[2]!;
-      this.buffer = new Uint8Array(totalLength || fragment.length);
-      this.offset = 0;
+      const totalLength = ((data[1] ?? 0) << 8) | (data[2] ?? 0)
+      this.buffer = new Uint8Array(totalLength || fragment.length)
+      this.offset = 0
     }
 
     if (this.buffer) {
       if (this.offset + fragment.length <= this.buffer.length) {
-        this.buffer.set(fragment, this.offset);
+        this.buffer.set(fragment, this.offset)
       } else {
-        const grown = new Uint8Array(this.offset + fragment.length);
-        grown.set(this.buffer.subarray(0, this.offset));
-        grown.set(fragment, this.offset);
-        this.buffer = grown;
+        const grown = new Uint8Array(this.offset + fragment.length)
+        grown.set(this.buffer.subarray(0, this.offset))
+        grown.set(fragment, this.offset)
+        this.buffer = grown
       }
-      this.offset += fragment.length;
+      this.offset += fragment.length
     }
 
     if (isLast && this.buffer) {
-      const result = new TextDecoder().decode(this.buffer.subarray(0, this.offset));
-      this.buffer = null;
-      this.offset = 0;
-      return result;
+      const result = new TextDecoder().decode(this.buffer.subarray(0, this.offset))
+      this.buffer = null
+      this.offset = 0
+      return result
     }
 
-    return null;
+    return null
   }
 
   reset(): void {
-    this.buffer = null;
-    this.offset = 0;
+    this.buffer = null
+    this.offset = 0
   }
 }

package/src/ble/index.ts

@@ -6,13 +6,13 @@
  */
 
 export {
-  frameMessage,
-  Defragmenter,
-  DEFAULT_FRAME_PAYLOAD,
-  MIN_FRAME_PAYLOAD,
+  BLE_NOTIFY_CHAR_UUID,
   BLE_SERVICE_UUID,
   BLE_WRITE_CHAR_UUID,
-  BLE_NOTIFY_CHAR_UUID,
-} from './framing.js';
+  DEFAULT_FRAME_PAYLOAD,
+  Defragmenter,
+  frameMessage,
+  MIN_FRAME_PAYLOAD,
+} from './framing.js'
 
-export { WebBleCentralTransport, isWebBleSupported } from './web-ble-transport.js';
+export { isWebBleSupported, WebBleCentralTransport } from './web-ble-transport.js'