@onekeyfe/hd-core 1.2.0-alpha.50 → 1.2.0-alpha.52

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,
@@ -26,7 +26,6 @@ import {
   createRequestContext,
   createSdkTracingContext,
   formatRequestContext,
-  generateInstanceId,
   getActiveRequestsByDeviceInstance,
   updateRequestContext,
 } from '../utils/tracing';
@@ -54,15 +53,13 @@ import {
 import TransportManager from '../data-manager/TransportManager';
 import DeviceConnector from '../device/DeviceConnector';
 import RequestQueue from './RequestQueue';
-import { findUiPromiseForResponse } from './uiPromiseRegistry';
 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';
@@ -106,7 +103,6 @@ const parseInitOptions = (method?: BaseMethod): InitOptions => ({
   deviceId: method?.payload.deviceId,
   deriveCardano: method && hasDeriveCardano(method),
   connectProtocol: method?.payload.connectProtocol,
-  forceProtocolDetection: method?.payload.forceProtocolDetection,
   protocolV2DeviceInfoTimeoutMs: method?.payload.protocolV2DeviceInfoTimeoutMs,
 });
 
@@ -158,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, {
@@ -415,8 +406,6 @@ const onCallDevice = async (
 
   registerHardwareUiEventListeners(device, {
     pin: onDevicePinHandler,
-    pinOnDevice: onEnterPinOnDeviceHandler,
-    pinOnDeviceComplete: onPinOnDeviceCompleteHandler,
     button: onDeviceButtonHandler,
     passphrase: message.payload.useEmptyPassphrase
       ? onEmptyPassphraseHandler
@@ -432,9 +421,6 @@ const onCallDevice = async (
   );
 
   const protocolV2UiCoordinator = new ProtocolV2UiInteractionCoordinator(device, postMessage);
-  let protocolV2Operation = false;
-  let protocolV2CloseEmitted = false;
-  device.beginProtocolV2UiInteraction();
   device.on(
     DEVICE.SELECT_DEVICE_FOR_SWITCH_FIRMWARE_WEB_DEVICE,
     onSelectDeviceForSwitchFirmwareWebDeviceHandler
@@ -452,7 +438,6 @@ const onCallDevice = async (
       // Protocol is established from an active device response during acquire/initialize.
       // Reject unsupported methods before any method-specific device command is sent.
       method.assertProtocolSupported(device.getProtocol(), device.getCurrentFirmwareType());
-      protocolV2Operation = device.isProtocolV2();
 
       // check firmware version
       const versionRange = device.getCurrentMethodVersionRange(
@@ -562,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);
@@ -665,12 +647,7 @@ const onCallDevice = async (
           throw error;
         }
       } finally {
-        if (isProtocolV2UiEnabled(method)) {
-          protocolV2CloseEmitted = protocolV2UiCoordinator.close({
-            ensureOperationClose: protocolV2Operation,
-            protocolV2Operation,
-          });
-        }
+        protocolV2UiCoordinator.close();
       }
     };
     Log.debug('Call API - Device Run: ', device.mainId);
@@ -725,15 +702,7 @@ const onCallDevice = async (
     requestQueue.releaseTask(method.responseID);
 
     if (isProtocolV2UiEnabled(method)) {
-      if (!protocolV2CloseEmitted && protocolV2Operation) {
-        protocolV2CloseEmitted = protocolV2UiCoordinator.close({
-          ensureOperationClose: true,
-          protocolV2Operation: true,
-        });
-      }
-      if (!protocolV2CloseEmitted) {
-        closePopup();
-      }
+      closePopup();
     }
 
     cleanup();
@@ -896,18 +865,10 @@ function isRetryableBleProtocolV2ProbeError(method: BaseMethod, error: unknown)
  */
 async function connectDeviceForBle(method: BaseMethod, device: Device, retryCount = 0) {
   try {
-    if (method.payload.forceProtocolDetection && device.hasDeviceAcquire()) {
-      await device.release();
-    }
     const shouldAcquire =
-      method.payload.forceProtocolDetection ||
-      !device.hasDeviceAcquire() ||
-      !device.commands ||
-      device.commands.disposed;
+      !device.hasDeviceAcquire() || !device.commands || device.commands.disposed;
     if (shouldAcquire) {
-      await device.acquire(method.payload.connectProtocol, {
-        forceProtocolDetection: method.payload.forceProtocolDetection,
-      });
+      await device.acquire(method.payload.connectProtocol);
     }
     if (method.payload?.onlyConnectBleDevice) {
       if (shouldAcquire) {
@@ -1271,7 +1232,6 @@ const onDevicePinHandler = async (...[device, type, callback]: DeviceEvents['pin
     createUiMessage(UI_REQUEST.REQUEST_PIN, {
       device: device.toMessageObject() as unknown as KnownDevice,
       type,
-      responseCorrelation: uiPromise.responseCorrelation,
     })
   );
   // wait for pin
@@ -1319,8 +1279,6 @@ const onDevicePassphraseHandler = async (
       source: requestPayload.source,
       reason: requestPayload.reason,
       expectedPassphraseState: requestPayload.expectedPassphraseState,
-      ...(requestPayload.interaction ? { interaction: requestPayload.interaction } : {}),
-      responseCorrelation: uiPromise.responseCorrelation,
     })
   );
   // wait for passphrase
@@ -1350,7 +1308,6 @@ const onEnterPassphraseOnDeviceHandler = (
       passphraseState: device.passphraseState,
       source: requestPayload?.source,
       reason: requestPayload?.reason,
-      ...(requestPayload?.interaction ? { interaction: requestPayload.interaction } : {}),
     })
   );
 };
@@ -1364,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']]
 ) => {
@@ -1444,21 +1372,14 @@ const postMessage = (message: CoreMessage) => {
 
 const createUiPromise = <T extends UiPromiseResponse['type']>(promiseEvent: T, device?: Device) => {
   const uiPromise: UiPromise<T> = createDeferred(promiseEvent, device);
-  if (
-    device &&
-    (promiseEvent === UI_RESPONSE.RECEIVE_PIN || promiseEvent === UI_RESPONSE.RECEIVE_PASSPHRASE)
-  ) {
-    const publicDeviceId = device.toMessageObject()?.deviceId;
-    uiPromise.responseCorrelation = {
-      interactionId: generateInstanceId('UiResponse', device.sdkInstanceId),
-      deviceId: publicDeviceId || device.instanceId,
-    };
-  }
   _uiPromises.push(uiPromise as any);
 
   return uiPromise;
 };
 
+const findUiPromise = <T extends UiPromiseResponse['type']>(promiseEvent: T) =>
+  _uiPromises.find(p => p.id === promiseEvent);
+
 const removeUiPromise = (promise: Deferred<any>) => {
   _uiPromises = _uiPromises.filter(p => p !== promise);
 };
@@ -1510,16 +1431,11 @@ export default class Core extends EventEmitter {
       case UI_RESPONSE.RECEIVE_PASSPHRASE:
       case UI_RESPONSE.SELECT_DEVICE_IN_BOOTLOADER_FOR_WEB_DEVICE:
       case UI_RESPONSE.SELECT_DEVICE_FOR_SWITCH_FIRMWARE_WEB_DEVICE: {
-        const uiPromise = findUiPromiseForResponse(_uiPromises, message);
+        const uiPromise = findUiPromise(message.type);
         if (uiPromise) {
           Log.log('receive UI Response: ', message.type);
           uiPromise.resolve(message);
           removeUiPromise(uiPromise);
-        } else if (
-          message.type === UI_RESPONSE.RECEIVE_PIN ||
-          message.type === UI_RESPONSE.RECEIVE_PASSPHRASE
-        ) {
-          Log.warn('Ignored unmatched or ambiguous sensitive UI response:', message.type);
         }
         break;
       }

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
       },
@@ -12201,26 +12200,11 @@
         "DeviceSessionError_Busy": 5
       }
     },
-    "DeviceSessionSeedDomain": {
-      "values": {
-        "SeedDomain_Standard": 1,
-        "SeedDomain_Cardano": 2
-      }
-    },
     "DeviceSessionGet": {
       "fields": {
         "session_id": {
           "type": "bytes",
           "id": 1
-        },
-        "btc_test_address": {
-          "type": "string",
-          "id": 2
-        },
-        "seed_domains": {
-          "rule": "repeated",
-          "type": "DeviceSessionSeedDomain",
-          "id": 3
         }
       }
     },
@@ -12554,15 +12538,6 @@
         }
       }
     },
-    "NftUpdate": {
-      "fields": {
-        "file_name_no_ext": {
-          "rule": "required",
-          "type": "string",
-          "id": 1
-        }
-      }
-    },
     "OnboardingStep": {
       "values": {
         "ONBOARDING_STEP_UNKNOWN": 0,

package/src/data-manager/DataManager.ts

@@ -17,7 +17,6 @@ import {
 } from '../utils';
 import { DeviceModelToTypes } from '../types';
 import { findLatestRelease, getReleaseChangelog, getReleaseStatus } from '../utils/release';
-import { parseProtocolV2Resources } from '../protocols/protocol-v2/resources';
 
 import type {
   AssetsMap,
@@ -398,10 +397,20 @@ export default class DataManager {
     return enrichedData;
   }
 
-  static async load(settings: ConnectSettings): Promise<boolean> {
+  static async load(settings: ConnectSettings) {
     this.settings = settings;
-    if (!settings.fetchConfig) {
-      return false;
+    const manifestMode =
+      settings.firmwareManifestMode ?? (settings.fetchConfig ? 'sdk-managed' : undefined);
+    if (settings.preloadedConfig) {
+      this.applyRemoteConfig(settings.preloadedConfig);
+      Log.log('[DataConfig] Preloaded firmware config loaded');
+      return;
+    }
+    if (manifestMode === 'external-only') {
+      throw new Error('External firmware config snapshot is required');
+    }
+    if (manifestMode !== 'sdk-managed') {
+      return;
     }
 
     const url = settings.preRelease
@@ -410,65 +419,48 @@ export default class DataManager {
 
     const urlWithCache = `${url}?noCache=${getTimeStamp()}`;
     let data: RemoteConfigResponse | null = null;
-    let fetchMethod: 'configFetcher' | 'axios' | 'none' = 'none';
-
-    // 1. Try custom configFetcher first (client-side IP direct connection support)
     if (settings.configFetcher) {
-      Log.debug('[DataConfig] Trying configFetcher (client-side fetcher)...');
+      Log.debug('[DataConfig] Trying client configFetcher...');
       try {
         data = await settings.configFetcher(urlWithCache);
-        if (data) {
-          fetchMethod = 'configFetcher';
-          Log.log('[DataConfig] ConfigFetcher success');
-        } else {
-          Log.debug('[DataConfig] ConfigFetcher returned null, will fallback to axios');
-        }
       } catch (e) {
-        Log.warn('[DataConfig] ConfigFetcher error, will fallback to axios:', e);
+        Log.warn('[DataConfig] Client configFetcher failed:', e);
       }
     }
-
-    // 2. Fallback to default axios request
     if (!data) {
-      Log.debug('[DataConfig] Trying axios (SDK default fetcher)...');
+      Log.debug('[DataConfig] Trying SDK-managed config request...');
       try {
         const response = await axios.get<RemoteConfigResponse>(urlWithCache, {
           // because of iframe timeout is 10000
           timeout: 7000,
         });
         data = response.data;
-        fetchMethod = 'axios';
-        Log.log('[DataConfig] Axios fetch success');
+        Log.log('[DataConfig] SDK-managed config request succeeded');
       } catch (e) {
-        Log.warn('[DataConfig] Axios fetch error:', e);
+        Log.warn('[DataConfig] SDK-managed config request failed:', e);
       }
     }
 
-    // 3. Apply config if available
     if (data) {
-      const pro2Resources = parseProtocolV2Resources(
-        (data.pro2 as { resources?: unknown } | undefined)?.resources
-      );
-      Log.log(`[DataConfig] Config loaded successfully via [${fetchMethod}]`);
-      this.deviceMap = {
-        [EDeviceType.Classic]: this.enrichFirmwareReleaseInfo(data.classic),
-        [EDeviceType.Classic1s]: this.enrichFirmwareReleaseInfo(data.classic1s),
-        [EDeviceType.ClassicPure]: this.enrichFirmwareReleaseInfo(data.classicpure),
-        [EDeviceType.Mini]: this.enrichFirmwareReleaseInfo(data.mini),
-        [EDeviceType.Touch]: this.enrichFirmwareReleaseInfo(data.touch),
-        [EDeviceType.Pro]: this.enrichFirmwareReleaseInfo(data.pro),
-        [EDeviceType.Pro2]: {
-          ...this.enrichFirmwareReleaseInfo(data.pro2),
-          ...(pro2Resources ? { resources: pro2Resources } : undefined),
-        },
-      };
-      this.assets = {
-        bridge: data.bridge,
-      };
-      return true;
+      this.applyRemoteConfig(data);
+    } else {
+      Log.warn('[DataConfig] SDK-managed config request failed, using built-in default config');
     }
-    Log.warn('[DataConfig] All fetch methods failed, using built-in default config');
-    return false;
+  }
+
+  private static applyRemoteConfig(data: RemoteConfigResponse) {
+    this.deviceMap = {
+      [EDeviceType.Classic]: this.enrichFirmwareReleaseInfo(data.classic),
+      [EDeviceType.Classic1s]: this.enrichFirmwareReleaseInfo(data.classic1s),
+      [EDeviceType.ClassicPure]: this.enrichFirmwareReleaseInfo(data.classicpure),
+      [EDeviceType.Mini]: this.enrichFirmwareReleaseInfo(data.mini),
+      [EDeviceType.Touch]: this.enrichFirmwareReleaseInfo(data.touch),
+      [EDeviceType.Pro]: this.enrichFirmwareReleaseInfo(data.pro),
+      [EDeviceType.Pro2]: this.enrichFirmwareReleaseInfo(data.pro2),
+    };
+    this.assets = {
+      bridge: data.bridge,
+    };
   }
 
   static updateEnv(newEnv: ConnectSettings['env']) {
@@ -486,31 +478,10 @@ export default class DataManager {
 
   static async checkAndReloadData() {
     if (getTimeStamp() - this.lastCheckTimestamp > 1000 * 60 * 60 * 3) {
-      const loaded = await this.load(this.settings);
-      if (loaded) {
+      await this.load(this.settings).then(() => {
         this.lastCheckTimestamp = getTimeStamp();
-      }
-    }
-  }
-
-  /** Force a fresh remote config before an update is allowed to mutate the device. */
-  static async forceReloadData(): Promise<void> {
-    if (!this.settings) {
-      throw new Error('Remote config settings are not initialized');
-    }
-    const loaded = await this.load(this.settings);
-    if (!loaded) {
-      throw new Error('Unable to refresh the latest remote config');
+      });
     }
-    this.lastCheckTimestamp = getTimeStamp();
-  }
-
-  static getProtocolV2Resources() {
-    return this.deviceMap[EDeviceType.Pro2]?.resources?.stable;
-  }
-
-  static getProtocolV2BootResources() {
-    return this.deviceMap[EDeviceType.Pro2]?.resources?.boot;
   }
 
   static getProtobufMessages(schema: ProtobufMessageSchema = 'v1CurrentSchema'): JSON {

package/src/data-manager/connectSettings.ts

@@ -115,10 +115,21 @@ export const parseConnectSettings = (input: Partial<ConnectSettings> = {}) => {
     settings.fetchConfig = input.fetchConfig;
   }
 
+  if (
+    input.firmwareManifestMode === 'sdk-managed' ||
+    input.firmwareManifestMode === 'external-only'
+  ) {
+    settings.firmwareManifestMode = input.firmwareManifestMode;
+  }
+
   if (input.configFetcher) {
     settings.configFetcher = input.configFetcher;
   }
 
+  if (input.preloadedConfig) {
+    settings.preloadedConfig = input.preloadedConfig;
+  }
+
   return settings;
 };