@onekeyfe/hd-core 1.2.2-alpha.11 → 1.2.2-alpha.110

package/src/api/OpenWalletSession.ts

@@ -1,7 +1,6 @@
 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';
 import { getPassphraseStateWithRefreshDeviceInfo } from '../utils/deviceFeaturesUtils';
 import { BaseMethod } from './BaseMethod';
@@ -13,16 +12,6 @@ import type {
   OpenWalletSessionPayload,
 } from '../types/api/openWalletSession';
 
-const requiredString = (value: unknown, name: string) => {
-  if (value === undefined || value === null) {
-    throw invalidParameter(`Missing required parameter: ${name}`);
-  }
-  if (typeof value !== 'string' || !value.trim()) {
-    throw invalidParameter(`Parameter [${name}] must be a non-empty string.`);
-  }
-  return value.trim();
-};
-
 const wasResumed = (session: unknown) =>
   !!session &&
   typeof session === 'object' &&
@@ -53,34 +42,21 @@ const normalizeParams = (payload: Record<string, unknown>): OpenWalletSessionPar
   }
   if (
     payload.mode !== OpenWalletSessionMode.Standard &&
-    payload.mode !== OpenWalletSessionMode.SelectHidden &&
-    payload.mode !== OpenWalletSessionMode.ResumeHidden
+    payload.mode !== OpenWalletSessionMode.SelectHidden
   ) {
-    throw invalidParameter(
-      'Parameter [mode] must be one of standard, select-hidden, or resume-hidden.'
-    );
+    throw invalidParameter('Parameter [mode] must be one of standard or select-hidden.');
   }
   if (payload.useEmptyPassphrase !== undefined || payload.initSession !== undefined) {
     throw invalidParameter(
       'Legacy parameters [useEmptyPassphrase] and [initSession] are not supported by openWalletSession.'
     );
   }
-  if (
-    payload.mode === OpenWalletSessionMode.Standard ||
-    payload.mode === OpenWalletSessionMode.SelectHidden
-  ) {
-    if (payload.deviceId !== undefined || payload.passphraseState !== undefined) {
-      throw invalidParameter(
-        'Parameters [deviceId] and [passphraseState] are only allowed with mode [resume-hidden].'
-      );
-    }
-    return { mode: payload.mode };
+  if (payload.deviceId !== undefined || payload.passphraseState !== undefined) {
+    throw invalidParameter(
+      'Parameters [deviceId] and [passphraseState] are not supported by openWalletSession. Pass passphraseState on later address and signing calls.'
+    );
   }
-  return {
-    mode: OpenWalletSessionMode.ResumeHidden,
-    deviceId: requiredString(payload.deviceId, 'deviceId'),
-    passphraseState: requiredString(payload.passphraseState, 'passphraseState'),
-  };
+  return { mode: payload.mode };
 };
 
 export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParams> {
@@ -196,52 +172,6 @@ export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParam
       };
     }
 
