@onekeyfe/hd-core 1.2.2-alpha.9 → 1.2.2

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

@@ -17,7 +17,7 @@ jest.mock('../src/data-manager/TransportManager', () => ({
 }));
 
 describe('openWalletSession error response', () => {
-  test('returns a structured invalid-parameter response for an incomplete resume request', async () => {
+  test('returns a structured invalid-parameter response for the removed resume-hidden mode', async () => {
     const core = initCore();
 
     const response = await core.handleMessage({
@@ -34,7 +34,7 @@ describe('openWalletSession error response', () => {
     expect(response).toMatchObject({
       success: false,
       payload: {
-        error: 'Missing required parameter: deviceId',
+        error: 'Parameter [mode] must be one of standard or select-hidden.',
         code: HardwareErrorCode.CallMethodInvalidParameter,
       },
     });

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

@@ -982,45 +982,6 @@ describe('openWalletSession', () => {
     );
   });
 
-  test('uses an explicit wallet binding to resume on Protocol V2', async () => {
-    const typedCall = jest
-      .fn()
-      .mockResolvedValueOnce({ message: { version: 2 } })
-      .mockResolvedValueOnce({
-        message: {
-          btc_test_address: 'hidden-state',
-          session_id: 'renewed-session',
-        },
-      });
-    const promptPassphrase = jest.fn();
-    const method = new OpenWalletSession({
-      payload: {
-        method: 'openWalletSession',
-        connectId: 'connect-id',
-        mode: 'resume-hidden',
-        deviceId: 'device-1',
-        passphraseState: 'hidden-state',
-      },
-    });
-    method.init();
-    deviceWalletSessionStore.set('device-1', 'hidden-state', 'known-session');
-    method.device = createDevice({ typedCall, promptPassphrase }) as any;
-
-    await expect(method.run()).resolves.toEqual({
-      protocol: 'V2',
-      walletType: 'hidden',
-      deviceId: 'device-1',
-      passphraseState: 'hidden-state',
-      resumed: true,
-    });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      session_id: 'known-session',
-      btc_test_address: 'hidden-state',
-      ...standardSessionGet,
-    });
-    expect(promptPassphrase).not.toHaveBeenCalled();
-  });
-
   test.each([
     {
       mode: 'standard',
@@ -1035,12 +996,6 @@ describe('openWalletSession', () => {
       deviceId: 'device-1',
       passphraseState: 'hidden-state',
     },
-    {
-      mode: 'resume-hidden',
-      deviceId: 'device-1',
-      passphraseState: 'hidden-state',
-      initSession: false,
-    },
   ])('rejects legacy parameters combined with explicit mode: %o', params => {
     const method = new OpenWalletSession({
       payload: {
@@ -1076,63 +1031,7 @@ describe('openWalletSession', () => {
     }
   );
 
-  test('reuses the SDK-managed Protocol V1 hidden-wallet session before validation', async () => {
-    const typedCall = jest.fn().mockResolvedValue({
-      type: 'PassphraseState',
-      message: {
-        passphrase_state: 'hidden-state',
-        session_id: 'known-session',
-        unlocked_attach_pin: false,
-      },
-    });
-    const method = new OpenWalletSession({
-      payload: {
-        method: 'openWalletSession',
-        connectId: 'connect-id',
-        mode: 'resume-hidden',
-        deviceId: 'device-1',
-        passphraseState: 'hidden-state',
-      },
-    });
-    method.init();
-    deviceWalletSessionStore.set('device-1', 'hidden-state', 'known-session');
-    const device = createDevice({ typedCall });
-    device.isProtocolV2 = () => false;
-    device.features = {
-      ...device.features,
-      deviceId: 'device-1',
-      unlocked: true,
-      sessionId: null,
-    };
-    device.getCurrentFirmwareVersionString = () => '4.15.0';
-    device.getCurrentDeviceType = () => EDeviceType.Pro;
-    device.getFeatures = jest.fn();
-    method.device = device as any;
-
-    await expect(method.run()).resolves.toMatchObject({
-      protocol: 'V1',
-      walletType: 'hidden',
-      passphraseState: 'hidden-state',
-      resumed: true,
-    });
-    expect(device.initialize).toHaveBeenCalledWith({
-      deviceId: 'device-1',
-      passphraseState: 'hidden-state',
-    });
-    expect(typedCall).toHaveBeenCalledWith('GetPassphraseState', 'PassphraseState', {
-      passphrase_state: 'hidden-state',
-    });
-  });
-
-  test('rejects a Protocol V1 resume when the device returns another hidden wallet', async () => {
-    const typedCall = jest.fn().mockResolvedValue({
-      type: 'PassphraseState',
-      message: {
-        passphrase_state: 'other-hidden-state',
-        session_id: 'other-session',
-        unlocked_attach_pin: false,
-      },
-    });
+  test('rejects the removed resume-hidden mode', () => {
     const method = new OpenWalletSession({
       payload: {
         method: 'openWalletSession',
@@ -1140,28 +1039,15 @@ describe('openWalletSession', () => {
         mode: 'resume-hidden',
         deviceId: 'device-1',
         passphraseState: 'hidden-state',
-      },
+      } as any,
     });
-    method.init();
-    deviceWalletSessionStore.set('device-1', 'hidden-state', 'known-session');
-    const device = createDevice({ typedCall });
-    device.isProtocolV2 = () => false;
-    device.features = {
-      ...device.features,
-      deviceId: 'device-1',
-      unlocked: true,
-      sessionId: null,
-    };
-    device.getCurrentFirmwareVersionString = () => '4.15.0';
-    device.getCurrentDeviceType = () => EDeviceType.Pro;
-    device.getFeatures = jest.fn();
-    method.device = device as any;
 
-    await expect(method.run()).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.DeviceCheckPassphraseStateError,
-    });
-    expect(device.clearInternalState).toHaveBeenCalledTimes(1);
-    expect(deviceWalletSessionStore.get('device-1', 'hidden-state')).toBeUndefined();
+    expect(() => method.init()).toThrow(
+      expect.objectContaining({
+        errorCode: HardwareErrorCode.CallMethodInvalidParameter,
+        message: 'Parameter [mode] must be one of standard or select-hidden.',
+      })
+    );
   });
 
   test('opens the standard wallet without selecting a hidden wallet', async () => {
@@ -1882,242 +1768,6 @@ describe('openWalletSession', () => {
     }
   );
 
-  test('resumes a known hidden wallet without prompting or device selection', async () => {
-    const typedCall = jest
-      .fn()
-      .mockResolvedValueOnce({ message: { version: 2 } })
-      .mockResolvedValueOnce({
-        message: {
-          btc_test_address: 'hidden-state',
-          session_id: 'renewed-session',
-        },
-      });
-    const promptPassphrase = jest.fn();
-    const method = new OpenWalletSession({
-      payload: {
-        method: 'openWalletSession',
-        connectId: 'connect-id',
-        mode: 'resume-hidden',
-        deviceId: 'device-1',
-        passphraseState: 'hidden-state',
-      },
-    });
-    method.init();
-    deviceWalletSessionStore.set('device-1', 'hidden-state', 'known-session');
-    method.device = createDevice({ typedCall, promptPassphrase }) as any;
-
-    await expect(method.run()).resolves.toEqual({
-      protocol: 'V2',
-      walletType: 'hidden',
-      deviceId: 'device-1',
-      passphraseState: 'hidden-state',
-      resumed: true,
-    });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      session_id: 'known-session',
-      btc_test_address: 'hidden-state',
-      ...standardSessionGet,
-    });
-    expect(promptPassphrase).not.toHaveBeenCalled();
-  });
-
-  test('validates a locked Protocol V2 resume binding after deviceId refresh', async () => {
-    const typedCall = jest
-      .fn()
-      .mockResolvedValueOnce({ message: { version: 2 } })
-      .mockResolvedValueOnce({
-        message: {
-          btc_test_address: 'hidden-state',
-          session_id: 'renewed-session',
-        },
-      });
-    const method = new OpenWalletSession({
-      payload: {
-        method: 'openWalletSession',
-        connectId: 'connect-id',
-        mode: 'resume-hidden',
-        deviceId: 'device-1',
-        passphraseState: 'hidden-state',
-      },
-    });
-    method.init();
-    deviceWalletSessionStore.set('device-1', 'hidden-state', 'known-session');
-    const device = createDevice({ typedCall });
-    device.features.unlocked = false;
-    device.getDeviceState = jest
-      .fn()
-      .mockResolvedValueOnce({
-        identity: { deviceId: undefined },
-        status: { unlocked: false, passphraseProtection: true },
-      })
-      .mockResolvedValueOnce({
-        identity: { deviceId: 'device-1' },
-        status: {
-          unlocked: true,
-          passphraseProtection: true,
-          unlockedAttachPin: false,
-        },
-      });
-    device.unlockDevice = jest.fn().mockImplementation(() => {
-      device.features.unlocked = true;
-      return Promise.resolve(device.features);
-    });
-    method.device = device as any;
-
-    await expect(method.run()).resolves.toMatchObject({
-      protocol: 'V2',
-      walletType: 'hidden',
-      deviceId: 'device-1',
-      passphraseState: 'hidden-state',
-      resumed: true,
-    });
-    expect(device.unlockDevice).toHaveBeenCalledTimes(1);
-    expect(device.getDeviceState).toHaveBeenCalledTimes(2);
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      session_id: 'known-session',
-      btc_test_address: 'hidden-state',
-      ...standardSessionGet,
-    });
-    const sessionGetCall = typedCall.mock.calls.findIndex(
-      ([requestName]) => requestName === 'DeviceSessionGet'
-    );
-    expect(device.getDeviceState.mock.invocationCallOrder[1]).toBeLessThan(
-      typedCall.mock.invocationCallOrder[sessionGetCall]
-    );
-  });
-
-  test('rejects a Protocol V2 resume when the refreshed deviceId does not match', async () => {
-    const typedCall = jest.fn().mockResolvedValue({
-      message: {
-        btc_test_address: 'hidden-state',
-        session_id: 'renewed-session',
-      },
-    });
-    const method = new OpenWalletSession({
-      payload: {
-        method: 'openWalletSession',
-        connectId: 'connect-id',
-        mode: 'resume-hidden',
-        deviceId: 'device-1',
-        passphraseState: 'hidden-state',
-      },
-    });
-    method.init();
-    deviceWalletSessionStore.set('device-1', 'hidden-state', 'known-session');
-    const device = createDevice({ typedCall });
-    device.features.unlocked = false;
-    device.getDeviceState = jest
-      .fn()
-      .mockResolvedValueOnce({
-        identity: { deviceId: undefined },
-        status: { passphraseProtection: true },
-      })
-      .mockResolvedValueOnce({
-        identity: { deviceId: 'other-device' },
-        status: {
-          unlocked: true,
-          passphraseProtection: true,
-          unlockedAttachPin: false,
-        },
-      });
-    device.unlockDevice = jest.fn().mockImplementation(() => {
-      device.features.unlocked = true;
-      return Promise.resolve(device.features);
-    });
-    method.device = device as any;
-
-    await expect(method.run()).rejects.toMatchObject({
-      errorCode: HardwareErrorCode.DeviceCheckDeviceIdError,
-    });
-    expect(typedCall).not.toHaveBeenCalled();
-    expect(device.clearInternalState).not.toHaveBeenCalled();
-    expect(deviceWalletSessionStore.get('device-1', 'hidden-state')).toBeUndefined();
-  });
-
-  test('reselects the expected hidden wallet when a cached Protocol V2 session is invalid', async () => {
-    const typedCall = jest
-      .fn()
-      .mockResolvedValueOnce({ message: { version: 2 } })
-      .mockRejectedValueOnce(
-        Object.assign(new Error('Invalid session'), {
-          errorCode: HardwareErrorCode.WalletSessionInvalid,
-        })
-      )
-      .mockResolvedValueOnce({ message: {} })
-      .mockResolvedValueOnce({
-        message: {
-          btc_test_address: 'hidden-state',
-          session_id: 'renewed-session',
-        },
-      });
-    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' });
-    const method = new OpenWalletSession({
-      payload: {
-        method: 'openWalletSession',
-        connectId: 'connect-id',
-        mode: 'resume-hidden',
-        deviceId: 'device-1',
-        passphraseState: 'hidden-state',
-      },
-    });
-    method.init();
-    deviceWalletSessionStore.set('device-1', 'hidden-state', 'expired-session');
-    method.device = createDevice({ typedCall, promptPassphrase }) as any;
-
-    await expect(method.run()).resolves.toEqual({
-      protocol: 'V2',
-      walletType: 'hidden',
-      deviceId: 'device-1',
-      passphraseState: 'hidden-state',
-      resumed: false,
-    });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      session_id: 'expired-session',
-      btc_test_address: 'hidden-state',
-      ...standardSessionGet,
-    });
-    expect(promptPassphrase).toHaveBeenCalledTimes(1);
-    expect(deviceWalletSessionStore.get('device-1', 'hidden-state')).toBe('renewed-session');
-  });
-
-  test('selects the expected hidden wallet when Protocol V2 has no cached session', async () => {
-    const typedCall = jest
-      .fn()
-      .mockResolvedValueOnce({ message: { version: 2 } })
-      .mockResolvedValueOnce({
-        message: {
-          btc_test_address: 'hidden-state',
-          session_id: 'new-session',
-        },
-      });
-    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' });
-    const method = new OpenWalletSession({
-      payload: {
-        method: 'openWalletSession',
-        connectId: 'connect-id',
-        mode: 'resume-hidden',
-        deviceId: 'device-1',
-        passphraseState: 'hidden-state',
-      },
-    });
-    method.init();
-    method.device = createDevice({ typedCall, promptPassphrase }) as any;
-
-    await expect(method.run()).resolves.toEqual({
-      protocol: 'V2',
-      walletType: 'hidden',
-      deviceId: 'device-1',
-      passphraseState: 'hidden-state',
-      resumed: false,
-    });
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      btc_test_address: 'hidden-state',
-      ...standardSessionGet,
-    });
-    expect(promptPassphrase).not.toHaveBeenCalled();
-    expect(deviceWalletSessionStore.get('device-1', 'hidden-state')).toBe('new-session');
-  });
-
   test.each([false, true])(
     'openWalletSession does not thread CommonParams.deriveCardano: %s',
     async deriveCardano => {

package/__tests__/protocol-v2.test.ts

@@ -1,4 +1,5 @@
 import { Buffer } from 'buffer';
+import { randomBytes } from 'crypto';
 import { EDeviceType, EFirmwareType, ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 import { sha256 } from '@noble/hashes/sha256';
 import { bytesToHex } from '@noble/hashes/utils';
@@ -536,6 +537,41 @@ describe('UploadPortfolio', () => {
     });
   });
 
+  test('emits transfer progress when progress UI is requested', async () => {
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ message: { processed_byte: 3 } })
+      .mockResolvedValueOnce({ message: { message: 'Portfolio updated' } });
+    const method = new UploadPortfolio({
+      id: 1,
+      payload: {
+        method: 'uploadPortfolio',
+        packageBase64: 'AQID',
+        uiMode: 'progress',
+      },
+    });
+    (method as any).device = stubPortfolioDevice({ commands: { typedCall } });
+    method.postMessage = jest.fn();
+
+    method.init();
+    await method.run();
+
+    expect(method.unlockPolicy).toBe('none');
+    expect(method.protocolV2UiMode).toBe('auto');
+    expect(method.protocolV2UiInteraction).toBeUndefined();
+    expect(method.payload.emitProgress).toBe(true);
+    expect(method.postMessage).toHaveBeenCalledWith({
+      event: 'UI_EVENT',
+      type: UI_REQUEST.DEVICE_PROGRESS,
+      payload: expect.objectContaining({
+        progress: 100,
+        transferredBytes: 3,
+        totalBytes: 3,
+        elapsedMs: expect.any(Number),
+      }),
+    });
+  });
+
   test('does not apply PortfolioUpdate when staging fails', async () => {
     const typedCall = jest.fn().mockRejectedValue(new Error('write failed'));
     const method = new UploadPortfolio({
@@ -1789,6 +1825,56 @@ describe('Protocol V2 feature adapter', () => {
     ]);
   });
 
+  test.each([false, true])(
+    'rejects the first incorrect passphrase after a missing or expired session (cached: %s)',
+    async cached => {
+      const deviceId = `first-passphrase-error-${String(cached)}`;
+      const device = Device.fromDescriptor({
+        id: deviceId,
+        path: deviceId,
+        protocolType: 'V2',
+      } as never);
+      device.features = normalizeProtocolV2Features(
+        { ...descriptor, protocolType: 'V2' } as never,
+        {
+          status: { device_id: deviceId, unlocked: true, passphrase_enabled: true },
+        }
+      );
+      device.passphraseState = 'expected-public-address';
+      if (cached) {
+        preloadSessionCache(deviceId, device.passphraseState, randomBytes(32).toString('hex'));
+      }
+      let reads = 0;
+      const typedCall = createWalletSessionTypedCall(
+        jest.fn((request: string) => {
+          if (request === 'DeviceSessionAskPassphrase') return { message: {} };
+          if (request === 'DeviceSessionGet') {
+            reads += 1;
+            if (reads === 1) {
+              throw ERRORS.TypedError(HardwareErrorCode.WalletSessionInvalid);
+            }
+            return {
+              message: {
+                session_id: randomBytes(32).toString('hex'),
+                btc_test_address: 'different-public-address',
+              },
+            };
+          }
+          throw new Error(`Unexpected request: ${request}`);
+        })
+      );
+      const promptPassphrase = jest.fn().mockResolvedValue({ passphraseOnDevice: true });
+      device.commands = { typedCall, promptPassphrase } as never;
+
+      await expect(getProtocolV2WalletSession(device)).rejects.toMatchObject({
+        errorCode: HardwareErrorCode.DeviceCheckPassphraseStateError,
+      });
+      expect(promptPassphrase).toHaveBeenCalledTimes(1);
+      expect(reads).toBe(2);
+      expect(device.getInternalState()).toBeUndefined();
+    }
+  );
+
   test('reselects a hidden wallet when the cached Pro2 session resolves to another wallet', async () => {
     const device = Device.fromDescriptor({
       id: 'cache-device-mismatch',
@@ -8892,6 +8978,50 @@ describe('Protocol V2 firmware update targets', () => {
     expect(recoverProtocolV2FileTransfer).not.toHaveBeenCalled();
   });
 
+  test('keeps public transfer bytes monotonic when a V4 file retry restarts at zero', async () => {
+    const method = new FirmwareUpdateV4({
+      id: 1,
+      payload: {
+        method: 'firmwareUpdateV4',
+      },
+    });
+    let writeCount = 0;
+    (method as any).fileWriteChunk = jest.fn(
+      (_path: string, _size: number, offset: number, data: Uint8Array) => {
+        writeCount += 1;
+        if (writeCount === 3) {
+          return Promise.reject(new Error('transport timeout'));
+        }
+        return Promise.resolve({
+          message: { processed_byte: offset + data.byteLength },
+        });
+      }
+    );
+    (method as any).getProtocolV2FirmwareChunkSize = jest.fn().mockReturnValue(1000);
+    (method as any).recoverProtocolV2FileTransfer = jest.fn().mockResolvedValue(undefined);
+    method.postProgressMessage = jest.fn();
+    const source = await openFirmwareByteSource({
+      binary: new Uint8Array(3000).buffer,
+    });
+
+    try {
+      await (method as any).protocolV2SourceUpdateProcess({
+        source,
+        filePath: 'vol1:firmware.bin',
+        processedSize: 0,
+        totalSize: 3000,
+      });
+    } finally {
+      await source?.close();
+    }
+
+    const transferredBytes = (method.postProgressMessage as jest.Mock).mock.calls.map(
+      ([, , metrics]) => metrics.transferredBytes
+    );
+    expect(transferredBytes).toEqual([1000, 2000, 3000]);
+    expect((method as any).recoverProtocolV2FileTransfer).toHaveBeenCalledTimes(1);
+  });
+
   test('throttles repeated transfer progress while preserving file completion', async () => {
     const method = new FirmwareUpdateV4({
       id: 1,

package/__tests__/public-device-state-api.test.ts

@@ -22,7 +22,6 @@ describe('public device state API boundary', () => {
     expect((publicTypes as Record<string, unknown>).OpenWalletSessionMode).toEqual({
       Standard: 'standard',
       SelectHidden: 'select-hidden',
-      ResumeHidden: 'resume-hidden',
     });
   });
 
@@ -83,9 +82,7 @@ describe('public device state API boundary', () => {
       useEmptyPassphrase: false,
     });
     await api.openWalletSession('device-2', {
-      mode: publicTypes.OpenWalletSessionMode.ResumeHidden,
-      deviceId: 'wallet-device-1',
-      passphraseState: 'wallet-state-1',
+      mode: publicTypes.OpenWalletSessionMode.SelectHidden,
     });
     await api.clearSessionCache({
       deviceId: 'wallet-device-1',
@@ -100,9 +97,7 @@ describe('public device state API boundary', () => {
     });
     expect(call).toHaveBeenNthCalledWith(2, {
       connectId: 'device-2',
-      mode: 'resume-hidden',
-      deviceId: 'wallet-device-1',
-      passphraseState: 'wallet-state-1',
+      mode: 'select-hidden',
       method: 'openWalletSession',
     });
     expect(call).toHaveBeenNthCalledWith(3, {