@onekeyfe/hd-core 1.2.0-alpha.25 → 1.2.0-alpha.26

package/__tests__/protocol-v2.test.ts

@@ -200,6 +200,42 @@ describe('DeviceUploadWallpaper', () => {
 });
 
 describe('UploadPortfolio', () => {
+  test('writes and applies the portfolio while the device is locked without unlocking', async () => {
+    const packageBytes = new Uint8Array([1, 2, 3]);
+    const typedCall = jest
+      .fn()
+      .mockResolvedValueOnce({ message: { processed_byte: 3 } })
+      .mockResolvedValueOnce({ message: { message: 'Portfolio updated' } });
+    const unlockDevice = jest.fn().mockResolvedValue(undefined);
+    const device = stubDevice({
+      features: { unlocked: false },
+      commands: { typedCall },
+      isProtocolV2: () => true,
+      unlockDevice,
+    });
+    const method = new UploadPortfolio({
+      id: 1,
+      payload: {
+        method: 'uploadPortfolio',
+        packageBytes,
+      },
+    });
+    (method as any).device = device;
+
+    method.init();
+    await runMethodWithUnlockRetry(method, device as any);
+
+    expect(unlockDevice).not.toHaveBeenCalled();
+    expect(typedCall).toHaveBeenNthCalledWith(
+      1,
+      'FilesystemFileWrite',
+      'FilesystemFile',
+      expect.any(Object),
+      { timeoutMs: undefined }
+    );
+    expect(typedCall).toHaveBeenNthCalledWith(2, 'PortfolioUpdate', 'Success', {});
+  });
+
   test('stages the complete package before applying PortfolioUpdate', async () => {
     const packageBytes = new Uint8Array([1, 2, 3]);
     const typedCall = jest
@@ -219,7 +255,7 @@ describe('UploadPortfolio', () => {
     method.init();
     const result = await method.run();
 
-    expect(method.unlockPolicy).toBe('unlock-before-run');
+    expect(method.unlockPolicy).toBe('none');
     expect(method.protocolV2UiMode).toBe('none');
     expect(method.protocolV2UiInteraction).toBeUndefined();
     expect(method.payload.emitProgress).toBe(false);
@@ -5359,6 +5395,93 @@ describe('Protocol V2 protected method execution', () => {
     ]);
   });
 
+  test('restores the expected hidden-wallet session after pre-unlock without selecting Attach PIN', async () => {
+    const calls: string[] = [];
+    const method = {
+      name: 'evmSignMessage',
+      payload: { passphraseState: 'hidden-state' },
+      useDevicePassphraseState: true,
+      unlockPolicy: 'retry-on-locked',
+      run: jest.fn(() => {
+        calls.push('run');
+        return Promise.resolve({ message: 'ok' });
+      }),
+    };
+    const typedCall = jest.fn((requestType: string, _responseType: string, request: any) => {
+      if (requestType === 'ProtocolInfoRequest') {
+        calls.push('negotiate-session');
+        return Promise.resolve({ message: { version: 2 } });
+      }
+      if (requestType === 'DeviceSessionGet') {
+        calls.push('resume-hidden-session');
+        expect(request).toEqual({ session_id: 'hidden-session' });
+        return Promise.resolve({
+          message: {
+            session_id: 'hidden-session',
+            btc_test_address: 'hidden-state',
+          },
+        });
+      }
+      throw new Error(`Unexpected request: ${requestType}`);
+    });
+    const features = {
+      unlocked: false,
+      unlockedAttachPin: true,
+      passphraseProtection: true,
+    };
+    const device = {
+      features,
+      passphraseState: 'hidden-state',
+      commands: { typedCall },
+      isProtocolV2: () => true,
+      unlockDevice: jest.fn(() => {
+        calls.push('unlock-main');
+        features.unlocked = true;
+        features.unlockedAttachPin = false;
+        return Promise.resolve();
+      }),
+      getCurrentPassphraseProtection: () => true,
+      getInternalState: () => 'hidden-session',
+      clearInternalState: jest.fn(),
+      getCurrentDeviceId: () => 'wallet-device-id',
+      updateInternalState: jest.fn(() => calls.push('validate-hidden-session')),
+    };
+
+    await expect(runMethodWithUnlockRetry(method as any, device as any)).resolves.toEqual({
+      message: 'ok',
+    });
+    expect(device.unlockDevice).toHaveBeenCalledWith();
+    expect(calls).toEqual([
+      'unlock-main',
+      'negotiate-session',
+      'resume-hidden-session',
+      'validate-hidden-session',
+      'run',
+    ]);
+  });
+
+  test('does not restore a hidden-wallet session for a standard-wallet pre-unlock', async () => {
+    const method = {
+      name: 'evmGetAddress',
+      payload: { useEmptyPassphrase: true },
+      useDevicePassphraseState: true,
+      unlockPolicy: 'retry-on-locked',
+      run: jest.fn().mockResolvedValue({ address: 'standard-wallet-address' }),
+    };
+    const device = {
+      features: { unlocked: false },
+      passphraseState: 'stale-hidden-state',
+      isProtocolV2: () => true,
+      unlockDevice: jest.fn().mockResolvedValue(undefined),
+    };
+
+    await expect(runMethodWithUnlockRetry(method as any, device as any)).resolves.toEqual({
+      address: 'standard-wallet-address',
+    });
+    expect(device.unlockDevice).toHaveBeenCalledTimes(1);
+    expect(method.run).toHaveBeenCalledTimes(1);
+  });
+
   test('unlocks before showing the method interaction when cached status is locked', async () => {
     const calls: string[] = [];
     const method = {
@@ -5444,10 +5567,10 @@ describe('Protocol V2 protected method execution', () => {
     }
   });
 
-  test('keeps auto unlock but suppresses all synthesized UI for eventless methods', async () => {
+  test('runs lock-free eventless methods without unlocking or synthesized UI', async () => {
     const method = {
       name: 'uploadPortfolio',
-      unlockPolicy: 'unlock-before-run',
+      unlockPolicy: 'none',
       protocolV2UiMode: 'none',
       run: jest.fn().mockResolvedValue({ message: 'ok' }),
     };
@@ -5465,17 +5588,17 @@ describe('Protocol V2 protected method execution', () => {
     await expect(
       runMethodWithUnlockRetry(method as any, device as any, uiCoordinator as any)
     ).resolves.toEqual({ message: 'ok' });
-    expect(device.unlockDevice).toHaveBeenCalledTimes(1);
+    expect(device.unlockDevice).not.toHaveBeenCalled();
     expect(uiCoordinator.enterMethodInteraction).not.toHaveBeenCalled();
     expect(uiCoordinator.enterUnlockInteraction).not.toHaveBeenCalled();
     expect(uiCoordinator.resumeMethodInteraction).not.toHaveBeenCalled();
   });
 
-  test('does not replay a state-changing method after a locked response', async () => {
+  test('does not unlock or replay a lock-free state-changing method after a locked response', async () => {
     const error = deviceLockedError();
     const method = {
       name: 'uploadPortfolio',
-      unlockPolicy: 'unlock-before-run',
+      unlockPolicy: 'none',
       run: jest.fn().mockRejectedValue(error),
     };
     const device = {

package/__tests__/tron-sign-message-init.test.ts

@@ -43,4 +43,32 @@ describe('TronSignMessage legacy message validation', () => {
       }
     }
   );
+
+  test('allows Protocol V2 message signing on Pro2', async () => {
+    const method = new TronSignMessage({
+      id: 1,
+      payload: {
+        method: 'tronSignMessage',
+        path: "m/44'/195'/0'/0/0",
+        messageHex: '00',
+        messageType: 'V2',
+      },
+    });
+    method.init();
+
+    const typedCall = jest.fn().mockResolvedValue({ message: { signature: 'signature' } });
+    method.device = {
+      commands: { typedCall },
+      getCurrentFirmwareVersionString: jest.fn(() => '0.0.0'),
+      getCurrentMethodVersionRange: jest.fn(selector => selector('pro2')),
+      getCurrentFirmwareType: jest.fn(() => EFirmwareType.Universal),
+    } as unknown as Device;
+
+    await expect(method.run()).resolves.toEqual({ signature: 'signature' });
+    expect(typedCall).toHaveBeenCalledWith('TronSignMessage', 'TronMessageSignature', {
+      address_n: [2147483692, 2147483843, 2147483648, 0, 0],
+      message: '00',
+      message_type: 2,
+    });
+  });
 });

package/dist/api/tron/TronSignMessage.d.ts

@@ -13,6 +13,9 @@ export default class TronSignMessage extends BaseMethod<HardwareTronSignMessage>
         };
     };
     getMessageV2VersionRange(): {
+        pro2: {
+            min: string;
+        };
         pro: {
             min: string;
         };

package/dist/api/tron/TronSignMessage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TronSignMessage.d.ts","sourceRoot":"","sources":["../../../src/api/tron/TronSignMessage.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAI3C,OAAO,KAAK,EAAE,eAAe,IAAI,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AAEzF,MAAM,CAAC,OAAO,OAAO,eAAgB,SAAQ,UAAU,CAAC,uBAAuB,CAAC;IAC9E,OAAO,CAAC,mBAAmB,CAAS;IAEpC,qBAAqB;IAIrB,IAAI;IA4BJ,eAAe;;;;;;;;IAWf,wBAAwB;;;;;;;;;;;;;;IAiBlB,GAAG;CA0BV"}
+{"version":3,"file":"TronSignMessage.d.ts","sourceRoot":"","sources":["../../../src/api/tron/TronSignMessage.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAI3C,OAAO,KAAK,EAAE,eAAe,IAAI,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AAEzF,MAAM,CAAC,OAAO,OAAO,eAAgB,SAAQ,UAAU,CAAC,uBAAuB,CAAC;IAC9E,OAAO,CAAC,mBAAmB,CAAS;IAEpC,qBAAqB;IAIrB,IAAI;IA4BJ,eAAe;;;;;;;;IAWf,wBAAwB;;;;;;;;;;;;;;;;;IAoBlB,GAAG;CA0BV"}

package/dist/index.js

@@ -51421,7 +51421,7 @@ class UploadPortfolio extends FileWrite {
         const { packageBytes, timeoutMs } = this.payload;
         this.payload = Object.assign(Object.assign({}, this.payload), { path: PORTFOLIO_PENDING_PATH, offset: 0, data: packageBytes, chunkSize: PORTFOLIO_CHUNK_SIZE, overwrite: true, append: false, emitProgress: false, timeoutMs });
         super.init();
-        this.unlockPolicy = 'unlock-before-run';
+        this.unlockPolicy = 'none';
         this.protocolV2UiMode = 'none';
     }
     run() {
@@ -55761,6 +55761,9 @@ class TronSignMessage extends BaseMethod {
     }
     getMessageV2VersionRange() {
         return {
+            pro2: {
+                min: '0.0.0',
+            },
             pro: {
                 min: '4.16.0',
             },
@@ -61507,8 +61510,21 @@ class ProtocolV2UiInteractionCoordinator {
 }
 
 const Log$1 = getLogger(exports.LoggerNames.Core);
+const restoreExpectedWalletSessionAfterUnlock = (method, device) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b, _c;
+    const expectedPassphraseState = ((_a = method.payload) === null || _a === void 0 ? void 0 : _a.useEmptyPassphrase)
+        ? undefined
+        : (_c = (_b = method.payload) === null || _b === void 0 ? void 0 : _b.passphraseState) !== null && _c !== void 0 ? _c : device.passphraseState;
+    if (!method.useDevicePassphraseState ||
+        typeof expectedPassphraseState !== 'string' ||
+        expectedPassphraseState.length === 0) {
+        return;
+    }
+    yield restoreProtocolV2WalletSession(device, expectedPassphraseState);
+    Log$1.debug('Protocol V2 wallet session restored after unlock', { method: method.name });
+});
 function runMethodWithUnlockRetry(method, device, uiCoordinator) {
-    var _a, _b, _c, _d;
+    var _a;
     return __awaiter(this, void 0, void 0, function* () {
         const shouldEmitUi = isProtocolV2UiEnabled(method);
         const shouldUnlockBeforeRun = device.isProtocolV2() && method.unlockPolicy !== 'none' && ((_a = device.features) === null || _a === void 0 ? void 0 : _a.unlocked) === false;
@@ -61518,6 +61534,7 @@ function runMethodWithUnlockRetry(method, device, uiCoordinator) {
             }
             yield device.unlockDevice();
             Log$1.debug('Protocol V2 pre-unlock completed', { method: method.name });
+            yield restoreExpectedWalletSessionAfterUnlock(method, device);
             if (shouldEmitUi) {
                 uiCoordinator === null || uiCoordinator === void 0 ? void 0 : uiCoordinator.enterMethodInteraction(resolveProtocolV2UiInteraction(method));
             }
@@ -61541,15 +61558,7 @@ function runMethodWithUnlockRetry(method, device, uiCoordinator) {
             }
             yield device.unlockDevice();
             Log$1.debug('Protocol V2 unlock completed', { method: method.name });
-            const expectedPassphraseState = ((_b = method.payload) === null || _b === void 0 ? void 0 : _b.useEmptyPassphrase)
-                ? undefined
-                : (_d = (_c = method.payload) === null || _c === void 0 ? void 0 : _c.passphraseState) !== null && _d !== void 0 ? _d : device.passphraseState;
-            if (method.useDevicePassphraseState &&
-                typeof expectedPassphraseState === 'string' &&
-                expectedPassphraseState.length > 0) {
-                yield restoreProtocolV2WalletSession(device, expectedPassphraseState);
-                Log$1.debug('Protocol V2 wallet session restored after unlock', { method: method.name });
-            }
+            yield restoreExpectedWalletSessionAfterUnlock(method, device);
             if (shouldEmitUi) {
                 uiCoordinator === null || uiCoordinator === void 0 ? void 0 : uiCoordinator.resumeMethodInteraction();
             }

package/dist/protocols/protocol-v2/unlockRetry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"unlockRetry.d.ts","sourceRoot":"","sources":["../../../src/protocols/protocol-v2/unlockRetry.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,iBAAiB,CAAC;AAI1E,KAAK,cAAc,GAAG,IAAI,CACxB,UAAU,EACR,KAAK,GACL,cAAc,GACd,yBAAyB,GACzB,kBAAkB,GAClB,QAAQ,GACR,SAAS,GACT,0BAA0B,CAC7B,GAAG;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AACtB,KAAK,wBAAwB,GAAG,IAAI,CAClC,kCAAkC,EAClC,wBAAwB,GAAG,wBAAwB,GAAG,yBAAyB,CAChF,CAAC;AAEF,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,cAAc,EACtB,MAAM,EAAE,MAAM,EACd,aAAa,CAAC,EAAE,wBAAwB,gBA6DzC"}
+{"version":3,"file":"unlockRetry.d.ts","sourceRoot":"","sources":["../../../src/protocols/protocol-v2/unlockRetry.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,iBAAiB,CAAC;AAI1E,KAAK,cAAc,GAAG,IAAI,CACxB,UAAU,EACR,KAAK,GACL,cAAc,GACd,yBAAyB,GACzB,kBAAkB,GAClB,QAAQ,GACR,SAAS,GACT,0BAA0B,CAC7B,GAAG;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AACtB,KAAK,wBAAwB,GAAG,IAAI,CAClC,kCAAkC,EAClC,wBAAwB,GAAG,wBAAwB,GAAG,yBAAyB,CAChF,CAAC;AAkBF,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,cAAc,EACtB,MAAM,EAAE,MAAM,EACd,aAAa,CAAC,EAAE,wBAAwB,gBAoDzC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/hd-core",
-  "version": "1.2.0-alpha.25",
+  "version": "1.2.0-alpha.26",
   "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.0-alpha.25",
-    "@onekeyfe/hd-transport": "1.2.0-alpha.25",
+    "@onekeyfe/hd-shared": "1.2.0-alpha.26",
+    "@onekeyfe/hd-transport": "1.2.0-alpha.26",
     "axios": "1.15.2",
     "bignumber.js": "^9.0.2",
     "bytebuffer": "^5.0.1",
@@ -44,5 +44,5 @@
     "@types/w3c-web-usb": "^1.0.10",
     "@types/web-bluetooth": "^0.0.21"
   },
-  "gitHead": "20bb98b8530c509299b9e109d2b5ada7c6a6d034"
+  "gitHead": "1401fef3eb93f5a83ed5e8375b99181b7aaa6054"
 }

package/src/api/UploadPortfolio.ts

@@ -23,7 +23,7 @@ export default class UploadPortfolio extends FileWrite {
       timeoutMs,
     };
     super.init();
-    this.unlockPolicy = 'unlock-before-run';
+    this.unlockPolicy = 'none';
     // Portfolio is a background write/apply flow and never synthesizes UI events.
     this.protocolV2UiMode = 'none';
   }

package/src/api/tron/TronSignMessage.ts

@@ -57,6 +57,9 @@ export default class TronSignMessage extends BaseMethod<HardwareTronSignMessage>
 
   getMessageV2VersionRange() {
     return {
+      pro2: {
+        min: '0.0.0',
+      },
       pro: {
         min: '4.16.0',
       },

package/src/protocols/protocol-v2/unlockRetry.ts

@@ -24,6 +24,22 @@ type UiInteractionCoordinator = Pick<
   'enterMethodInteraction' | 'enterUnlockInteraction' | 'resumeMethodInteraction'
 >;
 
+const restoreExpectedWalletSessionAfterUnlock = async (method: RunnableMethod, device: Device) => {
+  const expectedPassphraseState = method.payload?.useEmptyPassphrase
+    ? undefined
+    : method.payload?.passphraseState ?? device.passphraseState;
+  if (
+    !method.useDevicePassphraseState ||
+    typeof expectedPassphraseState !== 'string' ||
+    expectedPassphraseState.length === 0
+  ) {
+    return;
+  }
+
+  await restoreProtocolV2WalletSession(device, expectedPassphraseState);
+  Log.debug('Protocol V2 wallet session restored after unlock', { method: method.name });
+};
+
 export async function runMethodWithUnlockRetry(
   method: RunnableMethod,
   device: Device,
@@ -39,6 +55,7 @@ export async function runMethodWithUnlockRetry(
     }
     await device.unlockDevice();
     Log.debug('Protocol V2 pre-unlock completed', { method: method.name });
+    await restoreExpectedWalletSessionAfterUnlock(method, device);
     if (shouldEmitUi) {
       uiCoordinator?.enterMethodInteraction(resolveProtocolV2UiInteraction(method));
     }
@@ -65,17 +82,7 @@ export async function runMethodWithUnlockRetry(
     }
     await device.unlockDevice();
     Log.debug('Protocol V2 unlock completed', { method: method.name });
-    const expectedPassphraseState = method.payload?.useEmptyPassphrase
-      ? undefined
-      : method.payload?.passphraseState ?? device.passphraseState;
-    if (
-      method.useDevicePassphraseState &&
-      typeof expectedPassphraseState === 'string' &&
-      expectedPassphraseState.length > 0
-    ) {
-      await restoreProtocolV2WalletSession(device, expectedPassphraseState);
-      Log.debug('Protocol V2 wallet session restored after unlock', { method: method.name });
-    }
+    await restoreExpectedWalletSessionAfterUnlock(method, device);
     if (shouldEmitUi) {
       uiCoordinator?.resumeMethodInteraction();
     }