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

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,16 @@ export default abstract class AllNetworkGetAddressBase extends BaseMethod<
 
   abortController: AbortController | null = null;
 
+  protected loadingCleanupInBackground = false;
+
+  private loadingCommands?: DeviceCommands;
+
+  // DeviceSessionGet selects the SE wallet like Initialize(session_id). Nested
+  // all-network methods skip callAPI, so the first chain call still resumes;
+  // later same-domain calls reuse that session. Cardano may Ask [Standard,
+  // Cardano] once, which also covers later non-Cardano commands.
+  private protocolV2ResumedSeedDomains = new Set<'standard' | 'cardano'>();
+
   init() {
     this.checkDeviceId = true;
     this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.NOT_INITIALIZE];
@@ -313,12 +326,30 @@ export default abstract class AllNetworkGetAddressBase extends BaseMethod<
     };
   }
 
+  private hasProtocolV2WalletResume(deriveCardano?: boolean) {
+    if (deriveCardano) {
+      return this.protocolV2ResumedSeedDomains.has('cardano');
+    }
+    return (
+      this.protocolV2ResumedSeedDomains.has('standard') ||
+      this.protocolV2ResumedSeedDomains.has('cardano')
+    );
+  }
+
+  private markProtocolV2WalletResumed(deriveCardano?: boolean) {
+    this.protocolV2ResumedSeedDomains.add('standard');
+    if (deriveCardano) {
+      this.protocolV2ResumedSeedDomains.add('cardano');
+    }
+  }
+
   async callMethod(
     methodName: keyof CoreApi,
     params: any & {
       bundle: (any & { _originRequestParams: CommonResponseParams })[];
     },
-    rootFingerprint: number
+    rootFingerprint: number,
+    postMessage = this.postMessage
   ) {
     const method: BaseMethod = findMethod({
       event: IFRAME.CALL,
@@ -332,7 +363,7 @@ export default abstract class AllNetworkGetAddressBase extends BaseMethod<
     });
 
     method.connector = this.connector;
-    method.postMessage = this.postMessage;
+    method.postMessage = postMessage;
     if (this.context) {
       method.setContext?.(this.context);
     }
@@ -388,16 +419,17 @@ export default abstract class AllNetworkGetAddressBase extends BaseMethod<
             }
           }
 
-          // 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 standard or hidden wallet before sending its device command.
+          // Nested chain methods skip callAPI's session gate. Resume the requested
+          // wallet once per seed domain; DeviceSessionGet is sticky like V1
+          // Initialize, so later addresses and chains reuse it.
           const useEmptyPassphrase = this.payload.useEmptyPassphrase === true;
-          // Nested Cardano methods opt in to [Standard, Cardano] if Ask rebuilds.
-          // Other chains stay Standard-only.
           const deriveCardano = method.name.startsWith('cardano') ? true : undefined;
           const shouldResumeWalletSession = useEmptyPassphrase || !!this.payload.passphraseState;
-          if (this.device.isProtocolV2() && shouldResumeWalletSession) {
+          if (
+            this.device.isProtocolV2() &&
+            shouldResumeWalletSession &&
+            !this.hasProtocolV2WalletResume(deriveCardano)
+          ) {
             const passphraseStateSafety = await this.device.checkPassphraseStateSafety(
               this.payload.passphraseState,
               useEmptyPassphrase,
@@ -408,6 +440,7 @@ export default abstract class AllNetworkGetAddressBase extends BaseMethod<
             if (!passphraseStateSafety) {
               throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckPassphraseStateError);
             }
+            this.markProtocolV2WalletResumed(deriveCardano);
           }
         },
       });
@@ -457,30 +490,68 @@ 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 ||
+          this.device.getCurrentDeviceType() === EDeviceType.Neo)
+      ) {
+        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));
+      }
+
+      if (res.message.root_fingerprint == null) {
+        throw ERRORS.TypedError(HardwareErrorCode.CallMethodInvalidParameter);
+      }
 
-    this.abortController = new AbortController();
+      this.abortController = new AbortController();
 
-    return this.getAllNetworkAddress(res.message.root_fingerprint).catch(e => {
+      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;