@onekeyfe/hd-core 1.2.0-alpha.32 → 1.2.0-alpha.34

package/__tests__/open-wallet-session.test.ts

@@ -3,6 +3,7 @@ import { DeviceSessionPinType } from '@onekeyfe/hd-transport';
 
 import GetPassphraseState from '../src/api/GetPassphraseState';
 import OpenWalletSession from '../src/api/OpenWalletSession';
+import { Device } from '../src/device/Device';
 import { deviceWalletSessionStore } from '../src/device/DeviceWalletSessionStore';
 
 jest.mock('../src/data/config', () => ({
@@ -26,7 +27,22 @@ const createDevice = ({
       passphraseProtection,
       attachToPinEnabled: false,
     },
-    commands: { typedCall, promptPassphrase },
+    commands: {
+      typedCall: jest.fn((request: string, ...args: unknown[]) => {
+        if (request === 'DeviceStatusGet') {
+          return {
+            message: {
+              device_id: 'device-1',
+              unlocked: true,
+              unlocked_attach_pin: false,
+              passphrase_enabled: passphraseProtection,
+            },
+          };
+        }
+        return typedCall(request, ...args);
+      }),
+      promptPassphrase,
+    },
     getDeviceState: jest.fn().mockResolvedValue({
       identity: { deviceId: 'device-1' },
       status: { passphraseProtection },
@@ -47,6 +63,12 @@ const createDevice = ({
     }),
     lockDevice: jest.fn(),
     unlockDevice: jest.fn(),
+    updateProtocolV2Status: jest.fn((status: Record<string, unknown>) => {
+      device.features.unlocked = status.unlocked ?? device.features.unlocked;
+      device.features.unlockedAttachPin =
+        status.unlocked_attach_pin ?? device.features.unlockedAttachPin;
+      return device.features;
+    }),
     initialize: jest.fn(),
     emit: jest.fn(),
     isProtocolV2: () => true,
@@ -79,7 +101,7 @@ describe('openWalletSession', () => {
     const typedCall = jest
       .fn()
       .mockResolvedValueOnce({ message: { version: 2 } })
-      .mockResolvedValueOnce({ message: { message: 'passphrase prepared' } })
+      .mockResolvedValueOnce({ message: {} })
       .mockResolvedValueOnce({
         message: {
           btc_test_address: 'pro2-wallet-state',
@@ -101,7 +123,7 @@ describe('openWalletSession', () => {
     expect(promptPassphrase).toHaveBeenCalledWith(
       {
         existsAttachPinUser: false,
-        deviceOnly: true,
+        deviceOnly: false,
         source: 'wallet-session-coordinator',
         reason: 'open-wallet',
       },
@@ -186,7 +208,7 @@ describe('openWalletSession', () => {
       protocol: 'V1',
       walletType: 'standard',
       deviceId: 'device-1',
-      passphraseState: null,
+      passphraseState: 'main-wallet-state',
       resumed: false,
     });
     expect(method.payload.useEmptyPassphrase).toBe(true);
@@ -200,7 +222,7 @@ describe('openWalletSession', () => {
     const typedCall = jest
       .fn()
       .mockResolvedValueOnce({ message: { version: 2 } })
-      .mockResolvedValueOnce({ message: { message: 'passphrase prepared' } })
+      .mockResolvedValueOnce({ message: {} })
       .mockResolvedValueOnce({
         message: {
           btc_test_address: 'hidden-state',
@@ -234,7 +256,7 @@ describe('openWalletSession', () => {
     const typedCall = jest
       .fn()
       .mockResolvedValueOnce({ message: { version: 2 } })
-      .mockResolvedValueOnce({ message: { message: 'passphrase prepared' } })
+      .mockResolvedValueOnce({ message: {} })
       .mockResolvedValueOnce({
         message: {
           btc_test_address: 'hidden-state-after-unlock',
@@ -267,7 +289,7 @@ describe('openWalletSession', () => {
       passphraseState: 'hidden-state-after-unlock',
       resumed: false,
     });
-    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Main);
+    expect(device.unlockDevice).not.toHaveBeenCalled();
     expect(promptPassphrase).toHaveBeenCalledTimes(1);
   });
 
@@ -275,7 +297,7 @@ describe('openWalletSession', () => {
     const typedCall = jest
       .fn()
       .mockResolvedValueOnce({ message: { version: 2 } })
-      .mockResolvedValueOnce({ message: { message: 'passphrase prepared' } })
+      .mockResolvedValueOnce({ message: {} })
       .mockResolvedValueOnce({
         message: {
           btc_test_address: 'new-hidden-state',
@@ -315,7 +337,7 @@ describe('openWalletSession', () => {
     const typedCall = jest
       .fn()
       .mockResolvedValueOnce({ message: { version: 2 } })
-      .mockResolvedValueOnce({ message: { message: 'passphrase prepared' } })
+      .mockResolvedValueOnce({ message: {} })
       .mockResolvedValueOnce({
         message: {
           btc_test_address: 'current-device-state',
@@ -484,8 +506,56 @@ describe('openWalletSession', () => {
     });
   });
 
+  test('rejects a Protocol V1 resume when the device returns another hidden wallet', async () => {
+    const typedCall = jest.fn().mockResolvedValue({
+      type: 'PassphraseState',
+      message: {
+        passphrase_state: 'other-hidden-state',
+        session_id: 'other-session',
+        unlocked_attach_pin: false,
+      },
+    });
+    const method = new OpenWalletSession({
+      payload: {
+        method: 'openWalletSession',
+        connectId: 'connect-id',
+        mode: 'resume-hidden',
+        deviceId: 'device-1',
+        passphraseState: 'hidden-state',
+      },
+    });
+    method.init();
+    deviceWalletSessionStore.set('device-1', 'hidden-state', 'known-session');
+    const device = createDevice({ typedCall });
+    device.isProtocolV2 = () => false;
+    device.features = {
+      ...device.features,
+      deviceId: 'device-1',
+      unlocked: true,
+      sessionId: null,
+    };
+    device.getCurrentFirmwareVersionString = () => '4.15.0';
+    device.getCurrentDeviceType = () => EDeviceType.Pro;
+    device.getFeatures = jest.fn();
+    method.device = device as any;
+
+    await expect(method.run()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.DeviceCheckPassphraseStateError,
+    });
+    expect(device.clearInternalState).toHaveBeenCalledTimes(1);
+    expect(deviceWalletSessionStore.get('device-1', 'hidden-state')).toBeUndefined();
+  });
+
   test('opens the standard wallet without selecting a hidden wallet', async () => {
-    const typedCall = jest.fn().mockResolvedValue({ message: { version: 2 } });
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ message: { version: 2 } })
+      .mockResolvedValueOnce({
+        message: {
+          btc_test_address: 'main-wallet-state',
+          session_id: 'main-wallet-session',
+        },
+      });
     const promptPassphrase = jest.fn();
     const method = new OpenWalletSession({
       payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'standard' },
@@ -499,19 +569,29 @@ describe('openWalletSession', () => {
       protocol: 'V2',
       walletType: 'standard',
       deviceId: 'device-1',
-      passphraseState: null,
+      passphraseState: 'main-wallet-state',
       resumed: false,
     });
-    expect(typedCall).toHaveBeenCalledTimes(1);
+    expect(typedCall).toHaveBeenCalledTimes(2);
     expect(typedCall).toHaveBeenCalledWith('ProtocolInfoRequest', 'ProtocolInfo', {
       eventless_wallet_session: true,
     });
+    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Main);
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
     expect(promptPassphrase).not.toHaveBeenCalled();
     expect(device.passphraseState).toBeUndefined();
   });
 
   test('opens a locked Protocol V2 standard wallet after deviceId becomes available', async () => {
-    const typedCall = jest.fn().mockResolvedValue({ message: { version: 2 } });
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ message: { version: 2 } })
+      .mockResolvedValueOnce({
+        message: {
+          btc_test_address: 'main-wallet-state',
+          session_id: 'main-wallet-session',
+        },
+      });
     const method = new OpenWalletSession({
       payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'standard' },
     });
@@ -538,21 +618,21 @@ describe('openWalletSession', () => {
       protocol: 'V2',
       walletType: 'standard',
       deviceId: 'device-1',
-      passphraseState: null,
+      passphraseState: 'main-wallet-state',
       resumed: false,
     });
-    expect(device.unlockDevice).toHaveBeenCalledTimes(1);
+    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Main);
     expect(device.getDeviceState).toHaveBeenCalledTimes(2);
   });
 
-  test('rejects a standard-wallet request when Protocol V2 is unlocked by Attach PIN', async () => {
+  test('switches from Attach PIN to Main PIN before opening the standard wallet', async () => {
     const typedCall = jest
       .fn()
       .mockResolvedValueOnce({ message: { version: 2 } })
       .mockResolvedValueOnce({
         message: {
-          btc_test_address: 'attach-wallet-state',
-          session_id: 'attach-wallet-session',
+          btc_test_address: 'main-wallet-state',
+          session_id: 'main-wallet-session',
         },
       });
     const method = new OpenWalletSession({
@@ -561,20 +641,25 @@ describe('openWalletSession', () => {
     method.init();
     const device = createDevice({ typedCall });
     device.features.unlockedAttachPin = true;
+    device.unlockDevice = jest.fn().mockImplementation(() => {
+      device.features.unlockedAttachPin = false;
+      return Promise.resolve(device.features);
+    });
     method.device = device as any;
 
-    await expect(method.run()).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.DeviceCheckUnlockTypeError,
+    await expect(method.run()).resolves.toMatchObject({
+      walletType: 'standard',
+      passphraseState: 'main-wallet-state',
     });
-    expect(device.lockDevice).toHaveBeenCalled();
-    expect(device.clearInternalState).toHaveBeenCalled();
+    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Main);
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
   });
 
   test('selects a hidden wallet without exposing the internal device session', async () => {
     const typedCall = jest
       .fn()
       .mockResolvedValueOnce({ message: { version: 2 } })
-      .mockResolvedValueOnce({ message: { message: 'passphrase prepared' } })
+      .mockResolvedValueOnce({ message: {} })
       .mockResolvedValueOnce({
         message: {
           btc_test_address: 'hidden-state',
@@ -606,11 +691,11 @@ describe('openWalletSession', () => {
     expect(deviceWalletSessionStore.get('device-1', 'hidden-state')).toBe('hidden-session');
   });
 
-  test('selects on-device passphrase entry before getting the prepared session', async () => {
+  test('gets the prepared session after on-device passphrase entry', async () => {
     const typedCall = jest
       .fn()
       .mockResolvedValueOnce({ message: { version: 2 } })
-      .mockResolvedValueOnce({ message: { message: 'passphrase prepared' } })
+      .mockResolvedValueOnce({ message: {} })
       .mockResolvedValueOnce({
         message: { btc_test_address: 'device-state', session_id: 'device-session' },
       });
@@ -635,7 +720,7 @@ describe('openWalletSession', () => {
     const typedCall = jest
       .fn()
       .mockResolvedValueOnce({ message: { version: 2 } })
-      .mockResolvedValueOnce({ message: { message: 'passphrase prepared' } })
+      .mockResolvedValueOnce({ message: {} })
       .mockResolvedValueOnce({
         message: { btc_test_address: 'host-state', session_id: 'host-session' },
       });
@@ -660,7 +745,7 @@ describe('openWalletSession', () => {
     expect(promptPassphrase).toHaveBeenCalledWith(
       {
         existsAttachPinUser: false,
-        deviceOnly: true,
+        deviceOnly: false,
         source: 'wallet-session-coordinator',
         reason: 'open-wallet',
       },
@@ -670,6 +755,52 @@ describe('openWalletSession', () => {
       passphrase: 'host hidden wallet',
       on_device: false,
     });
+    expect(typedCall).toHaveBeenNthCalledWith(3, 'DeviceSessionGet', 'DeviceSession', {});
+  });
+
+  test('normalizes a Unicode Host passphrase before sending it to Pro2 firmware', async () => {
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ message: { version: 2 } })
+      .mockResolvedValueOnce({ message: {} })
+      .mockResolvedValueOnce({
+        message: { btc_test_address: 'host-state', session_id: 'host-session' },
+      });
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'caf\u00e9' });
+    const method = new OpenWalletSession({
+      payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'select-hidden' },
+    });
+    method.init();
+    method.device = createDevice({ typedCall, promptPassphrase }) as any;
+
+    await expect(method.run()).resolves.toMatchObject({ passphraseState: 'host-state' });
+    expect(typedCall).toHaveBeenNthCalledWith(2, 'DeviceSessionAskPassphrase', 'Success', {
+      passphrase: 'cafe\u0301',
+      on_device: false,
+    });
+  });
+
+  test('accepts a Host passphrase at the 50-byte firmware boundary', async () => {
+    const passphrase = 'a'.repeat(50);
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ message: { version: 2 } })
+      .mockResolvedValueOnce({ message: {} })
+      .mockResolvedValueOnce({
+        message: { btc_test_address: 'host-state', session_id: 'host-session' },
+      });
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase });
+    const method = new OpenWalletSession({
+      payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'select-hidden' },
+    });
+    method.init();
+    method.device = createDevice({ typedCall, promptPassphrase }) as any;
+
+    await expect(method.run()).resolves.toMatchObject({ passphraseState: 'host-state' });
+    expect(typedCall).toHaveBeenNthCalledWith(2, 'DeviceSessionAskPassphrase', 'Success', {
+      passphrase,
+      on_device: false,
+    });
   });
 
   test('selects Attach PIN only when the device reports an existing binding', async () => {
@@ -695,7 +826,7 @@ describe('openWalletSession', () => {
     expect(promptPassphrase).toHaveBeenCalledWith(
       {
         existsAttachPinUser: true,
-        deviceOnly: true,
+        deviceOnly: false,
         source: 'wallet-session-coordinator',
         reason: 'open-wallet',
       },
@@ -705,6 +836,179 @@ describe('openWalletSession', () => {
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
   });
 
+  test('uses the complete Attach PIN wire flow without a main PIN unlock', async () => {
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ message: { version: 2 } })
+      .mockResolvedValueOnce({ message: { message: 'PIN verified' } })
+      .mockResolvedValueOnce({
+        message: { btc_test_address: 'attach-state', session_id: 'attach-session' },
+      });
+    const promptPassphrase = jest.fn().mockResolvedValue({ attachPinOnDevice: true });
+    const method = new OpenWalletSession({
+      payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'select-hidden' },
+    });
+    method.init();
+    const device = createDevice({ typedCall, promptPassphrase });
+    device.features.attachToPinEnabled = true;
+    device.unlockDevice = Device.prototype.unlockDevice.bind(device);
+    method.device = device as any;
+
+    await expect(method.run()).resolves.toMatchObject({
+      walletType: 'hidden',
+      passphraseState: 'attach-state',
+    });
+    expect(device.commands.typedCall.mock.calls).toEqual([
+      ['ProtocolInfoRequest', 'ProtocolInfo', { eventless_wallet_session: true }],
+      ['DeviceSessionAskPin', 'Success', { type: DeviceSessionPinType.AttachToPin }],
+      ['DeviceStatusGet', 'DeviceStatus', {}],
+      ['DeviceSessionGet', 'DeviceSession', {}],
+    ]);
+    expect(device.commands.typedCall).not.toHaveBeenCalledWith('DeviceSessionAskPin', 'Success', {
+      type: DeviceSessionPinType.Main,
+    });
+  });
+
+  test.each([
+    ['no selection', {}],
+    ['an empty Host passphrase', { passphrase: '' }],
+    ['more than one selection', { passphrase: 'host hidden wallet', passphraseOnDevice: true }],
+  ])('rejects %s before sending a wallet selection command', async (_name, response) => {
+    const typedCall = jest.fn().mockResolvedValueOnce({ message: { version: 2 } });
+    const promptPassphrase = jest.fn().mockResolvedValue(response);
+    const method = new OpenWalletSession({
+      payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'select-hidden' },
+    });
+    method.init();
+    method.device = createDevice({ typedCall, promptPassphrase }) as any;
+
+    await expect(method.run()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.RuntimeError,
+      message: 'Wallet selection must contain exactly one passphrase access mode.',
+    });
+    expect(typedCall).toHaveBeenCalledTimes(1);
+  });
+
+  test('stops before sending a wallet command when the App cancels selection', async () => {
+    const cancellation = new Error('Wallet selection cancelled');
+    const typedCall = jest.fn().mockResolvedValueOnce({ message: { version: 2 } });
+    const promptPassphrase = jest.fn().mockRejectedValue(cancellation);
+    const method = new OpenWalletSession({
+      payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'select-hidden' },
+    });
+    method.init();
+    method.device = createDevice({ typedCall, promptPassphrase }) as any;
+
+    await expect(method.run()).rejects.toBe(cancellation);
+    expect(typedCall).toHaveBeenCalledTimes(1);
+  });
+
+  test.each(['User cancelled', 'Device disconnected'])(
+    'does not issue a resume request after the wallet selection reports %s',
+    async message => {
+      const typedCall = jest
+        .fn()
+        .mockResolvedValueOnce({ message: { version: 2 } })
+        .mockRejectedValueOnce(new Error(message));
+      const promptPassphrase = jest.fn().mockResolvedValue({ passphraseOnDevice: true });
+      const method = new OpenWalletSession({
+        payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'select-hidden' },
+      });
+      method.init();
+      method.device = createDevice({ typedCall, promptPassphrase }) as any;
+
+      await expect(method.run()).rejects.toThrow(message);
+      expect(typedCall).toHaveBeenCalledTimes(2);
+      expect(typedCall).not.toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
+    }
+  );
+
+  test.each([
+    ['a NUL byte', 'hidden\0wallet'],
+    ['more than 50 UTF-8 bytes', 'a'.repeat(51)],
+    ['more than 50 UTF-8 bytes after NFKD normalization', '\u00e9'.repeat(17)],
+    ['an unpaired UTF-16 surrogate', '\ud800'],
+  ])('rejects a Host passphrase containing %s', async (_name, passphrase) => {
+    const typedCall = jest.fn().mockResolvedValueOnce({ message: { version: 2 } });
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase });
+    const method = new OpenWalletSession({
+      payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'select-hidden' },
+    });
+    method.init();
+    method.device = createDevice({ typedCall, promptPassphrase }) as any;
+
+    await expect(method.run()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.RuntimeError,
+      message: 'Host passphrase must contain 1 to 50 valid UTF-8 bytes without NUL.',
+    });
+    expect(typedCall).toHaveBeenCalledTimes(1);
+  });
+
+  test('rejects an unavailable Attach PIN selection before asking the device for a PIN', async () => {
+    const typedCall = jest.fn().mockResolvedValueOnce({ message: { version: 2 } });
+    const promptPassphrase = jest.fn().mockResolvedValue({ attachPinOnDevice: true });
+    const method = new OpenWalletSession({
+      payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'select-hidden' },
+    });
+    method.init();
+    const device = createDevice({ typedCall, promptPassphrase });
+    device.features.attachToPinEnabled = false;
+    method.device = device as any;
+
+    await expect(method.run()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.RuntimeError,
+      message: 'Attach PIN wallet selection is unavailable on this device.',
+    });
+    expect(device.unlockDevice).not.toHaveBeenCalled();
+    expect(typedCall).toHaveBeenCalledTimes(1);
+  });
+
+  test('unlocks and retries hidden-wallet preparation when the device is locked', async () => {
+    const lockedError = { errorCode: HardwareErrorCode.DeviceLocked };
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ message: { version: 2 } })
+      .mockRejectedValueOnce(lockedError)
+      .mockResolvedValueOnce({ message: {} })
+      .mockResolvedValueOnce({
+        message: { btc_test_address: 'hidden-state', session_id: 'hidden-session' },
+      });
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphraseOnDevice: true });
+    const method = new OpenWalletSession({
+      payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'select-hidden' },
+    });
+    method.init();
+    const device = createDevice({ typedCall, promptPassphrase });
+    method.device = device as any;
+
+    await expect(method.run()).resolves.toMatchObject({
+      walletType: 'hidden',
+      passphraseState: 'hidden-state',
+    });
+    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Main);
+    expect(typedCall).toHaveBeenCalledTimes(4);
+  });
+
+  test('does not fall back when wallet preparation is rejected', async () => {
+    const invalidSessionError = { errorCode: HardwareErrorCode.WalletSessionInvalid };
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ message: { version: 2 } })
+      .mockRejectedValueOnce(invalidSessionError);
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphraseOnDevice: true });
+    const method = new OpenWalletSession({
+      payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'select-hidden' },
+    });
+    method.init();
+    const device = createDevice({ typedCall, promptPassphrase });
+    method.device = device as any;
+
+    await expect(method.run()).rejects.toBe(invalidSessionError);
+    expect(promptPassphrase).toHaveBeenCalledTimes(1);
+    expect(typedCall).toHaveBeenCalledTimes(2);
+    expect(device.updateInternalState).not.toHaveBeenCalled();
+  });
+
   test.each([
     {
       missingField: 'session_id',
@@ -720,7 +1024,7 @@ describe('openWalletSession', () => {
       const typedCall = jest
         .fn()
         .mockResolvedValueOnce({ message: { version: 2 } })
-        .mockResolvedValueOnce({ message: { message: 'passphrase prepared' } })
+        .mockResolvedValueOnce({ message: {} })
         .mockResolvedValueOnce({ message });
       const promptPassphrase = jest.fn().mockResolvedValue({ passphraseOnDevice: true });
       const method = new OpenWalletSession({
@@ -732,7 +1036,7 @@ describe('openWalletSession', () => {
 
       await expect(method.run()).rejects.toMatchObject({
         errorCode: HardwareErrorCode.RuntimeError,
-        message: 'DeviceSessionGet returned an incomplete DeviceSession response.',
+        message: 'Device returned an incomplete DeviceSession response.',
       });
       expect(device.clearInternalState).toHaveBeenCalled();
       expect(device.updateInternalState).not.toHaveBeenCalled();

package/__tests__/pro2Wallpaper.test.ts

@@ -12,7 +12,7 @@ describe('encodePro2Wallpaper', () => {
     expect(Array.from(result.data.slice(0, 12))).toEqual([
       0x19, 0x12, 0, 0, 2, 0, 1, 0, 4, 0, 0, 0,
     ]);
-    expect(Array.from(result.data.slice(12))).toEqual([0x00, 0xf0, 0xc0, 0x07]);
+    expect(Array.from(result.data.slice(12))).toEqual([0x00, 0xf8, 0xe0, 0x07]);
   });
 
   test('encodes transparent pixels as RGB565A8 with alpha plane after RGB data', () => {