@onekeyfe/hd-core 1.2.0-alpha.104 → 1.2.0-alpha.106

package/__tests__/DeviceCommands.test.ts

@@ -19,12 +19,12 @@ const createCommands = () => {
 };
 
 describe('DeviceCommands failure mapping', () => {
-  it('logs passphrase call request and response without exposing the passphrase', async () => {
+  it('logs passphrase request and canonical response without exposing the passphrase', async () => {
     const commands = createCommands();
-    const requestLog = getLogger(LoggerNames.DeviceCommands);
-    const responseLog = getLogger(LoggerNames.Core);
-    requestLog.messages.length = 0;
-    responseLog.messages.length = 0;
+    const log = getLogger(LoggerNames.DeviceCommands);
+    const coreLog = getLogger(LoggerNames.Core);
+    log.messages.length = 0;
+    coreLog.messages.length = 0;
     commands.mainId = 'main-id';
     commands.transport = {
       call: jest.fn().mockResolvedValue({
@@ -36,13 +36,13 @@ describe('DeviceCommands failure mapping', () => {
     } as any;
 
     await expect(
-      commands.call('DeviceSessionAskPassphrase', {
+      commands._commonCall('DeviceSessionAskPassphrase', {
         passphrase: 'hidden-wallet-secret',
         on_device: false,
       })
     ).resolves.toMatchObject({ type: 'Success' });
 
-    expect(requestLog.messages.at(-1)?.message).toEqual([
+    expect(log.messages.at(-2)?.message).toEqual([
       '[DeviceCommands] [call] Sending',
       'DeviceSessionAskPassphrase',
       {
@@ -50,21 +50,27 @@ describe('DeviceCommands failure mapping', () => {
         on_device: false,
       },
     ]);
-    expect(responseLog.messages.at(-1)?.message).toEqual([
-      '[DeviceCommands] [call] Received',
-      'Success',
+    expect(log.messages.at(-1)?.message).toEqual([
+      '_filterCommonTypes: ',
       {
-        message: 'Passphrase accepted',
+        request: 'DeviceSessionAskPassphrase',
+        response: {
+          type: 'Success',
+          message: {
+            message: 'Passphrase accepted',
+          },
+        },
       },
     ]);
-    expect(JSON.stringify([...requestLog.messages, ...responseLog.messages])).not.toContain(
-      'hidden-wallet-secret'
-    );
+    expect(
+      coreLog.messages.some(entry => entry.message[0] === '[DeviceCommands] [call] Received')
+    ).toBe(false);
+    expect(JSON.stringify(log.messages)).not.toContain('hidden-wallet-secret');
   });
 
-  it('logs DeviceStatus response fields without exposing the device ID', async () => {
+  it('logs canonical DeviceStatus response fields without exposing the device ID', async () => {
     const commands = createCommands();
-    const log = getLogger(LoggerNames.Core);
+    const log = getLogger(LoggerNames.DeviceCommands);
     log.messages.length = 0;
     commands.mainId = 'main-id';
     commands.transport = {
@@ -82,22 +88,27 @@ describe('DeviceCommands failure mapping', () => {
       }),
     } as any;
 
-    await expect(commands.call('DeviceStatusGet', {})).resolves.toMatchObject({
+    await expect(commands._commonCall('DeviceStatusGet', {})).resolves.toMatchObject({
       type: 'DeviceStatus',
     });
 
     const receivedLog = log.messages.at(-1)?.message;
     expect(receivedLog).toEqual([
-      '[DeviceCommands] [call] Received',
-      'DeviceStatus',
+      '_filterCommonTypes: ',
       {
-        device_id: '[REDACTED]',
-        unlocked: true,
-        init_states: true,
-        backup_required: false,
-        passphrase_enabled: true,
-        attach_to_pin_enabled: false,
-        unlocked_by_attach_to_pin: false,
+        request: 'DeviceStatusGet',
+        response: {
+          type: 'DeviceStatus',
+          message: {
+            device_id: '[REDACTED]',
+            unlocked: true,
+            init_states: true,
+            backup_required: false,
+            passphrase_enabled: true,
+            attach_to_pin_enabled: false,
+            unlocked_by_attach_to_pin: false,
+          },
+        },
       },
     ]);
     expect(JSON.stringify(receivedLog)).not.toContain('sensitive-device-id');
@@ -125,6 +136,59 @@ describe('DeviceCommands failure mapping', () => {
     expect(JSON.stringify(log.messages)).not.toContain('secret-wallet-address');
   });
 
+  it('logs the sanitized DeviceInfo response payload', async () => {
+    const commands = createCommands();
+    const log = getLogger(LoggerNames.DeviceCommands);
+    log.messages.length = 0;
+
+    await expect(
+      commands._filterCommonTypes(
+        {
+          type: 'DeviceInfo',
+          message: {
+            protocol_version: 2,
+            hw: {
+              Device_type: 7,
+              hardware_version: '1.0.0',
+            },
+            fw: {
+              application: {
+                version: '5.0.0',
+                build_id: '20260811',
+                hash: 'firmware-hash',
+              },
+            },
+          },
+        } as any,
+        'DeviceInfoGet'
+      )
+    ).resolves.toMatchObject({ type: 'DeviceInfo' });
+
+    expect(log.messages.at(-1)?.message).toEqual([
+      '_filterCommonTypes: ',
+      {
+        request: 'DeviceInfoGet',
+        response: {
+          type: 'DeviceInfo',
+          message: {
+            protocol_version: 2,
+            hw: {
+              Device_type: 7,
+              hardware_version: '1.0.0',
+            },
+            fw: {
+              application: {
+                version: '5.0.0',
+                build_id: '20260811',
+                hash: 'firmware-hash',
+              },
+            },
+          },
+        },
+      },
+    ]);
+  });
+
   it('logs the sanitized DeviceFirmwareUpdateStatus response payload', async () => {
     const commands = createCommands();
     const log = getLogger(LoggerNames.DeviceCommands);
@@ -561,17 +625,22 @@ describe('DeviceCommands failure mapping', () => {
 });
 
 describe('DeviceCommands Protocol V2 interactive response compatibility', () => {
-  it('still auto-acks ButtonRequest when no hardware UI listener is registered', async () => {
+  it('auto-acks Pro2 ButtonRequest and registers Cancel instead of Initialize', async () => {
     const commands = createCommands();
     const emit = jest.fn();
+    const cancelDevice = jest.spyOn(commands, 'cancelDevice').mockResolvedValue(undefined);
+    const cancelDeviceOnOneKeyDevice = jest
+      .spyOn(commands, 'cancelDeviceOnOneKeyDevice')
+      .mockResolvedValue(undefined);
     const commonCall = jest.fn().mockResolvedValue({
       type: 'Success',
       message: {},
     });
+    const setCancelableAction = jest.fn();
     commands.device = {
       ...commands.device,
       getCurrentDeviceType: jest.fn(() => 'pro2'),
-      setCancelableAction: jest.fn(),
+      setCancelableAction,
       emit,
       listenerCount: jest.fn(() => 0),
     } as any;
@@ -593,6 +662,9 @@ describe('DeviceCommands Protocol V2 interactive response compatibility', () =>
       expect.objectContaining({ code: 'ButtonRequest_PinEntry' })
     );
     expect(commonCall).toHaveBeenCalledWith('ButtonAck', {}, undefined);
+    await setCancelableAction.mock.calls[0][0]();
+    expect(cancelDevice).toHaveBeenCalledTimes(1);
+    expect(cancelDeviceOnOneKeyDevice).not.toHaveBeenCalled();
   });
 
   it('rejects PassphraseRequest when the Pro2 UI listener is not registered', async () => {

package/__tests__/check-all-firmware-release-protocol-v2.test.ts

@@ -346,7 +346,6 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
     expect(typedCall).not.toHaveBeenCalled();
     expect(getDeviceState).toHaveBeenCalledWith({
       refreshSections: ['identity', 'versions'],
-      allowLegacyProtocolV2ProtocolInfo: true,
     });
     expect(method.getSupportedProtocols()).toEqual(['V1', 'V2']);
   });
@@ -726,7 +725,6 @@ describe('checkAllFirmwareRelease Protocol V2 support', () => {
     });
     expect(getDeviceState).toHaveBeenCalledWith({
       refreshSections: ['identity', 'versions', 'verification'],
-      allowLegacyProtocolV2ProtocolInfo: true,
     });
   });
 

package/__tests__/device-lifecycle-events.test.ts

@@ -1,12 +1,14 @@
-import { HardwareErrorCode } from '@onekeyfe/hd-shared';
-import { TRANSPORT_EVENT } from '@onekeyfe/hd-transport';
+import { EDeviceType, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { DeviceType, TRANSPORT_EVENT } from '@onekeyfe/hd-transport';
 
 import { initConnector, initCore } from '../src/core';
 import { DataManager } from '../src/data-manager';
 import TransportManager from '../src/data-manager/TransportManager';
 import { Device } from '../src/device/Device';
+import { cancelDeviceInPrompt, cancelDeviceWithInitialize } from '../src/device/DeviceCommands';
 import { DevicePool } from '../src/device/DevicePool';
 import { CORE_EVENT, DEVICE, IFRAME } from '../src/events';
+import { PROTOCOL_V2_DEVICE_STATUS_GET_MESSAGE_TYPE } from '../src/protocols/protocol-v2';
 
 import type Core from '../src/core';
 import type { CoreMessage } from '../src/events';
@@ -271,6 +273,115 @@ describe('public device lifecycle events', () => {
     expect(device.isUsedHere()).toBe(false);
   });
 
+  test.each([
+    ['V2', 'Cancel', 'webusb'],
+    ['V2', 'Cancel', 'desktop-web-ble'],
+    ['V2', 'Cancel', 'react-native'],
+    ['V1', 'Initialize', 'webusb'],
+    ['V1', 'Cancel', 'desktop-web-ble'],
+  ] as const)(
+    'sends Protocol %s %s without treating the acquired %s session as disconnected',
+    async (protocol, messageType, env) => {
+      jest.spyOn(DataManager, 'getSettings').mockReturnValue(env as never);
+      const device = createInitializedDevice(protocol);
+      const post = jest.fn().mockResolvedValue(undefined);
+      const call = jest.fn().mockResolvedValue(undefined);
+      const cancel = jest.fn().mockResolvedValue(undefined);
+      device.originalDescriptor.session = device.mainId;
+      (device as unknown as { deviceAcquired: boolean }).deviceAcquired = true;
+      (device as any).commands = { transport: { post, call }, cancel };
+      device.setCancelableAction(() =>
+        messageType === 'Cancel'
+          ? cancelDeviceInPrompt(device, false)
+          : cancelDeviceWithInitialize(device)
+      );
+
+      await device.interruptionFromUser();
+
+      if (messageType === 'Cancel') {
+        expect(post).toHaveBeenCalledWith(device.mainId, 'Cancel', {});
+        expect(call).not.toHaveBeenCalled();
+      } else {
+        expect(call).toHaveBeenCalledWith(device.mainId, 'Initialize', {});
+        expect(post).not.toHaveBeenCalled();
+      }
+      expect(cancel).toHaveBeenCalledTimes(1);
+      expect(device.hasDeviceAcquire()).toBe(true);
+    }
+  );
+
+  test.each([
+    [EDeviceType.Pro2, 'webusb', false, DeviceType.PRO2],
+    [EDeviceType.Neo, 'webusb', false, DeviceType.NEO],
+    [EDeviceType.Pro2, 'desktop-web-ble', true, DeviceType.PRO2],
+    [EDeviceType.Neo, 'desktop-web-ble', true, DeviceType.NEO],
+    [EDeviceType.Pro2, 'react-native', true, DeviceType.PRO2],
+    [EDeviceType.Neo, 'react-native', true, DeviceType.NEO],
+    [EDeviceType.Pro2, 'lowlevel', false, DeviceType.PRO2],
+  ] as const)(
+    'refreshes %s runtime state after acquiring a fresh %s session',
+    async (deviceType, env, isBle, protocolV2DeviceType) => {
+      jest.spyOn(DataManager, 'getSettings').mockReturnValue(env as never);
+      const device = createInitializedDevice('V2');
+      const staleProtocolInfo = {
+        version: 1,
+        build_fingerprint: 'bootloader__1.0.0__abcdef0__PROD__RELEASE',
+        supported_messages: [],
+      };
+      const freshProtocolInfo = {
+        version: 1,
+        build_fingerprint: 'application__5.0.0__abcdef0__PROD__RELEASE',
+        supported_messages: [PROTOCOL_V2_DEVICE_STATUS_GET_MESSAGE_TYPE],
+      };
+      device.updateState(
+        {
+          identity: { deviceType },
+          status: { mode: 'bootloader' },
+          raw: { protocolV2ProtocolInfo: staleProtocolInfo },
+        },
+        'initialize'
+      );
+      const acquire = jest
+        .fn()
+        .mockResolvedValue(isBle ? { uuid: 'fresh-session', protocolType: 'V2' } : 'fresh-session');
+      device.deviceConnector = { acquire } as never;
+
+      await device.acquire('V2', { throwOnRunPromiseError: true });
+      const typedCall = jest.fn().mockImplementation((requestType: string) => {
+        if (requestType === 'DeviceInfoGet') {
+          return {
+            message: {
+              protocol_version: 2,
+              hw: { Device_type: protocolV2DeviceType, serial_no: 'SERIAL-001' },
+              fw: { application: { version: '5.0.0' } },
+            },
+          };
+        }
+        if (requestType === 'ProtocolInfoRequest') {
+          return { message: freshProtocolInfo };
+        }
+        if (requestType === 'DeviceStatusGet') {
+          return {
+            message: { init_states: true, unlocked: true, device_id: 'wallet-device-id' },
+          };
+        }
+        throw new Error(`Unexpected request: ${requestType}`);
+      });
+      device.commands.typedCall = typedCall as never;
+
+      await device.initialize();
+
+      expect(typedCall.mock.calls.map(callArgs => callArgs[0])).toEqual([
+        'DeviceInfoGet',
+        'ProtocolInfoRequest',
+        'DeviceStatusGet',
+      ]);
+      expect(device.state?.status.mode).toBe('normal');
+      expect(device.state?.identity.deviceType).toBe(deviceType);
+      expect(device.hasDeviceAcquire()).toBe(true);
+    }
+  );
+
   test('exposes the current transport usage state in public device snapshots', () => {
     const getSettings = jest
       .spyOn(DataManager, 'getSettings')

package/__tests__/device-pool-state.test.ts

@@ -38,7 +38,7 @@ describe('DevicePool state lifecycle', () => {
     expect(getDeviceState).toHaveBeenNthCalledWith(2, { refreshSections: ['settings'] });
   });
 
-  test('keeps legacy ProtocolInfo compatibility scoped to a discovery refresh', async () => {
+  test('refreshes Protocol V2 discovery state without legacy-specific options', async () => {
     const getDeviceState = jest.fn().mockResolvedValue({ status: { mode: 'bootloader' } });
     const run = jest.fn(async (callback: () => Promise<void>) => callback());
     const device = {
@@ -49,21 +49,17 @@ describe('DevicePool state lifecycle', () => {
 
     await (DevicePool as any)._refreshRuntimeState(device, {
       refreshRuntimeState: true,
-      allowLegacyProtocolV2ProtocolInfo: true,
     });
 
     expect(run).toHaveBeenCalledWith(expect.any(Function), {
       connectProtocol: undefined,
       forceProtocolDetection: undefined,
-      allowLegacyProtocolV2ProtocolInfo: true,
     });
     expect(getDeviceState).toHaveBeenNthCalledWith(1, {
       refreshSections: ['status'],
-      allowLegacyProtocolV2ProtocolInfo: true,
     });
     expect(getDeviceState).toHaveBeenNthCalledWith(2, {
       refreshSections: ['settings'],
-      allowLegacyProtocolV2ProtocolInfo: true,
     });
   });
 

package/__tests__/deviceSettings.test.ts

@@ -67,7 +67,6 @@ describe('Pro 2 device settings options', () => {
       { label: '2 minutes', valueMs: 120_000 },
       { label: '5 minutes', valueMs: 300_000 },
       { label: '10 minutes', valueMs: 600_000 },
-      { label: '30 minutes', valueMs: 1_800_000 },
       { label: 'Never', valueMs: PROTOCOL_V2_NEVER_TIMEOUT_MS },
     ]);
   });

package/__tests__/firmware-update/firmware-update-v4-install-poll.test.ts

@@ -0,0 +1,145 @@
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import FirmwareUpdateV4 from '../../src/api/FirmwareUpdateV4';
+import { DataManager } from '../../src/data-manager';
+
+import type { Device } from '../../src/device/Device';
+
+jest.mock('../../src/data/config', () => ({
+  DEFAULT_DOMAIN: 'https://example.com/',
+  getSDKVersion: () => '0.0.0-test',
+}));
+
+describe('FirmwareUpdateV4 install polling', () => {
+  let getSettingsSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    getSettingsSpy = jest
+      .spyOn(DataManager, 'getSettings')
+      .mockReturnValue('react-native' as never);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test('polls status instead of replaying install after React Native BLE releases', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        connectId: 'pro2-ble',
+      },
+    });
+    const targets = [{ target_id: 4, path: 'vol0:/application_p1.bin' }];
+    const typedCall = jest
+      .fn()
+      .mockRejectedValueOnce(new Error('React Native BLE transport released'))
+      .mockResolvedValueOnce({
+        message: {
+          records: [
+            {
+              target_id: 4,
+              status: 'FW_MGMT_UPDATER_TASK_STATUS_FINISHED',
+              path: 'vol0:/application_p1.bin',
+            },
+          ],
+        },
+      });
+
+    method.device = {
+      getCommands: () => ({ typedCall }),
+    } as unknown as Device;
+    method.postTipMessage = jest.fn();
+    method.postProgressMessage = jest.fn();
+
+    const firmwareUpdate = method as unknown as {
+      protocolV2StartFirmwareUpdate: (params: { targets: typeof targets }) => Promise<unknown>;
+      waitForProtocolV2FirmwareUpdateComplete: (value: typeof targets) => Promise<void>;
+      reconnectProtocolV2Device: () => Promise<void>;
+      verifyProtocolV2ReconnectIdentity: () => Promise<Record<string, never>>;
+    };
+    firmwareUpdate.reconnectProtocolV2Device = jest.fn().mockResolvedValue(undefined);
+    firmwareUpdate.verifyProtocolV2ReconnectIdentity = jest.fn().mockResolvedValue({});
+
+    await expect(
+      firmwareUpdate.protocolV2StartFirmwareUpdate({ targets })
+    ).resolves.toBeUndefined();
+    await expect(
+      firmwareUpdate.waitForProtocolV2FirmwareUpdateComplete(targets)
+    ).resolves.toBeUndefined();
+
+    expect(typedCall).toHaveBeenCalledTimes(2);
+    expect(typedCall.mock.calls[0]?.[0]).toBe('DeviceFirmwareUpdateRequest');
+    expect(typedCall.mock.calls[1]?.[0]).toBe('DeviceFirmwareUpdateStatusGet');
+  });
+
+  test('does not treat an explicit workflow cancellation as an install reboot', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+        connectId: 'pro2-ble',
+      },
+    });
+    const targets = [{ target_id: 4, path: 'vol0:/application_p1.bin' }];
+    const typedCall = jest.fn().mockRejectedValue(new Error('React Native BLE transport released'));
+    const abortController = new AbortController();
+    abortController.abort();
+
+    method.abortSignal = abortController.signal;
+    method.device = {
+      getCommands: () => ({ typedCall }),
+    } as unknown as Device;
+
+    await expect(
+      (
+        method as unknown as {
+          protocolV2StartFirmwareUpdate: (params: { targets: typeof targets }) => Promise<unknown>;
+        }
+      ).protocolV2StartFirmwareUpdate({ targets })
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.CallQueueActionCancelled,
+    });
+
+    expect(typedCall).toHaveBeenCalledTimes(1);
+  });
+
+  test.each([
+    ['webusb', 'React Native BLE transport released'],
+    ['react-native', 'Connection error has occured: Device disconnected'],
+  ])(
+    'requires both a BLE environment and an explicit transport release signal: %s / %s',
+    async (env, message) => {
+      getSettingsSpy.mockReturnValue(env);
+      const method = new FirmwareUpdateV4({
+        id: 1,
+        payload: {
+          method: 'firmwareUpdateV4',
+          connectId: 'pro2-device',
+        },
+      });
+      const targets = [{ target_id: 4, path: 'vol0:/application_p1.bin' }];
+      const typedCall = jest.fn().mockRejectedValue(new Error(message));
+
+      method.device = {
+        getCommands: () => ({ typedCall }),
+      } as unknown as Device;
+      method.postTipMessage = jest.fn();
+      method.postProgressMessage = jest.fn();
+
+      await expect(
+        (
+          method as unknown as {
+            protocolV2StartFirmwareUpdate: (params: {
+              targets: typeof targets;
+            }) => Promise<unknown>;
+          }
+        ).protocolV2StartFirmwareUpdate({ targets })
+      ).rejects.toThrow(message);
+
+      expect(method.postTipMessage).not.toHaveBeenCalled();
+      expect(method.postProgressMessage).not.toHaveBeenCalled();
+    }
+  );
+});

package/__tests__/get-device-state.test.ts

@@ -252,56 +252,6 @@ describe('getDeviceState', () => {
     }
   );
 
-  test.each([
-    [EDeviceType.Pro2, DeviceType.PRO2],
-    [EDeviceType.Neo, DeviceType.NEO],
-  ] as const)('invalidates cached loader state when %s is cancelled', async (deviceType, type) => {
-    const typedCall = jest.fn().mockImplementation((requestType: string) => {
-      if (requestType === 'DeviceInfoGet') {
-        return {
-          message: {
-            protocol_version: 2,
-            hw: { Device_type: type, serial_no: 'SERIAL-1' },
-            fw: { application: { version: '5.0.0' } },
-          },
-        };
-      }
-      if (requestType === 'ProtocolInfoRequest') {
-        return { message: protocolV2ApplicationInfo };
-      }
-      if (requestType === 'DeviceStatusGet') {
-        return {
-          message: { init_states: true, unlocked: true, device_id: 'wallet-1' },
-        };
-      }
-      throw new Error(`Unexpected request: ${requestType}`);
-    });
-    const cancel = jest.fn().mockResolvedValue(undefined);
-    const device = createV2Device(typedCall);
-    (device as any).commands = { cancel, typedCall };
-    device.updateState(
-      {
-        protocol: 'V2',
-        identity: { deviceType },
-        status: { mode: 'bootloader' },
-        raw: { protocolV2ProtocolInfo: getProtocolV2LoaderInfo('bootloader') },
-      },
-      'initialize'
-    );
-
-    await device.interruptionFromUser();
-    await device.initialize();
-
-    expect(cancel).toHaveBeenCalledTimes(1);
-    expect(device.state?.status.mode).toBe('normal');
-    expect(device.state?.identity.deviceId).toBe('wallet-1');
-    expect(typedCall.mock.calls.map(call => call[0])).toEqual([
-      'DeviceInfoGet',
-      'ProtocolInfoRequest',
-      'DeviceStatusGet',
-    ]);
-  });
-
   test.each(['bootloader', 'romloader'] as const)(
     'keeps live %s mode after refreshing cached loader state',
     async mode => {

package/__tests__/logBlockEvent.test.ts

@@ -104,7 +104,19 @@ describe('getLogBlockLabel', () => {
     });
   });
 
-  it.each(['deviceUploadNft', 'deviceUploadWallpaper', 'uploadPortfolio', 'fileWrite', 'fileRead'])(
+  it.each(['deviceUploadNft', 'deviceUploadWallpaper', 'uploadPortfolio'])(
+    'skips large Base64 resource payload logging for %s',
+    method => {
+      const request = { method, path: 'resource.bin', data: 'A'.repeat(1024 * 1024) };
+      expect(getLogBlockLabel(request)).toBe(method);
+      expect(getSafeLogPayload(request, method)).toEqual({
+        method,
+        payload: '[REDACTED]',
+      });
+    }
+  );
+
+  it.each(['fileWrite', 'fileRead'])(
     'keeps metadata and replaces binary payloads with their size for %s',
     method => {
       const request = { method, path: 'resource.bin', data: new Uint8Array(1024) };