@onekeyfe/hd-core 1.1.27-alpha.34 → 1.1.27-alpha.4

package/src/core/index.ts

@@ -1,7 +1,6 @@
 import semver from 'semver';
 import EventEmitter from 'events';
 import {
-  EDeviceType,
   ERRORS,
   ERROR_CODES_REQUIRE_RELEASE,
   HardwareError,
@@ -20,11 +19,9 @@ import {
   enableLog,
   getDeviceBLEFirmwareVersion,
   getDeviceFirmwareVersion,
-  getDeviceType,
   getFirmwareType,
   getLogger,
   getMethodVersionRange,
-  isMethodVersionRangeUnsupported,
   setLoggerPostMessage,
   wait,
 } from '../utils';
@@ -45,6 +42,7 @@ import {
 import { Device } from '../device/Device';
 import { DeviceList } from '../device/DeviceList';
 import { DevicePool } from '../device/DevicePool';
+import { PollingStateManager } from './PollingStateManager';
 import { findMethod } from '../api/utils';
 import { DataManager } from '../data-manager';
 import { UI_REQUEST as UI_REQUEST_CONST } from '../constants/ui-request';
@@ -76,6 +74,12 @@ import type {
 import type { BaseMethod } from '../api/BaseMethod';
 
 const Log = getLogger(LoggerNames.Core);
+const PRE_INITIALIZE_TTL_MS = 60 * 1000;
+
+// Dedup/coalesce state for "pre-warm signal" methods (isPreWarmSignal),
+// keyed by getPreWarmKey(): coalesce in-flight, skip if warmed within TTL.
+const preWarmInflight = new Map<string, Promise<any>>();
+const preWarmDoneAt = new Map<string, number>();
 
 export type CoreContext = ReturnType<Core['getCoreContext']>;
 
@@ -98,7 +102,6 @@ const parseInitOptions = (method?: BaseMethod): InitOptions => ({
   passphraseState: method?.payload.passphraseState,
   deviceId: method?.payload.deviceId,
   deriveCardano: method && hasDeriveCardano(method),
-  connectProtocol: method?.payload.connectProtocol,
 });
 
 let _core: Core;
@@ -107,8 +110,7 @@ let _connector: DeviceConnector | undefined;
 let _uiPromises: UiPromise<UiPromiseResponse['type']>[] = []; // Waiting for ui response
 
 const deviceCacheMap = new Map<string, Device>();
-let pollingId = 1;
-const pollingState: Record<number, boolean> = {};
+const pollingManager = new PollingStateManager();
 
 let preConnectCache: {
   passphraseState: string | undefined;
@@ -210,9 +212,63 @@ export const callAPI = async (context: CoreContext, message: CoreMessage) => {
     return createResponseMessage(method.responseID, false, { error });
   }
 
+  // only the pre-warm signal (PreInitialize) forks here; normal methods fall
+  // through to onCallDevice below, so the pre-warm dedup/guards never touch them
+  if (method.isPreWarmSignal) {
+    return handlePreWarmSignal(context, message, method);
+  }
+
   return onCallDevice(context, message, method);
 };
 
+// Wrapper for "pre-warm signal" methods: coalesce in-flight same-key pre-warm,
+// skip if warmed within TTL, else run + track. The "hang up so the next real
+// call waits" part lives in onCallDevice (setPrePendingCallPromise).
+const handlePreWarmSignal = async (
+  context: CoreContext,
+  message: CoreMessage,
+  method: BaseMethod
+): Promise<any> => {
+  // no connectId: can't target a device safely, skip pre-warm (ack only)
+  if (!method.connectId) {
+    return createResponseMessage(method.responseID, true, true);
+  }
+
+  const key = method.getPreWarmKey();
+
+  const inflight = preWarmInflight.get(key);
+  if (inflight) {
+    // reply with THIS call's responseID (not the other call's response object)
+    try {
+      await inflight;
+    } catch {
+      // pre-warm is best-effort; ignore its failure for the coalesced caller
+    }
+    return createResponseMessage(method.responseID, true, true);
+  }
+
+  const doneAt = preWarmDoneAt.get(key);
+  if (typeof doneAt === 'number' && Date.now() - doneAt <= method.preWarmTtl) {
+    return createResponseMessage(method.responseID, true, true);
+  }
+
+  const run = onCallDevice(context, message, method);
+  preWarmInflight.set(key, run);
+  try {
+    const result = await run;
+    // Only remember the warm if it actually succeeded — a failed pre-warm must
+    // not suppress the next pre-warm within the TTL.
+    if (result?.success === true && result?.payload === true) {
+      preWarmDoneAt.set(key, Date.now());
+    }
+    return result;
+  } finally {
+    if (preWarmInflight.get(key) === run) {
+      preWarmInflight.delete(key);
+    }
+  }
+};
+
 const waitWithTimeout = async (promise: Promise<any>, timeout: number) => {
   const timeoutPromise = new Promise((_, reject) => {
     setTimeout(() => reject(new Error('Request timeout')), timeout);
@@ -248,7 +304,15 @@ const onCallDevice = async (
 
   updateMethodRequestContext(method, { status: 'running' });
 
-  const connectStateChange = preConnectCache.passphraseState !== method.payload.passphraseState;
+  // Normalize undefined / null / '' to '' — they all mean "main wallet, no
+  // passphrase". Without this, the first call (preConnectCache starts undefined)
+  // or any '' call after a non-'' one is wrongly treated as a passphrase switch
+  // and needlessly clears the device cache -> forces a re-enumeration Initialize.
+  // A real switch ('' <-> 'stateX', or 'stateX' <-> 'stateY') still differs.
+  const normalizePassphraseState = (s?: string | null) => s || '';
+  const connectStateChange =
+    normalizePassphraseState(preConnectCache.passphraseState) !==
+    normalizePassphraseState(method.payload.passphraseState);
 
   preConnectCache = {
     passphraseState: method.payload.passphraseState,
@@ -268,18 +332,31 @@ const onCallDevice = async (
 
   const task = requestQueue.createTask(method);
 
+  // Pre-warm holds the device as a per-connectId callback task so a concurrent
+  // real call waits (before ensureConnected) instead of racing its Initialize.
+  // Only covers pre-warm -> real-call ordering; the reverse is fail-closed.
+  let preWarmCallbackTask: Deferred<void> | undefined;
+  if (method.isPreWarmSignal && method.connectId) {
+    preWarmCallbackTask = createDeferred<void>();
+    context.registerCallbackTask(method.connectId, preWarmCallbackTask);
+  }
+
   let device: Device;
   try {
     /**
      * Polling to ensure successful connection
      */
-    if (pollingState[pollingId]) {
-      pollingState[pollingId] = false;
-    }
-    pollingId += 1;
-
-    device = await ensureConnected(context, method, pollingId, task.abortController?.signal);
+    const connectId = method.connectId ?? '';
+    const pollingId = pollingManager.start(connectId);
+    device = await ensureConnected(
+      context,
+      method,
+      connectId,
+      pollingId,
+      task.abortController?.signal
+    );
   } catch (e) {
+    preWarmCallbackTask?.resolve();
     console.log('ensureConnected error: ', e);
 
     completeMethodRequestContext(method, e);
@@ -295,6 +372,7 @@ const onCallDevice = async (
   }
 
   if (method.payload?.onlyConnectBleDevice) {
+    preWarmCallbackTask?.resolve();
     Log.debug('Call API - only connect ble device: ', device?.mainId);
     return createResponseMessage(method.responseID, true, null);
   }
@@ -334,8 +412,9 @@ const onCallDevice = async (
   );
 
   try {
+    // Wait for any pending task except our own (self-wait would deadlock).
     if (method.connectId) {
-      await context.waitForCallbackTasks(method.connectId);
+      await context.waitForCallbackTasks(method.connectId, preWarmCallbackTask);
     }
 
     await waitForPendingPromise(getPrePendingCallPromise, setPrePendingCallPromise);
@@ -396,10 +475,6 @@ const onCallDevice = async (
           );
         }
 
-        if (isMethodVersionRangeUnsupported(versionRange)) {
-          throw createDeviceNotSupportMethodError(method.name, getFirmwareType(device.features));
-        }
-
         if (versionRange) {
           if (
             semver.valid(versionRange.min) &&
@@ -479,7 +554,7 @@ const onCallDevice = async (
       // Check to see if it is safe to use Passphrase
       checkPassphraseEnableState(method, device.features);
 
-      if (shouldCheckPassphraseState(method, device)) {
+      if (device.hasUsePassphrase() && method.useDevicePassphraseState) {
         // check version
         const support = supportNewPassphrase(device.features);
         if (!support.support) {
@@ -533,7 +608,6 @@ const onCallDevice = async (
 
       try {
         const response: object = await method.run();
-        Log.debug('Call API - Inner Method Run: ');
         messageResponse = createResponseMessage(method.responseID, true, response);
         requestQueue.resolveRequest(method.responseID, messageResponse);
         completeMethodRequestContext(method);
@@ -556,6 +630,7 @@ const onCallDevice = async (
 
     const runOptions: RunOptions = {
       keepSession: method.payload.keepSession,
+      skipInitialize: canSkipInitialize(method, device),
       ...parseInitOptions(method),
     };
     const deviceRun = () => device.run(inner, runOptions);
@@ -577,6 +652,9 @@ const onCallDevice = async (
     Log.debug('Call API - Run Error: ', error);
     completeMethodRequestContext(method, error);
   } finally {
+    // Release the pre-warm callback task so the next real call can proceed.
+    preWarmCallbackTask?.resolve();
+
     const response = messageResponse;
 
     if (response) {
@@ -656,7 +734,6 @@ function initDevice(method: BaseMethod) {
   } else if (allDevices.length > 1) {
     throw ERRORS.TypedError(
       [
-        'firmwareUpdateV4',
         'firmwareUpdateV3',
         'firmwareUpdateV2',
         'checkFirmwareRelease',
@@ -707,38 +784,59 @@ function initDeviceForBle(method: BaseMethod) {
 }
 
 /**
- * If the Bluetooth connection times out, retry 6 times
+ * Check if we can skip initialize for this method
  */
-let bleTimeoutRetry = 0;
-
-function isRetryableBleProtocolV2ProbeError(method: BaseMethod, error: unknown) {
-  const message = error instanceof Error ? error.message : String(error ?? '');
-  return (
-    method.payload.connectProtocol === 'V2' &&
-    message.includes('Device protocol mismatch') &&
-    message.includes('expected V2') &&
-    message.includes('did not respond to expected protocol')
-  );
+function canSkipInitialize(method: BaseMethod, device: Device): boolean {
+  const reasons: string[] = [];
+  // only sign-style methods opt in; getAddress/getPublicKey never do
+  if (!method.allowUsePreInitialize) reasons.push('method.disallow');
+  // caller must opt in per call
+  if (!method.payload?.usePreInitialize) reasons.push('payload.usePreInitialize=false');
+  // no connectId: can't pin the target device, never skip
+  if (!method.connectId) reasons.push('connectId.missing');
+  // passphrase state must match the pre-initialize
+  if (!device.isPreInitializeMetaMatch(method.payload)) reasons.push('meta.mismatch');
+  // device must have been initialized before (has features)
+  if (!device.features) reasons.push('features.missing');
+  // within pre-initialize TTL
+  if (!device.isPreInitializedValid(PRE_INITIALIZE_TTL_MS)) reasons.push('ttl.expired');
+
+  if (reasons.length) {
+    Log.debug(`[PRE-INIT][MISS] method=${method.name} ${reasons.join(',')}`);
+    return false;
+  }
+
+  const savedMs = device.getLastInitializeDuration();
+  const saved = typeof savedMs === 'number' ? `saved ${savedMs}ms` : 'within TTL + meta match';
+  Log.debug(`[PRE-INIT][HIT] method=${method.name} skip Initialize (${saved})`);
+
+  return true;
 }
 
-async function connectDeviceForBle(method: BaseMethod, device: Device) {
+/**
+ * If the Bluetooth connection times out, retry up to 6 times
+ * @param retryCount - Current retry count (default 0)
+ */
+async function connectDeviceForBle(method: BaseMethod, device: Device, retryCount = 0) {
   try {
-    await device.acquire(method.payload.connectProtocol);
+    await device.acquire();
     if (method.payload?.onlyConnectBleDevice) {
       return;
     }
-    await device.initialize(parseInitOptions(method));
+    // Skip initialize if conditions are met
+    if (!canSkipInitialize(method, device)) {
+      const initOptions = parseInitOptions(method);
+      await device.initialize(initOptions);
+      device.markPreInitialized({
+        passphraseState: initOptions.passphraseState,
+      });
+    }
   } catch (err) {
-    if (
-      (err.errorCode === HardwareErrorCode.BleTimeoutError ||
-        err.errorCode === HardwareErrorCode.BleConnectedError ||
-        isRetryableBleProtocolV2ProbeError(method, err)) &&
-      bleTimeoutRetry <= 5
-    ) {
-      bleTimeoutRetry += 1;
-      Log.debug(`Bletooth connect timeout and will retry, retry count: ${bleTimeoutRetry}`);
+    if (err.errorCode === HardwareErrorCode.BleTimeoutError && retryCount < 6) {
+      const nextRetry = retryCount + 1;
+      Log.debug(`Bluetooth connect timeout and will retry, retry count: ${nextRetry}`);
       await wait(3000);
-      await connectDeviceForBle(method, device);
+      await connectDeviceForBle(method, device, nextRetry);
     } else {
       throw err;
     }
@@ -750,6 +848,7 @@ type IPollFn<T> = (time?: number) => T;
 const ensureConnected = async (
   _context: CoreContext,
   method: BaseMethod,
+  connectId: string,
   pollingId: number,
   abortSignal?: AbortSignal
 ) => {
@@ -781,7 +880,7 @@ const ensureConnected = async (
         return;
       }
 
-      if (!pollingState[pollingId]) {
+      if (!pollingManager.isActive(connectId, pollingId)) {
         Log.debug('EnsureConnected function stop, polling id: ', pollingId);
         reject(ERRORS.TypedError(HardwareErrorCode.PollingStop));
         return;
@@ -839,8 +938,6 @@ const ensureConnected = async (
            * Bluetooth should call initialize here
            */
           if (DataManager.isBleConnect(env)) {
-            bleTimeoutRetry = 0;
-
             if (abort()) {
               return;
             }
@@ -903,7 +1000,7 @@ const ensureConnected = async (
       // eslint-disable-next-line no-promise-executor-return
       return setTimeout(() => resolve(poll(time * 1.5)), time);
     });
-  pollingState[pollingId] = true;
+  // pollingManager.start(connectId) already registered this pollingId as active
   return poll();
 };
 
@@ -1012,16 +1109,6 @@ const checkPassphraseEnableState = (method: BaseMethod, features?: Features) =>
   }
 };
 
-const shouldCheckPassphraseState = (method: BaseMethod, device: Device) => {
-  if (!method.useDevicePassphraseState) return false;
-
-  const isPro2 = getDeviceType(device.features) === EDeviceType.Pro2;
-  const pro2ExplicitWalletSelection =
-    isPro2 && (!!method.payload?.passphraseState || !!method.payload?.useEmptyPassphrase);
-
-  return device.hasUsePassphrase() || pro2ExplicitWalletSelection;
-};
-
 const cleanup = () => {
   _uiPromises = [];
   Log.debug('Cleanup...');
@@ -1047,6 +1134,7 @@ const onDeviceConnectHandler = (device: Device) => {
 };
 
 const onDeviceDisconnectHandler = (device: Device) => {
+  device.clearPreInitialized();
   const env = DataManager.getSettings('env');
   const deviceObject = DataManager.isBleConnect(env) ? device : device.toMessageObject();
   postMessage(createDeviceMessage(DEVICE.DISCONNECT, { device: deviceObject as KnownDevice }));
@@ -1223,8 +1311,8 @@ export default class Core extends EventEmitter {
       registerCallbackTask: (connectId: string, callbackPromise: Deferred<any>) => {
         this.requestQueue.registerPendingCallbackTask(connectId, callbackPromise);
       },
-      waitForCallbackTasks: (connectId: string) =>
-        this.requestQueue.waitForPendingCallbackTasks(connectId),
+      waitForCallbackTasks: (connectId: string, exceptTask?: Deferred<void>) =>
+        this.requestQueue.waitForPendingCallbackTasks(connectId, exceptTask),
       cancelCallbackTasks: (connectId: string) => this.requestQueue.cancelCallbackTasks(connectId),
     };
   }
@@ -1255,10 +1343,10 @@ export default class Core extends EventEmitter {
       }
 
       case IFRAME.CALL: {
-        Log.log('call API: ', message);
+        Log.log(`[${Date.now()}][CALL_API]`, message);
         const response = await callAPI(this.getCoreContext(), message);
         const { success, payload } = response;
-        Log.log('call API Response: ', response);
+        Log.log(`[${Date.now()}][CALL_API_RESPONSE]`, response);
         if (success) {
           return response;
         }
@@ -1291,6 +1379,9 @@ export default class Core extends EventEmitter {
   dispose() {
     _deviceList = undefined;
     _connector = undefined;
+    deviceCacheMap.clear();
+    preWarmInflight.clear();
+    preWarmDoneAt.clear();
     Log.debug(`[Core] Disposing SDK instance: ${this.sdkInstanceId}`);
     cleanupSdkInstance(this.sdkInstanceId);
   }

package/src/data-manager/DataManager.ts

@@ -4,7 +4,6 @@ import { EDeviceType, EFirmwareType } from '@onekeyfe/hd-shared';
 
 import MessagesJSON from '../data/messages/messages.json';
 import MessagesLegacyV1JSON from '../data/messages/messages_legacy_v1.json';
-import MessagesProtocolV2JSON from '../data/messages/messages-protocol-v2.json';
 import {
   LoggerNames,
   getDeviceBLEFirmwareVersion,
@@ -41,8 +40,7 @@ export const FIRMWARE_FIELDS = [
 
 export type IFirmwareField = (typeof FIRMWARE_FIELDS)[number];
 
-export type ProtocolV1MessageSchema = 'v1CurrentSchema' | 'v1LegacySchema';
-export type ProtobufMessageSchema = ProtocolV1MessageSchema | 'v2Schema';
+export type MessageVersion = 'latest' | 'v1';
 
 const FIRMWARE_FIELD_TYPE_MAP: Readonly<Record<IFirmwareField, EFirmwareType>> = {
   firmware: EFirmwareType.Universal,
@@ -64,9 +62,7 @@ function getFirmwareTypeFromField(firmwareField: IFirmwareField): EFirmwareType
 }
 
 export default class DataManager {
-  static deviceMap: DeviceTypeMap & {
-    [k: string]: DeviceTypeMap[keyof DeviceTypeMap] | undefined;
-  } = {
+  static deviceMap: DeviceTypeMap = {
     [EDeviceType.Classic]: {
       firmware: [],
       ble: [],
@@ -97,10 +93,9 @@ export default class DataManager {
 
   static settings: ConnectSettings;
 
-  static messages: { [schema in ProtobufMessageSchema]: JSON } = {
-    v1CurrentSchema: MessagesJSON as unknown as JSON,
-    v1LegacySchema: MessagesLegacyV1JSON as unknown as JSON,
-    v2Schema: MessagesProtocolV2JSON as unknown as JSON,
+  static messages: { [version in MessageVersion]: JSON } = {
+    latest: MessagesJSON as unknown as JSON,
+    v1: MessagesLegacyV1JSON as unknown as JSON,
   };
 
   static lastCheckTimestamp = 0;
@@ -477,8 +472,8 @@ export default class DataManager {
     }
   }
 
-  static getProtobufMessages(schema: ProtobufMessageSchema = 'v1CurrentSchema'): JSON {
-    return this.messages[schema];
+  static getProtobufMessages(messageVersion: MessageVersion = 'latest'): JSON {
+    return this.messages[messageVersion];
   }
 
   static getSettings(key?: undefined): ConnectSettings;

package/src/data-manager/MessagesConfig.ts

@@ -1,28 +1,28 @@
 import type { IDeviceModel, IDeviceType } from '../types';
-import type { ProtocolV1MessageSchema } from './DataManager';
+import type { MessageVersion } from './DataManager';
 
 type DeviceVersionConfig = {
   [deviceType in IDeviceType | IDeviceModel]?: {
     minVersion: string;
-    protocolV1MessageSchema: ProtocolV1MessageSchema;
+    messageVersion: MessageVersion;
   }[];
 };
 
 export const PROTOBUF_MESSAGE_CONFIG: DeviceVersionConfig = {
   model_mini: [
-    // Classic1s starts from 3.5.0, so use the current Protocol V1 schema by default.
-    // Only use the legacy Protocol V1 schema for specific old versions (< 3.3.0).
-    { minVersion: '3.3.0', protocolV1MessageSchema: 'v1CurrentSchema' },
-    { minVersion: '0.0.1', protocolV1MessageSchema: 'v1LegacySchema' },
-    // Fallback to current Protocol V1 schema for unknown versions (0.0.0).
-    { minVersion: '0.0.0', protocolV1MessageSchema: 'v1CurrentSchema' },
+    // Classic1s starts from 3.5.0, so use latest by default
+    // Only use v1 for specific old versions (< 3.3.0)
+    { minVersion: '3.3.0', messageVersion: 'latest' },
+    { minVersion: '0.0.1', messageVersion: 'v1' },
+    // Fallback to latest for unknown versions (0.0.0) to prevent device type detection issues
+    { minVersion: '0.0.0', messageVersion: 'latest' },
   ],
   model_touch: [
-    // Use the current Protocol V1 schema by default for Touch/Pro.
-    // Only use the legacy Protocol V1 schema for specific old versions (< 4.5.0).
-    { minVersion: '4.5.0', protocolV1MessageSchema: 'v1CurrentSchema' },
-    { minVersion: '0.0.1', protocolV1MessageSchema: 'v1LegacySchema' },
-    // Fallback to current Protocol V1 schema for unknown versions (0.0.0).
-    { minVersion: '0.0.0', protocolV1MessageSchema: 'v1CurrentSchema' },
+    // Use latest by default for Touch/Pro
+    // Only use v1 for specific old versions (< 4.5.0)
+    { minVersion: '4.5.0', messageVersion: 'latest' },
+    { minVersion: '0.0.1', messageVersion: 'v1' },
+    // Fallback to latest for unknown versions (0.0.0)
+    { minVersion: '0.0.0', messageVersion: 'latest' },
   ],
 };

package/src/data-manager/TransportManager.ts

@@ -4,9 +4,9 @@ import DataManager from './DataManager';
 import { LoggerNames, getLogger } from '../utils';
 // eslint-disable-next-line import/no-cycle
 import { DevicePool } from '../device/DevicePool';
-import { getSupportProtocolV1MessageSchema } from '../utils/deviceFeaturesUtils';
+import { getSupportMessageVersion } from '../utils/deviceFeaturesUtils';
 
-import type { ProtocolV1MessageSchema } from './DataManager';
+import type { MessageVersion } from './DataManager';
 import type { LowlevelTransportSharedPlugin, Transport } from '@onekeyfe/hd-transport';
 import type { Features } from '../types';
 
@@ -17,7 +17,6 @@ const LowLevelLogger = getLogger(LoggerNames.HdTransportLowLevel);
 const NodeUsbLogger = getLogger(LoggerNames.HdTransportNodeUsb);
 const WebBleLogger = getLogger(LoggerNames.HdWebBleTransport);
 const WebUsbLogger = getLogger(LoggerNames.HdTransportWebUsb);
-const REACT_NATIVE_BLE_SCAN_TIMEOUT_MS = 8000;
 
 /**
  * transport 在同一个环境中只会存在一个
@@ -33,7 +32,7 @@ export default class TransportManager {
 
   static reactNativeInit = false;
 
-  static protocolV1MessageSchema: ProtocolV1MessageSchema = 'v1CurrentSchema';
+  static messageVersion: MessageVersion = 'latest';
 
   static plugin: LowlevelTransportSharedPlugin | null = null;
 
@@ -41,7 +40,7 @@ export default class TransportManager {
     Log.debug('transport manager load');
     this.defaultMessages = DataManager.getProtobufMessages();
     this.currentMessages = this.defaultMessages;
-    this.protocolV1MessageSchema = 'v1CurrentSchema';
+    this.messageVersion = 'latest';
   }
 
   static async configure() {
@@ -75,9 +74,6 @@ export default class TransportManager {
       }
       Log.debug('Configuring transports');
       await this.transport.configure(JSON.stringify(this.defaultMessages));
-      this.currentMessages = this.defaultMessages;
-      this.protocolV1MessageSchema = 'v1CurrentSchema';
-      await this.configureProtocolV2Messages();
       Log.debug('Configuring transports done');
     } catch (error) {
       Log.debug('Initializing transports error: ', error);
@@ -87,31 +83,20 @@ export default class TransportManager {
     }
   }
 
-  /**
-   * Re-load the transport's main protobuf schema based on a device's reported features.
-   *
-   * This handles protobuf schema compatibility within Protocol V1 (e.g. Touch's legacy
-   * vs current Protocol V1 schema). It is NOT used to switch between Protocol V1 and Protocol V2 —
-   * the transport already holds both schemas after initial configure(), and routes per
-   * device by `getProtocolType()`.
-   */
-  static async reconfigure(features?: Features) {
-    if (!features) {
-      return;
-    }
-
-    const { protocolV1MessageSchema, messages } = getSupportProtocolV1MessageSchema(features);
+  static async reconfigure(features?: Features | undefined) {
+    Log.debug(`Begin reconfiguring transports`);
+    const { messageVersion, messages } = getSupportMessageVersion(features);
 
     if (this.currentMessages === messages || !messages) {
       return;
     }
 
-    Log.debug(`Reconfiguring transports Protocol V1 schema:${protocolV1MessageSchema}`);
+    Log.debug(`Reconfiguring transports version:${messageVersion}`);
 
     try {
       await this.transport.configure(JSON.stringify(messages));
       this.currentMessages = messages;
-      this.protocolV1MessageSchema = protocolV1MessageSchema;
+      this.messageVersion = messageVersion;
     } catch (error) {
       throw ERRORS.TypedError(
         HardwareErrorCode.TransportInvalidProtobuf,
@@ -124,9 +109,7 @@ export default class TransportManager {
     const env = DataManager.getSettings('env');
     if (env === 'react-native') {
       /** Actually initializes the ReactNativeTransport */
-      this.transport = new TransportConstructor({
-        scanTimeout: REACT_NATIVE_BLE_SCAN_TIMEOUT_MS,
-      }) as unknown as Transport;
+      this.transport = new TransportConstructor({ scanTimeout: 3000 }) as unknown as Transport;
     } else {
       /** Actually initializes the HttpTransport */
       this.transport = new TransportConstructor() as unknown as Transport;
@@ -147,15 +130,6 @@ export default class TransportManager {
     return this.transport;
   }
 
-  private static async configureProtocolV2Messages() {
-    const protocolV2Messages = DataManager.getProtobufMessages('v2Schema');
-    const { configureProtocolV2 } = this.transport;
-    if (protocolV2Messages && typeof configureProtocolV2 === 'function') {
-      await configureProtocolV2.call(this.transport, JSON.stringify(protocolV2Messages));
-      Log.debug('Protocol V2 messages configured');
-    }
-  }
-
   static getDefaultMessages() {
     return this.defaultMessages;
   }
@@ -164,7 +138,7 @@ export default class TransportManager {
     return this.currentMessages;
   }
 
-  static getProtocolV1MessageSchema() {
-    return this.protocolV1MessageSchema;
+  static getMessageVersion() {
+    return this.messageVersion;
   }
 }