@onetokenfe/hd-core 1.1.23

package/src/data-manager/CoinManager.ts

@@ -0,0 +1,31 @@
+import { fromHardened } from '../api/helpers/pathUtils';
+import bitcoin from '../data/coins/bitcoin.json';
+
+const btcCoins = bitcoin.map(coin => coin.name);
+
+export type BitcoinInfo = {
+  name: string;
+  slip44: number;
+  label: string;
+};
+
+export default class CoinManager {
+  static getCoins(): string[] {
+    return btcCoins;
+  }
+
+  static getBitcoinCoinInfo(info: { name?: string; path?: number[] }): BitcoinInfo | undefined {
+    let coinInfo: BitcoinInfo | undefined;
+    if (info.name) {
+      const coinName = info.name.toLowerCase();
+      coinInfo = bitcoin.find(
+        c => c.name.toLowerCase() === coinName || c.label.toLowerCase() === coinName
+      );
+    } else if (info.path) {
+      const slip44 = fromHardened(info.path[1]);
+      coinInfo = bitcoin.find(c => c.slip44 === slip44);
+    }
+
+    return coinInfo;
+  }
+}

package/src/data-manager/DataManager.ts

@@ -0,0 +1,499 @@
+import axios from 'axios';
+import semver from 'semver';
+import { EDeviceType, EFirmwareType } from '@onetokenfe/hd-shared';
+
+import MessagesJSON from '../data/messages/messages.json';
+import MessagesLegacyV1JSON from '../data/messages/messages_legacy_v1.json';
+import {
+  LoggerNames,
+  getDeviceBLEFirmwareVersion,
+  getDeviceFirmwareVersion,
+  getDeviceType,
+  getFirmwareType,
+  getFirmwareUpdateField,
+  getLogger,
+  getTimeStamp,
+} from '../utils';
+import { DeviceModelToTypes } from '../types';
+import { findLatestRelease, getReleaseChangelog, getReleaseStatus } from '../utils/release';
+
+import type {
+  AssetsMap,
+  ConnectSettings,
+  DeviceTypeMap,
+  Features,
+  IDeviceBLEFirmwareStatus,
+  IDeviceFirmwareStatus,
+  ITransportStatus,
+  IVersionArray,
+  RemoteConfigResponse,
+} from '../types';
+
+const Log = getLogger(LoggerNames.Core);
+
+export const FIRMWARE_FIELDS = [
+  'firmware',
+  'firmware-v2',
+  'firmware-v8',
+  'firmware-btc-v8',
+] as const;
+
+export type IFirmwareField = (typeof FIRMWARE_FIELDS)[number];
+
+export type MessageVersion = 'latest' | 'v1';
+
+const FIRMWARE_FIELD_TYPE_MAP: Readonly<Record<IFirmwareField, EFirmwareType>> = {
+  firmware: EFirmwareType.Universal,
+  'firmware-v2': EFirmwareType.Universal,
+  'firmware-v8': EFirmwareType.Universal,
+  'firmware-btc-v8': EFirmwareType.BitcoinOnly,
+} as const;
+
+function getFirmwareTypeFromField(firmwareField: IFirmwareField): EFirmwareType {
+  const firmwareType = FIRMWARE_FIELD_TYPE_MAP[firmwareField];
+
+  // Explicit check for type safety
+  if (firmwareType === undefined) {
+    // Fallback to Universal for safety
+    return EFirmwareType.Universal;
+  }
+
+  return firmwareType;
+}
+
+export default class DataManager {
+  static deviceMap: DeviceTypeMap = {
+    [EDeviceType.Classic]: {
+      firmware: [],
+      ble: [],
+    },
+    [EDeviceType.Classic1s]: {
+      firmware: [],
+      ble: [],
+    },
+    [EDeviceType.Mini]: {
+      firmware: [],
+      ble: [],
+    },
+    [EDeviceType.Touch]: {
+      firmware: [],
+      ble: [],
+    },
+    [EDeviceType.Pro]: {
+      firmware: [],
+      ble: [],
+    },
+    [EDeviceType.ClassicPure]: {
+      firmware: [],
+      ble: [],
+    },
+  };
+
+  static assets: AssetsMap | null = null;
+
+  static settings: ConnectSettings;
+
+  static messages: { [version in MessageVersion]: JSON } = {
+    latest: MessagesJSON as unknown as JSON,
+    v1: MessagesLegacyV1JSON as unknown as JSON,
+  };
+
+  static lastCheckTimestamp = 0;
+
+  static getFirmwareStatus = (
+    features: Features,
+    firmwareType: EFirmwareType
+  ): IDeviceFirmwareStatus => {
+    const deviceType = getDeviceType(features);
+    if (deviceType === EDeviceType.Unknown) return 'unknown';
+
+    const deviceFirmwareType = getFirmwareType(features);
+    const deviceFirmwareVersion = getDeviceFirmwareVersion(features);
+    if (features.firmware_present === false) {
+      return 'none';
+    }
+
+    if (DeviceModelToTypes.model_mini.includes(deviceType) && features.bootloader_mode) {
+      return 'unknown';
+    }
+
+    const firmwareUpdateField = getFirmwareUpdateField({
+      features,
+      updateType: 'firmware',
+      firmwareType,
+    });
+    const targetDeviceConfigList = this.deviceMap[deviceType]?.[firmwareUpdateField] ?? [];
+    let currentVersion = deviceFirmwareVersion.join('.');
+    if (targetDeviceConfigList.length > 0 && deviceFirmwareType !== firmwareType) {
+      currentVersion = '0.0.0';
+    }
+    return getReleaseStatus(targetDeviceConfigList, currentVersion);
+  };
+
+  /**
+   * Touch、Pro System UI Resource Update
+   * ** Interval upgrade is not considered **
+   */
+  static getSysResourcesLatestRelease = ({
+    features,
+    forcedUpdateRes,
+    firmwareType,
+  }: {
+    features: Features;
+    forcedUpdateRes?: boolean;
+    firmwareType: EFirmwareType;
+  }) => {
+    const deviceType = getDeviceType(features);
+    const deviceFirmwareVersion = getDeviceFirmwareVersion(features);
+
+    if (deviceType !== EDeviceType.Pro && deviceType !== EDeviceType.Touch) return undefined;
+
+    const firmwareUpdateField = getFirmwareUpdateField({
+      features,
+      updateType: 'firmware',
+      firmwareType,
+    }) as IFirmwareField;
+    const targetDeviceConfigList = this.deviceMap[deviceType]?.[firmwareUpdateField] ?? [];
+    const currentVersion = deviceFirmwareVersion.join('.');
+    const targetDeviceConfig = targetDeviceConfigList.filter(item =>
+      forcedUpdateRes
+        ? !!item.resource
+        : semver.gt(item.version.join('.'), currentVersion) && !!item.resource
+    );
+
+    return findLatestRelease(targetDeviceConfig)?.resource;
+  };
+
+  /**
+   * Touch、Pro System full UI Resource Update
+   * ** Interval upgrade is not considered **
+   */
+  static getSysFullResource = (features: Features, firmwareType: EFirmwareType) => {
+    const deviceType = getDeviceType(features);
+    if (deviceType === EDeviceType.Unknown) return undefined;
+
+    if (deviceType !== EDeviceType.Pro && deviceType !== EDeviceType.Touch) return undefined;
+
+    const firmwareUpdateField = getFirmwareUpdateField({
+      features,
+      updateType: 'firmware',
+      firmwareType,
+    }) as IFirmwareField;
+    const targetDeviceConfigList = this.deviceMap[deviceType]?.[firmwareUpdateField] ?? [];
+    const targetDeviceConfig = targetDeviceConfigList.filter(item => !!item.fullResource);
+
+    return findLatestRelease(targetDeviceConfig)?.fullResource;
+  };
+
+  static getBootloaderResource = (features: Features, firmwareType: EFirmwareType) => {
+    const deviceType = getDeviceType(features);
+    if (deviceType === EDeviceType.Unknown) throw new Error('Device type is unknown');
+
+    if (deviceType !== EDeviceType.Pro && deviceType !== EDeviceType.Touch) return undefined;
+    const firmwareUpdateField = getFirmwareUpdateField({
+      features,
+      updateType: 'firmware',
+      firmwareType,
+    }) as IFirmwareField;
+    const targetDeviceConfigList = this.deviceMap[deviceType]?.[firmwareUpdateField] ?? [];
+    if (targetDeviceConfigList.length === 0) {
+      throw new Error(
+        `Could not found bootloader resource with deviceType:${deviceType} firmwareUpdateField:${firmwareUpdateField}`
+      );
+    }
+    const targetDeviceConfig = targetDeviceConfigList.filter(item => !!item.bootloaderResource);
+
+    return findLatestRelease(targetDeviceConfig)?.bootloaderResource;
+  };
+
+  static getBootloaderTargetVersion = (
+    features: Features,
+    firmwareType: EFirmwareType
+  ): IVersionArray | undefined => {
+    const deviceType = getDeviceType(features);
+    if (deviceType === EDeviceType.Unknown) return undefined;
+
+    const firmwareUpdateField = getFirmwareUpdateField({
+      features,
+      updateType: 'firmware',
+      firmwareType,
+    }) as IFirmwareField;
+    const targetDeviceConfigList = this.deviceMap[deviceType]?.[firmwareUpdateField] ?? [];
+    const targetDeviceConfig = targetDeviceConfigList.filter(item => !!item.bootloaderResource);
+
+    return targetDeviceConfig?.[0]?.bootloaderVersion ?? undefined;
+  };
+
+  static getBootloaderRelatedFirmwareVersion = (
+    features: Features,
+    firmwareType: EFirmwareType
+  ): IVersionArray | undefined => {
+    const deviceType = getDeviceType(features);
+    if (deviceType === EDeviceType.Unknown) return undefined;
+
+    if (!DeviceModelToTypes.model_mini.includes(deviceType)) return undefined;
+    const firmwareUpdateField = getFirmwareUpdateField({
+      features,
+      updateType: 'firmware',
+      firmwareType,
+    }) as IFirmwareField;
+    const targetDeviceConfigList = this.deviceMap[deviceType]?.[firmwareUpdateField] ?? [];
+    const targetDeviceConfig = targetDeviceConfigList.filter(
+      item => !!item.bootloaderRelatedFirmwareVersion
+    );
+
+    return targetDeviceConfig?.[0]?.bootloaderRelatedFirmwareVersion ?? undefined;
+  };
+
+  static getFirmwareChangelog = (features: Features, firmwareType: EFirmwareType) => {
+    const deviceType = getDeviceType(features);
+    if (deviceType === EDeviceType.Unknown) return [];
+
+    const deviceFirmwareVersion = getDeviceFirmwareVersion(features);
+
+    const firmwareUpdateField = getFirmwareUpdateField({
+      features,
+      updateType: 'firmware',
+      firmwareType,
+    }) as IFirmwareField;
+    const targetDeviceConfigList = this.deviceMap[deviceType]?.[firmwareUpdateField] ?? [];
+
+    if (
+      features.firmware_present === false ||
+      (DeviceModelToTypes.model_classic.includes(deviceType) && features.bootloader_mode)
+    ) {
+      // Always return least changelog
+      return getReleaseChangelog(targetDeviceConfigList, '0.0.0');
+    }
+
+    const currentVersion = deviceFirmwareVersion.join('.');
+    return getReleaseChangelog(targetDeviceConfigList, currentVersion);
+  };
+
+  static getFirmwareLatestRelease = (features: Features, firmwareType: EFirmwareType) => {
+    const deviceType = getDeviceType(features);
+    if (deviceType === EDeviceType.Unknown) return undefined;
+
+    const firmwareUpdateField = getFirmwareUpdateField({
+      features,
+      updateType: 'firmware',
+      firmwareType,
+    }) as IFirmwareField;
+    const targetDeviceConfigList = this.deviceMap[deviceType]?.[firmwareUpdateField] ?? [];
+
+    const target = findLatestRelease(targetDeviceConfigList);
+    if (!target) return target;
+
+    if (!target.resource) {
+      const resource = this.getSysResourcesLatestRelease({ features, firmwareType });
+      return {
+        ...target,
+        resource,
+      };
+    }
+    return target;
+  };
+
+  static getBLEFirmwareStatus = (features: Features): IDeviceBLEFirmwareStatus => {
+    const deviceType = getDeviceType(features);
+    if (deviceType === EDeviceType.Unknown) return 'unknown';
+
+    const deviceBLEFirmwareVersion = getDeviceBLEFirmwareVersion(features);
+
+    /** mini has no device ble_ver */
+    if (!deviceBLEFirmwareVersion) {
+      return 'none';
+    }
+
+    const targetDeviceConfigList = this.deviceMap[deviceType]?.ble ?? [];
+    const currentVersion = deviceBLEFirmwareVersion.join('.');
+    return getReleaseStatus(targetDeviceConfigList, currentVersion);
+  };
+
+  static getBleFirmwareChangelog = (features: Features) => {
+    const deviceType = getDeviceType(features);
+    if (deviceType === EDeviceType.Unknown) return [];
+
+    const deviceBLEFirmwareVersion = getDeviceBLEFirmwareVersion(features);
+
+    if (!deviceBLEFirmwareVersion) {
+      return [];
+    }
+
+    const targetDeviceConfigList = this.deviceMap[deviceType]?.ble ?? [];
+    const currentVersion = deviceBLEFirmwareVersion.join('.');
+    return getReleaseChangelog(targetDeviceConfigList, currentVersion);
+  };
+
+  static getBleFirmwareLatestRelease = (features: Features) => {
+    const deviceType = getDeviceType(features);
+    if (deviceType === EDeviceType.Unknown) return undefined;
+
+    const targetDeviceConfigList = this.deviceMap[deviceType]?.ble ?? [];
+    return findLatestRelease(targetDeviceConfigList);
+  };
+
+  static getTransportStatus = (localVersion: string): ITransportStatus => {
+    const latestTransportVersion = this.assets?.bridge?.version;
+    if (!latestTransportVersion) return 'valid';
+    const isLatest = semver.gte(localVersion, latestTransportVersion.join('.'));
+    return isLatest ? 'valid' : 'outdated';
+  };
+
+  static getBridgeChangelog = () => this.assets?.bridge.changelog;
+
+  private static enrichFirmwareReleaseInfo(
+    deviceData: DeviceTypeMap[keyof DeviceTypeMap] | undefined
+  ): DeviceTypeMap[keyof DeviceTypeMap] {
+    // Safety check: return default structure if input is undefined/null
+    if (!deviceData || typeof deviceData !== 'object') {
+      return {
+        firmware: [],
+        ble: [],
+      };
+    }
+
+    // Create a shallow copy to avoid mutating original data
+    const enrichedData = { ...deviceData };
+
+    FIRMWARE_FIELDS.forEach(field => {
+      const releases = enrichedData[field];
+
+      if (!releases || !Array.isArray(releases) || releases.length === 0) {
+        return; // Skip this field
+      }
+
+      // Add firmwareType to each release in this field
+      try {
+        enrichedData[field] = releases.map(release => {
+          // Safety checks:
+          if (!release || typeof release !== 'object' || !!release.firmwareType) {
+            return release; // Return as-is if invalid or already has firmwareType
+          }
+
+          const firmwareType = getFirmwareTypeFromField(field);
+
+          return {
+            ...release,
+            firmwareType,
+          };
+        });
+      } catch (error) {
+        console.error(`Error enriching firmware field "${field}":`, error);
+      }
+    });
+
+    return enrichedData;
+  }
+
+  static async load(settings: ConnectSettings) {
+    this.settings = settings;
+    if (!settings.fetchConfig) {
+      return;
+    }
+
+    const url = settings.preRelease
+      ? 'https://data.onetoken.so/pre-config.json'
+      : 'https://data.onetoken.so/config.json';
+
+    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)...');
+      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);
+      }
+    }
+
+    // 2. Fallback to default axios request
+    if (!data) {
+      Log.debug('[DataConfig] Trying axios (SDK default fetcher)...');
+      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');
+      } catch (e) {
+        Log.warn('[DataConfig] Axios fetch error:', e);
+      }
+    }
+
+    // 3. Apply config if available
+    if (data) {
+      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),
+      };
+      this.assets = {
+        bridge: data.bridge,
+      };
+    } else {
+      Log.warn('[DataConfig] All fetch methods failed, using built-in default config');
+    }
+  }
+
+  static updateEnv(newEnv: ConnectSettings['env']) {
+    if (this.settings) {
+      const prevEnv = this.settings.env;
+      this.settings = {
+        ...this.settings,
+        env: newEnv,
+      };
+
+      // Log the environment change
+      console.debug(`DataManager env updated: ${prevEnv} -> ${newEnv}`);
+    }
+  }
+
+  static async checkAndReloadData() {
+    if (getTimeStamp() - this.lastCheckTimestamp > 1000 * 60 * 60 * 3) {
+      await this.load(this.settings).then(() => {
+        this.lastCheckTimestamp = getTimeStamp();
+      });
+    }
+  }
+
+  static getProtobufMessages(messageVersion: MessageVersion = 'latest'): JSON {
+    return this.messages[messageVersion];
+  }
+
+  static getSettings(key?: undefined): ConnectSettings;
+
+  static getSettings<T extends keyof ConnectSettings>(key: T): ConnectSettings[T];
+
+  static getSettings(key?: keyof ConnectSettings) {
+    if (!this.settings) return null;
+    if (typeof key === 'string') {
+      return this.settings[key];
+    }
+    return this.settings;
+  }
+
+  static isBleConnect = (env: ConnectSettings['env']) =>
+    env === 'react-native' || env === 'lowlevel' || env === 'desktop-web-ble';
+
+  /** Desktop WebUSB doesn't need browser permission prompt */
+  static isDesktopWebUsb = (env: ConnectSettings['env']) => env === 'desktop-webusb';
+
+  /** Browser WebUSB needs permission prompt */
+  static isBrowserWebUsb = (env: ConnectSettings['env']) => env === 'webusb';
+}

