@onekeyfe/hd-core 1.2.0-alpha.16 → 1.2.0-alpha.18

package/src/api/kaspa/helpers/TransferSerialize.ts

@@ -1,4 +1,6 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+
 import { SignatureType } from './SignatureType';
 import { HashWriter } from './HashWriter';
 
@@ -76,6 +78,12 @@ function getSigOpCountsHash(transaction: KaspaSignTransactionParams, sighashType
 function hashTxOut(hashWriter: HashWriter, output: KaspaSignOutputParams) {
   hashWriter.writeUInt64LE(output.satoshis);
   hashWriter.writeUInt16LE(0); // TODO: USE REAL SCRIPT VERSION
+  if (output.script === undefined) {
+    throw ERRORS.TypedError(
+      HardwareErrorCode.CallMethodInvalidParameter,
+      'Kaspa legacy sighash requires output.script'
+    );
+  }
   hashWriter.writeVarBytes(Buffer.from(output.script, 'hex'));
 }
 
@@ -126,6 +134,12 @@ export function serialize(transaction: KaspaSignTransactionParams, inputNumber:
   const input = transaction.inputs[inputNumber];
   hashOutpoint(hashWriter, input);
   hashWriter.writeUInt16LE(0); // TODO: USE REAL SCRIPT VERSION
+  if (input.output.script === undefined) {
+    throw ERRORS.TypedError(
+      HardwareErrorCode.CallMethodInvalidParameter,
+      'Kaspa legacy sighash requires input.output.script'
+    );
+  }
   hashWriter.writeVarBytes(Buffer.from(input.output.script, 'hex'));
   hashWriter.writeUInt64LE(input.output.satoshis);
   hashWriter.writeUInt64LE(input.sequenceNumber);

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

@@ -45,7 +45,6 @@ const DEFAULT_TARGETS: DeviceInfoGetTargets = {
   hw: true,
   fw: true,
   coprocessor: true,
-  status: true,
 };
 
 const DEFAULT_TYPES: DeviceInfoGetTypes = {

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

@@ -0,0 +1,100 @@
+import { BaseMethod } from '../BaseMethod';
+import { invalidParameter } from '../helpers/filesystemValidation';
+
+import type {
+  DeviceAttachPinOnDevice,
+  DeviceHostPassphrase,
+  DevicePassphraseOnDevice,
+  DeviceSessionResume,
+} from '@onekeyfe/hd-transport';
+
+type HiddenWalletSelection =
+  | {
+      host_passphrase: DeviceHostPassphrase;
+      passphrase_on_device?: never;
+      attach_pin_on_device?: never;
+    }
+  | {
+      host_passphrase?: never;
+      passphrase_on_device: DevicePassphraseOnDevice;
+      attach_pin_on_device?: never;
+    }
+  | {
+      host_passphrase?: never;
+      passphrase_on_device?: never;
+      attach_pin_on_device: DeviceAttachPinOnDevice;
+    };
+
+export type DeviceSessionOpenParams =
+  | { resume: DeviceSessionResume; select?: never }
+  | { resume?: never; select: HiddenWalletSelection };
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  !!value && typeof value === 'object' && !Array.isArray(value);
+
+const normalizeParams = (payload: Record<string, unknown>): DeviceSessionOpenParams => {
+  const hasResume = payload.resume !== undefined;
+  const hasSelect = payload.select !== undefined;
+  if (hasResume === hasSelect) {
+    throw invalidParameter('DeviceSessionOpen requires exactly one of [resume] or [select].');
+  }
+
+  if (hasResume) {
+    if (!isRecord(payload.resume) || typeof payload.resume.session_id !== 'string') {
+      throw invalidParameter('Parameter [resume.session_id] must be a non-empty string.');
+    }
+    const sessionId = payload.resume.session_id.trim();
+    if (!sessionId) {
+      throw invalidParameter('Parameter [resume.session_id] must be a non-empty string.');
+    }
+    return { resume: { session_id: sessionId } };
+  }
+
+  if (!isRecord(payload.select)) {
+    throw invalidParameter('Parameter [select] must be a hidden-wallet selection object.');
+  }
+  const { select } = payload;
+  const accessKeys = ['host_passphrase', 'passphrase_on_device', 'attach_pin_on_device'] as const;
+  const selected = accessKeys.filter(key => select[key] !== undefined);
+  const unknown = Object.keys(select).filter(
+    key => !accessKeys.includes(key as (typeof accessKeys)[number])
+  );
+  if (unknown.length > 0 || selected.length !== 1) {
+    throw invalidParameter('Parameter [select] requires exactly one hidden-wallet access mode.');
+  }
+
+  if (selected[0] === 'host_passphrase') {
+    const host = select.host_passphrase;
+    if (!isRecord(host) || typeof host.passphrase !== 'string') {
+      throw invalidParameter('Parameter [select.host_passphrase.passphrase] is required.');
+    }
+    const passphrase = host.passphrase.normalize('NFKD');
+    if (!passphrase || passphrase.includes('\0') || passphrase.length > 50) {
+      throw invalidParameter('Parameter [select.host_passphrase.passphrase] is invalid.');
+    }
+    return { select: { host_passphrase: { passphrase } } };
+  }
+
+  if (selected[0] === 'passphrase_on_device') {
+    return { select: { passphrase_on_device: {} } };
+  }
+  return { select: { attach_pin_on_device: {} } };
+};
+
+export default class DeviceSessionOpen extends BaseMethod<DeviceSessionOpenParams> {
+  init() {
+    this.requireProtocolV2 = true;
+    this.useDevicePassphraseState = false;
+    this.skipForceUpdateCheck = true;
+    this.params = normalizeParams(this.payload as unknown as Record<string, unknown>);
+  }
+
+  async run() {
+    const { message } = await this.device.commands.typedCall(
+      'DeviceSessionOpen',
+      'DeviceSession',
+      this.params
+    );
+    return message;
+  }
+}

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

@@ -26,7 +26,7 @@ const SUPPORTED_PAGES = new Set<number>([
 function normalizePage(value: DeviceSettingsPageShowParams['page']): SupportedDeviceSettingsPage {
   const page = typeof value === 'string' ? DeviceSettingsPage[value] : value;
   if (page !== undefined && SUPPORTED_PAGES.has(page)) {
-    return page as SupportedDeviceSettingsPage;
+    return page;
   }
   throw invalidParameter(
     'Parameter [page] must be DeviceReset, DevicePinChange, DevicePassphrase, or DeviceAirgap.'
@@ -46,6 +46,14 @@ export default class DeviceSettingsPageShow extends BaseMethod<{
       page: normalizePage(this.payload.page),
       field_name: this.payload.field_name ?? this.payload.fieldName,
     };
+    this.protocolV2UiInteraction = {
+      request: 'button',
+      source: 'method-lifecycle',
+      reason: 'settings-page',
+      completion: 'operation-completed',
+      deviceOnly: true,
+      page: this.params.page,
+    };
   }
 
   async run() {

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

@@ -11,7 +11,7 @@ export default class DeviceSettingsSet extends BaseMethod<{
   settings: Omit<DeviceSettings, 'passphrase_enable' | 'airgap_mode'>;
 }> {
   init() {
-    const settings = this.payload.settings;
+    const { settings } = this.payload;
     if (!settings || typeof settings !== 'object' || Array.isArray(settings)) {
       throw invalidParameter('Parameter [settings] must be an object.');
     }
@@ -30,6 +30,16 @@ export default class DeviceSettingsSet extends BaseMethod<{
     this.skipForceUpdateCheck = true;
     this.useDevicePassphraseState = false;
     this.params = { settings: supported };
+    if (typeof supported.label === 'string') {
+      this.protocolV2UiInteraction = {
+        request: 'button',
+        source: 'method-lifecycle',
+        reason: 'device-management',
+        completion: 'operation-completed',
+        deviceOnly: true,
+        operation: 'change-label',
+      };
+    }
   }
 
   async run() {

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

@@ -9,6 +9,7 @@ export default class DeviceStatusGet extends BaseMethod {
 
   async run() {
     const { message } = await this.device.commands.typedCall('DeviceStatusGet', 'DeviceStatus', {});
+    this.device.updateProtocolV2Status(message);
     return message;
   }
 }

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

@@ -27,7 +27,7 @@ export type DeviceUploadWallpaperResponse = {
   message?: string;
 };
 
-const WALLPAPER_DIRECTORY = 'vol0:/wallpapers/user';
+const WALLPAPER_DIRECTORY = 'vol1:/wallpapers';
 const SAFE_FILE_NAME = /^[A-Za-z0-9_-]+(?:\.bin)?$/;
 
 function normalizeFileName(fileName: string | undefined, data: Uint8Array): string {
@@ -100,6 +100,7 @@ export default class DeviceUploadWallpaper extends BaseMethod<DeviceUploadWallpa
       data: encoded.data,
       totalSize: encoded.data.byteLength,
       chunkSize: this.params.chunkSize,
+      maxChunkRetries: 3,
       overwrite: true,
       append: false,
       throwIfAborted: () => this.throwIfAborted(),

package/src/core/deviceEventRegistration.ts

@@ -7,6 +7,7 @@ export type HardwareUiEventHandlers = {
   button: (...event: DeviceEvents[typeof DEVICE.BUTTON]) => void;
   passphrase: (...event: DeviceEvents[typeof DEVICE.PASSPHRASE]) => void;
   passphraseOnDevice: (...event: DeviceEvents[typeof DEVICE.PASSPHRASE_ON_DEVICE]) => void;
+  attachPinOnDevice: (...event: DeviceEvents[typeof DEVICE.ATTACH_PIN_ON_DEVICE]) => void;
 };
 
 export function registerHardwareUiEventListeners(
@@ -17,5 +18,6 @@ export function registerHardwareUiEventListeners(
   device.on(DEVICE.BUTTON, handlers.button);
   device.on(DEVICE.PASSPHRASE, handlers.passphrase);
   device.on(DEVICE.PASSPHRASE_ON_DEVICE, handlers.passphraseOnDevice);
+  device.on(DEVICE.ATTACH_PIN_ON_DEVICE, handlers.attachPinOnDevice);
   return true;
 }

package/src/core/index.ts

@@ -58,6 +58,10 @@ import RequestQueue from './RequestQueue';
 import { registerHardwareUiEventListeners } from './deviceEventRegistration';
 import { getSynchronize } from '../utils/getSynchronize';
 import { runMethodWithUnlockRetry } from '../protocols/protocol-v2/unlockRetry';
+import {
+  ProtocolV2UiInteractionCoordinator,
+  isProtocolV2UiEnabled,
+} from '../protocols/protocol-v2/uiInteraction';
 
 import type { ConnectSettings, Features, KnownDevice } from '../types';
 import type { CoreMessage, IFrameCallMessage, UiPromise, UiPromiseResponse } from '../events';
@@ -403,12 +407,15 @@ const onCallDevice = async (
       ? onEmptyPassphraseHandler
       : onDevicePassphraseHandler,
     passphraseOnDevice: onEnterPassphraseOnDeviceHandler,
+    attachPinOnDevice: onEnterAttachPinOnDeviceHandler,
   });
   device.on(DEVICE.FEATURES, onDeviceFeaturesHandler);
   device.on(
     DEVICE.SELECT_DEVICE_IN_BOOTLOADER_FOR_WEB_DEVICE,
     onSelectDeviceInBootloaderForWebDeviceHandler
   );
+
+  const protocolV2UiCoordinator = new ProtocolV2UiInteractionCoordinator(device, postMessage);
   device.on(
     DEVICE.SELECT_DEVICE_FOR_SWITCH_FIRMWARE_WEB_DEVICE,
     onSelectDeviceForSwitchFirmwareWebDeviceHandler
@@ -619,7 +626,11 @@ const onCallDevice = async (
       method.device?.commands?.checkDisposed();
 
       try {
-        const response: object = await runMethodWithUnlockRetry(method, device);
+        const response: object = await runMethodWithUnlockRetry(
+          method,
+          device,
+          protocolV2UiCoordinator
+        );
         messageResponse = createResponseMessage(method.responseID, true, response);
         requestQueue.resolveRequest(method.responseID, messageResponse);
         completeMethodRequestContext(method);
@@ -636,6 +647,8 @@ const onCallDevice = async (
         ) {
           throw error;
         }
+      } finally {
+        protocolV2UiCoordinator.close();
       }
     };
     Log.debug('Call API - Device Run: ', device.mainId);
@@ -689,7 +702,9 @@ const onCallDevice = async (
 
     requestQueue.releaseTask(method.responseID);
 
-    closePopup();
+    if (isProtocolV2UiEnabled(method)) {
+      closePopup();
+    }
 
     cleanup();
 
@@ -1235,6 +1250,9 @@ const onDevicePassphraseHandler = async (
       device: device.toMessageObject() as KnownDevice,
       passphraseState: device.passphraseState,
       existsAttachPinUser: requestPayload.existsAttachPinUser,
+      source: requestPayload.source,
+      reason: requestPayload.reason,
+      expectedPassphraseState: requestPayload.expectedPassphraseState,
     })
   );
   // wait for passphrase
@@ -1256,12 +1274,27 @@ const onEmptyPassphraseHandler = (...[_, , callback]: DeviceEvents['passphrase']
 };
 
 const onEnterPassphraseOnDeviceHandler = (
-  ...[device]: [...DeviceEvents['passphrase_on_device']]
+  ...[device, requestPayload]: [...DeviceEvents['passphrase_on_device']]
 ) => {
   postMessage(
     createUiMessage(UI_REQUEST.REQUEST_PASSPHRASE_ON_DEVICE, {
       device: device.toMessageObject() as KnownDevice,
       passphraseState: device.passphraseState,
+      source: requestPayload?.source,
+      reason: requestPayload?.reason,
+    })
+  );
+};
+
+const onEnterAttachPinOnDeviceHandler = (
+  ...[device, requestPayload]: [...DeviceEvents['attach_pin_on_device']]
+) => {
+  postMessage(
+    createUiMessage(UI_REQUEST.REQUEST_PIN, {
+      device: device.toMessageObject() as KnownDevice,
+      type: 'ButtonRequest_AttachPin',
+      source: requestPayload?.source,
+      reason: requestPayload?.reason,
     })
   );
 };

package/src/data/messages/messages-protocol-v2.json

@@ -482,7 +482,7 @@
         "MessageType_DeviceStatus": 60603,
         "MessageType_DevGetOnboardingStatus": 60604,
         "MessageType_DevOnboardingStatus": 60605,
-        "MessageType_DeviceSessionGet": 60606,
+        "MessageType_DeviceSessionOpen": 60606,
         "MessageType_DeviceSession": 60607,
         "MessageType_DeviceSessionAskPin": 60608,
         "MessageType_FilesystemPermissionFix": 60800,
@@ -12418,14 +12418,68 @@
         }
       }
     },
-    "DeviceSessionGet": {
+    "DeviceSessionResume": {
       "fields": {
         "session_id": {
+          "rule": "required",
           "type": "bytes",
           "id": 1
         }
       }
     },
+    "DeviceHostPassphrase": {
+      "fields": {
+        "passphrase": {
+          "rule": "required",
+          "type": "string",
+          "id": 1
+        }
+      }
+    },
+    "DevicePassphraseOnDevice": {
+      "fields": {}
+    },
+    "DeviceAttachPinOnDevice": {
+      "fields": {}
+    },
+    "DeviceWalletSelect": {
+      "oneofs": {
+        "access": {
+          "oneof": ["host_passphrase", "passphrase_on_device", "attach_pin_on_device"]
+        }
+      },
+      "fields": {
+        "host_passphrase": {
+          "type": "DeviceHostPassphrase",
+          "id": 1
+        },
+        "passphrase_on_device": {
+          "type": "DevicePassphraseOnDevice",
+          "id": 2
+        },
+        "attach_pin_on_device": {
+          "type": "DeviceAttachPinOnDevice",
+          "id": 3
+        }
+      }
+    },
+    "DeviceSessionOpen": {
+      "oneofs": {
+        "mode": {
+          "oneof": ["resume", "select"]
+        }
+      },
+      "fields": {
+        "resume": {
+          "type": "DeviceSessionResume",
+          "id": 1
+        },
+        "select": {
+          "type": "DeviceWalletSelect",
+          "id": 2
+        }
+      }
+    },
     "DeviceSession": {
       "fields": {
         "session_id": {
@@ -12481,21 +12535,59 @@
     "DeviceStatusGet": {
       "fields": {}
     },
-    "DevOnboardingStage": {
+    "DevOnboardingStep": {
+      "values": {
+        "DEV_ONBOARDING_STEP_UNKNOWN": 0,
+        "DEV_ONBOARDING_STEP_CHECKING": 1,
+        "DEV_ONBOARDING_STEP_PERSONALIZATION": 2,
+        "DEV_ONBOARDING_STEP_PIN": 3,
+        "DEV_ONBOARDING_STEP_SETUP": 4,
+        "DEV_ONBOARDING_STEP_DONE": 5
+      }
+    },
+    "DevOnboardingPhase": {
+      "values": {
+        "DEV_ONBOARDING_PHASE_UNKNOWN": 0,
+        "DEV_ONBOARDING_PHASE_SAFETY_CHECK": 1,
+        "DEV_ONBOARDING_PHASE_PIN_SETUP": 2,
+        "DEV_ONBOARDING_PHASE_FINGERPRINT_SETUP": 3,
+        "DEV_ONBOARDING_PHASE_SETUP_CHOICE": 4,
+        "DEV_ONBOARDING_PHASE_WALLET_CREATE_START": 5,
+        "DEV_ONBOARDING_PHASE_RECOVERY_PHRASE_VIEW": 6,
+        "DEV_ONBOARDING_PHASE_RECOVERY_PHRASE_CONFIRM": 7,
+        "DEV_ONBOARDING_PHASE_RESTORE_METHOD_CHOICE": 8,
+        "DEV_ONBOARDING_PHASE_RECOVERY_PHRASE_RESTORE": 9,
+        "DEV_ONBOARDING_PHASE_SEEDCARD_RESTORE": 10,
+        "DEV_ONBOARDING_PHASE_WALLET_READY": 11,
+        "DEV_ONBOARDING_PHASE_SEEDCARD_BACKUP_PROMPT": 12,
+        "DEV_ONBOARDING_PHASE_SEEDCARD_BACKUP": 13
+      }
+    },
+    "DevOnboardingSetupKind": {
       "values": {
-        "DEV_ONBOARDING_STAGE_UNKNOWN": 0,
-        "DEV_ONBOARDING_STAGE_SAFETY_CHECK": 1,
-        "DEV_ONBOARDING_STAGE_PERSONALIZATION": 2,
-        "DEV_ONBOARDING_STAGE_SELECT_SETUP_METHOD": 3,
-        "DEV_ONBOARDING_STAGE_NEW_DEVICE": 4,
-        "DEV_ONBOARDING_STAGE_SELECT_RESTORE_METHOD": 5,
-        "DEV_ONBOARDING_STAGE_RESTORE_MNEMONIC": 6,
-        "DEV_ONBOARDING_STAGE_RESTORE_SEEDCARD": 7,
-        "DEV_ONBOARDING_STAGE_WALLET_READY": 8,
-        "DEV_ONBOARDING_STAGE_SEEDCARD_BACKUP_PROMPT": 9,
-        "DEV_ONBOARDING_STAGE_SELECT_SEEDCARD_BACKUP_METHOD": 10,
-        "DEV_ONBOARDING_STAGE_SEEDCARD_BACKUP": 11,
-        "DEV_ONBOARDING_STAGE_DONE": 12
+        "DEV_ONBOARDING_SETUP_KIND_UNKNOWN": 0,
+        "DEV_ONBOARDING_SETUP_KIND_CHOICE": 1,
+        "DEV_ONBOARDING_SETUP_KIND_CREATE": 2,
+        "DEV_ONBOARDING_SETUP_KIND_RESTORE": 3
+      }
+    },
+    "DevOnboardingSetupMethod": {
+      "values": {
+        "DEV_ONBOARDING_SETUP_METHOD_UNKNOWN": 0,
+        "DEV_ONBOARDING_SETUP_METHOD_RECOVERY_PHRASE": 1,
+        "DEV_ONBOARDING_SETUP_METHOD_SEEDCARD": 2
+      }
+    },
+    "DevOnboardingSetupStatus": {
+      "fields": {
+        "kind": {
+          "type": "DevOnboardingSetupKind",
+          "id": 1
+        },
+        "method": {
+          "type": "DevOnboardingSetupMethod",
+          "id": 2
+        }
       }
     },
     "DevGetOnboardingStatus": {
@@ -12503,18 +12595,25 @@
     },
     "DevOnboardingStatus": {
       "fields": {
-        "stage": {
-          "rule": "required",
-          "type": "DevOnboardingStage",
+        "step": {
+          "type": "DevOnboardingStep",
           "id": 1
         },
-        "status_code": {
-          "type": "uint32",
+        "phase": {
+          "type": "DevOnboardingPhase",
           "id": 2
         },
-        "detail_code": {
-          "type": "uint32",
+        "setup": {
+          "type": "DevOnboardingSetupStatus",
           "id": 3
+        },
+        "pin_set": {
+          "type": "bool",
+          "id": 4
+        },
+        "wallet_initialized": {
+          "type": "bool",
+          "id": 5
         }
       }
     },