@onekeyfe/hd-transport 1.2.0-alpha.13 → 1.2.0-alpha.131

package/src/types/transport.ts

@@ -1,5 +1,15 @@
 import type EventEmitter from 'events';
 
+export const TRANSPORT_EVENT = {
+  DEVICE_DISCONNECT: 'transport-device-disconnect',
+} as const;
+
+export type TransportDeviceDisconnectEvent = {
+  id: string;
+  connectId: string;
+  name: string | null;
+};
+
 export type ProtocolType = 'V1' | 'V2';
 
 export type OneKeyDeviceCommType =
@@ -43,15 +53,27 @@ export type AcquireInput = {
   uuid?: string;
   forceCleanRunPromise?: boolean;
   expectedProtocol?: ProtocolType;
+  protocolHint?: ProtocolType;
 };
 
 export type MessageFromOneKey = { type: string; message: Record<string, any> };
 
+export type TransportWriteMetrics = {
+  elapsedMs: number;
+  frameBytes: number;
+};
+
 export type TransportCallOptions = {
   timeoutMs?: number;
   expectedTypes?: string[];
   intermediateTypes?: string[];
   onIntermediateResponse?: (response: MessageFromOneKey) => void;
+  /** Called after the complete request frame has been submitted to the transport. */
+  onWriteCompleted?: (metrics: TransportWriteMetrics) => void;
+  /** Resolve after the complete request frame is written without waiting for a response. */
+  returnAfterWrite?: boolean;
+  /** Prefer acknowledged BLE characteristic writes for this call when supported. */
+  writeWithResponse?: boolean;
 };
 
 type ITransportInitFn = (
@@ -64,7 +86,12 @@ export type Transport = {
   enumerate(): Promise<Array<OneKeyDeviceInfo>>;
   listen(old?: Array<OneKeyDeviceInfo>): Promise<Array<OneKeyDeviceInfo>>;
   acquire(input: AcquireInput): Promise<string>;
-  release(session: string, onclose: boolean): Promise<void>;
+  /**
+   * `keepSession` tells a transport that the caller intends to keep using this
+   * device across calls (firmware update, batched signing). Transports that
+   * hold the link open may use it to pick a longer idle window; the rest ignore it.
+   */
+  release(session: string, onclose: boolean, keepSession?: boolean): Promise<void>;
   configure(signedData: JSON | string): Promise<void>;
   configureProtocolV2?: (signedData: JSON | string) => Promise<void> | void;
   call(
@@ -92,7 +119,7 @@ export type Transport = {
 
   // resolves when the transport can be used; rejects when it cannot
   init: ITransportInitFn;
-  stop(): void;
+  stop(): void | Promise<void>;
 
   configured: boolean;
   version: string;
@@ -105,7 +132,7 @@ export type Transport = {
 export type LowLevelDevice = OneKeyDeviceInfoBase & { id: string; name: string };
 export type LowlevelTransportSharedPlugin = {
   enumerate: () => Promise<LowLevelDevice[]>;
-  send: (uuid: string, data: string) => Promise<void>;
+  send: (uuid: string, data: string, options?: { withoutResponse?: boolean }) => Promise<void>;
   receive: (uuid?: string) => Promise<string>;
   connect: (uuid: string) => Promise<void>;
   disconnect: (uuid: string) => Promise<void>;

package/src/utils/transportLog.ts

@@ -0,0 +1,102 @@
+import type { ProtocolType } from '../types';
+
+const REDACTED = '[REDACTED]';
+
+const SENSITIVE_LOG_KEYS = new Set([
+  'accesstoken',
+  'address',
+  'apikey',
+  'connectid',
+  'devicestate',
+  'deviceid',
+  'entropy',
+  'expectedpassphrasestate',
+  'mnemonic',
+  'passphrase',
+  'passphrasestate',
+  'password',
+  'pin',
+  'privatekey',
+  'publickey',
+  'seed',
+  'serialnumber',
+  'session',
+  'sessionid',
+  'signature',
+  'token',
+  'uuid',
+  'walletsessionid',
+  'xprv',
+  'xpub',
+]);
+
+const normalizeLogKey = (key: string) => key.replace(/[_-]/g, '').toLowerCase();
+
+const isSensitiveLogKey = (key: string) => {
+  const normalizedKey = normalizeLogKey(key);
+  return (
+    SENSITIVE_LOG_KEYS.has(normalizedKey) ||
+    normalizedKey.endsWith('address') ||
+    normalizedKey.endsWith('privatekey') ||
+    normalizedKey.endsWith('publickey') ||
+    normalizedKey.endsWith('signature')
+  );
+};
+
+const isSigningMessage = (messageName?: string) =>
+  Boolean(messageName && /(?:sign|txack|transaction)/i.test(messageName));
+
+const redactLogValue = (value: unknown, seen: WeakSet<object>): unknown => {
+  if (ArrayBuffer.isView(value)) {
+    return `[BINARY:${value.byteLength}]`;
+  }
+  if (value instanceof ArrayBuffer) {
+    return `[BINARY:${value.byteLength}]`;
+  }
+  if (Array.isArray(value)) {
+    return value.map(item => redactLogValue(item, seen));
+  }
+  if (!value || typeof value !== 'object') {
+    return value;
+  }
+  if (seen.has(value)) {
+    return '[CIRCULAR]';
+  }
+
+  seen.add(value);
+  const redacted = Object.fromEntries(
+    Object.entries(value as Record<string, unknown>).map(([key, item]) => [
+      key,
+      isSensitiveLogKey(key) && item !== null && item !== undefined
+        ? REDACTED
+        : redactLogValue(item, seen),
+    ])
+  );
+  seen.delete(value);
+  return redacted;
+};
+
+export function getSafeTransportLogPayload(value: unknown, messageName?: string): unknown {
+  if (isSigningMessage(messageName)) {
+    return REDACTED;
+  }
+  return redactLogValue(value, new WeakSet());
+}
+
+export function createTransportCallLog(
+  name: string,
+  protocol: ProtocolType,
+  data: Record<string, unknown>
+) {
+  return {
+    name,
+    protocol,
+    request: getSafeTransportLogPayload(data, name),
+  };
+}
+
+const HIGH_VOLUME_CALLS = new Set(['FileWrite', 'FilesystemFileWrite', 'EmmcFileWrite']);
+
+export function shouldSuppressHighVolumeCallLog(name: string) {
+  return HIGH_VOLUME_CALLS.has(name);
+}