@onekeyfe/hd-core 1.2.2-alpha.5 → 1.2.2-alpha.7

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

@@ -8,6 +8,7 @@ import {
   isProtocolV2PeerRemovedPairingError,
   isRetryableBleConnectionError,
   isRetryableBleProtocolV2ProbeError,
+  resolveBleConnectProtocol,
 } from '../src/core';
 import { DataManager } from '../src/data-manager';
 import TransportManager from '../src/data-manager/TransportManager';
@@ -71,6 +72,19 @@ describe('public device lifecycle events', () => {
     jest.restoreAllMocks();
   });
 
+  test('prefers Protocol V2 only when the method contract is explicitly V2-only', () => {
+    const createMethod = (protocols: readonly ('V1' | 'V2')[], connectProtocol?: 'V1' | 'V2') =>
+      ({
+        payload: { connectProtocol },
+        getSupportedProtocols: () => protocols,
+      } as never);
+
+    expect(resolveBleConnectProtocol(createMethod(['V2']))).toBe('V2');
+    expect(resolveBleConnectProtocol(createMethod(['V1']))).toBeUndefined();
+    expect(resolveBleConnectProtocol(createMethod(['V1', 'V2']))).toBeUndefined();
+    expect(resolveBleConnectProtocol(createMethod(['V2'], 'V1'))).toBe('V1');
+  });
+
   test('registers the shared device lifecycle listeners exactly once', async () => {
     jest.spyOn(DataManager, 'getSettings').mockReturnValue('react-native' as never);
     core = initCore();

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

@@ -11,6 +11,13 @@ import {
   getProtocolV2WalletSession,
 } from '../src/protocols/protocol-v2/walletSession';
 
+const STANDARD_SEED_DOMAINS = [DeviceSessionSeedDomain.SeedDomain_Standard];
+const CARDANO_SEED_DOMAINS = [
+  DeviceSessionSeedDomain.SeedDomain_Standard,
+  DeviceSessionSeedDomain.SeedDomain_Cardano,
+];
+const standardSessionGet = {};
+
 jest.mock('../src/data/config', () => ({
   getSDKVersion: jest.fn(() => '1.0.0'),
   DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
@@ -144,7 +151,7 @@ describe('openWalletSession', () => {
       on_device: false,
       seed_domains: [DeviceSessionSeedDomain.SeedDomain_Standard],
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', standardSessionGet);
   });
 
   test('selects the Main PIN before opening the standard wallet when passphrase is disabled', async () => {
@@ -176,7 +183,7 @@ describe('openWalletSession', () => {
       'Success',
       expect.anything()
     );
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', standardSessionGet);
   });
 
   test('reuses a Main PIN selected by the current preflight when passphrase is disabled', async () => {
@@ -202,7 +209,7 @@ describe('openWalletSession', () => {
     });
 
     expect(device.unlockDevice).not.toHaveBeenCalled();
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', standardSessionGet);
   });
 
   test('does not treat an Attach PIN DeviceStatus as the Main wallet', async () => {
@@ -331,7 +338,12 @@ describe('openWalletSession', () => {
       on_device: false,
       seed_domains: [DeviceSessionSeedDomain.SeedDomain_Standard],
     });
-    expect(typedCall).toHaveBeenNthCalledWith(3, 'DeviceSessionGet', 'DeviceSession', {});
+    expect(typedCall).toHaveBeenNthCalledWith(
+      3,
+      'DeviceSessionGet',
+      'DeviceSession',
+      standardSessionGet
+    );
   });
 
   test('keeps Legacy Protocol V1 getPassphraseState parameterless', async () => {
@@ -450,7 +462,12 @@ describe('openWalletSession', () => {
       on_device: false,
       seed_domains: [DeviceSessionSeedDomain.SeedDomain_Standard],
     });
-    expect(typedCall).toHaveBeenNthCalledWith(3, 'DeviceSessionGet', 'DeviceSession', {});
+    expect(typedCall).toHaveBeenNthCalledWith(
+      3,
+      'DeviceSessionGet',
+      'DeviceSession',
+      standardSessionGet
+    );
   });
 
   test('refreshes Pro2 status and unlocks before selecting a hidden wallet when locked', async () => {
@@ -724,7 +741,11 @@ describe('openWalletSession', () => {
     });
     expect(promptPassphrase).not.toHaveBeenCalled();
     expect(device.unlockDevice).not.toHaveBeenCalled();
-    expect(device.commands.typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
+    expect(device.commands.typedCall).toHaveBeenCalledWith(
+      'DeviceSessionGet',
+      'DeviceSession',
+      standardSessionGet
+    );
     expect(device.commands.typedCall).not.toHaveBeenCalledWith(
       'DeviceSessionAskPassphrase',
       'Success',
@@ -822,7 +843,7 @@ describe('openWalletSession', () => {
       on_device: false,
       seed_domains: [DeviceSessionSeedDomain.SeedDomain_Standard],
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', standardSessionGet);
     expect(promptPassphrase).toHaveBeenCalled();
     expect(deviceWalletSessionStore.get('device-1', 'new-hidden-state')).toBe('new-hidden-session');
   });
@@ -894,6 +915,7 @@ describe('openWalletSession', () => {
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
       session_id: 'known-session',
       btc_test_address: 'hidden-state',
+      ...standardSessionGet,
     });
     expect(promptPassphrase).not.toHaveBeenCalled();
   });
@@ -1078,7 +1100,7 @@ describe('openWalletSession', () => {
       on_device: false,
       seed_domains: [DeviceSessionSeedDomain.SeedDomain_Standard],
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', standardSessionGet);
     expect(promptPassphrase).not.toHaveBeenCalled();
     expect(device.passphraseState).toBeUndefined();
   });
@@ -1247,7 +1269,7 @@ describe('openWalletSession', () => {
       reason: 'open-wallet',
       deviceOnly: true,
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', standardSessionGet);
   });
 
   test('selects a hidden wallet without exposing the internal device session', async () => {
@@ -1282,7 +1304,7 @@ describe('openWalletSession', () => {
       on_device: false,
       seed_domains: [DeviceSessionSeedDomain.SeedDomain_Standard],
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', standardSessionGet);
     expect(promptPassphrase).toHaveBeenCalled();
     expect(device.passphraseState).toBeUndefined();
     expect(deviceWalletSessionStore.get('device-1', 'hidden-state')).toBe('hidden-session');
@@ -1343,7 +1365,7 @@ describe('openWalletSession', () => {
       on_device: false,
       seed_domains: [DeviceSessionSeedDomain.SeedDomain_Standard],
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', standardSessionGet);
   });
 
   test('selects an on-device passphrase wallet with an explicit on_device request', async () => {
@@ -1390,7 +1412,12 @@ describe('openWalletSession', () => {
       on_device: true,
       seed_domains: [DeviceSessionSeedDomain.SeedDomain_Standard],
     });
-    expect(typedCall).toHaveBeenNthCalledWith(3, 'DeviceSessionGet', 'DeviceSession', {});
+    expect(typedCall).toHaveBeenNthCalledWith(
+      3,
+      'DeviceSessionGet',
+      'DeviceSession',
+      standardSessionGet
+    );
     expect(device.createProtocolV2UiPhaseMetadata).toHaveBeenNthCalledWith(
       2,
       'passphrase-on-device',
@@ -1443,7 +1470,12 @@ describe('openWalletSession', () => {
       on_device: false,
       seed_domains: [DeviceSessionSeedDomain.SeedDomain_Standard],
     });
-    expect(typedCall).toHaveBeenNthCalledWith(3, 'DeviceSessionGet', 'DeviceSession', {});
+    expect(typedCall).toHaveBeenNthCalledWith(
+      3,
+      'DeviceSessionGet',
+      'DeviceSession',
+      standardSessionGet
+    );
   });
 
   test('normalizes a Unicode Host passphrase before sending it to Pro2 firmware', async () => {
@@ -1525,7 +1557,7 @@ describe('openWalletSession', () => {
     expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.AttachToPin, {
       emitUiEvent: false,
     });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', standardSessionGet);
   });
 
   test('uses the complete Attach PIN wire flow without a main PIN unlock', async () => {
@@ -1554,7 +1586,7 @@ describe('openWalletSession', () => {
       ['ProtocolInfoRequest', 'ProtocolInfo', { eventless_wallet_session: true }],
       ['DeviceSessionAskPin', 'Success', { type: DeviceSessionPinType.AttachToPin }],
       ['DeviceStatusGet', 'DeviceStatus', {}],
-      ['DeviceSessionGet', 'DeviceSession', {}],
+      ['DeviceSessionGet', 'DeviceSession', standardSessionGet],
     ]);
     expect(device.commands.typedCall).not.toHaveBeenCalledWith('DeviceSessionAskPin', 'Success', {
       type: DeviceSessionPinType.Main,
@@ -1766,6 +1798,7 @@ describe('openWalletSession', () => {
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
       session_id: 'known-session',
       btc_test_address: 'hidden-state',
+      ...standardSessionGet,
     });
     expect(promptPassphrase).not.toHaveBeenCalled();
   });
@@ -1825,6 +1858,7 @@ describe('openWalletSession', () => {
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
       session_id: 'known-session',
       btc_test_address: 'hidden-state',
+      ...standardSessionGet,
     });
     const sessionGetCall = typedCall.mock.calls.findIndex(
       ([requestName]) => requestName === 'DeviceSessionGet'
@@ -1922,6 +1956,7 @@ describe('openWalletSession', () => {
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
       session_id: 'expired-session',
       btc_test_address: 'hidden-state',
+      ...standardSessionGet,
     });
     expect(promptPassphrase).toHaveBeenCalledTimes(1);
     expect(deviceWalletSessionStore.get('device-1', 'hidden-state')).toBe('renewed-session');
@@ -1959,6 +1994,7 @@ describe('openWalletSession', () => {
     });
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
       btc_test_address: 'hidden-state',
+      ...standardSessionGet,
     });
     expect(promptPassphrase).not.toHaveBeenCalled();
     expect(deviceWalletSessionStore.get('device-1', 'hidden-state')).toBe('new-session');
@@ -2000,7 +2036,11 @@ describe('openWalletSession', () => {
         on_device: false,
         seed_domains: [DeviceSessionSeedDomain.SeedDomain_Standard],
       });
-      expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
+      expect(typedCall).toHaveBeenCalledWith(
+        'DeviceSessionGet',
+        'DeviceSession',
+        standardSessionGet
+      );
     }
   );
 
@@ -2043,11 +2083,9 @@ describe('openWalletSession', () => {
     expect(typedCall).toHaveBeenCalledWith('DeviceSessionAskPassphrase', 'Success', {
       passphrase: 'host hidden wallet',
       on_device: false,
-      seed_domains: [
-        DeviceSessionSeedDomain.SeedDomain_Standard,
-        DeviceSessionSeedDomain.SeedDomain_Cardano,
-      ],
+      seed_domains: CARDANO_SEED_DOMAINS,
     });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', standardSessionGet);
   });
 
   test('asks Cardano seed domains after Get reports a Standard-only session', async () => {
@@ -2106,6 +2144,266 @@ describe('openWalletSession', () => {
     });
   });
 
+  test('uses empty AskPassphrase to add Cardano on an Attach PIN session', async () => {
+    const typedCall = jest.fn((request: string) => {
+      if (request === 'ProtocolInfoRequest') {
+        return { message: { version: 2 } };
+      }
+      if (request === 'DeviceSessionAskPassphrase') {
+        return { message: {} };
+      }
+      if (request === 'DeviceSessionGet') {
+        const askedCardano = typedCall.mock.calls.some(
+          call =>
+            call[0] === 'DeviceSessionAskPassphrase' &&
+            Array.isArray(call[2]?.seed_domains) &&
+            call[2].seed_domains.includes(DeviceSessionSeedDomain.SeedDomain_Cardano)
+        );
+        return {
+          message: {
+            btc_test_address: 'attach-state',
+            session_id: 'attach-session',
+            seed_domains: askedCardano ? CARDANO_SEED_DOMAINS : STANDARD_SEED_DOMAINS,
+          },
+        };
+      }
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'should-not-ask' });
+    const device = createDevice({
+      typedCall,
+      promptPassphrase,
+      unlockedAttachPin: true,
+    });
+
+    await expect(
+      getProtocolV2WalletSession(device as any, {
+        readCurrentAttachPinSession: true,
+        deriveCardano: true,
+      })
+    ).resolves.toMatchObject({
+      passphraseState: 'attach-state',
+      newSession: 'attach-session',
+      unlockedAttachPin: true,
+    });
+    expect(promptPassphrase).not.toHaveBeenCalled();
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionAskPassphrase', 'Success', {
+      passphrase: '',
+      on_device: false,
+      seed_domains: CARDANO_SEED_DOMAINS,
+    });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
+    expect(
+      typedCall.mock.calls
+        .filter(call => call[0] === 'DeviceSessionGet')
+        .every(call => !('seed_domains' in (call[2] ?? {})))
+    ).toBe(true);
+  });
+
+  test('uses empty AskPassphrase after selecting Attach PIN for Cardano intent', async () => {
+    const typedCall = jest.fn((request: string) => {
+      if (request === 'ProtocolInfoRequest') {
+        return { message: { version: 2 } };
+      }
+      if (request === 'DeviceSessionAskPassphrase') {
+        return { message: {} };
+      }
+      if (request === 'DeviceSessionGet') {
+        return {
+          message: {
+            btc_test_address: 'attach-state',
+            session_id: 'attach-session',
+            seed_domains: CARDANO_SEED_DOMAINS,
+          },
+        };
+      }
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const promptPassphrase = jest.fn().mockResolvedValue({ attachPinOnDevice: true });
+    const device = createDevice({ typedCall, promptPassphrase });
+    device.features.attachToPinEnabled = true;
+
+    await expect(
+      getProtocolV2WalletSession(device as any, {
+        forceWalletSelection: true,
+        deriveCardano: true,
+      })
+    ).resolves.toMatchObject({
+      passphraseState: 'attach-state',
+      newSession: 'attach-session',
+      unlockedAttachPin: true,
+    });
+    expect(promptPassphrase).toHaveBeenCalledTimes(1);
+    expect(device.unlockDevice).toHaveBeenCalledWith(
+      DeviceSessionPinType.AttachToPin,
+      expect.objectContaining({ emitUiEvent: false })
+    );
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionAskPassphrase', 'Success', {
+      passphrase: '',
+      on_device: false,
+      seed_domains: CARDANO_SEED_DOMAINS,
+    });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
+    expect(
+      typedCall.mock.calls
+        .filter(call => call[0] === 'DeviceSessionGet')
+        .every(call => !('seed_domains' in (call[2] ?? {})))
+    ).toBe(true);
+  });
+
+  test('still locks before a passphrase picker after Attach PIN Cardano empty Ask', async () => {
+    const typedCall = jest.fn((request: string) => {
+      if (request === 'ProtocolInfoRequest') {
+        return { message: { version: 2 } };
+      }
+      if (request === 'DeviceSessionAskPassphrase') {
+        return { message: {} };
+      }
+      if (request === 'DeviceSessionGet') {
+        return {
+          message: {
+            btc_test_address: 'attach-state',
+            session_id: 'attach-session',
+            seed_domains: CARDANO_SEED_DOMAINS,
+          },
+        };
+      }
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'should-not-ask' });
+    const device = createDevice({
+      typedCall,
+      promptPassphrase,
+      unlockedAttachPin: true,
+    });
+
+    await getProtocolV2WalletSession(device as any, {
+      readCurrentAttachPinSession: true,
+      deriveCardano: true,
+    });
+    await expect(
+      getProtocolV2WalletSession(device as any, { forceWalletSelection: true })
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.DeviceCheckUnlockTypeError,
+    });
+    expect(device.lockDevice).toHaveBeenCalled();
+    expect(promptPassphrase).not.toHaveBeenCalled();
+  });
+
+  test('uses a second Get for Cardano when passphrase protection is off', async () => {
+    const typedCall = jest.fn((request: string) => {
+      if (request === 'ProtocolInfoRequest') {
+        return { message: { version: 2 } };
+      }
+      if (request === 'DeviceSessionGet') {
+        const getCount = typedCall.mock.calls.filter(call => call[0] === 'DeviceSessionGet').length;
+        return {
+          message: {
+            btc_test_address: 'standard-state',
+            session_id: 'standard-session',
+            seed_domains: getCount > 1 ? CARDANO_SEED_DOMAINS : STANDARD_SEED_DOMAINS,
+          },
+        };
+      }
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const device = createDevice({
+      typedCall,
+      passphraseProtection: false,
+    });
+
+    await expect(
+      getProtocolV2WalletSession(device as any, {
+        onlyMainPin: true,
+        deriveCardano: true,
+      })
+    ).resolves.toMatchObject({
+      passphraseState: 'standard-state',
+      newSession: 'standard-session',
+    });
+    expect(typedCall).not.toHaveBeenCalledWith(
+      'DeviceSessionAskPassphrase',
+      'Success',
+      expect.anything()
+    );
+    expect(typedCall.mock.calls.filter(call => call[0] === 'DeviceSessionGet')).toHaveLength(2);
+    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {});
+  });
+
+  test('fails closed when Cardano fallback still lacks Cardano', async () => {
+    const typedCall = jest.fn((request: string) => {
+      if (request === 'ProtocolInfoRequest') {
+        return { message: { version: 2 } };
+      }
+      if (request === 'DeviceSessionAskPassphrase') {
+        return { message: {} };
+      }
+      if (request === 'DeviceSessionGet') {
+        return {
+          message: {
+            btc_test_address: 'hidden-state',
+            session_id: 'hidden-session',
+            seed_domains: STANDARD_SEED_DOMAINS,
+          },
+        };
+      }
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const device = createDevice({
+      typedCall,
+      promptPassphrase: jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' }),
+    });
+    deviceWalletSessionStore.set('device-1', 'hidden-state', 'cached-session');
+
+    await expect(
+      getProtocolV2WalletSession(device as any, {
+        expectedPassphraseState: 'hidden-state',
+        deriveCardano: true,
+      })
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.WalletSessionInvalid,
+    });
+    expect(device.clearInternalState).toHaveBeenCalled();
+  });
+
+  test('locks before selecting a passphrase wallet from an Attach PIN session', async () => {
+    const typedCall = jest.fn((request: string) => {
+      if (request === 'ProtocolInfoRequest') {
+        return { message: { version: 2 } };
+      }
+      if (request === 'DeviceStatusGet') {
+        return {
+          message: {
+            device_id: 'device-1',
+            unlocked: true,
+            passphrase_enabled: true,
+            unlocked_by_attach_to_pin: true,
+          },
+        };
+      }
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'should-not-ask' });
+    const device = createDevice({
+      typedCall,
+      promptPassphrase,
+      unlockedAttachPin: true,
+    });
+
+    await expect(
+      getProtocolV2WalletSession(device as any, { forceWalletSelection: true })
+    ).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.DeviceCheckUnlockTypeError,
+    });
+    expect(device.lockDevice).toHaveBeenCalled();
+    expect(promptPassphrase).not.toHaveBeenCalled();
+    expect(typedCall).not.toHaveBeenCalledWith(
+      'DeviceSessionAskPassphrase',
+      'Success',
+      expect.anything()
+    );
+  });
+
   test('asks Standard-only seed domains when deriveCardano is false', async () => {
     const typedCall = jest.fn((request: string) => {
       if (request === 'ProtocolInfoRequest') {

package/__tests__/pro2HostAssetPackage.test.ts

@@ -1,3 +1,4 @@
+/* eslint-disable no-bitwise -- LZ4 decoding and deterministic test data generation require bitwise operations. */
 import { sha3_512 } from '@noble/hashes/sha3';
 
 import {
@@ -5,6 +6,82 @@ import {
   supportsPro2HostAssetPackage,
 } from '../src/utils/pro2HostAssetPackage';
 
+const decodeRawLz4Block = (compressed: Uint8Array, expectedLength: number) => {
+  const output = new Uint8Array(expectedLength);
+  let inputOffset = 0;
+  let outputOffset = 0;
+
+  const readLength = (initialLength: number) => {
+    let length = initialLength;
+    if (length === 15) {
+      let extension = 255;
+      while (extension === 255) {
+        extension = compressed[inputOffset];
+        inputOffset += 1;
+        length += extension;
+      }
+    }
+    return length;
+  };
+
+  while (inputOffset < compressed.byteLength) {
+    const token = compressed[inputOffset];
+    inputOffset += 1;
+    const literalLength = readLength(token >>> 4);
+    output.set(compressed.subarray(inputOffset, inputOffset + literalLength), outputOffset);
+    inputOffset += literalLength;
+    outputOffset += literalLength;
+    if (inputOffset >= compressed.byteLength) break;
+
+    const matchOffset = compressed[inputOffset] | (compressed[inputOffset + 1] << 8);
+    inputOffset += 2;
+    const matchLength = readLength(token & 0x0f) + 4;
+    for (let index = 0; index < matchLength; index += 1) {
+      output[outputOffset] = output[outputOffset - matchOffset];
+      outputOffset += 1;
+    }
+  }
+
+  expect(outputOffset).toBe(expectedLength);
+  return output;
+};
+
+const decodeFirstPackageEntry = (packageData: Uint8Array, rawLength: number) => {
+  const containerHeaderSize = 0x5f90;
+  const archive = packageData.subarray(containerHeaderSize);
+  const archiveView = new DataView(archive.buffer, archive.byteOffset, archive.byteLength);
+  const compressedOffset = archiveView.getUint32(42 + 0x100, true);
+  const compressed = archive.subarray(compressedOffset);
+  const compressedView = new DataView(
+    compressed.buffer,
+    compressed.byteOffset,
+    compressed.byteLength
+  );
+  const blockCount = compressedView.getUint16(0, true);
+  const blockSize = 1 << compressedView.getUint16(2, true);
+  let blockOffset = 8 + blockCount * 4;
+  const decodedBlocks: Uint8Array[] = [];
+
+  for (let index = 0; index < blockCount; index += 1) {
+    const compressedLength = compressedView.getUint32(8 + index * 4, true);
+    const expectedLength = Math.min(blockSize, rawLength - index * blockSize);
+    decodedBlocks.push(
+      decodeRawLz4Block(
+        compressed.subarray(blockOffset, blockOffset + compressedLength),
+        expectedLength
+      )
+    );
+    blockOffset += compressedLength;
+  }
+
+  const decoded = new Uint8Array(rawLength);
+  decodedBlocks.reduce((offset, block) => {
+    decoded.set(block, offset);
+    return offset + block.byteLength;
+  }, 0);
+  return decoded;
+};
+
 describe('Pro2 host asset package', () => {
   test('builds the unsigned RESOURCE container and LZ4-blocked archive expected by firmware', () => {
     const raw = new TextEncoder().encode('123456789');
@@ -40,12 +117,42 @@ describe('Pro2 host asset package', () => {
 
     const compressedOffset = archiveView.getUint32(42 + 0x100, true);
     expect(archiveView.getUint16(compressedOffset, true)).toBe(1);
-    expect(archiveView.getUint16(compressedOffset + 2, true)).toBe(12);
+    expect(archiveView.getUint16(compressedOffset + 2, true)).toBe(14);
     expect(archiveView.getUint32(compressedOffset + 4, true)).toBe(0);
     expect(archiveView.getUint32(compressedOffset + 8, true)).toBe(10);
     expect(payload.subarray(compressedOffset + 12)).toEqual(new Uint8Array([0x90, ...raw]));
   });
 
+  test('round-trips multi-block data byte-for-byte with best-match compression', () => {
+    const raw = Uint8Array.from({ length: 16_384 * 3 + 137 }, (_, index) => {
+      const column = index % 604;
+      const row = Math.floor(index / 604);
+      return (column * 31 + row * 17) & 0xff;
+    });
+
+    const packageData = buildPro2HostAssetPackage([{ name: 'wallpaper.bin', data: raw }]);
+
+    expect(decodeFirstPackageEntry(packageData, raw.byteLength)).toEqual(raw);
+  });
+
+  test('falls back to 8 KiB blocks when a compressed 16 KiB block exceeds firmware capacity', () => {
+    let state = 0x12345678;
+    const raw = Uint8Array.from({ length: 16_384 }, () => {
+      state ^= state << 13;
+      state ^= state >>> 17;
+      state ^= state << 5;
+      return state & 0xff;
+    });
+
+    const packageData = buildPro2HostAssetPackage([{ name: 'wallpaper.bin', data: raw }]);
+    const archive = packageData.subarray(0x5f90);
+    const archiveView = new DataView(archive.buffer, archive.byteOffset, archive.byteLength);
+    const compressedOffset = archiveView.getUint32(42 + 0x100, true);
+
+    expect(archiveView.getUint16(compressedOffset + 2, true)).toBe(13);
+    expect(decodeFirstPackageEntry(packageData, raw.byteLength)).toEqual(raw);
+  });
+
   test.each([
     ['1.0.0', false],
     ['1.0.1-beta.1', false],