-    if (this.params.mode === OpenWalletSessionMode.ResumeHidden) {
-      if (isProtocolV2) {
-        await ensureProtocolV2WalletStatus();
-        const refreshedDeviceId = requireDeviceId();
-        if (refreshedDeviceId !== this.params.deviceId) {
-          deviceWalletSessionStore.delete(this.params.deviceId, this.params.passphraseState);
-          throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckDeviceIdError);
-        }
-      } else if (requireDeviceId() !== this.params.deviceId) {
-        throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckDeviceIdError);
-      }
-      this.device.passphraseState = this.params.passphraseState;
-      const cachedSessionId = deviceWalletSessionStore.get(
-        this.params.deviceId,
-        this.params.passphraseState
-      );
-      if (!cachedSessionId && !isProtocolV2) {
-        throw ERRORS.TypedError(HardwareErrorCode.WalletSessionInvalid);
-      }
-      if (!isProtocolV2) {
-        await this.device.initialize({
-          deviceId: this.params.deviceId,
-          passphraseState: this.params.passphraseState,
-        });
-      }
-      const session = isProtocolV2
-        ? await getProtocolV2WalletSession(this.device, {
-            expectedPassphraseState: this.params.passphraseState,
-          })
-        : await getPassphraseStateWithRefreshDeviceInfo(this.device, {
-            expectPassphraseState: this.params.passphraseState,
-          });
-      const deviceId = requireDeviceId();
-      if (session.passphraseState !== this.params.passphraseState) {
-        this.device.clearInternalState();
-        throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckPassphraseStateError);
-      }
-      return {
-        protocol,
-        walletType: 'hidden',
-        deviceId,
-        ...requireHiddenWalletResponse(session),
-        resumed: wasResumed(session) || (!isProtocolV2 && session.newSession === cachedSessionId),
-      };
-    }
-
     this.device.passphraseState = undefined;
     const walletStatus = await ensureProtocolV2WalletStatus();
     if (isProtocolV2 && walletStatus.status.passphraseProtection !== true) {

package/src/api/UploadPortfolio.ts

@@ -7,6 +7,8 @@ import FileWrite from './FileWrite';
 export type UploadPortfolioParams = {
   packageBase64: string;
   timeoutMs?: number | string;
+  /** Controls transfer progress UI events. Defaults to `silent`. */
+  uiMode?: 'silent' | 'progress';
 };
 
 const PORTFOLIO_PENDING_PATH = 'vol1:/portfolio/portfolio.okpkg.pending';
@@ -17,7 +19,7 @@ const PORTFOLIO_UPDATE_MESSAGE_TYPE = 61400;
 
 export default class UploadPortfolio extends FileWrite {
   init() {
-    const { packageBase64, timeoutMs } = this.payload as UploadPortfolioParams;
+    const { packageBase64, timeoutMs, uiMode = 'silent' } = this.payload as UploadPortfolioParams;
     const packageBytes = decodeCanonicalBase64({
       value: packageBase64,
       parameterName: 'packageBase64',
@@ -31,13 +33,12 @@ export default class UploadPortfolio extends FileWrite {
       chunkSize: PORTFOLIO_CHUNK_SIZE,
       overwrite: true,
       append: false,
-      emitProgress: false,
+      emitProgress: uiMode === 'progress',
       timeoutMs,
     };
     super.init();
     this.unlockPolicy = 'none';
-    // Portfolio is a background write/apply flow and never synthesizes UI events.
-    this.protocolV2UiMode = 'none';
+    this.protocolV2UiMode = uiMode === 'progress' ? 'auto' : 'none';
   }
 
   async run() {

package/src/api/allnetwork/AllNetworkGetAddressBase.ts

@@ -1,5 +1,6 @@
 import semver from 'semver';
 import {
+  EDeviceType,
   ERRORS,
   HardwareError,
   HardwareErrorCode,
@@ -15,6 +16,7 @@ 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 { supportsProtocolV2Message } from '../../protocols/protocol-v2/features';
 import {
   completeRequestContext,
   createRequestContext,
@@ -22,6 +24,7 @@ import {
 } from '../../utils/tracing';
 
 import type { Device, DeviceEvents } from '../../device/Device';
+import type { DeviceCommands } from '../../device/DeviceCommands';
 import type { CoreApi } from '../../types';
 import type {
   AllNetworkAddress,
@@ -266,6 +269,10 @@ export default abstract class AllNetworkGetAddressBase extends BaseMethod<
 
   abortController: AbortController | null = null;
 
+  protected loadingCleanupInBackground = false;
+
+  private loadingCommands?: DeviceCommands;
+
   init() {
     this.checkDeviceId = true;
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
@@ -457,30 +464,64 @@ export default abstract class AllNetworkGetAddressBase extends BaseMethod<
 
   abstract getAllNetworkAddress(rootFingerprint: number): Promise<AllNetworkAddress[]>;
 
+  protected async stopAllNetworkLoading(canSend = true) {
+    const commands = this.loadingCommands;
+    this.loadingCommands = undefined;
+    // Never send cleanup through a replacement or disposed connection.
+    if (!canSend || !commands || commands.disposed || commands !== this.device.commands) return;
+    try {
+      await commands.typedCall('DeviceAnimationControl', 'Success', {
+        action: PROTO.DeviceAnimationAction.AnimationAction_Stop,
+      });
+    } catch {
+      // Cleanup must not mask the operation result. Firmware also has an idle timeout.
+    }
+  }
+
   async run() {
-    const res = await this.device.commands.typedCall('GetPublicKey', 'PublicKey', {
-      address_n: [toHardened(44), toHardened(1), toHardened(0)],
-      coin_name: 'Testnet',
-      script_type: 'SPENDADDRESS',
-      show_display: false,
-    });
+    this.loadingCleanupInBackground = false;
+    try {
+      if (this.device.isProtocolV2() && this.device.getCurrentDeviceType() === EDeviceType.Pro2) {
+        const protocolInfo = await this.device.ensureProtocolV2RuntimeContext();
+        if (supportsProtocolV2Message(protocolInfo, 60461)) {
+          const { commands } = this.device;
+          await commands.typedCall('DeviceAnimationControl', 'Success', {
+            action: PROTO.DeviceAnimationAction.AnimationAction_Start,
+          });
+          this.loadingCommands = commands;
+        }
+      }
 
-    if (!this.device.isProtocolV2()) {
-      this.postMessage(createUiMessage(UI_REQUEST.CLOSE_UI_PIN_WINDOW));
-    }
+      const res = await this.device.commands.typedCall('GetPublicKey', 'PublicKey', {
+        address_n: [toHardened(44), toHardened(1), toHardened(0)],
+        coin_name: 'Testnet',
+        script_type: 'SPENDADDRESS',
+        show_display: false,
+      });
 
-    if (res.message.root_fingerprint == null) {
-      throw ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter);
-    }
+      if (!this.device.isProtocolV2()) {
+        this.postMessage(createUiMessage(UI_REQUEST.CLOSE_UI_PIN_WINDOW));
+      }
 
-    this.abortController = new AbortController();
+      if (res.message.root_fingerprint == null) {
+        throw ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter);
+      }
 
-    return this.getAllNetworkAddress(res.message.root_fingerprint).catch(e => {
+      this.abortController = new AbortController();
+
+      return await this.getAllNetworkAddress(res.message.root_fingerprint);
+    } catch (e) {
+      // A failed call may have invalidated the transport link without disposing
+      // DeviceCommands. Let firmware time out instead of reconnecting for Stop.
+      await this.stopAllNetworkLoading(false);
       if (e instanceof HardwareError && e.errorCode === HardwareErrorCode.RepeatUnlocking) {
         throw ERRORS.TypedError(HardwareErrorCode.RepeatUnlocking, e.message);
       }
       throw e;
-    });
+    } finally {
+      // The callback API returns before its chain requests finish.
+      if (!this.loadingCleanupInBackground) await this.stopAllNetworkLoading();
+    }
   }
 }
 

package/src/api/allnetwork/AllNetworkGetAddressByLoop.ts

@@ -28,6 +28,7 @@ export default class AllNetworkGetAddressByLoop extends AllNetworkGetAddressBase
     const bundle = this.payload.bundle || [this.payload];
 
     // process callbacks in background
+    this.loadingCleanupInBackground = true;
     const callbackPromise = this.processCallbacksInBackground(
       bundle,
       rootFingerprint,
@@ -95,6 +96,7 @@ export default class AllNetworkGetAddressByLoop extends AllNetworkGetAddressBase
         data: allResults,
       });
     } catch (error: any) {
+      await this.stopAllNetworkLoading(false);
       let errorCode = error.errorCode || error.code;
       let errorMessage = error.message;
 
@@ -121,6 +123,7 @@ export default class AllNetworkGetAddressByLoop extends AllNetworkGetAddressBase
         },
       });
     } finally {
+      await this.stopAllNetworkLoading();
       this.context?.cancelCallbackTasks(this.payload.connectId);
       this.abortController = null;
     }

package/src/api/device/DeviceVerify.ts

@@ -22,6 +22,14 @@ export default class DeviceVerify extends BaseMethod<BixinVerifyDeviceRequest> {
     // the main PIN or an Attach PIN may authorize them.
     this.protocolV2PreUnlockPinType = DeviceSessionPinType.Any;
     this.useDevicePassphraseState = false;
+    this.protocolV2UiInteraction = {
+      request: 'button',
+      source: 'method-lifecycle',
+      reason: 'device-management',
+      completion: 'operation-completed',
+      deviceOnly: true,
+      operation: 'deviceVerify',
+    };
 
     // check payload
     validateParams(this.payload, [{ name: 'dataHex', type: 'hexString' }]);

package/src/api/solana/SolSignOffchainMessage.ts

@@ -1,11 +1,36 @@
 import { UI_REQUEST } from '../../constants/ui-request';
 import { validatePath } from '../helpers/pathUtils';
 import { BaseMethod } from '../BaseMethod';
-import { validateParams } from '../helpers/paramsValidator';
-import { stripHexPrefix } from '../helpers/hexUtils';
+import { invalidParameter, validateParams } from '../helpers/paramsValidator';
+import { addHexPrefix, isHexString, stripHexPrefix } from '../helpers/hexUtils';
 
 import type { SolanaSignOffChainMessage as HardwareSolSignOffChainMessage } from '@onekeyfe/hd-transport';
 
+const SOLANA_PUBLIC_KEY_LENGTH = 32;
+const SOLANA_APPLICATION_DOMAIN_LENGTH = 32;
+
+const normalizeRequiredSigners = (requiredSigners: unknown[] = []): string[] => {
+  const normalized = requiredSigners.map((signer, index) => {
+    if (
+      typeof signer !== 'string' ||
+      !isHexString(addHexPrefix(signer), SOLANA_PUBLIC_KEY_LENGTH)
+    ) {
+      throw invalidParameter(
+        `Parameter [requiredSigners][${index}] must be a ${SOLANA_PUBLIC_KEY_LENGTH}-byte hex public key.`
+      );
+    }
+    return stripHexPrefix(signer).toLowerCase();
+  });
+
+  for (let index = 1; index < normalized.length; index += 1) {
+    if (normalized[index - 1] >= normalized[index]) {
+      throw invalidParameter('Parameter [requiredSigners] must be strictly sorted and unique.');
+    }
+  }
+
+  return normalized;
+};
+
 export default class SolSignOffchainMessage extends BaseMethod<HardwareSolSignOffChainMessage> {
   getSupportedProtocols() {
     return ['V1', 'V2'] as const;
@@ -23,10 +48,24 @@ export default class SolSignOffchainMessage extends BaseMethod<HardwareSolSignOf
       { name: 'messageVersion', type: 'number', required: false },
       { name: 'messageFormat', type: 'number', required: false },
       { name: 'applicationDomainHex', type: 'hexString', required: false },
+      { name: 'requiredSigners', type: 'array', required: false, allowEmpty: true },
     ]);
 
-    const { path, messageHex, messageVersion, messageFormat, applicationDomainHex } = this.payload;
+    const {
+      path,
+      messageHex,
+      messageVersion,
+      messageFormat,
+      applicationDomainHex,
+      requiredSigners,
+    } = this.payload;
     const addressN = validatePath(path, 3);
+    if (
+      applicationDomainHex !== undefined &&
+      !isHexString(addHexPrefix(applicationDomainHex), SOLANA_APPLICATION_DOMAIN_LENGTH)
+    ) {
+      throw invalidParameter('Parameter [applicationDomainHex] must be 32 bytes.');
+    }
 
     // init params
     this.params = {
@@ -34,7 +73,8 @@ export default class SolSignOffchainMessage extends BaseMethod<HardwareSolSignOf
       message: stripHexPrefix(messageHex),
       message_version: messageVersion ?? undefined,
       message_format: messageFormat ?? undefined,
-      application_domain: applicationDomainHex ?? undefined,
+      application_domain: applicationDomainHex ? stripHexPrefix(applicationDomainHex) : undefined,
+      required_signers: normalizeRequiredSigners(requiredSigners),
     };
   }
 

package/src/core/RequestQueue.ts

@@ -1,3 +1,5 @@
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
 import { LoggerNames, getLogger } from '../utils';
 
 import type { Deferred } from '@onekeyfe/hd-shared';
@@ -40,6 +42,24 @@ export default class RequestQueue {
     return this.requestQueue.get(requestId);
   }
 
+  public async waitForTask<T>(task: RequestTask, pending: () => Promise<T>): Promise<T> {
+    const signal = task.method.abortSignal;
+    const cancellationError = () => ERRORS.TypedError(HardwareErrorCode.CallQueueActionCancelled);
+    if (signal?.aborted) throw cancellationError();
+    let onAbort: (() => void) | undefined;
+    try {
+      const cancelled = new Promise<never>((_, reject) => {
+        onAbort = () => reject(cancellationError());
+        signal?.addEventListener('abort', onAbort, { once: true });
+      });
+      const result = await Promise.race([pending(), cancelled]);
+      if (signal?.aborted) throw cancellationError();
+      return result;
+    } finally {
+      if (onAbort) signal?.removeEventListener('abort', onAbort);
+    }
+  }
+
   // 获取请求的AbortController
   public getAbortController(requestId: number) {
     return this.requestQueue.get(requestId)?.abortController;