@onekeyfe/hd-core 1.2.0-alpha.57 → 1.2.0-alpha.59

package/__tests__/AllNetworkGetAddressBase.tracing.test.ts

@@ -91,11 +91,93 @@ describe('AllNetworkGetAddressBase tracing', () => {
       0
     );
 
-    expect(checkPassphraseStateSafety).toHaveBeenCalledWith('hidden-state', false, undefined);
+    expect(checkPassphraseStateSafety).toHaveBeenCalledWith(
+      'hidden-state',
+      false,
+      undefined,
+      false
+    );
     expect(calls).toEqual(['resume-hidden-session', 'run-chain-method']);
     expect(typedCall).not.toHaveBeenCalled();
   });
 
+  test('resumes a Protocol V2 Cardano hidden wallet with the Cardano seed domain', async () => {
+    const calls: string[] = [];
+    const checkPassphraseStateSafety = jest.fn().mockImplementation(() => {
+      calls.push('resume-cardano-session');
+      return Promise.resolve(true);
+    });
+    const innerMethod = {
+      checkSafetyLevelOnTestNet: jest.fn().mockResolvedValue(false),
+      connectId: 'connect-id',
+      deviceId: 'device-id',
+      getVersionRange: jest.fn().mockReturnValue({}),
+      assertProtocolSupported: jest.fn(),
+      init: jest.fn(),
+      name: 'cardanoGetAddress',
+      responseID: 45,
+      unlockPolicy: 'unlock-before-run',
+      run: jest.fn().mockImplementation(() => {
+        calls.push('run-cardano-method');
+        return Promise.resolve([{ address: 'addr1hidden' }]);
+      }),
+      setDevice: jest.fn(),
+      strictCheckDeviceSupport: false,
+    };
+    (findMethod as jest.Mock).mockReturnValue(innerMethod);
+    const method = new TestAllNetworkMethod({
+      id: 5,
+      payload: {
+        method: 'allNetworkGetAddress',
+        connectId: 'connect-id',
+        deviceId: 'device-id',
+        passphraseState: 'hidden-state',
+        bundle: [],
+      },
+    });
+    method.protocolV2UnlockContext = { preflightCompleted: true };
+    const typedCall = jest.fn();
+    method.device = {
+      checkPassphraseStateSafety,
+      commands: {
+        typedCall,
+      },
+      getCurrentFirmwareType: jest.fn(),
+      getProtocol: jest.fn().mockReturnValue('V2'),
+      getCurrentFirmwareVersionString: jest.fn().mockReturnValue('1.0.0'),
+      getCurrentMethodVersionRange: jest
+        .fn()
+        .mockImplementation((getRange: (type: string) => unknown) => getRange('pro2')),
+      instanceId: 'device-instance',
+      isProtocolV2: jest.fn().mockReturnValue(true),
+      isBootloader: jest.fn().mockReturnValue(false),
+      isRomloader: jest.fn().mockReturnValue(false),
+      off: jest.fn(),
+      on: jest.fn(),
+      state: { status: { unlocked: true } },
+      updateProtocolV2Status: jest.fn(),
+    } as any;
+
+    await method.callMethod(
+      'cardanoGetAddress',
+      {
+        bundle: [
+          {
+            _originRequestParams: {
+              network: 'ada',
+              path: "m/1852'/1815'/0'/0/0",
+            },
+          },
+        ],
+      },
+      0
+    );
+
+    expect(checkPassphraseStateSafety).toHaveBeenCalledWith('hidden-state', false, undefined, true);
+    expect(calls).toEqual(['resume-cardano-session', 'run-cardano-method']);
+    expect(typedCall).not.toHaveBeenCalled();
+  });
+
   test('resumes a Protocol V2 standard wallet before running a nested chain method', async () => {
     const calls: string[] = [];
     const checkPassphraseStateSafety = jest.fn().mockImplementation(() => {
@@ -168,7 +250,7 @@ describe('AllNetworkGetAddressBase tracing', () => {
       0
     );
 
-    expect(checkPassphraseStateSafety).toHaveBeenCalledWith(undefined, true, undefined);
+    expect(checkPassphraseStateSafety).toHaveBeenCalledWith(undefined, true, undefined, false);
     expect(calls).toEqual(['resume-standard-session', 'run-chain-method']);
     expect(typedCall).not.toHaveBeenCalled();
   });

package/__tests__/DeviceCommands.test.ts

@@ -363,9 +363,9 @@ describe('DeviceCommands failure mapping', () => {
     }
   );
 
-  it.each(['Cancelled', 'User cancelled typed data signing'])(
-    'maps the Protocol V2 MP engine cancellation response "%s" to ActionCancelled',
-    async message => {
+  it.each(['SignTx', 'EthereumSignTypedDataOneKey', 'SolanaSignTx', 'GetAddress'] as const)(
+    'does not treat domain-ambiguous Protocol V2 subcode 1 for %s as cancellation',
+    async callType => {
       const commands = createCommands();
 
       await expect(
@@ -375,18 +375,13 @@ describe('DeviceCommands failure mapping', () => {
             message: {
               code: 'Failure_ProcessError',
               subcode: 1,
-              message,
+              message: 'Domain-specific failure',
             },
           } as any,
-          'SignTx'
+          callType
         )
       ).rejects.toMatchObject({
-        errorCode: HardwareErrorCode.ActionCancelled,
-        params: {
-          failureCode: 'Failure_ProcessError',
-          subcode: 1,
-          firmwareMessage: message,
-        },
+        errorCode: HardwareErrorCode.RuntimeError,
       });
     }
   );
@@ -401,6 +396,7 @@ describe('DeviceCommands failure mapping', () => {
           type: 'Failure',
           message: {
             code: 'Failure_ProcessError',
+            subcode: 1,
             message: 'Cancelled on device',
           },
         } as any,
@@ -411,7 +407,7 @@ describe('DeviceCommands failure mapping', () => {
     });
   });
 
-  it('keeps an unrecognized Protocol V2 process subcode generic', async () => {
+  it('maps the DeviceError subcode 1 exception to DeviceBusy', async () => {
     const commands = createCommands();
 
     await expect(
@@ -427,7 +423,12 @@ describe('DeviceCommands failure mapping', () => {
         'DeviceSettingsPageShow'
       )
     ).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.RuntimeError,
+      errorCode: HardwareErrorCode.DeviceBusy,
+      params: {
+        failureCode: 'Failure_ProcessError',
+        subcode: 1,
+        firmwareMessage: 'Another process error',
+      },
     });
   });
 

package/__tests__/core-initialization.test.ts

@@ -0,0 +1,23 @@
+import { DataManager } from '../src/data-manager';
+import { init } from '../src/core';
+
+import type { ConnectSettings } from '../src/types';
+
+jest.mock('../src/data/config', () => ({
+  getSDKVersion: jest.fn(() => '1.0.0-test'),
+  DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0-test/',
+}));
+
+describe('Core initialization', () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('does not create a partially initialized core when settings loading fails', async () => {
+    jest.spyOn(DataManager, 'load').mockRejectedValue(new Error('settings load failed'));
+
+    await expect(init({} as ConnectSettings, class TestTransport {})).rejects.toThrow(
+      'settings load failed'
+    );
+  });
+});

package/__tests__/device-connector-protocol.test.ts

@@ -0,0 +1,81 @@
+import { HardwareErrorCode } from '@onekeyfe/hd-shared';
+
+import DeviceConnector from '../src/device/DeviceConnector';
+
+jest.mock('../src/data-manager/TransportManager', () => ({
+  __esModule: true,
+  default: {
+    load: jest.fn(),
+    getTransport: jest.fn(),
+  },
+}));
+
+jest.mock('../src/data-manager', () => ({
+  DataManager: {
+    getSettings: jest.fn(() => 'desktop-web-ble'),
+    isBleConnect: jest.fn(() => true),
+  },
+}));
+
+jest.mock('../src/device/DevicePool', () => ({
+  DevicePool: {
+    setConnector: jest.fn(),
+  },
+}));
+
+const transportManagerMock: {
+  default: {
+    getTransport: jest.Mock;
+  };
+} = jest.requireMock('../src/data-manager/TransportManager');
+
+describe('DeviceConnector protocol validation', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('reports an explicit transport error when connector initialization ran too early', async () => {
+    transportManagerMock.default.getTransport.mockReturnValue(undefined);
+    const connector = new DeviceConnector();
+
+    await expect(connector.enumerate()).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.TransportNotConfigured,
+    });
+  });
+
+  it('uses the actively probed protocol returned by acquire when the cache was cleared', async () => {
+    const acquire = jest.fn().mockResolvedValue({
+      id: 'pro2-id',
+      path: 'pro2-id',
+      protocolType: 'V2',
+    });
+    transportManagerMock.default.getTransport.mockReturnValue({
+      acquire,
+      getProtocolType: jest.fn(() => undefined),
+    });
+    const connector = new DeviceConnector();
+
+    await expect(connector.acquire('pro2-id', undefined, undefined, 'V2')).resolves.toEqual(
+      expect.objectContaining({ protocolType: 'V2' })
+    );
+    expect(acquire).toHaveBeenCalledWith(
+      expect.objectContaining({ uuid: 'pro2-id', expectedProtocol: 'V2' })
+    );
+  });
+
+  it('still rejects a real mismatch reported by the active protocol probe', async () => {
+    transportManagerMock.default.getTransport.mockReturnValue({
+      acquire: jest.fn().mockResolvedValue({
+        id: 'classic-id',
+        path: 'classic-id',
+        protocolType: 'V1',
+      }),
+      getProtocolType: jest.fn(() => 'V1'),
+    });
+    const connector = new DeviceConnector();
+
+    await expect(connector.acquire('classic-id', undefined, undefined, 'V2')).rejects.toThrow(
+      'Device protocol mismatch: expected V2, detected V1'
+    );
+  });
+});

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

@@ -38,6 +38,28 @@ describe('DevicePool state lifecycle', () => {
     expect(getDeviceState).toHaveBeenNthCalledWith(2, { refreshSections: ['settings'] });
   });
 
+  test('actively re-detects a cached device when protocol detection is forced', async () => {
+    const descriptor = { path: 'cached-path', protocolType: 'V1' } as any;
+    const device = Device.fromDescriptor(descriptor);
+    const acquire = jest.spyOn(device, 'acquire').mockImplementation(() => {
+      device.originalDescriptor.protocolType = 'V2';
+      return Promise.resolve(true);
+    });
+    const initialize = jest.spyOn(device, 'initialize').mockResolvedValue(undefined);
+    const release = jest.spyOn(device, 'release').mockResolvedValue(undefined);
+    DevicePool.devicesCache = { 'cached-id': device };
+
+    const result = await DevicePool.getDevices([descriptor], 'cached-id', {
+      forceProtocolDetection: true,
+    });
+
+    expect(acquire).toHaveBeenCalledWith(undefined, { forceProtocolDetection: true });
+    expect(initialize).toHaveBeenCalledWith({ forceProtocolDetection: true });
+    expect(release).toHaveBeenCalledTimes(1);
+    expect(device.originalDescriptor.protocolType).toBe('V2');
+    expect(result.deviceList).toEqual([device]);
+  });
+
   test('keeps a discovered device when its Protocol V2 label cannot be read', async () => {
     const labelError = new Error('settings unavailable');
     const getDeviceState = jest

package/__tests__/device-settings.test.ts

@@ -115,8 +115,8 @@ describe('DeviceSettings protocol routing', () => {
     );
   });
 
-  it('uses DeviceSettingsSet and commits the confirmed patch for Protocol V2', async () => {
-    const { device, typedCall, updateState } = createDevice({ protocol: 'V2' });
+  it('uses DeviceSettingsSet and reloads Protocol V2 status and settings from the device', async () => {
+    const { device, typedCall, updateState, getDeviceState } = createDevice({ protocol: 'V2' });
     const method = new DeviceSettings({
       id: 2,
       payload: {
@@ -141,21 +141,10 @@ describe('DeviceSettings protocol routing', () => {
         haptic_feedback: true,
       },
     });
-    expect(updateState).toHaveBeenCalledWith(
-      {
-        identity: { label: 'Shared Label' },
-        settings: {
-          language: 'ja',
-          bleEnabled: true,
-          autoLockDelayMs: 60_000,
-          hapticFeedback: true,
-        },
-      },
-      'settings-write'
-    );
-    expect(typedCall.mock.calls.map(call => call[0])).not.toEqual(
-      expect.arrayContaining(['DeviceInfoGet', 'DeviceStatusGet', 'DeviceSettingsGet'])
-    );
+    expect(getDeviceState).toHaveBeenCalledWith({
+      refreshSections: ['status', 'settings'],
+    });
+    expect(updateState).not.toHaveBeenCalled();
   });
 
   it('uses the Pro2 passphrase page as a device-side toggle and verifies the target state', async () => {
@@ -183,7 +172,39 @@ describe('DeviceSettings protocol routing', () => {
     });
     expect(typedCall).not.toHaveBeenCalledWith('DeviceSettingsSet', 'Success', expect.anything());
     expect(getDeviceState).toHaveBeenNthCalledWith(1, { refreshSections: ['status'] });
-    expect(getDeviceState).toHaveBeenNthCalledWith(2, { refreshSections: ['status'] });
+    expect(getDeviceState).toHaveBeenNthCalledWith(2, {
+      refreshSections: ['status', 'settings'],
+    });
+  });
+
+  it('reloads Protocol V2 status and settings after changing air-gap mode', async () => {
+    const { device, typedCall, getDeviceState } = createDevice({ protocol: 'V2' });
+    getDeviceState
+      .mockResolvedValueOnce({
+        settings: { airgapMode: false },
+      })
+      .mockResolvedValueOnce({
+        status: { unlocked: true },
+        settings: { airgapMode: true },
+      });
+    const method = new DeviceSettings({
+      id: 4,
+      payload: {
+        method: 'deviceSettings',
+        airgapMode: true,
+      },
+    });
+    method.init();
+    (method as any).device = device;
+
+    await expect(method.run()).resolves.toEqual({ message: 'Success' });
+    expect(typedCall).toHaveBeenCalledWith('DeviceSettingsPageShow', 'Success', {
+      page: DeviceSettingsPage.DeviceAirgap,
+    });
+    expect(getDeviceState).toHaveBeenNthCalledWith(1, { refreshSections: ['settings'] });
+    expect(getDeviceState).toHaveBeenNthCalledWith(2, {
+      refreshSections: ['status', 'settings'],
+    });
   });
 
   it('does not open a Pro2 settings page when the hardware already matches the target', async () => {

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

@@ -145,6 +145,18 @@ describe('DeviceStateMapper', () => {
     expect(patch.status?.unlocked).toBeUndefined();
   });
 
+  test('maps the Protocol V2 Neo device type without treating it as Pro2', () => {
+    const patch = mapProtocolV2DeviceInfoToState({
+      hw: { Device_type: DeviceType.NEO, serial_no: 'NEO-SERIAL-1' },
+    });
+
+    expect(patch.identity).toMatchObject({
+      deviceType: EDeviceType.Neo,
+      model: 'neo',
+      serialNo: 'NEO-SERIAL-1',
+    });
+  });
+
   test('maps the hardware model independently from Protocol V2', () => {
     const pro = mapProtocolV2DeviceInfoToState({
       protocol_version: 2,

package/__tests__/device-utils.test.ts

@@ -1,10 +1,13 @@
 import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
+import { DeviceType } from '@onekeyfe/hd-transport';
 
 import {
   getDeviceSerialNo,
   getDeviceType,
+  getDeviceTypeByBleName,
   getDeviceUUID,
   getFirmwareType,
+  getMethodVersionRange,
 } from '../src/utils/deviceInfoUtils';
 import {
   getDeviceBLEFirmwareVersion,
@@ -85,7 +88,7 @@ describe('device feature selectors', () => {
   test('reads normalized Protocol V2 features through the same public selectors', () => {
     const features = buildProtocolV2FeaturesPayload({
       deviceInfo: {
-        hw: { serial_no: 'P2-001' },
+        hw: { Device_type: DeviceType.PRO2, serial_no: 'P2-001' },
         fw: {
           application: { version: '5.0.0' },
           bootloader: { version: '2.0.0' },
@@ -104,4 +107,48 @@ describe('device feature selectors', () => {
     expect(getDeviceBoardloaderVersion(features)).toEqual([1, 0, 0]);
     expect(getDeviceBLEFirmwareVersion(features)).toEqual([3, 0, 0]);
   });
+
+  test('preserves the real Neo type in Protocol V2 compatibility features', () => {
+    const features = buildProtocolV2FeaturesPayload({
+      deviceInfo: {
+        hw: { Device_type: DeviceType.NEO, serial_no: 'NEO-001' },
+      },
+    });
+
+    expect(features.deviceType).toBe(EDeviceType.Neo);
+    expect(features.onekey_device_type).toBe('NEO');
+    expect(getDeviceType(features)).toBe(EDeviceType.Neo);
+  });
+
+  test('recognizes Neo discovery names before initialization', () => {
+    expect(getDeviceTypeByBleName('OneKey Neo 1234')).toBe(EDeviceType.Neo);
+    expect(getDeviceTypeByBleName('Neo 1234')).toBe(EDeviceType.Neo);
+  });
+
+  test.each([EDeviceType.Pro2, EDeviceType.Neo])(
+    'uses the Pro2 product model as the chain capability fallback for %s',
+    deviceType => {
+      const checkedTypes: string[] = [];
+      const versionRange = getMethodVersionRange({ deviceType } as PROTO.Features, type => {
+        checkedTypes.push(type);
+        return type === 'model_pro2' ? { min: '1.0.0' } : undefined;
+      });
+
+      expect(versionRange).toEqual({ min: '1.0.0' });
+      expect(checkedTypes).toEqual([deviceType, 'model_pro2']);
+    }
+  );
+
+  test('prefers a Neo-specific chain range over the shared Pro2 product model', () => {
+    const versionRange = getMethodVersionRange(
+      { deviceType: EDeviceType.Neo } as PROTO.Features,
+      type => {
+        if (type === EDeviceType.Neo) return { min: '2.0.0' };
+        if (type === 'model_pro2') return { min: '1.0.0' };
+        return undefined;
+      }
+    );
+
+    expect(versionRange).toEqual({ min: '2.0.0' });
+  });
 });

package/__tests__/deviceSettings.test.ts

@@ -72,6 +72,16 @@ describe('Pro 2 device settings options', () => {
     ]);
   });
 
+  test('uses the shared Protocol V2 settings model for Neo', () => {
+    expect(getLanguageConfig(EDeviceType.Neo)).toEqual(getLanguageConfig(EDeviceType.Pro2));
+    expect(getAutoLockOptions(EDeviceType.Neo, 'V2')).toEqual(
+      getAutoLockOptions(EDeviceType.Pro2, 'V2')
+    );
+    expect(getAutoShutDownOptions(EDeviceType.Neo, 'V2')).toEqual(
+      getAutoShutDownOptions(EDeviceType.Pro2, 'V2')
+    );
+  });
+
   test('keeps the legacy and Protocol V2 never values protocol-specific', () => {
     expect(getAutoLockOptions(EDeviceType.Pro, 'V1').slice(-1)[0]).toEqual({
       label: 'Never',

package/__tests__/deviceUploadNft.test.ts

@@ -160,30 +160,24 @@ describe('DeviceUploadNft', () => {
     });
   });
 
-  test('retries one timed-out NftUpdate with the same basename', async () => {
+  test('does not retry a timed-out NftUpdate', async () => {
     const timeout = Object.assign(new Error('Protocol V2 response timeout'), {
       code: 'response-timeout',
     });
-    let updateCalls = 0;
     const typedCall = jest.fn((request: string, _response: string, params: any) => {
       if (request === 'FilesystemDirList') {
         return { message: { path: 'vol1:/nft', child_files: '' } };
       }
       if (request === 'FilesystemFileWrite') return fileWriteSuccess(params);
-      if (request === 'NftUpdate') {
-        updateCalls += 1;
-        if (updateCalls === 1) throw timeout;
-        return { message: { message: 'NFT updated' } };
-      }
+      if (request === 'NftUpdate') throw timeout;
       throw new Error(`Unexpected request: ${request}`);
     });
     const method = createMethod({ typedCall });
 
-    await expect(method.run()).resolves.toMatchObject({ nftUpdated: true });
+    await expect(method.run()).rejects.toBe(timeout);
 
     const updateRequests = typedCall.mock.calls.filter(call => call[0] === 'NftUpdate');
-    expect(updateRequests).toHaveLength(2);
-    expect(updateRequests[1]).toEqual(updateRequests[0]);
+    expect(updateRequests).toHaveLength(1);
   });
 
   test('does not retry a non-timeout NftUpdate failure', async () => {
@@ -201,24 +195,6 @@ describe('DeviceUploadNft', () => {
     expect(typedCall.mock.calls.filter(call => call[0] === 'NftUpdate')).toHaveLength(1);
   });
 
-  test('propagates a second NftUpdate timeout after one retry', async () => {
-    const timeout = Object.assign(new Error('Protocol V2 response timeout'), {
-      code: 'response-timeout',
-    });
-    const typedCall = jest.fn((request: string, _response: string, params: any) => {
-      if (request === 'FilesystemDirList') {
-        return { message: { path: 'vol1:/nft', child_files: '' } };
-      }
-      if (request === 'FilesystemFileWrite') return fileWriteSuccess(params);
-      if (request === 'NftUpdate') throw timeout;
-      throw new Error(`Unexpected request: ${request}`);
-    });
-    const method = createMethod({ typedCall });
-
-    await expect(method.run()).rejects.toBe(timeout);
-    expect(typedCall.mock.calls.filter(call => call[0] === 'NftUpdate')).toHaveLength(2);
-  });
-
   test('does not publish when a file write fails', async () => {
     const typedCall = jest.fn((request: string) => {
       if (request === 'FilesystemDirList') {

package/__tests__/kaspa-use-tweak-pro2.test.ts

@@ -6,7 +6,7 @@ jest.mock('../src/data/config', () => ({
   DEFAULT_DOMAIN: 'https://jssdk.onekey.so/1.0.0/',
 }));
 
-describe('Kaspa Pro2 useTweak capability', () => {
+describe('Kaspa Pro2 product-family useTweak capability', () => {
   test.each([
     ['get address', KaspaGetAddress],
     ['sign transaction', KaspaSignTransaction],
@@ -14,7 +14,7 @@ describe('Kaspa Pro2 useTweak capability', () => {
     const method = new Method({ id: 1, payload: {} } as never);
 
     expect(method.getUseTweakVersionRange()).toMatchObject({
-      pro2: { min: '0.0.0' },
+      model_pro2: { min: '0.0.0' },
     });
   });
 });

package/__tests__/protocol-v2-resources.test.ts

@@ -56,12 +56,17 @@ const resources: IProtocolV2Resource[] = PROTOCOL_V2_RESOURCE_TYPES.map((type, i
 
 const bootResources: IProtocolV2BootResources = {
   required: false,
-  target: 'CRATE',
-  url: 'https://example.com/boot-resources.crate.okpkg',
-  size: 1234,
-  fileHash: 'ab'.repeat(32),
-  payloadHash: 'cd'.repeat(64),
-  headerHash: 'ef'.repeat(64),
+  target: 'RES',
+  manifestUrl: 'https://example.com/manifest.json',
+  files: [
+    {
+      name: 'bootloader_crest.bin',
+      url: 'https://example.com/assets/bootloader_crest.bin',
+      devicePath: 'vol0:/assets/loaders/boot.staging/graphics/bootloader_crest.bin',
+      size: 1234,
+      fileHash: 'ab'.repeat(32),
+    },
+  ],
 };
 
 const createSettings = (configFetcher: ConnectSettings['configFetcher']): ConnectSettings =>
@@ -119,7 +124,7 @@ describe('Pro2 resource configuration', () => {
     ).toThrow('headerHash');
   });
 
-  test('requires boot resources to remain optional and use a CRATE package', () => {
+  test('requires boot resources to remain optional and use RES file entries', () => {
     expect(() =>
       parseProtocolV2Resources({
         stable: resources,
@@ -129,9 +134,18 @@ describe('Pro2 resource configuration', () => {
     expect(() =>
       parseProtocolV2Resources({
         stable: resources,
-        boot: { ...bootResources, target: 'RESC' },
+        boot: { ...bootResources, target: 'INVALID' },
       })
-    ).toThrow('expected CRATE');
+    ).toThrow('expected RES');
+    expect(() =>
+      parseProtocolV2Resources({
+        stable: resources,
+        boot: {
+          ...bootResources,
+          files: [{ ...bootResources.files[0], devicePath: '../outside.bin' }],
+        },
+      })
+    ).toThrow('devicePath');
   });
 
   test('downloads nothing when all resource identities match', () => {
@@ -269,6 +283,31 @@ describe('Pro2 resource configuration', () => {
     expect(DataManager.getProtocolV2BootResources()).toEqual(bootResources);
   });
 
+  test('keeps base SDK initialization available when remote Pro2 resources are invalid', async () => {
+    const remoteConfig = createRemoteConfig();
+    (remoteConfig.pro2 as { resources?: unknown }).resources = { stable: [] };
+    const configFetcher = jest.fn().mockResolvedValue(remoteConfig);
+
+    await expect(DataManager.load(createSettings(configFetcher))).resolves.toBe(true);
+
+    expect(DataManager.getProtocolV2Resources()).toBeUndefined();
+    expect(DataManager.getProtocolV2BootResources()).toBeUndefined();
+  });
+
+  test('only blocks resource mutation when the refreshed Pro2 resources are invalid', async () => {
+    const remoteConfig = createRemoteConfig();
+    (remoteConfig.pro2 as { resources?: unknown }).resources = { stable: [] };
+    const settings = createSettings(jest.fn().mockResolvedValue(remoteConfig));
+    DataManager.settings = settings;
+
+    await expect(DataManager.forceReloadData()).resolves.toBeUndefined();
+    await expect(DataManager.forceReloadData({ requireResources: true })).rejects.toMatchObject({
+      errorCode: HardwareErrorCode.FirmwareUpdateDownloadFailed,
+      message: expect.stringContaining('Invalid Pro2 resources config'),
+    });
+    expect(DataManager.lastCheckTimestamp).toBeGreaterThan(0);
+  });
+
   test('does not advance the cache timestamp when refresh fails', async () => {
     jest.spyOn(axios, 'get').mockRejectedValue(new Error('offline'));
     const settings = createSettings(jest.fn().mockResolvedValue(null));