@onekeyfe/hd-core 1.2.0-alpha.35 → 1.2.0-alpha.37

package/src/api/OpenWalletSession.ts

@@ -1,4 +1,5 @@
 import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { DeviceSessionPinType } from '@onekeyfe/hd-transport';
 
 import { deviceWalletSessionStore } from '../device/DeviceWalletSessionStore';
 import { getProtocolV2WalletSession } from '../protocols/protocol-v2/walletSession';
@@ -90,23 +91,40 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
 
   async run(): Promise<OpenWalletSessionPayload> {
     const isProtocolV2 = this.device.isProtocolV2();
-    const state = await this.device.getDeviceState({ refreshSections: ['status'] });
+    let state = await this.device.getDeviceState({ refreshSections: ['status'] });
     let currentDeviceId = state.identity.deviceId;
+    const hasAuthoritativeProtocolV2WalletStatus = (candidate: typeof state) =>
+      candidate.status.unlocked === true &&
+      typeof candidate.status.passphraseProtection === 'boolean' &&
+      typeof candidate.status.unlockedAttachPin === 'boolean';
+    const requireAuthoritativeProtocolV2WalletStatus = (candidate: typeof state) => {
+      if (!hasAuthoritativeProtocolV2WalletStatus(candidate)) {
+        throw ERRORS.TypedError(HardwareErrorCode.DeviceInitializeFailed);
+      }
+      return candidate;
+    };
     const requireDeviceId = () => {
       if (!currentDeviceId) {
         throw ERRORS.TypedError(HardwareErrorCode.DeviceInitializeFailed);
       }
       return currentDeviceId;
     };
-    const refreshProtocolV2DeviceId = async () => {
-      const refreshedState = await this.device.getDeviceState({ refreshSections: ['status'] });
-      currentDeviceId = refreshedState.identity.deviceId;
-      return requireDeviceId();
+    const refreshProtocolV2DeviceState = async () => {
+      state = await this.device.getDeviceState({ refreshSections: ['status'] });
+      currentDeviceId = state.identity.deviceId;
+      return state;
     };
-    const unlockProtocolV2IfLocked = async () => {
-      if (isProtocolV2 && state.status.unlocked === false) {
-        await this.device.unlockDevice();
+    const ensureProtocolV2WalletStatus = async () => {
+      if (isProtocolV2 && !hasAuthoritativeProtocolV2WalletStatus(state)) {
+        await this.device.unlockDevice(DeviceSessionPinType.Main, {
+          source: 'unlock-coordinator',
+          reason: 'device-locked',
+          deviceOnly: true,
+          method: 'openWalletSession',
+        });
+        requireAuthoritativeProtocolV2WalletStatus(await refreshProtocolV2DeviceState());
       }
+      return state;
     };
 
     const protocol = isProtocolV2 ? 'V2' : 'V1';
@@ -114,13 +132,25 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
     if (this.params.mode === OpenWalletSessionMode.Standard) {
       this.device.passphraseState = undefined;
       const session = isProtocolV2
-        ? await getProtocolV2WalletSession(this.device, { onlyMainPin: true })
+        ? await getProtocolV2WalletSession(this.device, {
+            onlyMainPin: true,
+            deriveCardano: this.payload.deriveCardano,
+            selectMainWalletBeforeRestore:
+              !hasAuthoritativeProtocolV2WalletStatus(state) ||
+              state.status.unlockedAttachPin === true,
+          })
         : await getPassphraseStateWithRefreshDeviceInfo(this.device, {
             onlyMainPin: true,
             initSession: this.payload.initSession,
           });
-      const deviceId = isProtocolV2 ? await refreshProtocolV2DeviceId() : requireDeviceId();
-      if (session.unlockedAttachPin) {
+      const refreshedState = isProtocolV2
+        ? requireAuthoritativeProtocolV2WalletStatus(await refreshProtocolV2DeviceState())
+        : state;
+      const deviceId = requireDeviceId();
+      if (
+        session.unlockedAttachPin ||
+        (isProtocolV2 && refreshedState.status.unlockedAttachPin === true)
+      ) {
         try {
           await this.device.lockDevice();
         } catch {
@@ -140,8 +170,8 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
 
     if (this.params.mode === OpenWalletSessionMode.ResumeHidden) {
       if (isProtocolV2) {
-        await unlockProtocolV2IfLocked();
-        const refreshedDeviceId = await refreshProtocolV2DeviceId();
+        await ensureProtocolV2WalletStatus();
+        const refreshedDeviceId = requireDeviceId();
         if (refreshedDeviceId !== this.params.deviceId) {
           deviceWalletSessionStore.delete(this.params.deviceId, this.params.passphraseState);
           throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckDeviceIdError);
@@ -166,6 +196,7 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
       const session = isProtocolV2
         ? await getProtocolV2WalletSession(this.device, {
             expectedPassphraseState: this.params.passphraseState,
+            deriveCardano: this.payload.deriveCardano,
           })
         : await getPassphraseStateWithRefreshDeviceInfo(this.device, {
             expectPassphraseState: this.params.passphraseState,
@@ -185,12 +216,18 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
     }
 
     this.device.passphraseState = undefined;
-    await unlockProtocolV2IfLocked();
+    await ensureProtocolV2WalletStatus();
     const session = isProtocolV2
-      ? await getProtocolV2WalletSession(this.device, { forceWalletSelection: true })
+      ? await getProtocolV2WalletSession(this.device, {
+          forceWalletSelection: true,
+          deriveCardano: this.payload.deriveCardano,
+        })
       : await getPassphraseStateWithRefreshDeviceInfo(this.device, { initSession: true });
-    const deviceId = isProtocolV2 ? await refreshProtocolV2DeviceId() : requireDeviceId();
-    if (isProtocolV2 && this.device.getCurrentPassphraseProtection() !== true) {
+    const refreshedState = isProtocolV2
+      ? requireAuthoritativeProtocolV2WalletStatus(await refreshProtocolV2DeviceState())
+      : state;
+    const deviceId = requireDeviceId();
+    if (isProtocolV2 && refreshedState.status.passphraseProtection !== true) {
       this.device.clearInternalState();
       throw ERRORS.TypedError(HardwareErrorCode.DeviceNotOpenedPassphrase);
     }

package/src/api/allnetwork/AllNetworkGetAddressBase.ts

@@ -14,6 +14,7 @@ import { findMethod } from '../utils';
 import { DEVICE, IFRAME, createUiMessage } from '../../events';
 import { UI_REQUEST } from '../../constants/ui-request';
 import { onDeviceButtonHandler } from '../../core';
+import { runMethodWithUnlockPolicy } from '../../protocols/protocol-v2/unlockPolicyRunner';
 import {
   completeRequestContext,
   createRequestContext,
@@ -375,16 +376,34 @@ export default abstract class AllNetworkGetAddressBase extends BaseMethod<
       this.device.on(DEVICE.PASSPHRASE, onSignalAbort);
 
       preCheckDeviceSupport(this.device, method);
-      if (this.temporarySafetyCheckPrompted) {
-        method.temporarySafetyCheckPrompted = true;
-      } else {
-        const appliedTemporarySafetyCheck = await method.checkSafetyLevelOnTestNet();
-        if (appliedTemporarySafetyCheck) {
-          this.temporarySafetyCheckPrompted = true;
-        }
-      }
-
-      const response = await method.run();
+      const response = await runMethodWithUnlockPolicy<any[]>(method, this.device, {
+        context: this.protocolV2UnlockContext,
+        prepare: async () => {
+          if (this.temporarySafetyCheckPrompted) {
+            method.temporarySafetyCheckPrompted = true;
+          } else {
+            const appliedTemporarySafetyCheck = await method.checkSafetyLevelOnTestNet();
+            if (appliedTemporarySafetyCheck) {
+              this.temporarySafetyCheckPrompted = true;
+            }
+          }
+
+          // Protocol V2 hands a wallet session to exactly one blockchain request.
+          // The parent all-network call consumes its first handoff while fetching
+          // the root fingerprint, so each nested chain method must resume the
+          // requested hidden wallet before it sends its own device command.
+          if (this.device.isProtocolV2() && this.payload.passphraseState) {
+            const passphraseStateSafety = await this.device.checkPassphraseStateSafety(
+              this.payload.passphraseState,
+              false,
+              this.payload.skipPassphraseCheck
+            );
+            if (!passphraseStateSafety) {
+              throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckPassphraseStateError);
+            }
+          }
+        },
+      });
 
       if (!Array.isArray(response) || response.length === 0) {
         throw new Error('No response');
@@ -439,7 +458,9 @@ export default abstract class AllNetworkGetAddressBase extends BaseMethod<
       show_display: false,
     });
 
-    this.postMessage(createUiMessage(UI_REQUEST.CLOSE_UI_PIN_WINDOW));
+    if (!this.device.isProtocolV2()) {
+      this.postMessage(createUiMessage(UI_REQUEST.CLOSE_UI_PIN_WINDOW));
+    }
 
     if (res.message.root_fingerprint == null) {
       throw ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter);

package/src/api/device/DeviceUnlock.ts

@@ -21,6 +21,6 @@ export default class DeviceUnlock extends BaseMethod<LockDevice> {
   }
 
   async run() {
-    return this.device.unlockDevice();
+    return this.device.unlockDevice(undefined, { emitUiEvent: false });
   }
 }

package/src/api/helpers/protocolV2FileWrite.ts

@@ -31,19 +31,21 @@ export type ProtocolV2FileWriteOptions = {
   uiPercentage?: number;
   timeoutMs?: number;
   maxChunkRetries?: number;
+  paceMs?: number;
   throwIfAborted?: () => void;
   onProgress?: (progress: ProtocolV2FileWriteProgress) => void;
 };
 
 const MIN_FILE_CHUNK_SIZE = 64;
 
-function isRetryableFileWriteTimeout(error: unknown) {
+export function isProtocolV2ResponseTimeout(error: unknown) {
   if (!error || typeof error !== 'object') return false;
-  const candidate = error as { errorCode?: number; code?: number; message?: string };
+  const candidate = error as { errorCode?: number; code?: number | string; message?: string };
   const code = candidate.errorCode ?? candidate.code;
   return (
     code === HardwareErrorCode.BleTimeoutError ||
-    /Lowlevel response timeout/i.test(candidate.message ?? '')
+    code === 'response-timeout' ||
+    /(?:BLE|Lowlevel|Protocol V2) response timeout/i.test(candidate.message ?? '')
   );
 }
 
@@ -147,7 +149,7 @@ export async function writeProtocolV2File(options: ProtocolV2FileWriteOptions) {
         );
         isWritePending = false;
       } catch (error) {
-        if (retryCount >= maxChunkRetries || !isRetryableFileWriteTimeout(error)) throw error;
+        if (retryCount >= maxChunkRetries || !isProtocolV2ResponseTimeout(error)) throw error;
         retryCount += 1;
         options.throwIfAborted?.();
       }
@@ -186,6 +188,11 @@ export async function writeProtocolV2File(options: ProtocolV2FileWriteOptions) {
         elapsedMs > 0 ? Math.round((transferredBytes / elapsedMs) * 1000) : undefined,
       elapsedMs,
     });
+    if (options.paceMs && options.paceMs > 0) {
+      await new Promise(resolve => {
+        setTimeout(resolve, options.paceMs);
+      });
+    }
   }
 
   return {

package/src/api/index.ts

@@ -49,6 +49,7 @@ export { default as promptWebDeviceAccess } from './PromptWebDeviceAccess';
 export { default as deviceReboot } from './protocol-v2/DeviceReboot';
 export { default as deviceGetOnboardingStatus } from './protocol-v2/DeviceGetOnboardingStatus';
 export { default as deviceUploadWallpaper } from './protocol-v2/DeviceUploadWallpaper';
+export { default as deviceUploadNft } from './protocol-v2/DeviceUploadNft';
 export { default as uploadPortfolio } from './UploadPortfolio';
 
 export { default as cipherKeyValue } from './CipherKeyValue';

package/src/api/protocol-v2/DeviceUploadNft.ts

@@ -0,0 +1,166 @@
+import { createDeviceNotSupportMethodError } from '@onekeyfe/hd-shared';
+
+import { UI_REQUEST, createUiMessage } from '../../events/ui-request';
+import { supportsProtocolV2Message } from '../../protocols/protocol-v2/features';
+import {
+  PRO2_NFT_DEFAULT_CHUNK_SIZE,
+  PRO2_NFT_DEFAULT_PACE_MS,
+  PRO2_NFT_DEFAULT_TIMEOUT_MS,
+  PRO2_NFT_DIRECTORY,
+  PRO2_NFT_MAX_CHUNK_SIZE,
+  PRO2_NFT_MIN_CHUNK_SIZE,
+  type Pro2NftBundle,
+  type Pro2NftImage,
+  buildPro2NftBundle,
+} from '../../utils/pro2Nft';
+import { BaseMethod } from '../BaseMethod';
+import { invalidParameter } from '../helpers/filesystemValidation';
+import { isProtocolV2ResponseTimeout, writeProtocolV2File } from '../helpers/protocolV2FileWrite';
+
+export type DeviceUploadNftParams = {
+  image: Pro2NftImage;
+  thumbnail: Pro2NftImage;
+  title: string;
+  subtitle: string;
+  timestampMs?: number;
+  chunkSize?: number;
+  paceMs?: number;
+  timeoutMs?: number;
+};
+
+export type DeviceUploadNftResponse = {
+  basename: string;
+  imagePath: string;
+  thumbnailPath: string;
+  metadataPath: string;
+  totalSize: number;
+  nftUpdated: true;
+  message?: string;
+};
+
+const FILESYSTEM_FILE_WRITE_MESSAGE_TYPE = 60805;
+const NFT_UPDATE_MESSAGE_TYPE = 61500;
+
+export default class DeviceUploadNft extends BaseMethod<DeviceUploadNftParams> {
+  private bundle?: Pro2NftBundle;
+
+  getSupportedProtocols() {
+    return ['V2'] as const;
+  }
+
+  init() {
+    const {
+      image,
+      thumbnail,
+      title,
+      subtitle,
+      timestampMs = Date.now(),
+      chunkSize = PRO2_NFT_DEFAULT_CHUNK_SIZE,
+      paceMs = PRO2_NFT_DEFAULT_PACE_MS,
+      timeoutMs = PRO2_NFT_DEFAULT_TIMEOUT_MS,
+    } = this.payload;
+    if (
+      !Number.isInteger(chunkSize) ||
+      chunkSize < PRO2_NFT_MIN_CHUNK_SIZE ||
+      chunkSize > PRO2_NFT_MAX_CHUNK_SIZE
+    ) {
+      throw invalidParameter(
+        `Parameter [chunkSize] must be an integer between ${PRO2_NFT_MIN_CHUNK_SIZE} and ${PRO2_NFT_MAX_CHUNK_SIZE}.`
+      );
+    }
+    if (!Number.isInteger(paceMs) || paceMs < 0) {
+      throw invalidParameter('Parameter [paceMs] must be a non-negative integer.');
+    }
+    if (!Number.isInteger(timeoutMs) || timeoutMs <= 0) {
+      throw invalidParameter('Parameter [timeoutMs] must be a positive integer.');
+    }
+
+    this.bundle = buildPro2NftBundle({ image, thumbnail, title, subtitle, timestampMs });
+    this.params = { image, thumbnail, title, subtitle, timestampMs, chunkSize, paceMs, timeoutMs };
+    this.unlockPolicy = 'none';
+    this.skipForceUpdateCheck = true;
+    this.useDevicePassphraseState = false;
+  }
+
+  private async assertCapabilities() {
+    const protocolInfo = await this.device.ensureProtocolV2RuntimeContext();
+    const hasFileWrite = supportsProtocolV2Message(
+      protocolInfo,
+      FILESYSTEM_FILE_WRITE_MESSAGE_TYPE
+    );
+    const hasNftUpdate = supportsProtocolV2Message(protocolInfo, NFT_UPDATE_MESSAGE_TYPE);
+    if (!hasFileWrite || !hasNftUpdate) {
+      throw createDeviceNotSupportMethodError(this.name, this.device.getCurrentFirmwareType());
+    }
+  }
+
+  private async updateNft(basename: string) {
+    const params = { file_name_no_ext: basename };
+    const options = { timeoutMs: this.params.timeoutMs };
+    try {
+      return await this.device.commands.typedCall('NftUpdate', 'Success', params, options);
+    } catch (error) {
+      if (!isProtocolV2ResponseTimeout(error)) {
+        throw error;
+      }
+      this.throwIfAborted();
+      return this.device.commands.typedCall('NftUpdate', 'Success', params, options);
+    }
+  }
+
+  async run(): Promise<DeviceUploadNftResponse> {
+    const { bundle } = this;
+    if (!bundle) throw invalidParameter('NFT data has not been initialized.');
+
+    await this.assertCapabilities();
+
+    const files = [
+      { path: `${PRO2_NFT_DIRECTORY}/${bundle.basename}.bin`, data: bundle.image },
+      { path: `${PRO2_NFT_DIRECTORY}/${bundle.basename}_m.bin`, data: bundle.thumbnail },
+      { path: `${PRO2_NFT_DIRECTORY}/${bundle.basename}.json`, data: bundle.metadata },
+    ];
+    const totalSize = files.reduce((sum, file) => sum + file.data.byteLength, 0);
+    let transferredBeforeFile = 0;
+
+    for (const file of files) {
+      const transferredAtFileStart = transferredBeforeFile;
+      await writeProtocolV2File({
+        commands: this.device.commands,
+        path: file.path,
+        data: file.data,
+        totalSize: file.data.byteLength,
+        chunkSize: this.params.chunkSize,
+        timeoutMs: this.params.timeoutMs,
+        paceMs: this.params.paceMs,
+        overwrite: true,
+        append: false,
+        throwIfAborted: () => this.throwIfAborted(),
+        onProgress: progress => {
+          if (typeof this.postMessage !== 'function') return;
+          const transferredBytes = transferredAtFileStart + progress.transferredBytes;
+          this.postMessage(
+            createUiMessage(UI_REQUEST.DEVICE_PROGRESS, {
+              ...progress,
+              progress: Math.floor((transferredBytes / totalSize) * 100),
+              transferredBytes,
+              totalBytes: totalSize,
+            })
+          );
+        },
+      });
+      transferredBeforeFile += file.data.byteLength;
+    }
+
+    this.throwIfAborted();
+    const response = await this.updateNft(bundle.basename);
+    return {
+      basename: bundle.basename,
+      imagePath: files[0].path,
+      thumbnailPath: files[1].path,
+      metadataPath: files[2].path,
+      totalSize,
+      nftUpdated: true,
+      message: response.message?.message,
+    };
+  }
+}

package/src/api/protocol-v2/ProtocolInfoRequest.ts

@@ -13,7 +13,9 @@ export default class ProtocolInfoRequest extends BaseMethod {
   }
 
   async run() {
-    const res = await this.device.commands.typedCall('ProtocolInfoRequest', 'ProtocolInfo', {});
+    const res = await this.device.commands.typedCall('ProtocolInfoRequest', 'ProtocolInfo', {
+      eventless_wallet_session: true,
+    });
     return Promise.resolve(res.message);
   }
 }

package/src/core/deviceEventRegistration.ts

@@ -4,6 +4,8 @@ import type { Device, DeviceEvents } from '../device/Device';
 
 export type HardwareUiEventHandlers = {
   pin: (...event: DeviceEvents[typeof DEVICE.PIN]) => void;
+  pinOnDevice: (...event: DeviceEvents[typeof DEVICE.PIN_ON_DEVICE]) => void;
+  pinOnDeviceComplete: (...event: DeviceEvents[typeof DEVICE.PIN_ON_DEVICE_COMPLETE]) => void;
   button: (...event: DeviceEvents[typeof DEVICE.BUTTON]) => void;
   passphrase: (...event: DeviceEvents[typeof DEVICE.PASSPHRASE]) => void;
   passphraseOnDevice: (...event: DeviceEvents[typeof DEVICE.PASSPHRASE_ON_DEVICE]) => void;
@@ -15,6 +17,8 @@ export function registerHardwareUiEventListeners(
   handlers: HardwareUiEventHandlers
 ) {
   device.on(DEVICE.PIN, handlers.pin);
+  device.on(DEVICE.PIN_ON_DEVICE, handlers.pinOnDevice);
+  device.on(DEVICE.PIN_ON_DEVICE_COMPLETE, handlers.pinOnDeviceComplete);
   device.on(DEVICE.BUTTON, handlers.button);
   device.on(DEVICE.PASSPHRASE, handlers.passphrase);
   device.on(DEVICE.PASSPHRASE_ON_DEVICE, handlers.passphraseOnDevice);