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

package/__tests__/DeviceCommands.test.ts

@@ -363,14 +363,9 @@ describe('DeviceCommands failure mapping', () => {
     }
   );
 
-  it.each([
-    ['SignTx', 'Rejected by the user'],
-    ['EthereumSignTypedDataOneKey', ''],
-    ['SolanaSignTx', 'Localized cancellation message'],
-    ['GetAddress', 'Address confirmation rejected'],
-  ] as const)(
-    'maps Protocol V2 cancellation subcode 1 for %s regardless of message',
-    async (callType, 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(
@@ -380,18 +375,13 @@ describe('DeviceCommands failure mapping', () => {
             message: {
               code: 'Failure_ProcessError',
               subcode: 1,
-              message,
+              message: 'Domain-specific failure',
             },
           } as any,
           callType
         )
       ).rejects.toMatchObject({
-        errorCode: HardwareErrorCode.ActionCancelled,
-        params: {
-          failureCode: 'Failure_ProcessError',
-          subcode: 1,
-          firmwareMessage: message,
-        },
+        errorCode: HardwareErrorCode.RuntimeError,
       });
     }
   );

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-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', () => {
@@ -280,17 +294,18 @@ describe('Pro2 resource configuration', () => {
     expect(DataManager.getProtocolV2BootResources()).toBeUndefined();
   });
 
-  test('still blocks firmware mutation when the refreshed Pro2 resources are invalid', async () => {
+  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()).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.NetworkError,
+    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).toBe(0);
+    expect(DataManager.lastCheckTimestamp).toBeGreaterThan(0);
   });
 
   test('does not advance the cache timestamp when refresh fails', async () => {

package/__tests__/protocol-v2-unlock-policy.test.ts

@@ -2,6 +2,7 @@ import { DeviceSessionPinType } from '@onekeyfe/hd-transport';
 
 import ConfluxSignMessageCIP23 from '../src/api/conflux/ConfluxSignMessageCIP23';
 import DeviceLock from '../src/api/device/DeviceLock';
+import OpenWalletSession from '../src/api/OpenWalletSession';
 import { runMethodWithUnlockPolicy } from '../src/protocols/protocol-v2/unlockPolicyRunner';
 
 jest.mock('../src/data/config', () => ({
@@ -33,6 +34,39 @@ describe('Protocol V2 unlock semantics', () => {
     expect(method.unlockPolicy).toBe('none');
   });
 
+  test('pre-unlocks openWalletSession before opening or restoring a wallet session', async () => {
+    const method = new OpenWalletSession({
+      id: 1,
+      payload: { method: 'openWalletSession', mode: 'standard' },
+    });
+    method.init();
+    const run = jest.fn().mockResolvedValue({ walletType: 'standard' });
+    method.run = run as any;
+    const features = { unlocked: false };
+    const device = {
+      features,
+      commands: {
+        typedCall: jest.fn().mockResolvedValue({ message: { unlocked: false } }),
+      },
+      isProtocolV2: () => true,
+      isBootloader: () => false,
+      isRomloader: () => false,
+      updateProtocolV2Status: jest.fn(() => features),
+      unlockDevice: jest.fn().mockImplementation(() => {
+        features.unlocked = true;
+        return Promise.resolve(features);
+      }),
+    };
+
+    await expect(runMethodWithUnlockPolicy(method, device as any)).resolves.toEqual({
+      walletType: 'standard',
+    });
+
+    expect(method.unlockPolicy).toBe('unlock-before-run');
+    expect(device.unlockDevice).toHaveBeenCalledTimes(1);
+    expect(run).toHaveBeenCalledTimes(1);
+  });
+
   test('pre-unlocks an unregistered wallet business method', async () => {
     const features = { unlocked: false };
     const method = {