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

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

@@ -148,7 +148,7 @@ describe('openWalletSession', () => {
     });
   });
 
-  test('selects the Main PIN before opening the standard wallet when passphrase is disabled', async () => {
+  test('opens the standard wallet directly when passphrase is disabled', async () => {
     const typedCall = jest.fn((request: string) => {
       if (request === 'ProtocolInfoRequest') {
         return { message: { version: 2 } };
@@ -167,11 +167,6 @@ describe('openWalletSession', () => {
 
     await getProtocolV2WalletSession(device as any, { onlyMainPin: true });
 
-    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Main, {
-      source: 'wallet-session-coordinator',
-      reason: 'open-wallet',
-      deviceOnly: true,
-    });
     expect(typedCall).not.toHaveBeenCalledWith(
       'DeviceSessionAskPassphrase',
       'Success',
@@ -182,34 +177,6 @@ describe('openWalletSession', () => {
     });
   });
 
-  test('reuses a Main PIN selected by the current preflight when passphrase is disabled', async () => {
-    const typedCall = jest.fn((request: string) => {
-      if (request === 'ProtocolInfoRequest') {
-        return { message: { version: 2 } };
-      }
-      if (request === 'DeviceSessionGet') {
-        return {
-          message: {
-            btc_test_address: 'standard-state',
-            session_id: 'standard-session',
-          },
-        };
-      }
-      throw new Error(`Unexpected request: ${request}`);
-    });
-    const device = createDevice({ passphraseProtection: false, typedCall });
-
-    await getProtocolV2WalletSession(device as any, {
-      onlyMainPin: true,
-      mainPinSelected: true,
-    });
-
-    expect(device.unlockDevice).not.toHaveBeenCalled();
-    expect(typedCall).toHaveBeenCalledWith('DeviceSessionGet', 'DeviceSession', {
-      seed_domains: [],
-    });
-  });
-
   test('does not treat an Attach PIN DeviceStatus as the Main wallet', async () => {
     const typedCall = jest.fn((request: string) => {
       if (request === 'ProtocolInfoRequest') {
@@ -1147,68 +1114,6 @@ describe('openWalletSession', () => {
     expect(device.getDeviceState).toHaveBeenCalledTimes(2);
   });
 
-  test('does not restrict a locked hidden-wallet selection to the Main PIN', async () => {
-    const typedCall = jest
-      .fn()
-      .mockResolvedValueOnce({ message: { version: 2 } })
-      .mockResolvedValueOnce({ message: {} })
-      .mockResolvedValueOnce({
-        message: {
-          btc_test_address: 'hidden-state',
-          session_id: 'hidden-session',
-        },
-      });
-    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' });
-    const method = new OpenWalletSession({
-      payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'select-hidden' },
-    });
-    method.init();
-    const device = createDevice({ typedCall, promptPassphrase });
-    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,
-        },
-      })
-      .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({
-      walletType: 'hidden',
-      passphraseState: 'hidden-state',
-    });
-    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Any, {
-      source: 'unlock-coordinator',
-      reason: 'device-locked',
-      deviceOnly: true,
-      method: 'openWalletSession',
-    });
-    expect(device.unlockDevice).not.toHaveBeenCalledWith(
-      DeviceSessionPinType.Main,
-      expect.anything()
-    );
-  });
-
   test('switches from Attach PIN to Main PIN before opening the standard wallet', async () => {
     const typedCall = jest
       .fn()
@@ -1303,37 +1208,6 @@ describe('openWalletSession', () => {
     expect(deviceWalletSessionStore.get('device-1', 'hidden-state')).toBe('hidden-session');
   });
 
-  test('reuses the fresh unlock and wallet-selection statuses', async () => {
-    const typedCall = jest
-      .fn()
-      .mockResolvedValueOnce({ message: { version: 2 } })
-      .mockResolvedValueOnce({ message: {} })
-      .mockResolvedValueOnce({
-        message: {
-          btc_test_address: 'hidden-state',
-          session_id: 'hidden-session',
-        },
-      });
-    const promptPassphrase = jest.fn().mockResolvedValue({ passphrase: 'host hidden wallet' });
-    const method = new OpenWalletSession({
-      payload: { method: 'openWalletSession', connectId: 'connect-id', mode: 'select-hidden' },
-    });
-    method.init();
-    method.protocolV2UnlockContext = {
-      preflightCompleted: true,
-      preflightStatusRefreshed: true,
-    };
-    const device = createDevice({ typedCall, promptPassphrase });
-    method.device = device as any;
-
-    await expect(method.run()).resolves.toMatchObject({
-      walletType: 'hidden',
-      passphraseState: 'hidden-state',
-    });
-
-    expect(device.getDeviceState.mock.calls).toEqual([[], []]);
-  });
-
   test('gets the prepared session after host passphrase entry', async () => {
     const typedCall = jest
       .fn()

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

@@ -66,6 +66,8 @@ const createRemoteConfig = (): RemoteConfigResponse =>
         {
           required: false,
           version: [1, 0, 0],
+          url: 'https://example.com/pro2.okpkg',
+          fingerprint: 'a'.repeat(64),
           changelog: { 'zh-CN': 'Pro2', 'en-US': 'Pro2' },
           resources: { source: resourceSource },
         },
@@ -77,6 +79,8 @@ const createRemoteConfig = (): RemoteConfigResponse =>
         {
           required: false,
           version: [1, 0, 0],
+          url: 'https://example.com/neo.okpkg',
+          fingerprint: 'b'.repeat(64),
           changelog: { 'zh-CN': 'Neo', 'en-US': 'Neo' },
           resources: { source: neoResourceSource },
         },
@@ -105,11 +109,6 @@ describe('Pro2 resource configuration', () => {
     expect(
       isProtocolV2ResourceArchiveEntryName('bundles/firmware_logo-pro2-prod_resource-signed.okpkg')
     ).toBe(true);
-    expect(
-      isProtocolV2ResourceArchiveEntryName(
-        'pro2-prod_resource/bundles/firmware_logo-pro2-prod_resource-signed.okpkg'
-      )
-    ).toBe(true);
     expect(
       isProtocolV2ResourceArchiveEntryName(
         '__MACOSX/pro2-prod_resource 2/bundles/._firmware_logo-pro2-prod_resource-signed.okpkg'
@@ -120,8 +119,6 @@ describe('Pro2 resource configuration', () => {
         'bundles/._firmware_logo-pro2-prod_resource-signed.okpkg'
       )
     ).toBe(false);
-    expect(isProtocolV2ResourceArchiveEntryName('pro2-prod_resource/manifest.json')).toBe(false);
-    expect(isProtocolV2ResourceArchiveEntryName('pro2-prod_resource/.DS_Store')).toBe(false);
   });
 
   test('reads the version, hashes, and direct device path from a RESC package', () => {

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

@@ -151,42 +151,8 @@ describe('Protocol V2 unlock semantics', () => {
     });
 
     expect(method.unlockPolicy).toBe('unlock-before-run');
-    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Main, expect.any(Object));
+    expect(device.unlockDevice).toHaveBeenCalledTimes(1);
     expect(run).toHaveBeenCalledTimes(1);
-    expect(method.protocolV2UnlockContext).toMatchObject({
-      preflightCompleted: true,
-      preflightStatusRefreshed: true,
-      preflightMainPinSelected: true,
-    });
-  });
-
-  test('allows either PIN type when pre-unlocking hidden-wallet selection', async () => {
-    const method = new OpenWalletSession({
-      id: 1,
-      payload: { method: 'openWalletSession', mode: 'select-hidden' },
-    });
-    method.init();
-    method.run = jest.fn().mockResolvedValue({ walletType: 'hidden' }) 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 runMethodWithUnlockPolicy(method, device as any);
-
-    expect(device.unlockDevice).toHaveBeenCalledWith(DeviceSessionPinType.Any, expect.any(Object));
-    expect(method.protocolV2UnlockContext?.preflightMainPinSelected).toBe(false);
   });
 
   test('pre-unlocks an unregistered wallet business method', async () => {