@onekeyfe/hd-core 1.2.0-alpha.22 → 1.2.0-alpha.24

package/src/api/GetPassphraseState.ts

@@ -1,4 +1,4 @@
-import { ERRORS, HardwareErrorCode, createDeviceNotSupportMethodError } from '@onekeyfe/hd-shared';
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
 
 import { UI_REQUEST } from '../constants/ui-request';
 import { getPassphraseStateWithRefreshDeviceInfo } from '../utils/deviceFeaturesUtils';
@@ -11,14 +11,20 @@ export default class GetPassphraseState extends BaseMethod {
   }
 
   async run() {
-    if (this.device.isProtocolV2()) {
-      throw createDeviceNotSupportMethodError(this.name, this.device.getCurrentFirmwareType());
-    }
     if (!this.device.features) {
       throw ERRORS.TypedError(HardwareErrorCode.DeviceInitializeFailed);
     }
 
-    const { passphraseState } = await getPassphraseStateWithRefreshDeviceInfo(this.device);
+    const isProtocolV2 = this.device.isProtocolV2();
+    const { passphraseState } = await getPassphraseStateWithRefreshDeviceInfo(
+      this.device,
+      isProtocolV2
+        ? {
+            onlyMainPin: this.payload.useEmptyPassphrase === true,
+            initSession: this.payload.initSession === true,
+          }
+        : undefined
+    );
 
     const passphraseProtection = this.device.getCurrentPassphraseProtection();
 

package/src/api/OpenWalletSession.ts

@@ -21,13 +21,6 @@ const requiredString = (value: unknown, name: string) => {
   return value.trim();
 };
 
-const optionalBoolean = (value: unknown, name: string) => {
-  if (value !== undefined && typeof value !== 'boolean') {
-    throw invalidParameter(`Parameter [${name}] must be a boolean.`);
-  }
-  return value;
-};
-
 const wasResumed = (session: unknown) =>
   !!session &&
   typeof session === 'object' &&
@@ -53,72 +46,31 @@ const requireHiddenWalletResponse = (session: {
   };
 };
 
-type NormalizedOpenWalletSessionParams = OpenWalletSessionParams & {
-  legacySessionToClear?: {
-    deviceId?: string;
-    passphraseState: string;
-  };
-};
-
-const normalizeParams = (payload: Record<string, unknown>): NormalizedOpenWalletSessionParams => {
-  if (payload.mode !== undefined) {
-    if (
-      payload.mode !== 'standard' &&
-      payload.mode !== 'select-hidden' &&
-      payload.mode !== 'resume-hidden'
-    ) {
-      throw invalidParameter(
-        'Parameter [mode] must be one of standard, select-hidden, or resume-hidden.'
-      );
-    }
-    if (payload.useEmptyPassphrase !== undefined || payload.initSession !== undefined) {
-      throw invalidParameter(
-        'Parameters [useEmptyPassphrase] and [initSession] cannot be used with [mode].'
-      );
-    }
-    if (payload.mode === 'standard' || payload.mode === 'select-hidden') {
-      if (payload.deviceId !== undefined || payload.passphraseState !== undefined) {
-        throw invalidParameter(
-          'Parameters [deviceId] and [passphraseState] are only allowed with mode [resume-hidden].'
-        );
-      }
-      return { mode: payload.mode };
-    }
-    return {
-      mode: 'resume-hidden',
-      deviceId: requiredString(payload.deviceId, 'deviceId'),
-      passphraseState: requiredString(payload.passphraseState, 'passphraseState'),
-    };
+const normalizeParams = (payload: Record<string, unknown>): OpenWalletSessionParams => {
+  if (payload.mode === undefined) {
+    throw invalidParameter('Parameter [mode] is required.');
   }
-
-  const useEmptyPassphrase = optionalBoolean(payload.useEmptyPassphrase, 'useEmptyPassphrase');
-  const initSession = optionalBoolean(payload.initSession, 'initSession');
-  if (useEmptyPassphrase === true) {
-    return { mode: 'standard' };
+  if (
+    payload.mode !== 'standard' &&
+    payload.mode !== 'select-hidden' &&
+    payload.mode !== 'resume-hidden'
+  ) {
+    throw invalidParameter(
+      'Parameter [mode] must be one of standard, select-hidden, or resume-hidden.'
+    );
   }
-  if (initSession === true) {
-    const deviceId =
-      payload.deviceId === undefined ? undefined : requiredString(payload.deviceId, 'deviceId');
-    const passphraseState =
-      payload.passphraseState === undefined
-        ? undefined
-        : requiredString(payload.passphraseState, 'passphraseState');
-    return {
-      mode: 'select-hidden',
-      ...(passphraseState
-        ? {
-            legacySessionToClear: {
-              deviceId,
-              passphraseState,
-            },
-          }
-        : {}),
-    };
+  if (payload.useEmptyPassphrase !== undefined || payload.initSession !== undefined) {
+    throw invalidParameter(
+      'Legacy parameters [useEmptyPassphrase] and [initSession] are not supported by openWalletSession.'
+    );
   }
-
-  const hasWalletBinding = payload.deviceId !== undefined || payload.passphraseState !== undefined;
-  if (!hasWalletBinding) {
-    return { mode: 'select-hidden' };
+  if (payload.mode === 'standard' || payload.mode === 'select-hidden') {
+    if (payload.deviceId !== undefined || payload.passphraseState !== undefined) {
+      throw invalidParameter(
+        'Parameters [deviceId] and [passphraseState] are only allowed with mode [resume-hidden].'
+      );
+    }
+    return { mode: payload.mode };
   }
   return {
     mode: 'resume-hidden',
@@ -127,7 +79,7 @@ const normalizeParams = (payload: Record<string, unknown>): NormalizedOpenWallet
   };
 };
 
-export default class OpenWalletSession extends BaseMethod<NormalizedOpenWalletSessionParams> {
+export default class OpenWalletSession extends BaseMethod<OpenWalletSessionParams> {
   init() {
     this.useDevicePassphraseState = false;
     this.skipForceUpdateCheck = true;
@@ -139,33 +91,18 @@ export default class OpenWalletSession extends BaseMethod<NormalizedOpenWalletSe
     const isProtocolV2 = this.device.isProtocolV2();
     const state = await this.device.getDeviceState({ refreshSections: ['status'] });
     let currentDeviceId = state.identity.deviceId;
-    const { legacySessionToClear } = this.params;
     const requireDeviceId = () => {
       if (!currentDeviceId) {
         throw ERRORS.TypedError(HardwareErrorCode.DeviceInitializeFailed);
       }
       return currentDeviceId;
     };
-    const clearLegacySession = () => {
-      const deviceId = requireDeviceId();
-      if (
-        legacySessionToClear &&
-        (!legacySessionToClear.deviceId || legacySessionToClear.deviceId === deviceId)
-      ) {
-        deviceWalletSessionStore.delete(deviceId, legacySessionToClear.passphraseState);
-      }
-    };
     const refreshProtocolV2DeviceId = async () => {
       const refreshedState = await this.device.getDeviceState({ refreshSections: ['status'] });
       currentDeviceId = refreshedState.identity.deviceId;
-      clearLegacySession();
       return requireDeviceId();
     };
 
-    if (!isProtocolV2) {
-      clearLegacySession();
-    }
-
     const protocol = isProtocolV2 ? 'V2' : 'V1';
 
     if (this.params.mode === 'standard') {

package/src/api/device/DeviceUpdateBootloader.ts

@@ -5,19 +5,15 @@ import { UI_REQUEST } from '../../constants/ui-request';
 import { FirmwareUpdateTipMessage } from '../../events/ui-request';
 import { FirmwareUpdateBaseMethod } from '../firmware/FirmwareUpdateBaseMethod';
 import { getSysResourceBinary } from '../firmware/getBinary';
-import { updateBootloader, updateBootloaderFromSource } from '../firmware/uploadFirmware';
+import { updateBootloader } from '../firmware/uploadFirmware';
 import { DeviceModelToTypes } from '../../types';
 import { DataManager } from '../../data-manager';
-import { checkBootloaderLength, checkBootloaderSourceLength } from '../firmware/updateBootloader';
-import { openFirmwareByteSource } from '../firmware/FirmwareArtifactSource';
-import { resolveFirmwareUpdateHostBinding } from '../firmware/FirmwareHostBinding';
-import { assertFirmwareUpdatePreparedPlanBinding } from '../firmware/FirmwareUpdatePreparedPlan';
+import { checkBootloaderLength } from '../firmware/updateBootloader';
 
 import type { DeviceUpdateBootloaderParams } from '../../types/api/deviceUpdateBootloader';
 import type { EFirmwareType } from '@onekeyfe/hd-shared';
 import type { Device } from '../../device/Device';
 import type { Features } from '../../types';
-import type { FirmwareByteSource } from '../firmware/FirmwareArtifactSource';
 
 export default class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod<any> {
   init() {
@@ -47,68 +43,17 @@ export default class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod<any
     return true;
   }
 
-  async updateBootloaderWithEmmcFileWriteFromSource(_device: Device, source: FirmwareByteSource) {
-    const filePath = '0:boot/bootloader.bin';
-
-    this.postTipMessage(FirmwareUpdateTipMessage.StartTransferData);
-    await this.emmcCommonUpdateProcessFromSource({
-      source,
-      filePath,
-    });
-    this.postTipMessage(FirmwareUpdateTipMessage.ConfirmOnDevice);
-    await this.reboot(RebootType.Normal);
-    this.postTipMessage(FirmwareUpdateTipMessage.UpdateBootloaderSuccess);
-    return true;
-  }
-
   async updateTouchBootloader({
     device,
     features,
     firmwareType,
-    binary: preparedBinary,
-    source: preparedSource,
   }: {
     device: Device;
     features?: Features;
     firmwareType: EFirmwareType;
-    binary?: ArrayBuffer;
-    source?: FirmwareByteSource;
   }) {
-    if (preparedSource) {
-      if (!(await checkBootloaderSourceLength(preparedSource))) {
-        throw ERRORS.TypedError(HardwareErrorCode.CheckDownloadFileError);
-      }
-      if (features && device.isBootloader()) {
-        this.postTipMessage(FirmwareUpdateTipMessage.UpdateBootloader);
-        const result = await this.updateBootloaderWithEmmcFileWriteFromSource(
-          device,
-          preparedSource
-        );
-        return result;
-      }
-      if (features && !device.isBootloader()) {
-        await updateBootloaderFromSource(
-          this.device.getCommands().typedCall.bind(this.device.getCommands()),
-          this.postMessage,
-          device,
-          preparedSource
-        );
-        return true;
-      }
-    }
-
-    let binary = preparedBinary;
+    let { binary } = this.payload;
     if (!binary) {
-      if (DataManager.getSettings('firmwareManifestMode') === 'external-only') {
-        throw ERRORS.TypedError(
-          HardwareErrorCode.RuntimeError,
-          'Bootloader must be prepared by the external firmware host',
-          {
-            firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
-            artifactName: 'bootloader',
-          }
-        );
-      }
       this.postTipMessage(FirmwareUpdateTipMessage.CheckLatestUiResource);
       const resourceUrl = features
         ? DataManager.getBootloaderResource(features, firmwareType)
@@ -123,7 +68,7 @@ export default class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod<any
       }
     }
 
-    if (!binary || !checkBootloaderLength(binary)) {
+    if (!checkBootloaderLength(binary)) {
       throw ERRORS.TypedError(HardwareErrorCode.CheckDownloadFileError);
     }
 
@@ -131,8 +76,7 @@ export default class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod<any
     if (features && device.isBootloader()) {
       // Use emmcFileWrite + reboot logic for bootloader mode
       this.postTipMessage(FirmwareUpdateTipMessage.UpdateBootloader);
-      const result = await this.updateBootloaderWithEmmcFileWrite(device, binary);
-      return result;
+      return this.updateBootloaderWithEmmcFileWrite(device, binary);
     }
 
     if (features && !device.isBootloader()) {
@@ -152,65 +96,13 @@ export default class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod<any
     const { features } = device;
 
     const payload = this.payload as DeviceUpdateBootloaderParams;
-    const hostBinding = payload.artifact
-      ? resolveFirmwareUpdateHostBinding(payload.hostBindingGeneration)
-      : undefined;
-    const executionParams = {
-      ...payload,
-      artifactReader: hostBinding?.artifactReader ?? payload.artifactReader,
-    };
-    if (payload.artifact) {
-      assertFirmwareUpdatePreparedPlanBinding({
-        preparedPlan: payload.preparedPlan,
-        executor: 'v2',
-        scopeTargets: ['bootloader'],
-        bindings: [
-          {
-            target: 'bootloader',
-            artifact: payload.artifact,
-          },
-        ],
-      });
-      const source = await openFirmwareByteSource({
-        artifact: payload.artifact,
-        reader: executionParams.artifactReader,
-      });
-      if (!source) {
-        throw ERRORS.TypedError(
-          HardwareErrorCode.RuntimeError,
-          'Bootloader artifact is not prepared'
-        );
-      }
-      try {
-        const deviceType = device.getCurrentDeviceType();
-        const deviceFirmwareType = device.getCurrentFirmwareType();
-        const firmwareType = payload.firmwareType ?? deviceFirmwareType;
-        if (DeviceModelToTypes.model_touch.includes(deviceType)) {
-          return await this.updateTouchBootloader({
-            device,
-            features,
-            firmwareType,
-            source,
-          });
-        }
-        return true;
-      } finally {
-        await source.close();
-      }
-    }
 
-    const { binary } = payload;
     const deviceType = device.getCurrentDeviceType();
     const deviceFirmwareType = device.getCurrentFirmwareType();
     const firmwareType = payload.firmwareType ?? deviceFirmwareType;
 
     if (DeviceModelToTypes.model_touch.includes(deviceType)) {
-      return this.updateTouchBootloader({
-        device,
-        features,
-        firmwareType,
-        binary,
-      });
+      return this.updateTouchBootloader({ device, features, firmwareType });
     }
 
     return Promise.resolve(true);

package/src/api/device/DeviceWipe.ts

@@ -24,10 +24,12 @@ export default class DeviceWipe extends BaseMethod<WipeDevice> {
       const res = await this.device.commands.typedCall('DeviceSettingsPageShow', 'Success', {
         page: DeviceSettingsPage.DeviceReset,
       });
+      this.device.invalidateAfterWipe();
       return Promise.resolve(res.message);
     }
 
     const res = await this.device.commands.typedCall('WipeDevice', 'Success');
+    this.device.invalidateAfterWipe();
 
     return Promise.resolve(res.message);
   }

package/src/api/firmware/FirmwareUpdateBaseMethod.ts

@@ -14,7 +14,6 @@ import { DataManager } from '../../data-manager';
 import { BaseMethod } from '../BaseMethod';
 import { DEVICE } from '../../events';
 import { createFirmwareProgressThrottle } from './progressThrottle';
-import { writeFirmwareByteSource } from './FirmwareArtifactSource';
 
 import type {
   IFirmwareUpdateProgressType,
@@ -25,7 +24,6 @@ import type { RebootType } from '@onekeyfe/hd-transport';
 import type { Deferred } from '@onekeyfe/hd-shared';
 import type { KnownDevice } from '../../types';
 import type { TypedResponseMessage } from '../../device/DeviceCommands';
-import type { FirmwareByteSource } from './FirmwareArtifactSource';
 
 const Log = getLogger(LoggerNames.Method);
 const SESSION_ERROR = 'session not found';
@@ -389,54 +387,6 @@ export class FirmwareUpdateBaseMethod<Params> extends BaseMethod<Params> {
     return totalSize !== undefined ? (processedSize ?? 0) + payload.byteLength : 0;
   }
 
-  async emmcCommonUpdateProcessFromSource({
-    source,
-    filePath,
-    processedSize,
-    totalSize,
-  }: {
-    source: FirmwareByteSource;
-    filePath: string;
-    processedSize?: number;
-    totalSize?: number;
-  }) {
-    if (!filePath.startsWith('0:')) {
-      throw new Error('filePath must start with 0:');
-    }
-    const env = DataManager.getSettings('env');
-    const chunkSize = 1024 * (DataManager.isBleConnect(env) ? 16 : 128);
-
-    await writeFirmwareByteSource({
-      source,
-      chunkSize,
-      write: async ({ data, sourceOffset, length, first }) => {
-        const progress =
-          totalSize !== undefined && processedSize !== undefined
-            ? Math.min(Math.ceil(((processedSize + sourceOffset + length) / totalSize) * 100), 99)
-            : Math.min(Math.ceil(((sourceOffset + length) / source.size) * 100), 99);
-        const writeRes = await this.emmcFileWriteWithRetry(
-          filePath,
-          length,
-          sourceOffset,
-          data,
-          first,
-          progress
-        );
-        if (!writeRes) {
-          throw ERRORS.TypedError(
-            HardwareErrorCode.EmmcFileWriteFirmwareError,
-            'transfer data error'
-          );
-        }
-        const processedBytes = Number(writeRes.message.processed_byte);
-        this.postProgressMessage(progress, 'transferData');
-        return Number.isFinite(processedBytes) ? processedBytes : length;
-      },
-    });
-
-    return totalSize !== undefined ? (processedSize ?? 0) + source.size : 0;
-  }
-
   async emmcFileWriteWithRetry(
     filePath: string,
     chunkLength: number,

package/src/api/firmware/updateBootloader.ts

@@ -8,7 +8,6 @@ import { shouldUpdateBootloaderForClassicAndMini } from './bootloaderHelper';
 
 import type { Features } from '../../types';
 import type { EFirmwareType } from '@onekeyfe/hd-shared';
-import type { FirmwareByteSource } from './FirmwareArtifactSource';
 
 export function checkNeedUpdateBootForTouch(features: Features, firmwareType: EFirmwareType) {
   const deviceType = getDeviceType(features);
@@ -63,7 +62,8 @@ export function checkNeedUpdateBootForClassicAndMini({
 }
 
 const INIT_DATA_CHUNK_SIZE = 16 * 1024;
-const readBootloaderLength = (chunk: Uint8Array) => {
+export function checkBootloaderLength(data: ArrayBuffer) {
+  const chunk = new Uint8Array(data.slice(0, Math.min(INIT_DATA_CHUNK_SIZE, data.byteLength)));
   const buffer = ByteBuffer.wrap(chunk, undefined, undefined, true);
   buffer.LE();
   // byte 'O', 'K', 'T', 'B'
@@ -77,21 +77,6 @@ const readBootloaderLength = (chunk: Uint8Array) => {
   buffer.readUint32();
   // codelen
   const codelen = buffer.readUint32();
-  return hdrlen + codelen;
-};
-
-export function checkBootloaderLength(data: ArrayBuffer) {
-  if (data.byteLength < 16) {
-    return false;
-  }
-  const chunk = new Uint8Array(data.slice(0, Math.min(INIT_DATA_CHUNK_SIZE, data.byteLength)));
-  return readBootloaderLength(chunk) === data.byteLength;
+  const bootloaderLength = hdrlen + codelen;
+  return bootloaderLength === data.byteLength;
 }
-
-export const checkBootloaderSourceLength = async (source: FirmwareByteSource) => {
-  if (source.size < 16) {
-    return false;
-  }
-  const chunk = new Uint8Array(await source.readAt(0, Math.min(INIT_DATA_CHUNK_SIZE, source.size)));
-  return readBootloaderLength(chunk) === source.size;
-};