@onekeyfe/hd-core 1.2.0-alpha.40 → 1.2.0-alpha.41

package/src/api/firmware/uploadFirmware.ts

@@ -10,6 +10,7 @@ import { bytesToHex } from '../helpers/hexUtils';
 import { DataManager } from '../../data-manager';
 import { DevicePool } from '../../device/DevicePool';
 import { buildProtocolV1FeaturesPayload } from '../../deviceProfile';
+import { openFirmwareByteSource, readFirmwareByteSourceFully } from './FirmwareArtifactSource';
 
 import type { KnownDevice } from '../../types';
 import type { TypedCall, TypedResponseMessage } from '../../device/DeviceCommands';
@@ -17,6 +18,7 @@ import type { PROTO } from '../../constants';
 import type { CoreMessage, IFirmwareUpdateProgressType } from '../../events';
 import type { Success } from '@onekeyfe/hd-transport';
 import type { Device } from '../../device/Device';
+import type { FirmwareByteSource } from './FirmwareArtifactSource';
 
 const NEW_BOOT_UPRATE_FIRMWARE_VERSION = '2.4.5';
 const SESSION_ERROR = 'session not found';
@@ -88,17 +90,20 @@ export const waitBleInstall = async (updateType: string) => {
   }
 };
 
-export const uploadFirmware = async (
+const toArrayBuffer = (payload: ArrayBuffer | Buffer): ArrayBuffer => {
+  if (payload instanceof ArrayBuffer) {
+    return payload;
+  }
+  return new Uint8Array(payload.buffer, payload.byteOffset, payload.byteLength).slice().buffer;
+};
+
+export const uploadFirmwareFromSource = async (
   updateType: 'firmware' | 'ble',
   typedCall: TypedCall,
   postMessage: (message: CoreMessage) => void,
   device: Device,
-  {
-    payload,
-    rebootOnSuccess,
-  }: PROTO.FirmwareUpload & {
-    rebootOnSuccess?: boolean;
-  },
+  source: FirmwareByteSource,
+  rebootOnSuccess?: boolean,
   isUpdateBootloader?: boolean
 ) => {
   const deviceType = device.getCurrentDeviceType();
@@ -119,20 +124,20 @@ export const uploadFirmware = async (
       if (supportUpgradeFileHeader) {
         // Extract and validate firmware header (first 1KB)
         const HEADER_SIZE = 1024;
-        if (payload.byteLength < HEADER_SIZE) {
+        if (source.size < HEADER_SIZE) {
           throw ERRORS.TypedError(
             HardwareErrorCode.RuntimeError,
-            `firmware payload too small: ${payload.byteLength} bytes, expected at least ${HEADER_SIZE} bytes`
+            `firmware payload too small: ${source.size} bytes, expected at least ${HEADER_SIZE} bytes`
           );
         }
 
         Log.debug('Uploading firmware header:', {
           size: HEADER_SIZE,
-          totalSize: payload.byteLength,
+          totalSize: source.size,
         });
         postProgressTip(device, 'UploadingFirmwareHeader', postMessage);
 
-        const header = new Uint8Array(payload.slice(0, HEADER_SIZE));
+        const header = new Uint8Array(await source.readAt(0, HEADER_SIZE));
 
         try {
           const headerRes = await typedCall('UpgradeFileHeader', 'Success', {
@@ -169,6 +174,9 @@ export const uploadFirmware = async (
     postProgressMessage(device, 0, 'installingFirmware', postMessage);
     let updateResponse: TypedResponseMessage<'Success'>;
     try {
+      // Classic/Mini bootloaders accept one protobuf payload and do not expose
+      // a request-range protocol. Other device families remain fully streamed.
+      const payload = await readFirmwareByteSourceFully(source);
       updateResponse = await typedCall('FirmwareUpload', 'Success', {
         payload,
       });
@@ -200,9 +208,7 @@ export const uploadFirmware = async (
           updateType,
           postMessage,
           device,
-          {
-            payload,
-          },
+          source,
           rebootOnSuccess
         );
         return response.message;
@@ -211,7 +217,7 @@ export const uploadFirmware = async (
 
     postConfirmationMessage(device);
     postProgressTip(device, 'ConfirmOnDevice', postMessage);
-    const length = payload.byteLength;
+    const length = source.size;
 
     let response = await typedCall('FirmwareErase', ['FirmwareRequest', 'Success'], { length });
     postProgressTip(device, 'FirmwareEraseSuccess', postMessage);
@@ -220,7 +226,7 @@ export const uploadFirmware = async (
       const start = response.message.offset!;
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
       const end = response.message.offset! + response.message.length!;
-      const chunk = payload.slice(start, end);
+      const chunk = await source.readAt(start, end - start);
 
       if (start > 0) {
         postProgressMessage(
@@ -249,11 +255,45 @@ export const uploadFirmware = async (
   throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'uploadFirmware: unknown device model');
 };
 
+export const uploadFirmware = async (
+  updateType: 'firmware' | 'ble',
+  typedCall: TypedCall,
+  postMessage: (message: CoreMessage) => void,
+  device: Device,
+  {
+    payload,
+    rebootOnSuccess,
+  }: PROTO.FirmwareUpload & {
+    rebootOnSuccess?: boolean;
+  },
+  isUpdateBootloader?: boolean
+) => {
+  const source = await openFirmwareByteSource({
+    binary: toArrayBuffer(payload),
+  });
+  if (!source) {
+    throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'firmware payload is empty');
+  }
+  try {
+    return await uploadFirmwareFromSource(
+      updateType,
+      typedCall,
+      postMessage,
+      device,
+      source,
+      rebootOnSuccess,
+      isUpdateBootloader
+    );
+  } finally {
+    await source.close();
+  }
+};
+
 const newTouchUpdateProcess = async (
   updateType: 'firmware' | 'ble',
   postMessage: (message: CoreMessage) => void,
   device: Device,
-  { payload }: PROTO.FirmwareUpload,
+  source: FirmwareByteSource,
   rebootOnSuccess = true
 ) => {
   let typedCall = device.getCommands().typedCall.bind(device.getCommands());
@@ -263,13 +303,13 @@ const newTouchUpdateProcess = async (
   const env = DataManager.getSettings('env');
   const perPackageSize = DataManager.isBleConnect(env) ? 16 : 128;
   const chunkSize = 1024 * perPackageSize;
-  const totalChunks = Math.ceil(payload.byteLength / chunkSize);
+  const totalChunks = Math.ceil(source.size / chunkSize);
   let offset = 0;
   for (let i = 0; i < totalChunks; i++) {
     const chunkStart = i * chunkSize;
-    const chunkEnd = Math.min(chunkStart + chunkSize, payload.byteLength);
+    const chunkEnd = Math.min(chunkStart + chunkSize, source.size);
     const chunkLength = chunkEnd - chunkStart;
-    const chunk = payload.slice(chunkStart, chunkEnd);
+    const chunk = await source.readAt(chunkStart, chunkLength);
     const overwrite = i === 0;
     const progress = Math.round(((i + 1) / totalChunks) * 100);
     const writeRes = await emmcFileWriteWithRetry(
@@ -490,6 +530,67 @@ export const updateResource = async (
   return processResourceRequest(typedCall, res, data);
 };
 
+export const updateResourceFromSource = async (
+  typedCall: TypedCall,
+  fileName: string,
+  source: FirmwareByteSource,
+  onConfirmAfter?: () => void
+) => {
+  const initialLength = Math.min(INIT_DATA_CHUNK_SIZE, source.size);
+  const initialChunk = new Uint8Array(await source.readAt(0, initialLength));
+  let response = await typedCall('ResourceUpdate', ['ResourceRequest', 'Success'], {
+    file_name: fileName,
+    data_length: source.size,
+    initial_data_chunk: bytesToHex(initialChunk),
+    hash: bytesToHex(blake2s(initialChunk)),
+  });
+  onConfirmAfter?.();
+
+  while (response.type !== 'Success') {
+    const { offset, data_length: dataLength } = response.message;
+    if (
+      !Number.isSafeInteger(offset) ||
+      offset === undefined ||
+      offset < 0 ||
+      !Number.isSafeInteger(dataLength) ||
+      dataLength === undefined ||
+      dataLength <= 0 ||
+      offset + dataLength > source.size
+    ) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.RuntimeError,
+        'Device requested an invalid firmware resource range'
+      );
+    }
+    const chunk = new Uint8Array(await source.readAt(offset, dataLength));
+    response = await typedCall('ResourceAck', ['ResourceRequest', 'Success'], {
+      data_chunk: bytesToHex(chunk),
+      hash: bytesToHex(blake2s(chunk)),
+    });
+  }
+  return response.message;
+};
+
+export const updateResourcesFromSources = async (
+  typedCall: TypedCall,
+  postMessage: (message: CoreMessage) => void,
+  device: Device,
+  entries: ReadonlyArray<{ entryName: string; source: FirmwareByteSource }>
+) => {
+  postProgressTip(device, 'UpdateSysResource', postMessage);
+  for (const [index, entry] of entries.entries()) {
+    await updateResourceFromSource(typedCall, entry.entryName, entry.source);
+    postProgressMessage(
+      device,
+      Math.floor(((index + 1) / entries.length) * 100),
+      'installingFirmware',
+      postMessage
+    );
+  }
+  postProgressTip(device, 'UpdateSysResourceSuccess', postMessage);
+  return true;
+};
+
 export const updateResources = async (
   typedCall: TypedCall,
   postMessage: (message: CoreMessage) => void,
@@ -524,11 +625,28 @@ export const updateBootloader = async (
   typedCall: TypedCall,
   postMessage: (message: CoreMessage) => void,
   device: Device,
-  source: ArrayBuffer
+  data: ArrayBuffer
+) => {
+  const source = await openFirmwareByteSource({ binary: data });
+  if (!source) {
+    throw ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'bootloader payload is empty');
+  }
+  try {
+    return await updateBootloaderFromSource(typedCall, postMessage, device, source);
+  } finally {
+    await source.close();
+  }
+};
+
+export const updateBootloaderFromSource = async (
+  typedCall: TypedCall,
+  postMessage: (message: CoreMessage) => void,
+  device: Device,
+  source: FirmwareByteSource
 ) => {
   postProgressTip(device, 'UpdateBootloader', postMessage);
   postProgressMessage(device, Math.floor(0), 'installingFirmware', postMessage);
-  await updateResource(typedCall, 'bootloader.bin', source, () => {
+  await updateResourceFromSource(typedCall, 'bootloader.bin', source, () => {
     postProcessingMessage('resource', postMessage);
   });
   postProgressMessage(device, Math.floor(100), 'installingFirmware', postMessage);

package/src/api/helpers/protocolV2FileWrite.ts

@@ -31,21 +31,19 @@ export type ProtocolV2FileWriteOptions = {
   uiPercentage?: number;
   timeoutMs?: number;
   maxChunkRetries?: number;
-  paceMs?: number;
   throwIfAborted?: () => void;
   onProgress?: (progress: ProtocolV2FileWriteProgress) => void;
 };
 
 const MIN_FILE_CHUNK_SIZE = 64;
 
-export function isProtocolV2ResponseTimeout(error: unknown) {
+function isRetryableFileWriteTimeout(error: unknown) {
   if (!error || typeof error !== 'object') return false;
-  const candidate = error as { errorCode?: number; code?: number | string; message?: string };
+  const candidate = error as { errorCode?: number; code?: number; message?: string };
   const code = candidate.errorCode ?? candidate.code;
   return (
     code === HardwareErrorCode.BleTimeoutError ||
-    code === 'response-timeout' ||
-    /(?:BLE|Lowlevel|Protocol V2) response timeout/i.test(candidate.message ?? '')
+    /Lowlevel response timeout/i.test(candidate.message ?? '')
   );
 }
 
@@ -149,7 +147,7 @@ export async function writeProtocolV2File(options: ProtocolV2FileWriteOptions) {
         );
         isWritePending = false;
       } catch (error) {
-        if (retryCount >= maxChunkRetries || !isProtocolV2ResponseTimeout(error)) throw error;
+        if (retryCount >= maxChunkRetries || !isRetryableFileWriteTimeout(error)) throw error;
         retryCount += 1;
         options.throwIfAborted?.();
       }
@@ -188,11 +186,6 @@ 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,7 +49,6 @@ 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/ProtocolInfoRequest.ts

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

package/src/core/deviceEventRegistration.ts

@@ -4,8 +4,6 @@ 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;
@@ -17,8 +15,6 @@ 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);

package/src/core/index.ts

@@ -1,6 +1,6 @@
 import semver from 'semver';
 import EventEmitter from 'events';
-import { DeviceSessionPinType, TRANSPORT_EVENT } from '@onekeyfe/hd-transport';
+import { TRANSPORT_EVENT } from '@onekeyfe/hd-transport';
 import {
   ERRORS,
   ERROR_CODES_REQUIRE_RELEASE,
@@ -55,12 +55,11 @@ import DeviceConnector from '../device/DeviceConnector';
 import RequestQueue from './RequestQueue';
 import { registerHardwareUiEventListeners } from './deviceEventRegistration';
 import { getSynchronize } from '../utils/getSynchronize';
-import { runMethodWithUnlockPolicy } from '../protocols/protocol-v2/unlockPolicyRunner';
+import { runMethodWithUnlockRetry } from '../protocols/protocol-v2/unlockRetry';
 import {
   ProtocolV2UiInteractionCoordinator,
   isProtocolV2UiEnabled,
 } from '../protocols/protocol-v2/uiInteraction';
-import { createUiProgressMessageFilter } from '../utils/uiProgressThrottle';
 
 import type { ConnectSettings, Features, KnownDevice } from '../types';
 import type { CoreMessage, IFrameCallMessage, UiPromise, UiPromiseResponse } from '../events';
@@ -155,12 +154,7 @@ export const callAPI = async (context: CoreContext, message: CoreMessage) => {
   try {
     method = findMethod(message as IFrameCallMessage);
     method.connector = _connector;
-    const shouldPostMessage = createUiProgressMessageFilter();
-    method.postMessage = event => {
-      if (shouldPostMessage(event)) {
-        postMessage(event);
-      }
-    };
+    method.postMessage = postMessage;
     method.setContext?.(context);
 
     method.requestContext = createRequestContext(method.responseID, method.name, {
@@ -412,8 +406,6 @@ const onCallDevice = async (
 
   registerHardwareUiEventListeners(device, {
     pin: onDevicePinHandler,
-    pinOnDevice: onEnterPinOnDeviceHandler,
-    pinOnDeviceComplete: onPinOnDeviceCompleteHandler,
     button: onDeviceButtonHandler,
     passphrase: message.payload.useEmptyPassphrase
       ? onEmptyPassphraseHandler
@@ -429,7 +421,6 @@ const onCallDevice = async (
   );
 
   const protocolV2UiCoordinator = new ProtocolV2UiInteractionCoordinator(device, postMessage);
-  device.beginProtocolV2UiInteraction();
   device.on(
     DEVICE.SELECT_DEVICE_FOR_SWITCH_FIRMWARE_WEB_DEVICE,
     onSelectDeviceForSwitchFirmwareWebDeviceHandler
@@ -556,92 +547,89 @@ const onCallDevice = async (
         );
       }
 
-      try {
-        let deviceIdCheckedDuringUnlockPreflight = false;
-        const response = await runMethodWithUnlockPolicy<object>(method, device, {
-          uiCoordinator: protocolV2UiCoordinator,
-          afterStatusBeforeUnlock: () => {
-            if (method.deviceId && method.checkDeviceId) {
-              if (!device.checkDeviceId(method.deviceId)) {
-                throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckDeviceIdError);
-              }
-              deviceIdCheckedDuringUnlockPreflight = true;
-            }
-          },
-          prepare: async () => {
-            if (method.deviceId && method.checkDeviceId && !deviceIdCheckedDuringUnlockPreflight) {
-              const isSameDeviceID = await checkLiveDeviceId(device, method.deviceId);
-              if (!isSameDeviceID) {
-                throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckDeviceIdError);
-              }
-            }
+      if (method.deviceId && method.checkDeviceId) {
+        const isSameDeviceID = await checkLiveDeviceId(device, method.deviceId);
+        if (!isSameDeviceID) {
+          return Promise.reject(ERRORS.TypedError(HardwareErrorCode.DeviceCheckDeviceIdError));
+        }
+      }
 
-            /**
-             * check firmware release info
-             */
-            method.checkFirmwareRelease();
+      /**
+       * check firmware release info
+       */
+      method.checkFirmwareRelease();
 
-            /**
-             * check additional supported feature
-             */
-            method.checkDeviceSupportFeature();
+      /**
+       * check additional supported feature
+       */
+      method.checkDeviceSupportFeature();
 
-            // reconfigure messages
-            if (_deviceList && device.features && !device.isProtocolV2()) {
-              await TransportManager.reconfigure(device.features);
-            }
+      // reconfigure messages
+      if (_deviceList && device.features && !device.isProtocolV2()) {
+        await TransportManager.reconfigure(device.features);
+      }
+
+      // Check to see if it is safe to use Passphrase
+      checkPassphraseEnableState(method, device.features);
 
-            // Check to see if it is safe to use Passphrase
-            checkPassphraseEnableState(method, device.features);
-
-            if (shouldCheckPassphraseState(method, device)) {
-              // check version
-              const support = device.supportNewPassphrase();
-              if (!support.support) {
-                throw ERRORS.TypedError(
-                  HardwareErrorCode.DeviceNotSupportPassphrase,
-                  `Device not support passphrase, please update to ${support.require}`,
-                  {
-                    require: support.require,
-                  }
-                );
+      if (shouldCheckPassphraseState(method, device)) {
+        // check version
+        const support = device.supportNewPassphrase();
+        if (!support.support) {
+          return Promise.reject(
+            ERRORS.TypedError(
+              HardwareErrorCode.DeviceNotSupportPassphrase,
+              `Device not support passphrase, please update to ${support.require}`,
+              {
+                require: support.require,
               }
+            )
+          );
+        }
 
-              // Check Device passphrase State after the Protocol V2 pre-unlock gate.
-              const passphraseStateSafety = await device.checkPassphraseStateSafety(
-                method.payload?.passphraseState,
-                method.payload?.useEmptyPassphrase,
-                method.payload?.skipPassphraseCheck,
-                hasDeriveCardano(method)
-              );
+        // Check Device passphrase State
+        const passphraseStateSafety = await device.checkPassphraseStateSafety(
+          method.payload?.passphraseState,
+          method.payload?.useEmptyPassphrase,
+          method.payload?.skipPassphraseCheck
+        );
 
-              // Double check, handles the special case of Touch/Pro
-              checkPassphraseEnableState(method, device.features);
+        // Double check, handles the special case of Touch/Pro
+        checkPassphraseEnableState(method, device.features);
 
-              if (!passphraseStateSafety) {
-                DevicePool.clearDeviceCache(method.payload.connectId);
-                throw ERRORS.TypedError(HardwareErrorCode.DeviceCheckPassphraseStateError);
-              }
+        if (!passphraseStateSafety) {
+          DevicePool.clearDeviceCache(method.payload.connectId);
+          return Promise.reject(
+            ERRORS.TypedError(HardwareErrorCode.DeviceCheckPassphraseStateError)
+          );
+        }
 
-              // Protocol V2 emits the PIN phase completion from DeviceSessionAskPin.
-              // Keep the legacy compatibility close for Protocol V1 only.
-              if (!device.isProtocolV2()) {
-                postMessage(createUiMessage(UI_REQUEST.CLOSE_UI_PIN_WINDOW));
-              }
-            }
+        // close pin popup window
+        postMessage(createUiMessage(UI_REQUEST.CLOSE_UI_PIN_WINDOW));
+      }
 
-            // Automatic check safety_check level for Kovan, Ropsten, Rinkeby, Goerli test networks.
-            try {
-              await method.checkSafetyLevelOnTestNet();
-            } catch (e) {
-              throw e instanceof HardwareError
-                ? e
-                : ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'open safety check failed.');
-            }
+      // Automatic check safety_check level for Kovan, Ropsten, Rinkeby, Goerli test networks.
+      try {
+        await method.checkSafetyLevelOnTestNet();
+      } catch (e) {
+        const error =
+          e instanceof HardwareError
+            ? e
+            : ERRORS.TypedError(HardwareErrorCode.RuntimeError, 'open safety check failed.');
+        // messageResponse = createResponseMessage(method.responseID, false, { error });
+        // requestQueue.resolveRequest(method.responseID, messageResponse);
+        // return;
+        throw error;
+      }
 
-            method.device?.commands?.checkDisposed();
-          },
-        });
+      method.device?.commands?.checkDisposed();
+
+      try {
+        const response: object = await runMethodWithUnlockRetry(
+          method,
+          device,
+          protocolV2UiCoordinator
+        );
         messageResponse = createResponseMessage(method.responseID, true, response);
         requestQueue.resolveRequest(method.responseID, messageResponse);
         completeMethodRequestContext(method);
@@ -1291,7 +1279,6 @@ const onDevicePassphraseHandler = async (
       source: requestPayload.source,
       reason: requestPayload.reason,
       expectedPassphraseState: requestPayload.expectedPassphraseState,
-      ...(requestPayload.interaction ? { interaction: requestPayload.interaction } : {}),
     })
   );
   // wait for passphrase
@@ -1321,7 +1308,6 @@ const onEnterPassphraseOnDeviceHandler = (
       passphraseState: device.passphraseState,
       source: requestPayload?.source,
       reason: requestPayload?.reason,
-      ...(requestPayload?.interaction ? { interaction: requestPayload.interaction } : {}),
     })
   );
 };
@@ -1335,39 +1321,10 @@ const onEnterAttachPinOnDeviceHandler = (
       type: 'ButtonRequest_AttachPin',
       source: requestPayload?.source,
       reason: requestPayload?.reason,
-      ...(requestPayload?.interaction ? { interaction: requestPayload.interaction } : {}),
     })
   );
 };
 
-const onEnterPinOnDeviceHandler = (
-  ...[device, pinType, metadata]: [...DeviceEvents['pin_on_device']]
-) => {
-  postMessage(
-    createUiMessage(UI_REQUEST.REQUEST_PIN, {
-      device: device.toMessageObject() as KnownDevice,
-      type:
-        pinType === DeviceSessionPinType.AttachToPin
-          ? 'ButtonRequest_AttachPin'
-          : 'ButtonRequest_PinEntry',
-      source: metadata?.source,
-      reason: metadata?.reason,
-      deviceOnly: metadata?.deviceOnly ?? true,
-      completion: metadata?.completion,
-      method: metadata?.method,
-      page: metadata?.page,
-      operation: metadata?.operation,
-      ...(metadata?.interaction ? { interaction: metadata.interaction } : {}),
-    })
-  );
-};
-
-const onPinOnDeviceCompleteHandler = (
-  ...[_, metadata]: [...DeviceEvents['pin_on_device_complete']]
-) => {
-  postMessage(createUiMessage(UI_REQUEST.CLOSE_UI_PIN_WINDOW, metadata));
-};
-
 const onSelectDeviceInBootloaderForWebDeviceHandler = async (
   ...[device, callback]: [...DeviceEvents['select_device_in_bootloader_for_web_device']]
 ) => {

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

@@ -470,7 +470,6 @@
         "MessageType_DeviceSessionAskPin": 61202,
         "MessageType_DeviceSessionAskPassphrase": 61203,
         "MessageType_PortfolioUpdate": 61400,
-        "MessageType_NftUpdate": 61500,
         "MessageType_OnboardingStatusGet": 61600,
         "MessageType_OnboardingStatus": 61601
       },
@@ -12539,15 +12538,6 @@
         }
       }
     },
-    "NftUpdate": {
-      "fields": {
-        "file_name_no_ext": {
-          "rule": "required",
-          "type": "string",
-          "id": 1
-        }
-      }
-    },
     "OnboardingStep": {
       "values": {
         "ONBOARDING_STEP_UNKNOWN": 0,