package/src/data-manager/MessagesConfig.ts

@@ -0,0 +1,28 @@
+import type { IDeviceModel, IDeviceType } from '../types';
+import type { MessageVersion } from './DataManager';
+
+type DeviceVersionConfig = {
+  [deviceType in IDeviceType | IDeviceModel]?: {
+    minVersion: string;
+    messageVersion: MessageVersion;
+  }[];
+};
+
+export const PROTOBUF_MESSAGE_CONFIG: DeviceVersionConfig = {
+  model_mini: [
+    // 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 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

@@ -0,0 +1,140 @@
+import { ERRORS, HardwareErrorCode } from '@onetokenfe/hd-shared';
+
+import DataManager from './DataManager';
+import { LoggerNames, getLogger } from '../utils';
+// eslint-disable-next-line import/no-cycle
+import { DevicePool } from '../device/DevicePool';
+import { getSupportMessageVersion } from '../utils/deviceFeaturesUtils';
+
+import type { MessageVersion } from './DataManager';
+import type { LowlevelTransportSharedPlugin, Transport } from '@onetokenfe/hd-transport';
+import type { Features } from '../types';
+
+const Log = getLogger(LoggerNames.Transport);
+const BleLogger = getLogger(LoggerNames.HdBleTransport);
+const HttpLogger = getLogger(LoggerNames.HdTransportHttp);
+const LowLevelLogger = getLogger(LoggerNames.HdTransportLowLevel);
+const WebBleLogger = getLogger(LoggerNames.HdWebBleTransport);
+const WebUsbLogger = getLogger(LoggerNames.HdTransportWebUsb);
+
+/**
+ * transport 在同一个环境中只会存在一个
+ * 这里设计成单例获取
+ * 方便进行环境判断，读取不同的 transport
+ */
+export default class TransportManager {
+  static transport: Transport;
+
+  static defaultMessages: JSON | Record<string, any>;
+
+  static currentMessages: JSON | Record<string, any>;
+
+  static reactNativeInit = false;
+
+  static messageVersion: MessageVersion = 'latest';
+
+  static plugin: LowlevelTransportSharedPlugin | null = null;
+
+  static load() {
+    Log.debug('transport manager load');
+    this.defaultMessages = DataManager.getProtobufMessages();
+    this.currentMessages = this.defaultMessages;
+    this.messageVersion = 'latest';
+  }
+
+  static async configure() {
+    try {
+      const env = DataManager.getSettings('env');
+      Log.debug('Initializing transports', env);
+      if (env === 'react-native') {
+        if (!this.reactNativeInit) {
+          await this.transport.init(BleLogger, DevicePool.emitter);
+          this.reactNativeInit = true;
+        } else {
+          Log.debug('React Native Do Not Initializing transports');
+        }
+      } else if (env === 'lowlevel') {
+        if (!this.plugin) {
+          throw ERRORS.TypedError(
+            HardwareErrorCode.TransportNotConfigured,
+            'Lowlevel transport mast have plugin'
+          );
+        }
+        await this.transport.init(LowLevelLogger, DevicePool.emitter, this.plugin);
+      } else if (env === 'desktop-web-ble') {
+        await this.transport.init(WebBleLogger, DevicePool.emitter);
+      } else if (env === 'webusb' || env === 'desktop-webusb') {
+        await this.transport.init(WebUsbLogger);
+      } else {
+        await this.transport.init(HttpLogger);
+      }
+      Log.debug('Configuring transports');
+      await this.transport.configure(JSON.stringify(this.defaultMessages));
+      Log.debug('Configuring transports done');
+    } catch (error) {
+      Log.debug('Initializing transports error: ', error);
+      if (error.code === 'ECONNABORTED') {
+        throw ERRORS.TypedError(HardwareErrorCode.BridgeTimeoutError);
+      }
+    }
+  }
+
+  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 version:${messageVersion}`);
+
+    try {
+      await this.transport.configure(JSON.stringify(messages));
+      this.currentMessages = messages;
+      this.messageVersion = messageVersion;
+    } catch (error) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.TransportInvalidProtobuf,
+        `Transport_InvalidProtobuf:  ${error.message as unknown as string}`
+      );
+    }
+  }
+
+  static setTransport(TransportConstructor: any, plugin?: LowlevelTransportSharedPlugin) {
+    const env = DataManager.getSettings('env');
+    if (env === 'react-native') {
+      /** Actually initializes the ReactNativeTransport */
+      this.transport = new TransportConstructor({ scanTimeout: 3000 }) as unknown as Transport;
+    } else {
+      /** Actually initializes the HttpTransport */
+      this.transport = new TransportConstructor() as unknown as Transport;
+    }
+    if (plugin) {
+      this.plugin = plugin;
+      Log.debug('set transport plugin: ', this.plugin);
+    }
+    Log.debug(
+      'set transport: ',
+      this.transport.name,
+      this.transport.version,
+      this.transport.configured
+    );
+  }
+
+  static getTransport() {
+    return this.transport;
+  }
+
+  static getDefaultMessages() {
+    return this.defaultMessages;
+  }
+
+  static getCurrentMessages() {
+    return this.currentMessages;
+  }
+
+  static getMessageVersion() {
+    return this.messageVersion;
+  }
+}