@onekeyfe/hd-core 1.2.1 → 1.2.2-alpha.1

package/__tests__/deviceUploadNft.test.ts

@@ -32,10 +32,12 @@ const createMethod = ({
   typedCall,
   supportedMessages = [60802, 60805, 60808, 61500],
   useFullBundle = false,
+  firmwareVersion = '1.0.0',
 }: {
   typedCall: jest.Mock;
   supportedMessages?: number[];
   useFullBundle?: boolean;
+  firmwareVersion?: string;
 }) => {
   const method = new DeviceUploadNft({
     id: 1,
@@ -52,6 +54,7 @@ const createMethod = ({
   });
   (method as any).device = {
     commands: { typedCall },
+    state: { versions: { firmware: firmwareVersion } },
     ensureProtocolV2RuntimeContext: jest.fn(() =>
       Promise.resolve({
         version: 2,
@@ -60,6 +63,7 @@ const createMethod = ({
       })
     ),
     getCurrentFirmwareType: jest.fn(),
+    getCurrentFirmwareVersionString: jest.fn(() => firmwareVersion),
   };
   method.postMessage = jest.fn();
 
@@ -202,6 +206,70 @@ describe('DeviceUploadNft', () => {
     });
   });
 
+  test('uploads one host asset package on firmware 1.0.1', async () => {
+    const typedCall = jest.fn((request: string, _response: string, params: any) => {
+      if (request === 'FilesystemFileWrite') return fileWriteSuccess(params);
+      if (request === 'NftUpdate') return { message: { message: 'NFT updated' } };
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const method = createMethod({
+      typedCall,
+      supportedMessages: [60805, 61500],
+      firmwareVersion: '1.0.1',
+    });
+
+    const result = await method.run();
+
+    const requests = typedCall.mock.calls.map(call => call[0]);
+    expect(requests).not.toContain('FilesystemPathInfoQuery');
+    expect(requests).not.toContain('FilesystemDirList');
+    const fileWrites = typedCall.mock.calls.filter(call => call[0] === 'FilesystemFileWrite');
+    expect(new Set(fileWrites.map(call => call[2].file.path))).toEqual(
+      new Set(['vol1:/nft/nft-deadbeef-1760000000000.okpkg'])
+    );
+    expect(fileWrites[0][2].file.data.subarray(0, 4)).toEqual(
+      new Uint8Array([0x4f, 0x4b, 0x50, 0x50])
+    );
+    expect(typedCall).toHaveBeenLastCalledWith(
+      'NftUpdate',
+      'Success',
+      { file_name_no_ext: result.basename },
+      { timeoutMs: 15_000 }
+    );
+    expect(result).toMatchObject({
+      imagePath: 'vol1:/nft/nft-deadbeef-1760000000000.bin',
+      thumbnailPath: 'vol1:/nft/nft-deadbeef-1760000000000_m.bin',
+      metadataPath: 'vol1:/nft/nft-deadbeef-1760000000000.json',
+      nftUpdated: true,
+    });
+  });
+
+  test('keeps the legacy upload flow on a 1.0.1 prerelease', async () => {
+    const typedCall = jest.fn((request: string, _response: string, params: any) => {
+      if (request === 'FilesystemPathInfoQuery') {
+        return { message: { exist: true, directory: true } };
+      }
+      if (request === 'FilesystemDirList') {
+        return { message: { path: 'vol1:/nft', child_files: '' } };
+      }
+      if (request === 'FilesystemFileWrite') return fileWriteSuccess(params);
+      if (request === 'NftUpdate') return { message: {} };
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const method = createMethod({ typedCall, firmwareVersion: '1.0.1-beta.1' });
+
+    await method.run();
+
+    const requests = typedCall.mock.calls.map(call => call[0]);
+    expect(requests).toContain('FilesystemPathInfoQuery');
+    expect(requests).toContain('FilesystemDirList');
+    const paths = typedCall.mock.calls
+      .filter(call => call[0] === 'FilesystemFileWrite')
+      .map(call => call[2].file.path as string);
+    expect(paths.some(path => path.endsWith('.okpkg'))).toBe(false);
+    expect(paths).toContain('vol1:/nft/nft-deadbeef-1760000000000.bin');
+  });
+
   test('treats a missing NFT directory as empty before the first upload', async () => {
     const typedCall = jest.fn((request: string, _response: string, params: any) => {
       if (request === 'FilesystemPathInfoQuery') {

package/__tests__/evmSignTypedData.test.ts

@@ -1,3 +1,5 @@
+import { EDeviceType } from '@onekeyfe/hd-shared';
+
 import EVMSignTypedData from '../src/api/evm/EVMSignTypedData';
 
 import type { EthereumSignTypedDataMessage, EthereumSignTypedDataTypes } from '../src/types';
@@ -577,3 +579,43 @@ describe('EVMSignTypedData — OneKey Pro Safe Protocol V1', () => {
     });
   });
 });
+
+describe('EVMSignTypedData — Protocol V2 data size routing', () => {
+  const buildSafeTxData = (
+    dataSize: number
+  ): EthereumSignTypedDataMessage<EthereumSignTypedDataTypes> =>
+    ({
+      types: {
+        EIP712Domain: [],
+        SafeTx: [{ name: 'data', type: 'bytes' }],
+      },
+      primaryType: 'SafeTx',
+      domain: {},
+      message: { data: `0x${'ab'.repeat(dataSize)}` },
+    } as EthereumSignTypedDataMessage<EthereumSignTypedDataTypes>);
+
+  test.each([EDeviceType.Pro2, EDeviceType.Neo])(
+    'keeps SafeTx data up to 1536 bytes on the structured route for %s',
+    deviceType => {
+      const data = buildSafeTxData(1316);
+      const method = createMethod(data);
+      method.device.getCurrentDeviceType = jest.fn(() => deviceType);
+      method.device.getCurrentFirmwareVersionString = jest.fn(() => '1.0.0');
+
+      expect(method.hasBiggerData(data)).toBe(false);
+      expect(method.hasBiggerData(buildSafeTxData(1536))).toBe(false);
+    }
+  );
+
+  test.each([EDeviceType.Pro2, EDeviceType.Neo])(
+    'falls back to the hash route above 1536 bytes for %s',
+    deviceType => {
+      const data = buildSafeTxData(1537);
+      const method = createMethod(data);
+      method.device.getCurrentDeviceType = jest.fn(() => deviceType);
+      method.device.getCurrentFirmwareVersionString = jest.fn(() => '1.0.0');
+
+      expect(method.hasBiggerData(data)).toBe(true);
+    }
+  );
+});

package/__tests__/pro2HostAssetPackage.test.ts

@@ -0,0 +1,58 @@
+import { sha3_512 } from '@noble/hashes/sha3';
+
+import {
+  buildPro2HostAssetPackage,
+  supportsPro2HostAssetPackage,
+} from '../src/utils/pro2HostAssetPackage';
+
+describe('Pro2 host asset package', () => {
+  test('builds the unsigned RESOURCE container and LZ4-blocked archive expected by firmware', () => {
+    const raw = new TextEncoder().encode('123456789');
+    const packageData = buildPro2HostAssetPackage([{ name: 'wallpaper.bin', data: raw }]);
+    const headerSize = 0x5f90;
+    const payload = packageData.subarray(headerSize);
+    const packageView = new DataView(
+      packageData.buffer,
+      packageData.byteOffset,
+      packageData.byteLength
+    );
+
+    expect(packageView.getUint32(0, true)).toBe(0x50504b4f);
+    expect(packageView.getUint32(4, true)).toBe(1);
+    expect(packageView.getUint32(8, true)).toBe(0x43534552);
+    expect(packageView.getUint32(0x0c, true)).toBe(headerSize);
+    expect(packageView.getUint32(0x10, true)).toBe(1);
+    expect(packageView.getUint32(0x14, true)).toBe(payload.byteLength);
+    expect(packageData.subarray(0x200, 0x240)).toEqual(sha3_512(payload));
+    expect(packageData.subarray(0x240, 0x280)).toEqual(sha3_512(packageData.subarray(0, 0x240)));
+    expect(packageData[0x400]).toBe(0);
+    expect(packageView.getUint32(0x408, true)).toBe(0x71717171);
+
+    const archiveView = new DataView(payload.buffer, payload.byteOffset, payload.byteLength);
+    expect(archiveView.getUint32(0, true)).toBe(0x52414b4f);
+    expect(archiveView.getUint32(4, true)).toBe(1);
+    expect(archiveView.getUint16(8, true)).toBe(1);
+    expect(new TextDecoder().decode(payload.subarray(43, 56))).toBe('wallpaper.bin');
+    expect(archiveView.getUint32(42 + 0x100, true)).toBe(340);
+    expect(archiveView.getUint32(42 + 0x104, true)).toBe(raw.byteLength);
+    expect(archiveView.getUint32(42 + 0x10c, true)).toBe(0xcbf43926);
+    expect(payload[42 + 0x114]).toBe(1);
+
+    const compressedOffset = archiveView.getUint32(42 + 0x100, true);
+    expect(archiveView.getUint16(compressedOffset, true)).toBe(1);
+    expect(archiveView.getUint16(compressedOffset + 2, true)).toBe(12);
+    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.each([
+    ['1.0.0', false],
+    ['1.0.1-beta.1', false],
+    ['1.0.1', true],
+    ['1.1.0', true],
+    [undefined, false],
+  ])('selects package uploads for firmware %s', (firmwareVersion, expected) => {
+    expect(supportsPro2HostAssetPackage(firmwareVersion)).toBe(expected);
+  });
+});

package/__tests__/protocol-v2.test.ts

@@ -254,6 +254,88 @@ describe('DeviceUploadWallpaper', () => {
     });
   });
 
+  test('uploads and applies the fixed wallpaper package on firmware 1.0.1', async () => {
+    const typedCall = jest.fn().mockImplementation((request, _response, params) => {
+      if (request === 'FilesystemDirMake') return { message: {} };
+      if (request === 'FilesystemFileWrite') {
+        const file = params.file as { data: Uint8Array; offset: number };
+        return { message: { processed_byte: file.offset + file.data.byteLength } };
+      }
+      if (request === 'DeviceSettingsSet') {
+        return { message: { message: 'wallpaper applied' } };
+      }
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const method = new DeviceUploadWallpaper({
+      id: 1,
+      payload: {
+        method: 'deviceUploadWallpaper',
+        jpegBase64: createJpegBase64(604, 1024),
+        fileName: 'ignored-on-package-firmware.bin',
+      },
+    });
+    const device = stubWallpaperDevice({
+      commands: { typedCall },
+      state: { versions: { firmware: '1.0.1' } },
+      getCurrentFirmwareVersionString: jest.fn(() => '1.0.1'),
+    });
+    (method as any).device = device;
+    method.postMessage = jest.fn();
+
+    method.init();
+    const result = await method.run();
+
+    const fileWrites = typedCall.mock.calls.filter(call => call[0] === 'FilesystemFileWrite');
+    expect(new Set(fileWrites.map(call => call[2].file.path))).toEqual(
+      new Set(['vol1:/wallpapers/wallpaper.okpkg'])
+    );
+    expect(fileWrites[0][2].file.data.subarray(0, 4)).toEqual(
+      new Uint8Array([0x4f, 0x4b, 0x50, 0x50])
+    );
+    expect(typedCall).toHaveBeenLastCalledWith('DeviceSettingsSet', 'Success', {
+      settings: { wallpaper_path: 'vol1:/wallpapers/wallpaper.okpkg' },
+    });
+    expect(result).toMatchObject({
+      path: 'vol1:/wallpapers/wallpaper.okpkg',
+      colorFormat: 'RGB565',
+      message: 'wallpaper applied',
+    });
+  });
+
+  test('keeps the legacy wallpaper path on a 1.0.1 prerelease', async () => {
+    const typedCall = jest.fn().mockImplementation((request, _response, params) => {
+      if (request === 'FilesystemDirMake') return { message: {} };
+      if (request === 'FilesystemFileWrite') {
+        const file = params.file as { data: Uint8Array; offset: number };
+        return { message: { processed_byte: file.offset + file.data.byteLength } };
+      }
+      if (request === 'DeviceSettingsSet') return { message: {} };
+      throw new Error(`Unexpected request: ${request}`);
+    });
+    const method = new DeviceUploadWallpaper({
+      id: 1,
+      payload: {
+        method: 'deviceUploadWallpaper',
+        jpegBase64: createJpegBase64(604, 1024),
+        fileName: 'prerelease-wallpaper.bin',
+      },
+    });
+    const device = stubWallpaperDevice({
+      commands: { typedCall },
+      state: { versions: { firmware: '1.0.1-beta.1' } },
+    });
+    (method as any).device = device;
+
+    method.init();
+    const result = await method.run();
+
+    expect(result.path).toBe('vol1:/wallpapers/prerelease-wallpaper.bin');
+    const fileWrites = typedCall.mock.calls.filter(call => call[0] === 'FilesystemFileWrite');
+    expect(new Set(fileWrites.map(call => call[2].file.path))).toEqual(
+      new Set(['vol1:/wallpapers/prerelease-wallpaper.bin'])
+    );
+  });
+
   test('文件上传失败时不修改 wallpaper_path', async () => {
     const typedCall = jest.fn().mockImplementation(request => {
       if (request === 'FilesystemDirMake') return { message: {} };

package/dist/api/evm/EVMSignTypedData.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EVMSignTypedData.d.ts","sourceRoot":"","sources":["../../../src/api/evm/EVMSignTypedData.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAI3C,OAAO,EAEL,KAAK,4BAA4B,EACjC,KAAK,0BAA0B,EAChC,MAAM,aAAa,CAAC;AAQrB,OAAO,KAAK,EAIV,UAAU,EACV,eAAe,EACf,SAAS,EACV,MAAM,wBAAwB,CAAC;AAShC,MAAM,MAAM,sBAAsB,GAAG;IACnC,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,IAAI,EAAE,4BAA4B,CAAC,0BAA0B,CAAC,CAAC;IAC/D,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAUF,MAAM,CAAC,OAAO,OAAO,gBAAiB,SAAQ,UAAU,CAAC,sBAAsB,CAAC;IAC9E,qBAAqB;IAIrB,IAAI;IAuCE,mBAAmB,CAAC,EACxB,SAAS,EACT,QAAQ,EACR,QAAQ,EACR,aAAa,GACd,EAAE;QACD,SAAS,EAAE,SAAS,CAAC;QACrB,QAAQ,EAAE,4BAA4B,CAAC,0BAA0B,CAAC,CAAC;QACnE,QAAQ,EAAE,eAAe,CAAC,UAAU,CAAC,CAAC;QACtC,aAAa,EAAE,OAAO,CAAC;KACxB;;;;IAoKK,aAAa;;;;IAgCnB,aAAa,CAAC,EACZ,SAAS,EACT,QAAQ,EACR,OAAO,EACP,UAAU,EACV,WAAW,GACZ,EAAE;QACD,SAAS,EAAE,SAAS,CAAC;QACrB,QAAQ,EAAE,MAAM,EAAE,CAAC;QACnB,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;QAC5B,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;QAC/B,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;KACjC;IAuBD,eAAe;;;;;IAQf,aAAa,CAAC,IAAI,EAAE,4BAA4B,CAAC,0BAA0B,CAAC;IAuB5E,eAAe,CAAC,IAAI,EAAE,GAAG,GAAG,OAAO;IA8BnC,yCAAyC,CACvC,IAAI,EAAE,4BAA4B,CAAC,0BAA0B,CAAC;IAuIhE,gBAAgB;IAcV,GAAG;CAgFV"}
+{"version":3,"file":"EVMSignTypedData.d.ts","sourceRoot":"","sources":["../../../src/api/evm/EVMSignTypedData.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAI3C,OAAO,EAEL,KAAK,4BAA4B,EACjC,KAAK,0BAA0B,EAChC,MAAM,aAAa,CAAC;AAQrB,OAAO,KAAK,EAIV,UAAU,EACV,eAAe,EACf,SAAS,EACV,MAAM,wBAAwB,CAAC;AAShC,MAAM,MAAM,sBAAsB,GAAG;IACnC,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,IAAI,EAAE,4BAA4B,CAAC,0BAA0B,CAAC,CAAC;IAC/D,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAUF,MAAM,CAAC,OAAO,OAAO,gBAAiB,SAAQ,UAAU,CAAC,sBAAsB,CAAC;IAC9E,qBAAqB;IAIrB,IAAI;IAuCE,mBAAmB,CAAC,EACxB,SAAS,EACT,QAAQ,EACR,QAAQ,EACR,aAAa,GACd,EAAE;QACD,SAAS,EAAE,SAAS,CAAC;QACrB,QAAQ,EAAE,4BAA4B,CAAC,0BAA0B,CAAC,CAAC;QACnE,QAAQ,EAAE,eAAe,CAAC,UAAU,CAAC,CAAC;QACtC,aAAa,EAAE,OAAO,CAAC;KACxB;;;;IAoKK,aAAa;;;;IAgCnB,aAAa,CAAC,EACZ,SAAS,EACT,QAAQ,EACR,OAAO,EACP,UAAU,EACV,WAAW,GACZ,EAAE;QACD,SAAS,EAAE,SAAS,CAAC;QACrB,QAAQ,EAAE,MAAM,EAAE,CAAC;QACnB,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;QAC5B,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;QAC/B,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;KACjC;IAuBD,eAAe;;;;;IAQf,aAAa,CAAC,IAAI,EAAE,4BAA4B,CAAC,0BAA0B,CAAC;IAwB5E,eAAe,CAAC,IAAI,EAAE,GAAG,GAAG,OAAO;IA8BnC,yCAAyC,CACvC,IAAI,EAAE,4BAA4B,CAAC,0BAA0B,CAAC;IAuIhE,gBAAgB;IAcV,GAAG;CAgFV"}

package/dist/api/protocol-v2/DeviceUploadNft.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DeviceUploadNft.d.ts","sourceRoot":"","sources":["../../../src/api/protocol-v2/DeviceUploadNft.ts"],"names":[],"mappings":"AAsBA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAK3C,MAAM,MAAM,qBAAqB,GAAG;IAClC,eAAe,EAAE,MAAM,CAAC;IACxB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,IAAI,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAOF,MAAM,CAAC,OAAO,OAAO,eAAgB,SAAQ,UAAU,CAAC,qBAAqB,CAAC;IAC5E,OAAO,CAAC,MAAM,CAAC,CAAgB;IAE/B,qBAAqB;IAIrB,IAAI;YAgFU,kBAAkB;YAiBlB,qBAAqB;YAwBrB,SAAS;IASjB,GAAG,IAAI,OAAO,CAAC,uBAAuB,CAAC;CA0D9C"}
+{"version":3,"file":"DeviceUploadNft.d.ts","sourceRoot":"","sources":["../../../src/api/protocol-v2/DeviceUploadNft.ts"],"names":[],"mappings":"AA0BA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAK3C,MAAM,MAAM,qBAAqB,GAAG;IAClC,eAAe,EAAE,MAAM,CAAC;IACxB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,QAAQ,EAAE,MAAM,CAAC;IAEjB,SAAS,EAAE,MAAM,CAAC;IAElB,aAAa,EAAE,MAAM,CAAC;IAEtB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,IAAI,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAOF,MAAM,CAAC,OAAO,OAAO,eAAgB,SAAQ,UAAU,CAAC,qBAAqB,CAAC;IAC5E,OAAO,CAAC,MAAM,CAAC,CAAgB;IAE/B,qBAAqB;IAIrB,IAAI;YAgFU,kBAAkB;YAiBlB,qBAAqB;YAwBrB,SAAS;IASjB,GAAG,IAAI,OAAO,CAAC,uBAAuB,CAAC;CA0E9C"}

package/dist/api/protocol-v2/DeviceUploadWallpaper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DeviceUploadWallpaper.d.ts","sourceRoot":"","sources":["../../../src/api/protocol-v2/DeviceUploadWallpaper.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAO3C,OAAO,EAGL,KAAK,wBAAwB,EAE9B,MAAM,2BAA2B,CAAC;AAEnC,MAAM,MAAM,2BAA2B,GAAG;IACxC,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,6BAA6B,GAAG;IAC1C,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,wBAAwB,CAAC;IACtC,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAmBF,MAAM,CAAC,OAAO,OAAO,qBAAsB,SAAQ,UAAU,CAAC,2BAA2B,CAAC;IACxF,qBAAqB;IAIrB,OAAO,CAAC,OAAO,CAAC,CAA8D;IAE9E,OAAO,CAAC,cAAc,CAAS;IAE/B,OAAO,CAAC,QAAQ,CAAS;IAEzB,OAAO,CAAC,IAAI,CAAM;IAElB,IAAI;YA2BU,kBAAkB;YAgBlB,eAAe;YAaf,MAAM;IAwBd,GAAG,IAAI,OAAO,CAAC,6BAA6B,CAAC;CAyBpD"}
+{"version":3,"file":"DeviceUploadWallpaper.d.ts","sourceRoot":"","sources":["../../../src/api/protocol-v2/DeviceUploadWallpaper.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAO3C,OAAO,EAGL,KAAK,wBAAwB,EAE9B,MAAM,2BAA2B,CAAC;AAMnC,MAAM,MAAM,2BAA2B,GAAG;IACxC,UAAU,EAAE,MAAM,CAAC;IAKnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,6BAA6B,GAAG;IAK1C,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,wBAAwB,CAAC;IACtC,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAqBF,MAAM,CAAC,OAAO,OAAO,qBAAsB,SAAQ,UAAU,CAAC,2BAA2B,CAAC;IACxF,qBAAqB;IAIrB,OAAO,CAAC,OAAO,CAAC,CAA8D;IAE9E,OAAO,CAAC,cAAc,CAAS;IAE/B,OAAO,CAAC,QAAQ,CAAS;IAEzB,OAAO,CAAC,IAAI,CAAM;IAElB,IAAI;YA2BU,kBAAkB;YAgBlB,eAAe;YAaf,MAAM;IAsBd,GAAG,IAAI,OAAO,CAAC,6BAA6B,CAAC;CAgCpD"}

package/dist/index.d.ts

@@ -1127,10 +1127,18 @@ declare function encodePro2Wallpaper(options: {
 
 type DeviceUploadWallpaperParams = {
     jpegBase64: string;
+    /**
+     * Legacy firmware uses this name for the uploaded `.bin` file. Firmware
+     * 1.0.1+ always consumes the fixed `wallpaper.okpkg` package path.
+     */
     fileName?: string;
     chunkSize?: number;
 };
 type DeviceUploadWallpaperResponse = {
+    /**
+     * Filesystem path sent to `DeviceSettingsSet`. On firmware 1.0.1+ this is
+     * the temporary package path; firmware extracts and persists wallpaper.bin.
+     */
     path: string;
     size: number;
     colorFormat: Pro2WallpaperColorFormat;
@@ -1149,8 +1157,11 @@ type DeviceUploadNftParams = {
 };
 type DeviceUploadNftResponse = {
     basename: string;
+    /** Final image path after firmware extracts a host-asset package. */
     imagePath: string;
+    /** Final thumbnail path after firmware extracts a host-asset package. */
     thumbnailPath: string;
+    /** Final metadata path after firmware extracts a host-asset package. */
     metadataPath: string;
     totalSize: number;
     nftUpdated: true;

package/dist/index.js

@@ -42623,7 +42623,7 @@ function invalidParameter$2(message) {
 function asBytes(rgba) {
     return rgba instanceof Uint8Array ? rgba : new Uint8Array(rgba);
 }
-function align(value, boundary) {
+function align$1(value, boundary) {
     return Math.ceil(value / boundary) * boundary;
 }
 function encodePro2Image(options) {
@@ -42651,7 +42651,7 @@ function encodePro2Image(options) {
         }
     }
     const colorFormat = hasTransparency ? 'RGB565A8' : 'RGB565';
-    const stride = align(width * 2, 4);
+    const stride = align$1(width * 2, 4);
     const alphaStride = stride / 2;
     const rgbSize = stride * height;
     const alphaSize = hasTransparency ? alphaStride * height : 0;
@@ -54612,7 +54612,234 @@ function decodeJpegBase64ToRgba({ jpegBase64, parameterName, expectedWidth, expe
     return decoded;
 }
 
+const PRO2_HOST_ASSET_PACKAGE_MIN_VERSION = '1.0.1';
+const CONTAINER_HEADER_SIZE = 0x5f90;
+const CONTAINER_HEADER_HASH_INPUT_LENGTH = 0x240;
+const CONTAINER_HASH_SECTION_OFFSET = 0x200;
+const CONTAINER_SIGNATURE_ALGORITHM_OFFSET = 0x408;
+const CONTAINER_HEADER_MAGIC = 0x50504b4f;
+const CONTAINER_HEADER_VERSION = 1;
+const CONTAINER_RESOURCE_TYPE_MAGIC = 0x43534552;
+const CONTAINER_ED25519_SIGNATURE_ALGORITHM = 0x71717171;
+const HOST_ASSET_PACKAGE_MAX_SIZE = 4 * 1024 * 1024;
+const ARCHIVE_MAGIC = 0x52414b4f;
+const ARCHIVE_VERSION = 1;
+const ARCHIVE_HEADER_SIZE = 42;
+const ARCHIVE_ENTRY_SIZE = 296;
+const ARCHIVE_ENTRY_NAME_MAX_LENGTH = 255;
+const ARCHIVE_COMPRESS_LZ4_BLOCKED = 1;
+const ARCHIVE_ALIGNMENT = 4;
+const LZ4_BLOCK_SIZE_LOG2 = 12;
+function supportsPro2HostAssetPackage(firmwareVersion) {
+    return Boolean(firmwareVersion &&
+        semver__default["default"].valid(firmwareVersion) &&
+        semver__default["default"].gte(firmwareVersion, PRO2_HOST_ASSET_PACKAGE_MIN_VERSION));
+}
+function concatBytes(parts) {
+    const output = new Uint8Array(parts.reduce((length, part) => length + part.byteLength, 0));
+    let offset = 0;
+    for (const part of parts) {
+        output.set(part, offset);
+        offset += part.byteLength;
+    }
+    return output;
+}
+const LZ4_MIN_MATCH = 4;
+const LZ4_LAST_LITERALS = 5;
+const LZ4_MATCH_FIND_LIMIT = 12;
+const LZ4_MAX_OFFSET = 0xffff;
+const LZ4_LENGTH_MASK = 15;
+const LZ4_HASH_LOG = 16;
+const LZ4_HASH_MULTIPLIER = 2654435761;
+const LZ4_SKIP_TRIGGER = 6;
+function writeExtendedLength(output, offset, length) {
+    let remaining = length;
+    let nextOffset = offset;
+    while (remaining >= 255) {
+        output[nextOffset] = 255;
+        nextOffset += 1;
+        remaining -= 255;
+    }
+    output[nextOffset] = remaining;
+    return nextOffset + 1;
+}
+function copyBytes(output, outputOffset, input, inputOffset, length) {
+    output.set(input.subarray(inputOffset, inputOffset + length), outputOffset);
+    return outputOffset + length;
+}
+function emitSequence(output, outputOffset, input, anchor, literalLength, matchOffset, matchLengthCode) {
+    const tokenOffset = outputOffset;
+    let nextOffset = outputOffset + 1;
+    let token = 0;
+    if (literalLength >= LZ4_LENGTH_MASK) {
+        token = LZ4_LENGTH_MASK << 4;
+        nextOffset = writeExtendedLength(output, nextOffset, literalLength - LZ4_LENGTH_MASK);
+    }
+    else {
+        token = literalLength << 4;
+    }
+    nextOffset = copyBytes(output, nextOffset, input, anchor, literalLength);
+    output[nextOffset] = matchOffset & 0xff;
+    output[nextOffset + 1] = (matchOffset >>> 8) & 0xff;
+    nextOffset += 2;
+    if (matchLengthCode >= LZ4_LENGTH_MASK) {
+        token |= LZ4_LENGTH_MASK;
+        nextOffset = writeExtendedLength(output, nextOffset, matchLengthCode - LZ4_LENGTH_MASK);
+    }
+    else {
+        token |= matchLengthCode;
+    }
+    output[tokenOffset] = token;
+    return nextOffset;
+}
+function emitLastLiterals(output, outputOffset, input, anchor, literalLength) {
+    const tokenOffset = outputOffset;
+    let nextOffset = outputOffset + 1;
+    if (literalLength >= LZ4_LENGTH_MASK) {
+        output[tokenOffset] = LZ4_LENGTH_MASK << 4;
+        nextOffset = writeExtendedLength(output, nextOffset, literalLength - LZ4_LENGTH_MASK);
+    }
+    else {
+        output[tokenOffset] = literalLength << 4;
+    }
+    return copyBytes(output, nextOffset, input, anchor, literalLength);
+}
+function compressRawLz4Block(input, hashTable) {
+    const output = new Uint8Array(input.byteLength + Math.floor(input.byteLength / 255) + 16);
+    const inputView = new DataView(input.buffer, input.byteOffset, input.byteLength);
+    const matchFindLimit = input.byteLength - LZ4_MATCH_FIND_LIMIT;
+    const matchExtendLimit = input.byteLength - LZ4_LAST_LITERALS;
+    let anchor = 0;
+    let inputOffset = 0;
+    let outputOffset = 0;
+    let searchMatchCount = 1 << LZ4_SKIP_TRIGGER;
+    hashTable.fill(0);
+    while (inputOffset < matchFindLimit) {
+        const sequence = inputView.getUint32(inputOffset, true);
+        const hash = Math.imul(sequence, LZ4_HASH_MULTIPLIER) >>> (32 - LZ4_HASH_LOG);
+        const candidate = hashTable[hash] - 1;
+        hashTable[hash] = inputOffset + 1;
+        const hasMatch = !(candidate < 0 ||
+            inputOffset - candidate > LZ4_MAX_OFFSET ||
+            inputView.getUint32(candidate, true) !== sequence);
+        if (!hasMatch) {
+            inputOffset += searchMatchCount >> LZ4_SKIP_TRIGGER;
+            searchMatchCount += 1;
+        }
+        else {
+            searchMatchCount = 1 << LZ4_SKIP_TRIGGER;
+            let matchEnd = inputOffset + LZ4_MIN_MATCH;
+            let reference = candidate + LZ4_MIN_MATCH;
+            while (matchEnd < matchExtendLimit && input[matchEnd] === input[reference]) {
+                matchEnd += 1;
+                reference += 1;
+            }
+            outputOffset = emitSequence(output, outputOffset, input, anchor, inputOffset - anchor, inputOffset - candidate, matchEnd - inputOffset - LZ4_MIN_MATCH);
+            inputOffset = matchEnd;
+            anchor = inputOffset;
+        }
+    }
+    outputOffset = emitLastLiterals(output, outputOffset, input, anchor, input.byteLength - anchor);
+    return output.slice(0, outputOffset);
+}
+function encodeLz4Blocked(data) {
+    const blockSize = 1 << LZ4_BLOCK_SIZE_LOG2;
+    const blockCount = Math.ceil(data.byteLength / blockSize);
+    const hashTable = new Uint32Array(1 << LZ4_HASH_LOG);
+    const blocks = [];
+    const header = new Uint8Array(8 + blockCount * 4);
+    const headerView = new DataView(header.buffer);
+    headerView.setUint16(0, blockCount, true);
+    headerView.setUint16(2, LZ4_BLOCK_SIZE_LOG2, true);
+    for (let index = 0; index < blockCount; index += 1) {
+        const block = compressRawLz4Block(data.subarray(index * blockSize, Math.min((index + 1) * blockSize, data.byteLength)), hashTable);
+        headerView.setUint32(8 + index * 4, block.byteLength, true);
+        blocks.push(block);
+    }
+    return concatBytes([header, ...blocks]);
+}
+const CRC32_TABLE = (() => {
+    const table = new Uint32Array(256);
+    for (let index = 0; index < table.length; index += 1) {
+        let value = index;
+        for (let bit = 0; bit < 8; bit += 1) {
+            value = value & 1 ? 0xedb88320 ^ (value >>> 1) : value >>> 1;
+        }
+        table[index] = value >>> 0;
+    }
+    return table;
+})();
+function crc32(data) {
+    let value = 0xffffffff;
+    for (const byte of data) {
+        value = CRC32_TABLE[(value ^ byte) & 0xff] ^ (value >>> 8);
+    }
+    return (value ^ 0xffffffff) >>> 0;
+}
+function align(value) {
+    return (value + ARCHIVE_ALIGNMENT - 1) & ~(ARCHIVE_ALIGNMENT - 1);
+}
+function buildArchive(entries) {
+    const textEncoder = new TextEncoder();
+    let dataOffset = ARCHIVE_HEADER_SIZE + entries.length * ARCHIVE_ENTRY_SIZE;
+    const encodedEntries = entries.map(entry => {
+        const nameBytes = textEncoder.encode(entry.name);
+        if (!entry.name || nameBytes.byteLength > ARCHIVE_ENTRY_NAME_MAX_LENGTH) {
+            throw new Error('Pro2 host asset package entry names must contain 1 to 255 UTF-8 bytes.');
+        }
+        if (!(entry.data instanceof Uint8Array) || entry.data.byteLength === 0) {
+            throw new Error(`Pro2 host asset package entry [${entry.name}] must not be empty.`);
+        }
+        const compressed = encodeLz4Blocked(entry.data);
+        const offset = align(dataOffset);
+        dataOffset = offset + compressed.byteLength;
+        return Object.assign(Object.assign({}, entry), { nameBytes, compressed, offset });
+    });
+    const archive = new Uint8Array(dataOffset);
+    const view = new DataView(archive.buffer);
+    view.setUint32(0, ARCHIVE_MAGIC, true);
+    view.setUint32(4, ARCHIVE_VERSION, true);
+    view.setUint16(8, encodedEntries.length, true);
+    encodedEntries.forEach((entry, index) => {
+        const recordOffset = ARCHIVE_HEADER_SIZE + index * ARCHIVE_ENTRY_SIZE;
+        archive[recordOffset] = entry.nameBytes.byteLength;
+        archive.set(entry.nameBytes, recordOffset + 1);
+        view.setUint32(recordOffset + 0x100, entry.offset, true);
+        view.setUint32(recordOffset + 0x104, entry.data.byteLength, true);
+        view.setUint32(recordOffset + 0x108, entry.compressed.byteLength, true);
+        view.setUint32(recordOffset + 0x10c, crc32(entry.data), true);
+        view.setUint32(recordOffset + 0x110, crc32(entry.compressed), true);
+        archive[recordOffset + 0x114] = ARCHIVE_COMPRESS_LZ4_BLOCKED;
+        archive.set(entry.compressed, entry.offset);
+    });
+    return archive;
+}
+function buildPro2HostAssetPackage(entries) {
+    if (entries.length === 0 || new Set(entries.map(entry => entry.name)).size !== entries.length) {
+        throw new Error('Pro2 host asset package entries must have unique, non-empty names.');
+    }
+    const payload = buildArchive(entries);
+    const header = new Uint8Array(CONTAINER_HEADER_SIZE);
+    const view = new DataView(header.buffer);
+    view.setUint32(0, CONTAINER_HEADER_MAGIC, true);
+    view.setUint32(4, CONTAINER_HEADER_VERSION, true);
+    view.setUint32(8, CONTAINER_RESOURCE_TYPE_MAGIC, true);
+    view.setUint32(0x0c, CONTAINER_HEADER_SIZE, true);
+    view.setUint32(0x10, 1, true);
+    view.setUint32(0x14, payload.byteLength, true);
+    header.set(sha3.sha3_512(payload), CONTAINER_HASH_SECTION_OFFSET);
+    header.set(sha3.sha3_512(header.subarray(0, CONTAINER_HEADER_HASH_INPUT_LENGTH)), 0x240);
+    view.setUint32(CONTAINER_SIGNATURE_ALGORITHM_OFFSET, CONTAINER_ED25519_SIGNATURE_ALGORITHM, true);
+    const packageData = concatBytes([header, payload]);
+    if (packageData.byteLength > HOST_ASSET_PACKAGE_MAX_SIZE) {
+        throw new Error('Pro2 host asset package exceeds the firmware 4 MiB limit.');
+    }
+    return packageData;
+}
+
 const WALLPAPER_DIRECTORY = 'vol1:/wallpapers';
+const WALLPAPER_PACKAGE_PATH = `${WALLPAPER_DIRECTORY}/wallpaper.okpkg`;
+const WALLPAPER_PACKAGE_ENTRY = 'wallpaper.bin';
 const SAFE_FILE_NAME = /^[A-Za-z0-9_-]+(?:\.bin)?$/;
 const DEVICE_SETTINGS_SET_MESSAGE_TYPE = 60412;
 const FILESYSTEM_FILE_WRITE_MESSAGE_TYPE$2 = 60805;
@@ -54688,18 +54915,15 @@ class DeviceUploadWallpaper extends BaseMethod {
             this.directoryReady = true;
         });
     }
-    upload() {
+    upload(path, data) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.uploaded)
                 return;
-            const { encoded } = this;
-            if (!encoded)
-                throw invalidParameter$1('Wallpaper data has not been initialized.');
             yield writeProtocolV2File({
                 commands: this.device.commands,
-                path: this.path,
-                data: encoded.data,
-                totalSize: encoded.data.byteLength,
+                path,
+                data,
+                totalSize: data.byteLength,
                 chunkSize: this.params.chunkSize,
                 maxChunkRetries: 3,
                 overwrite: true,
@@ -54715,14 +54939,20 @@ class DeviceUploadWallpaper extends BaseMethod {
         });
     }
     run() {
-        var _a;
+        var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
             const { encoded } = this;
             if (!encoded)
                 throw invalidParameter$1('Wallpaper data has not been initialized.');
             yield this.assertCapabilities();
             yield this.ensureDirectory();
-            yield this.upload();
+            const useHostAssetPackage = supportsPro2HostAssetPackage((_b = (_a = this.device.state) === null || _a === void 0 ? void 0 : _a.versions.firmware) !== null && _b !== void 0 ? _b : undefined);
+            const data = useHostAssetPackage
+                ? buildPro2HostAssetPackage([{ name: WALLPAPER_PACKAGE_ENTRY, data: encoded.data }])
+                : encoded.data;
+            if (useHostAssetPackage)
+                this.path = WALLPAPER_PACKAGE_PATH;
+            yield this.upload(this.path, data);
             const response = yield this.device.commands.typedCall('DeviceSettingsSet', 'Success', {
                 settings: { wallpaper_path: this.path },
             });
@@ -54736,9 +54966,9 @@ class DeviceUploadWallpaper extends BaseMethod {
             }
             return {
                 path: this.path,
-                size: encoded.data.byteLength,
+                size: data.byteLength,
                 colorFormat: encoded.colorFormat,
-                message: (_a = response.message) === null || _a === void 0 ? void 0 : _a.message,
+                message: (_c = response.message) === null || _c === void 0 ? void 0 : _c.message,
             };
         });
     }
@@ -54815,14 +55045,14 @@ class DeviceUploadNft extends BaseMethod {
         this.skipForceUpdateCheck = true;
         this.useDevicePassphraseState = false;
     }
-    assertCapabilities() {
+    assertCapabilities(useHostAssetPackage) {
         return __awaiter(this, void 0, void 0, function* () {
             const protocolInfo = yield this.device.ensureProtocolV2RuntimeContext();
             const hasFileWrite = supportsProtocolV2Message(protocolInfo, FILESYSTEM_FILE_WRITE_MESSAGE_TYPE$1);
             const hasPathInfo = supportsProtocolV2Message(protocolInfo, FILESYSTEM_PATH_INFO_QUERY_MESSAGE_TYPE);
             const hasDirList = supportsProtocolV2Message(protocolInfo, FILESYSTEM_DIR_LIST_MESSAGE_TYPE);
             const hasNftUpdate = supportsProtocolV2Message(protocolInfo, NFT_UPDATE_MESSAGE_TYPE);
-            if (!hasFileWrite || !hasPathInfo || !hasDirList || !hasNftUpdate) {
+            if (!hasFileWrite || !hasNftUpdate || (!useHostAssetPackage && (!hasPathInfo || !hasDirList))) {
                 throw hdShared.createDeviceNotSupportMethodError(this.name, this.device.getCurrentFirmwareType());
             }
         });
@@ -54848,20 +55078,33 @@ class DeviceUploadNft extends BaseMethod {
         });
     }
     run() {
-        var _a;
+        var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
             const { bundle } = this;
             if (!bundle)
                 throw invalidParameter$1('NFT data has not been initialized.');
-            yield this.assertCapabilities();
+            const useHostAssetPackage = supportsPro2HostAssetPackage((_b = (_a = this.device.state) === null || _a === void 0 ? void 0 : _a.versions.firmware) !== null && _b !== void 0 ? _b : undefined);
+            yield this.assertCapabilities(useHostAssetPackage);
             this.throwIfAborted();
-            yield this.assertStorageCapacity(bundle.basename);
+            if (!useHostAssetPackage)
+                yield this.assertStorageCapacity(bundle.basename);
             this.throwIfAborted();
-            const files = [
+            const extractedFiles = [
                 { path: `${PRO2_NFT_DIRECTORY}/${bundle.basename}.bin`, data: bundle.image },
                 { path: `${PRO2_NFT_DIRECTORY}/${bundle.basename}_m.bin`, data: bundle.thumbnail },
                 { path: `${PRO2_NFT_DIRECTORY}/${bundle.basename}.json`, data: bundle.metadata },
             ];
+            const files = useHostAssetPackage
+                ? [
+                    {
+                        path: `${PRO2_NFT_DIRECTORY}/${bundle.basename}.okpkg`,
+                        data: buildPro2HostAssetPackage(extractedFiles.map(file => ({
+                            name: file.path.slice(`${PRO2_NFT_DIRECTORY}/`.length),
+                            data: file.data,
+                        }))),
+                    },
+                ]
+                : extractedFiles;
             const totalSize = files.reduce((sum, file) => sum + file.data.byteLength, 0);
             let transferredBeforeFile = 0;
             for (const file of files) {
@@ -54890,12 +55133,12 @@ class DeviceUploadNft extends BaseMethod {
             const response = yield this.updateNft(bundle.basename);
             return {
                 basename: bundle.basename,
-                imagePath: files[0].path,
-                thumbnailPath: files[1].path,
-                metadataPath: files[2].path,
+                imagePath: extractedFiles[0].path,
+                thumbnailPath: extractedFiles[1].path,
+                metadataPath: extractedFiles[2].path,
                 totalSize,
                 nftUpdated: true,
-                message: (_a = response.message) === null || _a === void 0 ? void 0 : _a.message,
+                message: (_c = response.message) === null || _c === void 0 ? void 0 : _c.message,
             };
         });
     }
@@ -58187,6 +58430,7 @@ class EVMSignTypedData extends BaseMethod {
         const currentDeviceType = this.device.getCurrentDeviceType();
         const supportBiggerDataVersion = '4.4.0';
         const supportBiggerData = DeviceModelToTypes.model_classic1s.includes(currentDeviceType) ||
+            DeviceModelToTypes.model_pro2.includes(currentDeviceType) ||
             (DeviceModelToTypes.model_touch.includes(currentDeviceType) &&
                 semver__default["default"].gte(currentVersion, supportBiggerDataVersion));
         if (supportBiggerData) {

package/dist/utils/pro2HostAssetPackage.d.ts

@@ -0,0 +1,8 @@
+export declare const PRO2_HOST_ASSET_PACKAGE_MIN_VERSION = "1.0.1";
+export type Pro2HostAssetPackageEntry = {
+    name: string;
+    data: Uint8Array;
+};
+export declare function supportsPro2HostAssetPackage(firmwareVersion: string | undefined): boolean;
+export declare function buildPro2HostAssetPackage(entries: Pro2HostAssetPackageEntry[]): Uint8Array;
+//# sourceMappingURL=pro2HostAssetPackage.d.ts.map

package/dist/utils/pro2HostAssetPackage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pro2HostAssetPackage.d.ts","sourceRoot":"","sources":["../../src/utils/pro2HostAssetPackage.ts"],"names":[],"mappings":"AAiBA,eAAO,MAAM,mCAAmC,UAAU,CAAC;AAwB3D,MAAM,MAAM,yBAAyB,GAAG;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,UAAU,CAAC;CAClB,CAAC;AAQF,wBAAgB,4BAA4B,CAAC,eAAe,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAMzF;AA2QD,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,yBAAyB,EAAE,GAAG,UAAU,CA4B1F"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-core",
-  "version": "1.2.1",
+  "version": "1.2.2-alpha.1",
   "description": "Core processes and APIs for communicating with OneKey hardware devices.",
   "author": "OneKey",
   "homepage": "https://github.com/OneKeyHQ/hardware-js-sdk#readme",
@@ -25,8 +25,8 @@
     "url": "https://github.com/OneKeyHQ/hardware-js-sdk/issues"
   },
   "dependencies": {
-    "@onekeyfe/hd-shared": "1.2.1",
-    "@onekeyfe/hd-transport": "1.2.1",
+    "@onekeyfe/hd-shared": "1.2.2-alpha.1",
+    "@onekeyfe/hd-transport": "1.2.2-alpha.1",
     "axios": "1.15.2",
     "bignumber.js": "^9.0.2",
     "buffer": "^6.0.3",
@@ -46,5 +46,5 @@
     "@types/w3c-web-usb": "^1.0.10",
     "@types/web-bluetooth": "^0.0.21"
   },
-  "gitHead": "43d2856e593a93fbf056fdb334e0fe407a79cdc0"
+  "gitHead": "66f45610d36e06a46ac82cd49a4b0e1a128f19d4"
 }

package/src/api/evm/EVMSignTypedData.ts

@@ -360,6 +360,7 @@ export default class EVMSignTypedData extends BaseMethod<EVMSignTypedDataParams>
 
     const supportBiggerData =
       DeviceModelToTypes.model_classic1s.includes(currentDeviceType) ||
+      DeviceModelToTypes.model_pro2.includes(currentDeviceType) ||
       (DeviceModelToTypes.model_touch.includes(currentDeviceType) &&
         semver.gte(currentVersion, supportBiggerDataVersion));
 

package/src/api/protocol-v2/DeviceUploadNft.ts

@@ -20,6 +20,10 @@ import {
   getCompletePro2NftBasenames,
 } from '../../utils/pro2Nft';
 import { encodePro2Image } from '../../utils/pro2Wallpaper';
+import {
+  buildPro2HostAssetPackage,
+  supportsPro2HostAssetPackage,
+} from '../../utils/pro2HostAssetPackage';
 import { BaseMethod } from '../BaseMethod';
 import { decodeJpegBase64ToRgba } from '../helpers/base64Data';
 import { invalidParameter } from '../helpers/filesystemValidation';
@@ -38,8 +42,11 @@ export type DeviceUploadNftParams = {
 
 export type DeviceUploadNftResponse = {
   basename: string;
+  /** Final image path after firmware extracts a host-asset package. */
   imagePath: string;
+  /** Final thumbnail path after firmware extracts a host-asset package. */
   thumbnailPath: string;
+  /** Final metadata path after firmware extracts a host-asset package. */
   metadataPath: string;
   totalSize: number;
   nftUpdated: true;
@@ -138,7 +145,7 @@ export default class DeviceUploadNft extends BaseMethod<DeviceUploadNftParams> {
     this.useDevicePassphraseState = false;
   }
 
-  private async assertCapabilities() {
+  private async assertCapabilities(useHostAssetPackage: boolean) {
     const protocolInfo = await this.device.ensureProtocolV2RuntimeContext();
     const hasFileWrite = supportsProtocolV2Message(
       protocolInfo,
@@ -150,7 +157,7 @@ export default class DeviceUploadNft extends BaseMethod<DeviceUploadNftParams> {
     );
     const hasDirList = supportsProtocolV2Message(protocolInfo, FILESYSTEM_DIR_LIST_MESSAGE_TYPE);
     const hasNftUpdate = supportsProtocolV2Message(protocolInfo, NFT_UPDATE_MESSAGE_TYPE);
-    if (!hasFileWrite || !hasPathInfo || !hasDirList || !hasNftUpdate) {
+    if (!hasFileWrite || !hasNftUpdate || (!useHostAssetPackage && (!hasPathInfo || !hasDirList))) {
       throw createDeviceNotSupportMethodError(this.name, this.device.getCurrentFirmwareType());
     }
   }
@@ -192,16 +199,32 @@ export default class DeviceUploadNft extends BaseMethod<DeviceUploadNftParams> {
     const { bundle } = this;
     if (!bundle) throw invalidParameter('NFT data has not been initialized.');
 
-    await this.assertCapabilities();
+    const useHostAssetPackage = supportsPro2HostAssetPackage(
+      this.device.state?.versions.firmware ?? undefined
+    );
+    await this.assertCapabilities(useHostAssetPackage);
     this.throwIfAborted();
-    await this.assertStorageCapacity(bundle.basename);
+    if (!useHostAssetPackage) await this.assertStorageCapacity(bundle.basename);
     this.throwIfAborted();
 
-    const files = [
+    const extractedFiles = [
       { path: `${PRO2_NFT_DIRECTORY}/${bundle.basename}.bin`, data: bundle.image },
       { path: `${PRO2_NFT_DIRECTORY}/${bundle.basename}_m.bin`, data: bundle.thumbnail },
       { path: `${PRO2_NFT_DIRECTORY}/${bundle.basename}.json`, data: bundle.metadata },
     ];
+    const files = useHostAssetPackage
+      ? [
+          {
+            path: `${PRO2_NFT_DIRECTORY}/${bundle.basename}.okpkg`,
+            data: buildPro2HostAssetPackage(
+              extractedFiles.map(file => ({
+                name: file.path.slice(`${PRO2_NFT_DIRECTORY}/`.length),
+                data: file.data,
+              }))
+            ),
+          },
+        ]
+      : extractedFiles;
     const totalSize = files.reduce((sum, file) => sum + file.data.byteLength, 0);
     let transferredBeforeFile = 0;
 
@@ -238,9 +261,9 @@ export default class DeviceUploadNft extends BaseMethod<DeviceUploadNftParams> {
     const response = await this.updateNft(bundle.basename);
     return {
       basename: bundle.basename,
-      imagePath: files[0].path,
-      thumbnailPath: files[1].path,
-      metadataPath: files[2].path,
+      imagePath: extractedFiles[0].path,
+      thumbnailPath: extractedFiles[1].path,
+      metadataPath: extractedFiles[2].path,
       totalSize,
       nftUpdated: true,
       message: response.message?.message,

package/src/api/protocol-v2/DeviceUploadWallpaper.ts

@@ -16,14 +16,26 @@ import {
   type Pro2WallpaperColorFormat,
   encodePro2Wallpaper,
 } from '../../utils/pro2Wallpaper';
+import {
+  buildPro2HostAssetPackage,
+  supportsPro2HostAssetPackage,
+} from '../../utils/pro2HostAssetPackage';
 
 export type DeviceUploadWallpaperParams = {
   jpegBase64: string;
+  /**
+   * Legacy firmware uses this name for the uploaded `.bin` file. Firmware
+   * 1.0.1+ always consumes the fixed `wallpaper.okpkg` package path.
+   */
   fileName?: string;
   chunkSize?: number;
 };
 
 export type DeviceUploadWallpaperResponse = {
+  /**
+   * Filesystem path sent to `DeviceSettingsSet`. On firmware 1.0.1+ this is
+   * the temporary package path; firmware extracts and persists wallpaper.bin.
+   */
   path: string;
   size: number;
   colorFormat: Pro2WallpaperColorFormat;
@@ -31,6 +43,8 @@ export type DeviceUploadWallpaperResponse = {
 };
 
 const WALLPAPER_DIRECTORY = 'vol1:/wallpapers';
+const WALLPAPER_PACKAGE_PATH = `${WALLPAPER_DIRECTORY}/wallpaper.okpkg`;
+const WALLPAPER_PACKAGE_ENTRY = 'wallpaper.bin';
 const SAFE_FILE_NAME = /^[A-Za-z0-9_-]+(?:\.bin)?$/;
 const DEVICE_SETTINGS_SET_MESSAGE_TYPE = 60412;
 const FILESYSTEM_FILE_WRITE_MESSAGE_TYPE = 60805;
@@ -116,16 +130,14 @@ export default class DeviceUploadWallpaper extends BaseMethod<DeviceUploadWallpa
     this.directoryReady = true;
   }
 
-  private async upload() {
+  private async upload(path: string, data: Uint8Array) {
     if (this.uploaded) return;
-    const { encoded } = this;
-    if (!encoded) throw invalidParameter('Wallpaper data has not been initialized.');
 
     await writeProtocolV2File({
       commands: this.device.commands,
-      path: this.path,
-      data: encoded.data,
-      totalSize: encoded.data.byteLength,
+      path,
+      data,
+      totalSize: data.byteLength,
       chunkSize: this.params.chunkSize,
       maxChunkRetries: 3,
       overwrite: true,
@@ -145,7 +157,14 @@ export default class DeviceUploadWallpaper extends BaseMethod<DeviceUploadWallpa
     if (!encoded) throw invalidParameter('Wallpaper data has not been initialized.');
     await this.assertCapabilities();
     await this.ensureDirectory();
-    await this.upload();
+    const useHostAssetPackage = supportsPro2HostAssetPackage(
+      this.device.state?.versions.firmware ?? undefined
+    );
+    const data = useHostAssetPackage
+      ? buildPro2HostAssetPackage([{ name: WALLPAPER_PACKAGE_ENTRY, data: encoded.data }])
+      : encoded.data;
+    if (useHostAssetPackage) this.path = WALLPAPER_PACKAGE_PATH;
+    await this.upload(this.path, data);
     const response = await this.device.commands.typedCall('DeviceSettingsSet', 'Success', {
       settings: { wallpaper_path: this.path },
     });
@@ -160,7 +179,7 @@ export default class DeviceUploadWallpaper extends BaseMethod<DeviceUploadWallpa
     }
     return {
       path: this.path,
-      size: encoded.data.byteLength,
+      size: data.byteLength,
       colorFormat: encoded.colorFormat,
       message: response.message?.message,
     };

package/src/utils/pro2HostAssetPackage.ts

@@ -0,0 +1,354 @@
+import { sha3_512 } from '@noble/hashes/sha3';
+import semver from 'semver';
+
+/**
+ * Builds the unsigned host-asset package consumed by Pro2 firmware:
+ *
+ *   OKPP RESOURCE container
+ *   └── OKAR archive
+ *       └── independently compressed raw LZ4 blocks
+ *
+ * OKPP and OKAR are OneKey formats. Their constants mirror firmware-pro2's
+ * payload_package headers; the LZ4 bytes inside each block follow the standard
+ * raw block format and deliberately do not use an LZ4 frame or size prefix.
+ */
+
+/* eslint-disable no-bitwise */
+
+export const PRO2_HOST_ASSET_PACKAGE_MIN_VERSION = '1.0.1';
+
+// OKPP container layout. The fixed header has seven empty signature slots even
+// for a host-generated unsigned package.
+const CONTAINER_HEADER_SIZE = 0x5f90;
+const CONTAINER_HEADER_HASH_INPUT_LENGTH = 0x240;
+const CONTAINER_HASH_SECTION_OFFSET = 0x200;
+const CONTAINER_SIGNATURE_ALGORITHM_OFFSET = 0x408;
+const CONTAINER_HEADER_MAGIC = 0x50504b4f;
+const CONTAINER_HEADER_VERSION = 1;
+const CONTAINER_RESOURCE_TYPE_MAGIC = 0x43534552;
+const CONTAINER_ED25519_SIGNATURE_ALGORITHM = 0x71717171;
+const HOST_ASSET_PACKAGE_MAX_SIZE = 4 * 1024 * 1024;
+
+// OKAR archive layout.
+const ARCHIVE_MAGIC = 0x52414b4f;
+const ARCHIVE_VERSION = 1;
+const ARCHIVE_HEADER_SIZE = 42;
+const ARCHIVE_ENTRY_SIZE = 296;
+const ARCHIVE_ENTRY_NAME_MAX_LENGTH = 255;
+const ARCHIVE_COMPRESS_LZ4_BLOCKED = 1;
+const ARCHIVE_ALIGNMENT = 4;
+const LZ4_BLOCK_SIZE_LOG2 = 12;
+
+export type Pro2HostAssetPackageEntry = {
+  name: string;
+  data: Uint8Array;
+};
+
+type EncodedArchiveEntry = Pro2HostAssetPackageEntry & {
+  nameBytes: Uint8Array;
+  compressed: Uint8Array;
+  offset: number;
+};
+
+export function supportsPro2HostAssetPackage(firmwareVersion: string | undefined): boolean {
+  return Boolean(
+    firmwareVersion &&
+      semver.valid(firmwareVersion) &&
+      semver.gte(firmwareVersion, PRO2_HOST_ASSET_PACKAGE_MIN_VERSION)
+  );
+}
+
+function concatBytes(parts: Uint8Array[]): Uint8Array {
+  const output = new Uint8Array(parts.reduce((length, part) => length + part.byteLength, 0));
+  let offset = 0;
+  for (const part of parts) {
+    output.set(part, offset);
+    offset += part.byteLength;
+  }
+  return output;
+}
+
+// Raw LZ4 block encoder
+// ---------------------
+//
+// This encoder is adapted from lz4-lite 1.1.2 and intentionally kept local so
+// every SDK runtime uses the same dependency-free implementation. Keep this
+// section isolated from the OneKey package writer below. Firmware requires raw
+// blocks here; replacing it with an LZ4 frame encoder is not compatible.
+//
+// MIT License
+// Copyright (c) 2026 Alexander Vukov
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+const LZ4_MIN_MATCH = 4;
+const LZ4_LAST_LITERALS = 5;
+const LZ4_MATCH_FIND_LIMIT = 12;
+const LZ4_MAX_OFFSET = 0xffff;
+const LZ4_LENGTH_MASK = 15;
+const LZ4_HASH_LOG = 16;
+const LZ4_HASH_MULTIPLIER = 2654435761;
+const LZ4_SKIP_TRIGGER = 6;
+
+function writeExtendedLength(output: Uint8Array, offset: number, length: number): number {
+  let remaining = length;
+  let nextOffset = offset;
+  while (remaining >= 255) {
+    output[nextOffset] = 255;
+    nextOffset += 1;
+    remaining -= 255;
+  }
+  output[nextOffset] = remaining;
+  return nextOffset + 1;
+}
+
+function copyBytes(
+  output: Uint8Array,
+  outputOffset: number,
+  input: Uint8Array,
+  inputOffset: number,
+  length: number
+): number {
+  output.set(input.subarray(inputOffset, inputOffset + length), outputOffset);
+  return outputOffset + length;
+}
+
+function emitSequence(
+  output: Uint8Array,
+  outputOffset: number,
+  input: Uint8Array,
+  anchor: number,
+  literalLength: number,
+  matchOffset: number,
+  matchLengthCode: number
+): number {
+  const tokenOffset = outputOffset;
+  let nextOffset = outputOffset + 1;
+  let token = 0;
+
+  if (literalLength >= LZ4_LENGTH_MASK) {
+    token = LZ4_LENGTH_MASK << 4;
+    nextOffset = writeExtendedLength(output, nextOffset, literalLength - LZ4_LENGTH_MASK);
+  } else {
+    token = literalLength << 4;
+  }
+  nextOffset = copyBytes(output, nextOffset, input, anchor, literalLength);
+  output[nextOffset] = matchOffset & 0xff;
+  output[nextOffset + 1] = (matchOffset >>> 8) & 0xff;
+  nextOffset += 2;
+
+  if (matchLengthCode >= LZ4_LENGTH_MASK) {
+    token |= LZ4_LENGTH_MASK;
+    nextOffset = writeExtendedLength(output, nextOffset, matchLengthCode - LZ4_LENGTH_MASK);
+  } else {
+    token |= matchLengthCode;
+  }
+  output[tokenOffset] = token;
+  return nextOffset;
+}
+
+function emitLastLiterals(
+  output: Uint8Array,
+  outputOffset: number,
+  input: Uint8Array,
+  anchor: number,
+  literalLength: number
+): number {
+  const tokenOffset = outputOffset;
+  let nextOffset = outputOffset + 1;
+  if (literalLength >= LZ4_LENGTH_MASK) {
+    output[tokenOffset] = LZ4_LENGTH_MASK << 4;
+    nextOffset = writeExtendedLength(output, nextOffset, literalLength - LZ4_LENGTH_MASK);
+  } else {
+    output[tokenOffset] = literalLength << 4;
+  }
+  return copyBytes(output, nextOffset, input, anchor, literalLength);
+}
+
+function compressRawLz4Block(input: Uint8Array, hashTable: Uint32Array): Uint8Array {
+  const output = new Uint8Array(input.byteLength + Math.floor(input.byteLength / 255) + 16);
+  const inputView = new DataView(input.buffer, input.byteOffset, input.byteLength);
+  const matchFindLimit = input.byteLength - LZ4_MATCH_FIND_LIMIT;
+  const matchExtendLimit = input.byteLength - LZ4_LAST_LITERALS;
+  let anchor = 0;
+  let inputOffset = 0;
+  let outputOffset = 0;
+  let searchMatchCount = 1 << LZ4_SKIP_TRIGGER;
+
+  hashTable.fill(0);
+  while (inputOffset < matchFindLimit) {
+    const sequence = inputView.getUint32(inputOffset, true);
+    const hash = Math.imul(sequence, LZ4_HASH_MULTIPLIER) >>> (32 - LZ4_HASH_LOG);
+    const candidate = hashTable[hash] - 1;
+    hashTable[hash] = inputOffset + 1;
+
+    const hasMatch = !(
+      candidate < 0 ||
+      inputOffset - candidate > LZ4_MAX_OFFSET ||
+      inputView.getUint32(candidate, true) !== sequence
+    );
+    if (!hasMatch) {
+      inputOffset += searchMatchCount >> LZ4_SKIP_TRIGGER;
+      searchMatchCount += 1;
+    } else {
+      searchMatchCount = 1 << LZ4_SKIP_TRIGGER;
+      let matchEnd = inputOffset + LZ4_MIN_MATCH;
+      let reference = candidate + LZ4_MIN_MATCH;
+      while (matchEnd < matchExtendLimit && input[matchEnd] === input[reference]) {
+        matchEnd += 1;
+        reference += 1;
+      }
+      outputOffset = emitSequence(
+        output,
+        outputOffset,
+        input,
+        anchor,
+        inputOffset - anchor,
+        inputOffset - candidate,
+        matchEnd - inputOffset - LZ4_MIN_MATCH
+      );
+      inputOffset = matchEnd;
+      anchor = inputOffset;
+    }
+  }
+
+  outputOffset = emitLastLiterals(output, outputOffset, input, anchor, input.byteLength - anchor);
+  return output.slice(0, outputOffset);
+}
+
+// OneKey LZ4-blocked wrapper
+// --------------------------
+// The archive stores an 8-byte descriptor, one compressed-size value per
+// block, then the concatenated raw blocks. Blocks are independent so firmware
+// can validate and decompress them with bounded memory.
+function encodeLz4Blocked(data: Uint8Array): Uint8Array {
+  const blockSize = 1 << LZ4_BLOCK_SIZE_LOG2;
+  const blockCount = Math.ceil(data.byteLength / blockSize);
+  const hashTable = new Uint32Array(1 << LZ4_HASH_LOG);
+  const blocks: Uint8Array[] = [];
+  const header = new Uint8Array(8 + blockCount * 4);
+  const headerView = new DataView(header.buffer);
+  headerView.setUint16(0, blockCount, true);
+  headerView.setUint16(2, LZ4_BLOCK_SIZE_LOG2, true);
+
+  for (let index = 0; index < blockCount; index += 1) {
+    const block = compressRawLz4Block(
+      data.subarray(index * blockSize, Math.min((index + 1) * blockSize, data.byteLength)),
+      hashTable
+    );
+    headerView.setUint32(8 + index * 4, block.byteLength, true);
+    blocks.push(block);
+  }
+  return concatBytes([header, ...blocks]);
+}
+
+// OKAR integrity helpers
+// ----------------------
+const CRC32_TABLE = (() => {
+  const table = new Uint32Array(256);
+  for (let index = 0; index < table.length; index += 1) {
+    let value = index;
+    for (let bit = 0; bit < 8; bit += 1) {
+      value = value & 1 ? 0xedb88320 ^ (value >>> 1) : value >>> 1;
+    }
+    table[index] = value >>> 0;
+  }
+  return table;
+})();
+
+function crc32(data: Uint8Array): number {
+  let value = 0xffffffff;
+  for (const byte of data) {
+    value = CRC32_TABLE[(value ^ byte) & 0xff] ^ (value >>> 8);
+  }
+  return (value ^ 0xffffffff) >>> 0;
+}
+
+function align(value: number): number {
+  return (value + ARCHIVE_ALIGNMENT - 1) & ~(ARCHIVE_ALIGNMENT - 1);
+}
+
+// OKAR archive writer
+// -------------------
+function buildArchive(entries: Pro2HostAssetPackageEntry[]): Uint8Array {
+  const textEncoder = new TextEncoder();
+  let dataOffset = ARCHIVE_HEADER_SIZE + entries.length * ARCHIVE_ENTRY_SIZE;
+  const encodedEntries: EncodedArchiveEntry[] = entries.map(entry => {
+    const nameBytes = textEncoder.encode(entry.name);
+    if (!entry.name || nameBytes.byteLength > ARCHIVE_ENTRY_NAME_MAX_LENGTH) {
+      throw new Error('Pro2 host asset package entry names must contain 1 to 255 UTF-8 bytes.');
+    }
+    if (!(entry.data instanceof Uint8Array) || entry.data.byteLength === 0) {
+      throw new Error(`Pro2 host asset package entry [${entry.name}] must not be empty.`);
+    }
+    const compressed = encodeLz4Blocked(entry.data);
+    const offset = align(dataOffset);
+    dataOffset = offset + compressed.byteLength;
+    return { ...entry, nameBytes, compressed, offset };
+  });
+
+  const archive = new Uint8Array(dataOffset);
+  const view = new DataView(archive.buffer);
+  view.setUint32(0, ARCHIVE_MAGIC, true);
+  view.setUint32(4, ARCHIVE_VERSION, true);
+  view.setUint16(8, encodedEntries.length, true);
+
+  encodedEntries.forEach((entry, index) => {
+    const recordOffset = ARCHIVE_HEADER_SIZE + index * ARCHIVE_ENTRY_SIZE;
+    archive[recordOffset] = entry.nameBytes.byteLength;
+    archive.set(entry.nameBytes, recordOffset + 1);
+    view.setUint32(recordOffset + 0x100, entry.offset, true);
+    view.setUint32(recordOffset + 0x104, entry.data.byteLength, true);
+    view.setUint32(recordOffset + 0x108, entry.compressed.byteLength, true);
+    view.setUint32(recordOffset + 0x10c, crc32(entry.data), true);
+    view.setUint32(recordOffset + 0x110, crc32(entry.compressed), true);
+    archive[recordOffset + 0x114] = ARCHIVE_COMPRESS_LZ4_BLOCKED;
+    archive.set(entry.compressed, entry.offset);
+  });
+  return archive;
+}
+
+// OKPP container writer
+// ---------------------
+export function buildPro2HostAssetPackage(entries: Pro2HostAssetPackageEntry[]): Uint8Array {
+  if (entries.length === 0 || new Set(entries.map(entry => entry.name)).size !== entries.length) {
+    throw new Error('Pro2 host asset package entries must have unique, non-empty names.');
+  }
+
+  const payload = buildArchive(entries);
+  const header = new Uint8Array(CONTAINER_HEADER_SIZE);
+  const view = new DataView(header.buffer);
+  view.setUint32(0, CONTAINER_HEADER_MAGIC, true);
+  view.setUint32(4, CONTAINER_HEADER_VERSION, true);
+  view.setUint32(8, CONTAINER_RESOURCE_TYPE_MAGIC, true);
+  view.setUint32(0x0c, CONTAINER_HEADER_SIZE, true);
+  view.setUint32(0x10, 1, true);
+  view.setUint32(0x14, payload.byteLength, true);
+
+  // Host asset packages are unsigned, but firmware still requires a valid
+  // payload hash, header hash, and the Ed25519 algorithm discriminator. The
+  // zero-initialized header intentionally leaves sig_used_count and every
+  // signature slot empty.
+  header.set(sha3_512(payload), CONTAINER_HASH_SECTION_OFFSET);
+  header.set(sha3_512(header.subarray(0, CONTAINER_HEADER_HASH_INPUT_LENGTH)), 0x240);
+  view.setUint32(CONTAINER_SIGNATURE_ALGORITHM_OFFSET, CONTAINER_ED25519_SIGNATURE_ALGORITHM, true);
+
+  const packageData = concatBytes([header, payload]);
+  if (packageData.byteLength > HOST_ASSET_PACKAGE_MAX_SIZE) {
+    throw new Error('Pro2 host asset package exceeds the firmware 4 MiB limit.');
+  }
+  return packageData;
+}