@onekeyfe/hd-core 0.1.14 → 0.1.18

package/src/types/api/solGetAddress.ts

@@ -12,10 +12,12 @@ export type SolanaGetAddressParams = {
 
 export declare function solGetAddress(
   connectId: string,
+  deviceId: string,
   params: CommonParams & SolanaGetAddressParams
 ): Response<SolanaAddress>;
 
 export declare function solGetAddress(
   connectId: string,
+  deviceId: string,
   params: CommonParams & { bundle?: SolanaGetAddressParams[] }
 ): Response<Array<SolanaAddress>>;

package/src/types/api/solSignTransaction.ts

@@ -12,10 +12,12 @@ export type SolanaSignTransactionParams = {
 
 export declare function solSignTransaction(
   connectId: string,
+  deviceId: string,
   params: CommonParams & SolanaSignTransactionParams
 ): Response<SolanaSignedTx>;
 
 export declare function solSignTransaction(
   connectId: string,
+  deviceId: string,
   params: CommonParams & { bundle?: SolanaSignTransactionParams[] }
 ): Response<Array<SolanaSignedTx>>;

package/src/types/api/starcoinGetAddress.ts

@@ -12,10 +12,12 @@ export type StarcoinGetAddressParams = {
 
 export declare function starcoinGetAddress(
   connectId: string,
+  deviceId: string,
   params: CommonParams & StarcoinGetAddressParams
 ): Response<StarcoinAddress>;
 
 export declare function starcoinGetAddress(
   connectId: string,
+  deviceId: string,
   params: CommonParams & { bundle?: StarcoinGetAddressParams[] }
 ): Response<Array<StarcoinAddress>>;

package/src/types/api/starcoinGetPublicKey.ts

@@ -12,10 +12,12 @@ export type StarcoinGetPublicKeyParams = {
 
 export declare function starcoinGetPublicKey(
   connectId: string,
+  deviceId: string,
   params: CommonParams & StarcoinGetPublicKeyParams
 ): Response<StarcoinPublicKey>;
 
 export declare function starcoinGetPublicKey(
   connectId: string,
+  deviceId: string,
   params: CommonParams & { bundle?: StarcoinGetPublicKeyParams[] }
 ): Response<Array<StarcoinPublicKey>>;

package/src/types/api/starcoinSignMessage.ts

@@ -8,5 +8,6 @@ export type StarcoinSignMessageParams = {
 
 export declare function starcoinSignMessage(
   connectId: string,
+  deviceId: string,
   params: CommonParams & StarcoinSignMessageParams
 ): Response<StarcoinMessageSignature>;

package/src/types/api/starcoinSignTransaction.ts

@@ -8,5 +8,6 @@ export type StarcoinSignTransactionParams = {
 
 export declare function starcoinSignTransaction(
   connectId: string,
+  deviceId: string,
   params: CommonParams & StarcoinSignTransactionParams
 ): Response<StarcoinSignedTx>;

package/src/types/api/starcoinVerifyMessage.ts

@@ -9,5 +9,6 @@ export type StarcoinVerifyMessageParams = {
 
 export declare function starcoinVerifyMessage(
   connectId: string,
+  deviceId: string,
   params: CommonParams & StarcoinVerifyMessageParams
 ): Response<Success>;

package/src/types/api/stellarGetAddress.ts

@@ -12,10 +12,12 @@ export type StellarGetAddressParams = {
 
 export declare function stellarGetAddress(
   connectId: string,
+  deviceId: string,
   params: CommonParams & StellarGetAddressParams
 ): Response<StellarAddress>;
 
 export declare function stellarGetAddress(
   connectId: string,
+  deviceId: string,
   params: CommonParams & { bundle?: StellarGetAddressParams[] }
 ): Response<Array<StellarAddress>>;

package/src/types/api/stellarSignTransaction.ts

@@ -149,5 +149,6 @@ export type StellarSignTransactionParams = {
 
 export declare function stellarSignTransaction(
   connectId: string,
+  deviceId: string,
   params: CommonParams & StellarSignTransactionParams
 ): Response<StellarSignedTx>;

package/src/types/params.ts

@@ -1,5 +1,17 @@
 export interface CommonParams {
   keepSession?: boolean;
+  /**
+   * polling connect max retry count
+   */
+  retryCount?: number;
+  /**
+   * polling interval time
+   */
+  pollIntervalTime?: number;
+  /**
+   * Timeout time for single polling
+   */
+  timeout?: number;
 }
 
 export type Params<T> = CommonParams & T & { bundle?: undefined };

package/src/utils/deviceFeaturesUtils.ts

@@ -24,16 +24,8 @@ export const getDeviceType = (features?: Features): IDeviceType => {
   return 'classic';
 };
 
-export const getDeviceTypeOnBootloader = (features?: Features): IDeviceType => {
-  if (!features || typeof features !== 'object') {
-    return 'classic';
-  }
-  if (features.model === 'T') {
-    return 'touch';
-  }
-
-  return getDeviceType(features);
-};
+export const getDeviceTypeOnBootloader = (features?: Features): IDeviceType =>
+  getDeviceType(features);
 
 export const getDeviceTypeByBleName = (name?: string): IDeviceType | null => {
   if (!name) return 'classic';

package/src/utils/index.ts

@@ -1,5 +1,3 @@
-import { initLog, enableLog } from '@onekeyfe/hd-shared';
-
 export * from './assets';
 export * from './versionUtils';
 export * from './patch';
@@ -12,4 +10,4 @@ export {
 } from './deviceFeaturesUtils';
 export { getHDPath, getScriptType } from '../api/helpers/pathUtils';
 
-export { initLog, enableLog };
+export { getLogger, enableLog, LoggerNames, getLog, setLoggerPostMessage } from './logger';

package/src/utils/logger.ts

@@ -0,0 +1,179 @@
+import { CoreMessage } from '../events';
+import { createLogMessage, LOG } from '../events/log';
+
+type LogMessage = {
+  level: string;
+  prefix: string;
+  message: any[];
+  timestamp: number;
+};
+
+const MAX_ENTRIES = 500;
+
+let postMessage: (message: CoreMessage) => void;
+
+class Log {
+  prefix: string;
+
+  enabled: boolean;
+
+  messages: LogMessage[];
+
+  constructor(prefix: string, enabled: boolean) {
+    this.prefix = prefix;
+    this.enabled = enabled;
+    this.messages = [];
+  }
+
+  addMessage(level: string, prefix: string, ...args: any[]) {
+    this.messages.push({
+      level,
+      prefix,
+      message: args,
+      timestamp: new Date().getTime(),
+    });
+    if (this.messages.length > MAX_ENTRIES) {
+      this.messages.shift();
+    }
+  }
+
+  log(...args: any[]) {
+    this.addMessage('log', this.prefix, ...args);
+    sendLogMessage(this.prefix, ...args);
+    if (!this.enabled) {
+      return;
+    }
+    console.log(this.prefix, ...args);
+  }
+
+  error(...args: any[]) {
+    this.addMessage('error', this.prefix, ...args);
+    sendLogMessage(this.prefix, ...args);
+    if (!this.enabled) {
+      return;
+    }
+    console.error(this.prefix, ...args);
+  }
+
+  warn(...args: any[]) {
+    this.addMessage('warn', this.prefix, ...args);
+    sendLogMessage(this.prefix, ...args);
+    if (!this.enabled) {
+      return;
+    }
+    console.warn(this.prefix, ...args);
+  }
+
+  debug(...args: any[]) {
+    this.addMessage('debug', this.prefix, ...args);
+    sendLogMessage(this.prefix, ...args);
+    if (!this.enabled) {
+      return;
+    }
+    console.log(this.prefix, ...args);
+  }
+}
+
+const _logs: { [k: string]: Log } = {};
+
+export const initLog = (prefix: string, enabled?: boolean) => {
+  const instance = new Log(prefix, !!enabled);
+  _logs[prefix] = instance;
+  return instance;
+};
+
+export const enableLog = (enabled?: boolean) => {
+  Object.keys(_logs).forEach(key => {
+    _logs[key].enabled = !!enabled;
+  });
+};
+
+export const enableLogByPrefix = (prefix: string, enabled: boolean) => {
+  if (_logs[prefix]) {
+    _logs[prefix].enabled = enabled;
+  }
+};
+
+export const getLog = () => {
+  let logs: LogMessage[] = [];
+  Object.keys(_logs).forEach(key => {
+    logs = logs.concat(_logs[key].messages);
+  });
+  logs.sort((a, b) => a.timestamp - b.timestamp);
+  return logs;
+};
+
+export const setLoggerPostMessage = (postMessageFn: (message: CoreMessage) => void) => {
+  postMessage = postMessageFn;
+};
+
+const serializeLog = (...args: any[]) =>
+  args.map(arg => {
+    if (typeof arg === 'string') {
+      return arg;
+    }
+    if (typeof arg === 'number') {
+      return arg;
+    }
+    if (typeof arg === 'boolean') {
+      return arg;
+    }
+    if (typeof arg === 'undefined') {
+      return arg;
+    }
+    if (typeof arg === 'object') {
+      return JSON.stringify(arg, getCircularReplacer());
+    }
+    return arg;
+  });
+
+const getCircularReplacer = () => {
+  const seen = new WeakSet();
+  return (_: string, value: any) => {
+    if (typeof value === 'object' && value !== null) {
+      if (seen.has(value)) {
+        return;
+      }
+      seen.add(value);
+    }
+    return value;
+  };
+};
+
+const sendLogMessage = (prefix: string, ...args: any[]) => {
+  postMessage?.(createLogMessage(LOG.OUTPUT, serializeLog(prefix, ...args)));
+};
+
+export enum LoggerNames {
+  Core = 'Core',
+  Transport = 'Transport',
+  Device = 'Device',
+  DeviceCommands = 'DeviceCommands',
+  DeviceConnector = 'DeviceConnector',
+  DeviceList = 'DeviceList',
+  HdBleSdk = '@onekey/hd-ble-sdk',
+  HdTransportHttp = '@onekey/hd-transport-http',
+  HdBleTransport = '@onekey/hd-ble-transport',
+  Connect = '@onekey/connect',
+  Iframe = 'IFrame',
+  SendMessage = '[SendMessage]',
+  Method = '[Method]',
+}
+
+export const LoggerMap = {
+  [LoggerNames.Core]: initLog(LoggerNames.Core),
+  [LoggerNames.Transport]: initLog(LoggerNames.Transport),
+  [LoggerNames.Device]: initLog(LoggerNames.Device),
+  [LoggerNames.DeviceCommands]: initLog(LoggerNames.DeviceCommands),
+  [LoggerNames.DeviceConnector]: initLog(LoggerNames.DeviceConnector),
+  [LoggerNames.DeviceList]: initLog(LoggerNames.DeviceList),
+  [LoggerNames.HdBleSdk]: initLog(LoggerNames.HdBleSdk),
+  [LoggerNames.HdTransportHttp]: initLog(LoggerNames.HdTransportHttp),
+  [LoggerNames.HdBleTransport]: initLog(LoggerNames.HdBleTransport),
+  [LoggerNames.Connect]: initLog(LoggerNames.Connect),
+  [LoggerNames.Iframe]: initLog(LoggerNames.Iframe),
+  [LoggerNames.SendMessage]: initLog(LoggerNames.SendMessage),
+  [LoggerNames.Method]: initLog(LoggerNames.Method),
+};
+
+export const getLogger = (key: LoggerNames) => LoggerMap[key];