@onekeyfe/hwk-keystone-connector-usb 1.2.2-alpha.100

package/dist/chunk-5JU4E5XQ.mjs

@@ -0,0 +1,211 @@
+// src/errors.ts
+import { HardwareErrorCode, createHwkError } from "@onekeyfe/hwk-adapter-core";
+import { Status } from "@keystonehq/hw-transport-error";
+var DEVICE_STATUS_MAP = {
+  [Status.PRS_PARSING_REJECTED]: HardwareErrorCode.UserRejected,
+  [Status.PRS_PARSING_DISALLOWED]: HardwareErrorCode.DeviceLocked,
+  [Status.PRS_PARSING_MISMATCHED_WALLET]: HardwareErrorCode.DeviceMismatch,
+  [Status.PRS_EXPORT_ADDRESS_REJECTED]: HardwareErrorCode.UserRejected,
+  [Status.PRS_EXPORT_ADDRESS_DISALLOWED]: HardwareErrorCode.DeviceLocked
+};
+var CLIENT_STATUS_MAP = {
+  [Status.ERR_DEVICE_NOT_OPENED]: HardwareErrorCode.DeviceNotFound,
+  [Status.ERR_DEVICE_NOT_FOUND]: HardwareErrorCode.DeviceNotFound,
+  [Status.ERR_TIMEOUT]: HardwareErrorCode.OperationTimeout,
+  [Status.ERR_DATA_TOO_LARGE]: HardwareErrorCode.PayloadTooLarge,
+  [Status.ERR_NOT_SUPPORTED]: HardwareErrorCode.TransportNotAvailable
+};
+function mapKeystoneUsbError(err) {
+  if (err && typeof err === "object" && typeof err.code === "number") {
+    return err;
+  }
+  const statusCode = err && typeof err === "object" && typeof err.transportErrorCode === "number" ? err.transportErrorCode : void 0;
+  const message = err instanceof Error ? err.message : String(err);
+  if (statusCode !== void 0) {
+    const code = DEVICE_STATUS_MAP[statusCode] ?? CLIENT_STATUS_MAP[statusCode] ?? HardwareErrorCode.TransportError;
+    return createHwkError({
+      code,
+      message,
+      params: { statusCode, details: err.details }
+    });
+  }
+  return createHwkError({ code: HardwareErrorCode.TransportError, message });
+}
+
+// src/KeystoneUsbConnectorBase.ts
+import { UR, URDecoder, UREncoder } from "@ngraveio/bc-ur";
+import { Actions } from "@keystonehq/hw-transport-usb";
+import {
+  EConnectorInteraction,
+  HardwareErrorCode as HardwareErrorCode2,
+  TypedEventEmitter,
+  createHwkError as createHwkError2,
+  serializeConnectorError,
+  success
+} from "@onekeyfe/hwk-adapter-core";
+var DEFAULT_TIMEOUT_MS = 1e5;
+function toUrEncoded(ur) {
+  return new UREncoder(new UR(Buffer.from(ur.urData, "hex"), ur.urType), Infinity).nextPart().toUpperCase();
+}
+function fromUrEncoded(encoded) {
+  const decoder = new URDecoder();
+  decoder.receivePart(encoded);
+  if (!decoder.isComplete() || !decoder.isSuccess()) {
+    throw new Error("Keystone USB response is not a complete, valid UR");
+  }
+  const ur = decoder.resultUR();
+  return { urType: ur.type, urData: ur.cbor.toString("hex") };
+}
+var KeystoneUsbConnectorBase = class {
+  constructor(transportClass, options) {
+    this.connectionType = "usb";
+    this.emitter = new TypedEventEmitter();
+    this.sessions = /* @__PURE__ */ new Map();
+    this.transportClass = transportClass;
+    this.timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  }
+  async searchDevices(_options) {
+    const devices = await this.transportClass.getKeystoneDevices();
+    return devices.map((device, index) => ({
+      connectId: `keystone-usb:${device.serialNumber ?? index}`,
+      deviceId: "",
+      name: device.productName ?? "Keystone",
+      connectionType: "usb",
+      capabilities: { persistentDeviceIdentity: true }
+    }));
+  }
+  async connect(deviceId) {
+    this.emitter.emit("ui-event", {
+      type: EConnectorInteraction.Searching,
+      payload: { sessionId: "" }
+    });
+    const transport = await this.transportClass.connect({ timeout: this.timeoutMs });
+    try {
+      const config = await this._readAppConfig(transport);
+      if (deviceId && config.mfp && config.mfp.toLowerCase() !== deviceId.toLowerCase()) {
+        throw createHwkError2({
+          code: HardwareErrorCode2.DeviceMismatch,
+          message: `Connected Keystone wallet (mfp ${config.mfp}) does not match the requested device (${deviceId})`
+        });
+      }
+      const sessionId = config.mfp || "keystone-usb";
+      this.sessions.set(sessionId, { transport, mfp: config.mfp });
+      const device = {
+        connectId: sessionId,
+        deviceId: config.mfp ?? "",
+        name: "Keystone",
+        connectionType: "usb",
+        capabilities: { persistentDeviceIdentity: true }
+      };
+      this.emitter.emit("device-connect", { device });
+      return { sessionId, deviceInfo: this._toDeviceInfo(device, config.version) };
+    } catch (err) {
+      throw mapKeystoneUsbError(err);
+    }
+  }
+  disconnect(sessionId) {
+    const session = this.sessions.get(sessionId);
+    this.sessions.delete(sessionId);
+    if (session) {
+      this.emitter.emit("device-disconnect", { connectId: sessionId });
+    }
+    return Promise.resolve();
+  }
+  async call(sessionId, method, params) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      return {
+        success: false,
+        error: serializeConnectorError(
+          createHwkError2({
+            code: HardwareErrorCode2.DeviceNotFound,
+            message: `Unknown Keystone USB session: ${sessionId}`
+          })
+        )
+      };
+    }
+    try {
+      switch (method) {
+        case "resolveUr": {
+          const { urType, urData } = params;
+          const encoded = toUrEncoded({ urType, urData });
+          const response = await session.transport.send(
+            Actions.CMD_RESOLVE_UR,
+            encoded
+          );
+          return success(fromUrEncoded(response.payload));
+        }
+        case "checkLockStatus": {
+          const response = await session.transport.send(
+            Actions.CMD_CHECK_LOCK_STATUS,
+            ""
+          );
+          return success({ locked: response.payload });
+        }
+        case "getAppConfig": {
+          const config = await this._readAppConfig(session.transport);
+          return success(config);
+        }
+        default:
+          return {
+            success: false,
+            error: serializeConnectorError(
+              createHwkError2({
+                code: HardwareErrorCode2.MethodNotSupported,
+                message: `Unknown Keystone USB connector method: ${method}`
+              })
+            )
+          };
+      }
+    } catch (err) {
+      return { success: false, error: serializeConnectorError(mapKeystoneUsbError(err)) };
+    }
+  }
+  // No protocol-level cancel exists over USB (verified: nothing in the SDK's
+  // public surface can interrupt an in-flight transferIn/transferOut) — the
+  // best this connector can do is stop waiting on its side; the underlying
+  // `send()` promise still settles (or times out) on its own.
+  cancel(_sessionId) {
+    return Promise.resolve();
+  }
+  // Keystone USB never relays PIN/passphrase through the host — entry always
+  // happens on the device's own touchscreen — so there is nothing to answer.
+  uiResponse(_response) {
+  }
+  on(event, handler) {
+    this.emitter.on(event, handler);
+  }
+  off(event, handler) {
+    this.emitter.off(event, handler);
+  }
+  reset() {
+    this.sessions.clear();
+  }
+  async _readAppConfig(transport) {
+    const response = await transport.send(
+      Actions.CMD_GET_DEVICE_VERSION,
+      ""
+    );
+    return {
+      version: typeof response.firmwareVersion === "string" ? response.firmwareVersion : void 0,
+      mfp: typeof response.walletMFP === "string" ? response.walletMFP.toLowerCase() : void 0
+    };
+  }
+  _toDeviceInfo(device, firmwareVersion) {
+    return {
+      vendor: "keystone",
+      model: "unknown",
+      firmwareVersion: firmwareVersion ?? "0.0.0",
+      deviceId: device.deviceId,
+      connectId: device.connectId,
+      connectionType: "usb",
+      capabilities: { persistentDeviceIdentity: true }
+    };
+  }
+};
+
+export {
+  mapKeystoneUsbError,
+  KeystoneUsbConnectorBase
+};
+//# sourceMappingURL=chunk-5JU4E5XQ.mjs.map

package/dist/chunk-5JU4E5XQ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/errors.ts","../src/KeystoneUsbConnectorBase.ts"],"sourcesContent":["import { HardwareErrorCode, createHwkError } from '@onekeyfe/hwk-adapter-core';\nimport { Status } from '@keystonehq/hw-transport-error';\n\nimport type { HwkError } from '@onekeyfe/hwk-adapter-core';\n\n/**\n * Device-side rejections (`Status` values reported inside a JSON response\n * payload's status word) — see EAPDU_Readme.md in the Keystone USB SDK repo.\n */\nconst DEVICE_STATUS_MAP: Partial<Record<number, HardwareErrorCode>> = {\n  [Status.PRS_PARSING_REJECTED]: HardwareErrorCode.UserRejected,\n  [Status.PRS_PARSING_DISALLOWED]: HardwareErrorCode.DeviceLocked,\n  [Status.PRS_PARSING_MISMATCHED_WALLET]: HardwareErrorCode.DeviceMismatch,\n  [Status.PRS_EXPORT_ADDRESS_REJECTED]: HardwareErrorCode.UserRejected,\n  [Status.PRS_EXPORT_ADDRESS_DISALLOWED]: HardwareErrorCode.DeviceLocked,\n};\n\n/** Client-side (transport/framing) failures — never reached the device. */\nconst CLIENT_STATUS_MAP: Partial<Record<number, HardwareErrorCode>> = {\n  [Status.ERR_DEVICE_NOT_OPENED]: HardwareErrorCode.DeviceNotFound,\n  [Status.ERR_DEVICE_NOT_FOUND]: HardwareErrorCode.DeviceNotFound,\n  [Status.ERR_TIMEOUT]: HardwareErrorCode.OperationTimeout,\n  [Status.ERR_DATA_TOO_LARGE]: HardwareErrorCode.PayloadTooLarge,\n  [Status.ERR_NOT_SUPPORTED]: HardwareErrorCode.TransportNotAvailable,\n};\n\n/**\n * Maps a Keystone USB SDK failure to the shared `HardwareErrorCode`\n * vocabulary. Every device-side rejection and client-side transport failure\n * the SDK produces is a *thrown* `TransportError` with a numeric\n * `transportErrorCode` (see `@keystonehq/hw-transport-error`) — this is\n * called from every `catch` in `KeystoneUsbConnectorBase` to build the\n * `ConnectorCallResult` data-not-exception shape `IConnector.call` requires.\n *\n * Idempotent: an error `KeystoneUsbConnectorBase` already built via\n * `createHwkError` (e.g. its own `DeviceMismatch`/`DeviceNotFound` checks)\n * carries a numeric `.code` already and passes straight through unchanged —\n * without this it would fall through to the generic `TransportError`\n * fallback below and silently lose the real code, since `HwkError` uses\n * `.code`, not the raw SDK's `.transportErrorCode`.\n *\n * Reads `transportErrorCode` duck-typed rather than `instanceof\n * TransportError` — cheap defense against the exact-same class of\n * cross-package duplicate-module-instance bug already hit once in this\n * integration (see docs/design/keystone-integration), where two copies of a\n * `@keystonehq/*` package resolve to different physical files and\n * `instanceof` silently fails across them.\n */\nexport function mapKeystoneUsbError(err: unknown): HwkError {\n  if (err && typeof err === 'object' && typeof (err as { code?: unknown }).code === 'number') {\n    return err as HwkError;\n  }\n\n  const statusCode =\n    err &&\n    typeof err === 'object' &&\n    typeof (err as { transportErrorCode?: unknown }).transportErrorCode === 'number'\n      ? (err as { transportErrorCode: number }).transportErrorCode\n      : undefined;\n\n  const message = err instanceof Error ? err.message : String(err);\n\n  if (statusCode !== undefined) {\n    const code =\n      DEVICE_STATUS_MAP[statusCode] ??\n      CLIENT_STATUS_MAP[statusCode] ??\n      HardwareErrorCode.TransportError;\n    return createHwkError({\n      code,\n      message,\n      params: { statusCode, details: (err as { details?: string }).details },\n    });\n  }\n\n  return createHwkError({ code: HardwareErrorCode.TransportError, message });\n}\n","import { UR, URDecoder, UREncoder } from '@ngraveio/bc-ur';\nimport { Actions } from '@keystonehq/hw-transport-usb';\nimport {\n  EConnectorInteraction,\n  HardwareErrorCode,\n  TypedEventEmitter,\n  createHwkError,\n  serializeConnectorError,\n  success,\n} from '@onekeyfe/hwk-adapter-core';\n\nimport { mapKeystoneUsbError } from './errors';\n\nimport type {\n  ConnectorCallResult,\n  ConnectorDevice,\n  ConnectorEventMap,\n  ConnectorEventType,\n  ConnectorSearchDevicesOptions,\n  ConnectorSession,\n  IConnector,\n  UiResponseEvent,\n} from '@onekeyfe/hwk-adapter-core';\nimport type { TransportConfig, TransportHID } from '@keystonehq/hw-transport-usb';\n\n/**\n * The static surface both `TransportWebUSB` and `TransportNodeUSB` expose\n * (verified against their real `.d.ts`/`.js` — both implement `TransportHID`\n * identically, differing only in how they enumerate/open the underlying\n * device). Parametrizing on this instead of importing either transport\n * package directly is what lets `KeystoneUsbConnectorBase` stay\n * platform-agnostic; `_subpath/webusb.ts` and `_subpath/nodeusb.ts` are the\n * only files that actually import a concrete transport.\n */\nexport interface KeystoneUsbTransportStatic {\n  connect(config?: TransportConfig): Promise<TransportHID>;\n  getKeystoneDevices(): Promise<ReadonlyArray<{ serialNumber?: string; productName?: string }>>;\n  requestPermission?(): Promise<void>;\n  isSupported(): Promise<boolean>;\n}\n\ninterface KeystoneUr {\n  urType: string;\n  urData: string;\n}\n\ninterface UsbSession {\n  transport: TransportHID;\n  mfp?: string;\n}\n\nconst DEFAULT_TIMEOUT_MS = 100_000; // SDK's own raw default is 15s (\"may need users' action on the device\") — too short for real confirmation.\n\nfunction toUrEncoded(ur: KeystoneUr): string {\n  return new UREncoder(new UR(Buffer.from(ur.urData, 'hex'), ur.urType), Infinity)\n    .nextPart()\n    .toUpperCase();\n}\n\nfunction fromUrEncoded(encoded: string): KeystoneUr {\n  const decoder = new URDecoder();\n  decoder.receivePart(encoded);\n  if (!decoder.isComplete() || !decoder.isSuccess()) {\n    throw new Error('Keystone USB response is not a complete, valid UR');\n  }\n  const ur = decoder.resultUR();\n  return { urType: ur.type, urData: ur.cbor.toString('hex') };\n}\n\n/**\n * `IConnector` implementation for Keystone over USB. Every `TransportHID`\n * call the underlying SDK exposes is its own self-contained\n * open→claim→transfer→release→close cycle (verified in `TransportWebUSB`/\n * `TransportNodeUSB` source — there is no persistent USB claim to hold\n * across calls), so `connect()` just resolves one `TransportHID` instance\n * and caches it; each `call()` reuses that same JS object, and the\n * underlying SDK's own per-command open/close still happens on every send.\n *\n * USB carries the exact same UR payloads the QR channel does — `call()`'s\n * `'resolveUr'` method is a generic `{urType, urData}` (hex CBOR, matching\n * `hwk-keystone-adapter`'s `KeystoneUr` shape) in, `{urType, urData}` out.\n * The caller (a future dual-channel `KeystoneAdapter`) can build the UR once\n * via the same `KeystoneUrEngine` used for QR and send it down either\n * channel — this connector has no chain-specific knowledge at all.\n */\nexport class KeystoneUsbConnectorBase implements IConnector {\n  readonly connectionType = 'usb' as const;\n\n  private readonly transportClass: KeystoneUsbTransportStatic;\n\n  private readonly timeoutMs: number;\n\n  private readonly emitter = new TypedEventEmitter<ConnectorEventMap>();\n\n  private readonly sessions = new Map<string, UsbSession>();\n\n  constructor(transportClass: KeystoneUsbTransportStatic, options?: { timeoutMs?: number }) {\n    this.transportClass = transportClass;\n    this.timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;\n  }\n\n  async searchDevices(_options?: ConnectorSearchDevicesOptions): Promise<ConnectorDevice[]> {\n    const devices = await this.transportClass.getKeystoneDevices();\n    // No mfp available without opening+claiming the device (a real I/O cost\n    // just to enumerate) — connectId is a placeholder until connect()\n    // resolves the real identity. There is also no reliable way to target\n    // one of several already-connected Keystones by id: the underlying SDK's\n    // own connect() re-scans and picks for itself (WebUSB re-prompts the\n    // picker when more than one device already has permission; Node USB just\n    // takes the first match) — a real limitation of the vendor SDK, not\n    // something this connector can route around.\n    return devices.map((device, index) => ({\n      connectId: `keystone-usb:${device.serialNumber ?? index}`,\n      deviceId: '',\n      name: device.productName ?? 'Keystone',\n      connectionType: 'usb',\n      capabilities: { persistentDeviceIdentity: true },\n    }));\n  }\n\n  async connect(deviceId?: string): Promise<ConnectorSession> {\n    this.emitter.emit('ui-event', {\n      type: EConnectorInteraction.Searching,\n      payload: { sessionId: '' },\n    });\n    const transport = await this.transportClass.connect({ timeout: this.timeoutMs });\n    try {\n      const config = await this._readAppConfig(transport);\n      if (deviceId && config.mfp && config.mfp.toLowerCase() !== deviceId.toLowerCase()) {\n        throw createHwkError({\n          code: HardwareErrorCode.DeviceMismatch,\n          message: `Connected Keystone wallet (mfp ${config.mfp}) does not match the requested device (${deviceId})`,\n        });\n      }\n      const sessionId = config.mfp || 'keystone-usb';\n      this.sessions.set(sessionId, { transport, mfp: config.mfp });\n      const device: ConnectorDevice = {\n        connectId: sessionId,\n        deviceId: config.mfp ?? '',\n        name: 'Keystone',\n        connectionType: 'usb',\n        capabilities: { persistentDeviceIdentity: true },\n      };\n      this.emitter.emit('device-connect', { device });\n      return { sessionId, deviceInfo: this._toDeviceInfo(device, config.version) };\n    } catch (err) {\n      throw mapKeystoneUsbError(err);\n    }\n  }\n\n  disconnect(sessionId: string): Promise<void> {\n    const session = this.sessions.get(sessionId);\n    this.sessions.delete(sessionId);\n    if (session) {\n      // No persistent claim to release (see class doc) — nothing to await\n      // here beyond letting the underlying transport's own per-call close\n      // run its course, which already happened on the last send().\n      this.emitter.emit('device-disconnect', { connectId: sessionId });\n    }\n    return Promise.resolve();\n  }\n\n  async call(sessionId: string, method: string, params: unknown): Promise<ConnectorCallResult> {\n    const session = this.sessions.get(sessionId);\n    if (!session) {\n      return {\n        success: false,\n        error: serializeConnectorError(\n          createHwkError({\n            code: HardwareErrorCode.DeviceNotFound,\n            message: `Unknown Keystone USB session: ${sessionId}`,\n          })\n        ),\n      };\n    }\n\n    try {\n      switch (method) {\n        case 'resolveUr': {\n          const { urType, urData } = params as KeystoneUr;\n          const encoded = toUrEncoded({ urType, urData });\n          const response = await session.transport.send<{ payload: string }>(\n            Actions.CMD_RESOLVE_UR,\n            encoded\n          );\n          return success(fromUrEncoded(response.payload));\n        }\n        case 'checkLockStatus': {\n          const response = await session.transport.send<{ payload: boolean }>(\n            Actions.CMD_CHECK_LOCK_STATUS,\n            ''\n          );\n          // Naming-only assumption (no positive-case fixture to confirm\n          // against) — `checkDeviceLockStatus`'s own name is the only\n          // evidence `true` means locked; verify against real hardware.\n          return success({ locked: response.payload });\n        }\n        case 'getAppConfig': {\n          const config = await this._readAppConfig(session.transport);\n          return success(config);\n        }\n        default:\n          return {\n            success: false,\n            error: serializeConnectorError(\n              createHwkError({\n                code: HardwareErrorCode.MethodNotSupported,\n                message: `Unknown Keystone USB connector method: ${method}`,\n              })\n            ),\n          };\n      }\n    } catch (err) {\n      return { success: false, error: serializeConnectorError(mapKeystoneUsbError(err)) };\n    }\n  }\n\n  // No protocol-level cancel exists over USB (verified: nothing in the SDK's\n  // public surface can interrupt an in-flight transferIn/transferOut) — the\n  // best this connector can do is stop waiting on its side; the underlying\n  // `send()` promise still settles (or times out) on its own.\n  cancel(_sessionId: string): Promise<void> {\n    return Promise.resolve();\n  }\n\n  // Keystone USB never relays PIN/passphrase through the host — entry always\n  // happens on the device's own touchscreen — so there is nothing to answer.\n  uiResponse(_response: UiResponseEvent): void {}\n\n  on<K extends ConnectorEventType>(event: K, handler: (data: ConnectorEventMap[K]) => void): void {\n    this.emitter.on(event, handler);\n  }\n\n  off<K extends ConnectorEventType>(event: K, handler: (data: ConnectorEventMap[K]) => void): void {\n    this.emitter.off(event, handler);\n  }\n\n  reset(): void {\n    this.sessions.clear();\n  }\n\n  private async _readAppConfig(\n    transport: TransportHID\n  ): Promise<{ version?: string; mfp?: string }> {\n    const response = await transport.send<Record<string, unknown>>(\n      Actions.CMD_GET_DEVICE_VERSION,\n      ''\n    );\n    return {\n      version: typeof response.firmwareVersion === 'string' ? response.firmwareVersion : undefined,\n      mfp: typeof response.walletMFP === 'string' ? response.walletMFP.toLowerCase() : undefined,\n    };\n  }\n\n  private _toDeviceInfo(device: ConnectorDevice, firmwareVersion?: string) {\n    return {\n      vendor: 'keystone' as const,\n      model: 'unknown',\n      firmwareVersion: firmwareVersion ?? '0.0.0',\n      deviceId: device.deviceId,\n      connectId: device.connectId,\n      connectionType: 'usb' as const,\n      capabilities: { persistentDeviceIdentity: true },\n    };\n  }\n}\n"],"mappings":"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","names":["HardwareErrorCode","createHwkError","createHwkError","HardwareErrorCode"]}

package/dist/chunk-LA3RVME7.js

@@ -0,0 +1,211 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/errors.ts
+var _hwkadaptercore = require('@onekeyfe/hwk-adapter-core');
+var _hwtransporterror = require('@keystonehq/hw-transport-error');
+var DEVICE_STATUS_MAP = {
+  [_hwtransporterror.Status.PRS_PARSING_REJECTED]: _hwkadaptercore.HardwareErrorCode.UserRejected,
+  [_hwtransporterror.Status.PRS_PARSING_DISALLOWED]: _hwkadaptercore.HardwareErrorCode.DeviceLocked,
+  [_hwtransporterror.Status.PRS_PARSING_MISMATCHED_WALLET]: _hwkadaptercore.HardwareErrorCode.DeviceMismatch,
+  [_hwtransporterror.Status.PRS_EXPORT_ADDRESS_REJECTED]: _hwkadaptercore.HardwareErrorCode.UserRejected,
+  [_hwtransporterror.Status.PRS_EXPORT_ADDRESS_DISALLOWED]: _hwkadaptercore.HardwareErrorCode.DeviceLocked
+};
+var CLIENT_STATUS_MAP = {
+  [_hwtransporterror.Status.ERR_DEVICE_NOT_OPENED]: _hwkadaptercore.HardwareErrorCode.DeviceNotFound,
+  [_hwtransporterror.Status.ERR_DEVICE_NOT_FOUND]: _hwkadaptercore.HardwareErrorCode.DeviceNotFound,
+  [_hwtransporterror.Status.ERR_TIMEOUT]: _hwkadaptercore.HardwareErrorCode.OperationTimeout,
+  [_hwtransporterror.Status.ERR_DATA_TOO_LARGE]: _hwkadaptercore.HardwareErrorCode.PayloadTooLarge,
+  [_hwtransporterror.Status.ERR_NOT_SUPPORTED]: _hwkadaptercore.HardwareErrorCode.TransportNotAvailable
+};
+function mapKeystoneUsbError(err) {
+  if (err && typeof err === "object" && typeof err.code === "number") {
+    return err;
+  }
+  const statusCode = err && typeof err === "object" && typeof err.transportErrorCode === "number" ? err.transportErrorCode : void 0;
+  const message = err instanceof Error ? err.message : String(err);
+  if (statusCode !== void 0) {
+    const code = _nullishCoalesce(_nullishCoalesce(DEVICE_STATUS_MAP[statusCode], () => ( CLIENT_STATUS_MAP[statusCode])), () => ( _hwkadaptercore.HardwareErrorCode.TransportError));
+    return _hwkadaptercore.createHwkError.call(void 0, {
+      code,
+      message,
+      params: { statusCode, details: err.details }
+    });
+  }
+  return _hwkadaptercore.createHwkError.call(void 0, { code: _hwkadaptercore.HardwareErrorCode.TransportError, message });
+}
+
+// src/KeystoneUsbConnectorBase.ts
+var _bcur = require('@ngraveio/bc-ur');
+var _hwtransportusb = require('@keystonehq/hw-transport-usb');
+
+
+
+
+
+
+
+
+var DEFAULT_TIMEOUT_MS = 1e5;
+function toUrEncoded(ur) {
+  return new (0, _bcur.UREncoder)(new (0, _bcur.UR)(Buffer.from(ur.urData, "hex"), ur.urType), Infinity).nextPart().toUpperCase();
+}
+function fromUrEncoded(encoded) {
+  const decoder = new (0, _bcur.URDecoder)();
+  decoder.receivePart(encoded);
+  if (!decoder.isComplete() || !decoder.isSuccess()) {
+    throw new Error("Keystone USB response is not a complete, valid UR");
+  }
+  const ur = decoder.resultUR();
+  return { urType: ur.type, urData: ur.cbor.toString("hex") };
+}
+var KeystoneUsbConnectorBase = class {
+  constructor(transportClass, options) {
+    this.connectionType = "usb";
+    this.emitter = new (0, _hwkadaptercore.TypedEventEmitter)();
+    this.sessions = /* @__PURE__ */ new Map();
+    this.transportClass = transportClass;
+    this.timeoutMs = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _ => _.timeoutMs]), () => ( DEFAULT_TIMEOUT_MS));
+  }
+  async searchDevices(_options) {
+    const devices = await this.transportClass.getKeystoneDevices();
+    return devices.map((device, index) => ({
+      connectId: `keystone-usb:${_nullishCoalesce(device.serialNumber, () => ( index))}`,
+      deviceId: "",
+      name: _nullishCoalesce(device.productName, () => ( "Keystone")),
+      connectionType: "usb",
+      capabilities: { persistentDeviceIdentity: true }
+    }));
+  }
+  async connect(deviceId) {
+    this.emitter.emit("ui-event", {
+      type: _hwkadaptercore.EConnectorInteraction.Searching,
+      payload: { sessionId: "" }
+    });
+    const transport = await this.transportClass.connect({ timeout: this.timeoutMs });
+    try {
+      const config = await this._readAppConfig(transport);
+      if (deviceId && config.mfp && config.mfp.toLowerCase() !== deviceId.toLowerCase()) {
+        throw _hwkadaptercore.createHwkError.call(void 0, {
+          code: _hwkadaptercore.HardwareErrorCode.DeviceMismatch,
+          message: `Connected Keystone wallet (mfp ${config.mfp}) does not match the requested device (${deviceId})`
+        });
+      }
+      const sessionId = config.mfp || "keystone-usb";
+      this.sessions.set(sessionId, { transport, mfp: config.mfp });
+      const device = {
+        connectId: sessionId,
+        deviceId: _nullishCoalesce(config.mfp, () => ( "")),
+        name: "Keystone",
+        connectionType: "usb",
+        capabilities: { persistentDeviceIdentity: true }
+      };
+      this.emitter.emit("device-connect", { device });
+      return { sessionId, deviceInfo: this._toDeviceInfo(device, config.version) };
+    } catch (err) {
+      throw mapKeystoneUsbError(err);
+    }
+  }
+  disconnect(sessionId) {
+    const session = this.sessions.get(sessionId);
+    this.sessions.delete(sessionId);
+    if (session) {
+      this.emitter.emit("device-disconnect", { connectId: sessionId });
+    }
+    return Promise.resolve();
+  }
+  async call(sessionId, method, params) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      return {
+        success: false,
+        error: _hwkadaptercore.serializeConnectorError.call(void 0, 
+          _hwkadaptercore.createHwkError.call(void 0, {
+            code: _hwkadaptercore.HardwareErrorCode.DeviceNotFound,
+            message: `Unknown Keystone USB session: ${sessionId}`
+          })
+        )
+      };
+    }
+    try {
+      switch (method) {
+        case "resolveUr": {
+          const { urType, urData } = params;
+          const encoded = toUrEncoded({ urType, urData });
+          const response = await session.transport.send(
+            _hwtransportusb.Actions.CMD_RESOLVE_UR,
+            encoded
+          );
+          return _hwkadaptercore.success.call(void 0, fromUrEncoded(response.payload));
+        }
+        case "checkLockStatus": {
+          const response = await session.transport.send(
+            _hwtransportusb.Actions.CMD_CHECK_LOCK_STATUS,
+            ""
+          );
+          return _hwkadaptercore.success.call(void 0, { locked: response.payload });
+        }
+        case "getAppConfig": {
+          const config = await this._readAppConfig(session.transport);
+          return _hwkadaptercore.success.call(void 0, config);
+        }
+        default:
+          return {
+            success: false,
+            error: _hwkadaptercore.serializeConnectorError.call(void 0, 
+              _hwkadaptercore.createHwkError.call(void 0, {
+                code: _hwkadaptercore.HardwareErrorCode.MethodNotSupported,
+                message: `Unknown Keystone USB connector method: ${method}`
+              })
+            )
+          };
+      }
+    } catch (err) {
+      return { success: false, error: _hwkadaptercore.serializeConnectorError.call(void 0, mapKeystoneUsbError(err)) };
+    }
+  }
+  // No protocol-level cancel exists over USB (verified: nothing in the SDK's
+  // public surface can interrupt an in-flight transferIn/transferOut) — the
+  // best this connector can do is stop waiting on its side; the underlying
+  // `send()` promise still settles (or times out) on its own.
+  cancel(_sessionId) {
+    return Promise.resolve();
+  }
+  // Keystone USB never relays PIN/passphrase through the host — entry always
+  // happens on the device's own touchscreen — so there is nothing to answer.
+  uiResponse(_response) {
+  }
+  on(event, handler) {
+    this.emitter.on(event, handler);
+  }
+  off(event, handler) {
+    this.emitter.off(event, handler);
+  }
+  reset() {
+    this.sessions.clear();
+  }
+  async _readAppConfig(transport) {
+    const response = await transport.send(
+      _hwtransportusb.Actions.CMD_GET_DEVICE_VERSION,
+      ""
+    );
+    return {
+      version: typeof response.firmwareVersion === "string" ? response.firmwareVersion : void 0,
+      mfp: typeof response.walletMFP === "string" ? response.walletMFP.toLowerCase() : void 0
+    };
+  }
+  _toDeviceInfo(device, firmwareVersion) {
+    return {
+      vendor: "keystone",
+      model: "unknown",
+      firmwareVersion: _nullishCoalesce(firmwareVersion, () => ( "0.0.0")),
+      deviceId: device.deviceId,
+      connectId: device.connectId,
+      connectionType: "usb",
+      capabilities: { persistentDeviceIdentity: true }
+    };
+  }
+};
+
+
+
+
+exports.mapKeystoneUsbError = mapKeystoneUsbError; exports.KeystoneUsbConnectorBase = KeystoneUsbConnectorBase;
+//# sourceMappingURL=chunk-LA3RVME7.js.map

package/dist/chunk-LA3RVME7.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/hardware-js-sdk/hardware-js-sdk/packages/hwk-keystone-connector-usb/dist/chunk-LA3RVME7.js","../src/errors.ts","../src/KeystoneUsbConnectorBase.ts"],"names":[],"mappings":"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","file":"/home/runner/work/hardware-js-sdk/hardware-js-sdk/packages/hwk-keystone-connector-usb/dist/chunk-LA3RVME7.js","sourcesContent":[null,"import { HardwareErrorCode, createHwkError } from '@onekeyfe/hwk-adapter-core';\nimport { Status } from '@keystonehq/hw-transport-error';\n\nimport type { HwkError } from '@onekeyfe/hwk-adapter-core';\n\n/**\n * Device-side rejections (`Status` values reported inside a JSON response\n * payload's status word) — see EAPDU_Readme.md in the Keystone USB SDK repo.\n */\nconst DEVICE_STATUS_MAP: Partial<Record<number, HardwareErrorCode>> = {\n  [Status.PRS_PARSING_REJECTED]: HardwareErrorCode.UserRejected,\n  [Status.PRS_PARSING_DISALLOWED]: HardwareErrorCode.DeviceLocked,\n  [Status.PRS_PARSING_MISMATCHED_WALLET]: HardwareErrorCode.DeviceMismatch,\n  [Status.PRS_EXPORT_ADDRESS_REJECTED]: HardwareErrorCode.UserRejected,\n  [Status.PRS_EXPORT_ADDRESS_DISALLOWED]: HardwareErrorCode.DeviceLocked,\n};\n\n/** Client-side (transport/framing) failures — never reached the device. */\nconst CLIENT_STATUS_MAP: Partial<Record<number, HardwareErrorCode>> = {\n  [Status.ERR_DEVICE_NOT_OPENED]: HardwareErrorCode.DeviceNotFound,\n  [Status.ERR_DEVICE_NOT_FOUND]: HardwareErrorCode.DeviceNotFound,\n  [Status.ERR_TIMEOUT]: HardwareErrorCode.OperationTimeout,\n  [Status.ERR_DATA_TOO_LARGE]: HardwareErrorCode.PayloadTooLarge,\n  [Status.ERR_NOT_SUPPORTED]: HardwareErrorCode.TransportNotAvailable,\n};\n\n/**\n * Maps a Keystone USB SDK failure to the shared `HardwareErrorCode`\n * vocabulary. Every device-side rejection and client-side transport failure\n * the SDK produces is a *thrown* `TransportError` with a numeric\n * `transportErrorCode` (see `@keystonehq/hw-transport-error`) — this is\n * called from every `catch` in `KeystoneUsbConnectorBase` to build the\n * `ConnectorCallResult` data-not-exception shape `IConnector.call` requires.\n *\n * Idempotent: an error `KeystoneUsbConnectorBase` already built via\n * `createHwkError` (e.g. its own `DeviceMismatch`/`DeviceNotFound` checks)\n * carries a numeric `.code` already and passes straight through unchanged —\n * without this it would fall through to the generic `TransportError`\n * fallback below and silently lose the real code, since `HwkError` uses\n * `.code`, not the raw SDK's `.transportErrorCode`.\n *\n * Reads `transportErrorCode` duck-typed rather than `instanceof\n * TransportError` — cheap defense against the exact-same class of\n * cross-package duplicate-module-instance bug already hit once in this\n * integration (see docs/design/keystone-integration), where two copies of a\n * `@keystonehq/*` package resolve to different physical files and\n * `instanceof` silently fails across them.\n */\nexport function mapKeystoneUsbError(err: unknown): HwkError {\n  if (err && typeof err === 'object' && typeof (err as { code?: unknown }).code === 'number') {\n    return err as HwkError;\n  }\n\n  const statusCode =\n    err &&\n    typeof err === 'object' &&\n    typeof (err as { transportErrorCode?: unknown }).transportErrorCode === 'number'\n      ? (err as { transportErrorCode: number }).transportErrorCode\n      : undefined;\n\n  const message = err instanceof Error ? err.message : String(err);\n\n  if (statusCode !== undefined) {\n    const code =\n      DEVICE_STATUS_MAP[statusCode] ??\n      CLIENT_STATUS_MAP[statusCode] ??\n      HardwareErrorCode.TransportError;\n    return createHwkError({\n      code,\n      message,\n      params: { statusCode, details: (err as { details?: string }).details },\n    });\n  }\n\n  return createHwkError({ code: HardwareErrorCode.TransportError, message });\n}\n","import { UR, URDecoder, UREncoder } from '@ngraveio/bc-ur';\nimport { Actions } from '@keystonehq/hw-transport-usb';\nimport {\n  EConnectorInteraction,\n  HardwareErrorCode,\n  TypedEventEmitter,\n  createHwkError,\n  serializeConnectorError,\n  success,\n} from '@onekeyfe/hwk-adapter-core';\n\nimport { mapKeystoneUsbError } from './errors';\n\nimport type {\n  ConnectorCallResult,\n  ConnectorDevice,\n  ConnectorEventMap,\n  ConnectorEventType,\n  ConnectorSearchDevicesOptions,\n  ConnectorSession,\n  IConnector,\n  UiResponseEvent,\n} from '@onekeyfe/hwk-adapter-core';\nimport type { TransportConfig, TransportHID } from '@keystonehq/hw-transport-usb';\n\n/**\n * The static surface both `TransportWebUSB` and `TransportNodeUSB` expose\n * (verified against their real `.d.ts`/`.js` — both implement `TransportHID`\n * identically, differing only in how they enumerate/open the underlying\n * device). Parametrizing on this instead of importing either transport\n * package directly is what lets `KeystoneUsbConnectorBase` stay\n * platform-agnostic; `_subpath/webusb.ts` and `_subpath/nodeusb.ts` are the\n * only files that actually import a concrete transport.\n */\nexport interface KeystoneUsbTransportStatic {\n  connect(config?: TransportConfig): Promise<TransportHID>;\n  getKeystoneDevices(): Promise<ReadonlyArray<{ serialNumber?: string; productName?: string }>>;\n  requestPermission?(): Promise<void>;\n  isSupported(): Promise<boolean>;\n}\n\ninterface KeystoneUr {\n  urType: string;\n  urData: string;\n}\n\ninterface UsbSession {\n  transport: TransportHID;\n  mfp?: string;\n}\n\nconst DEFAULT_TIMEOUT_MS = 100_000; // SDK's own raw default is 15s (\"may need users' action on the device\") — too short for real confirmation.\n\nfunction toUrEncoded(ur: KeystoneUr): string {\n  return new UREncoder(new UR(Buffer.from(ur.urData, 'hex'), ur.urType), Infinity)\n    .nextPart()\n    .toUpperCase();\n}\n\nfunction fromUrEncoded(encoded: string): KeystoneUr {\n  const decoder = new URDecoder();\n  decoder.receivePart(encoded);\n  if (!decoder.isComplete() || !decoder.isSuccess()) {\n    throw new Error('Keystone USB response is not a complete, valid UR');\n  }\n  const ur = decoder.resultUR();\n  return { urType: ur.type, urData: ur.cbor.toString('hex') };\n}\n\n/**\n * `IConnector` implementation for Keystone over USB. Every `TransportHID`\n * call the underlying SDK exposes is its own self-contained\n * open→claim→transfer→release→close cycle (verified in `TransportWebUSB`/\n * `TransportNodeUSB` source — there is no persistent USB claim to hold\n * across calls), so `connect()` just resolves one `TransportHID` instance\n * and caches it; each `call()` reuses that same JS object, and the\n * underlying SDK's own per-command open/close still happens on every send.\n *\n * USB carries the exact same UR payloads the QR channel does — `call()`'s\n * `'resolveUr'` method is a generic `{urType, urData}` (hex CBOR, matching\n * `hwk-keystone-adapter`'s `KeystoneUr` shape) in, `{urType, urData}` out.\n * The caller (a future dual-channel `KeystoneAdapter`) can build the UR once\n * via the same `KeystoneUrEngine` used for QR and send it down either\n * channel — this connector has no chain-specific knowledge at all.\n */\nexport class KeystoneUsbConnectorBase implements IConnector {\n  readonly connectionType = 'usb' as const;\n\n  private readonly transportClass: KeystoneUsbTransportStatic;\n\n  private readonly timeoutMs: number;\n\n  private readonly emitter = new TypedEventEmitter<ConnectorEventMap>();\n\n  private readonly sessions = new Map<string, UsbSession>();\n\n  constructor(transportClass: KeystoneUsbTransportStatic, options?: { timeoutMs?: number }) {\n    this.transportClass = transportClass;\n    this.timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;\n  }\n\n  async searchDevices(_options?: ConnectorSearchDevicesOptions): Promise<ConnectorDevice[]> {\n    const devices = await this.transportClass.getKeystoneDevices();\n    // No mfp available without opening+claiming the device (a real I/O cost\n    // just to enumerate) — connectId is a placeholder until connect()\n    // resolves the real identity. There is also no reliable way to target\n    // one of several already-connected Keystones by id: the underlying SDK's\n    // own connect() re-scans and picks for itself (WebUSB re-prompts the\n    // picker when more than one device already has permission; Node USB just\n    // takes the first match) — a real limitation of the vendor SDK, not\n    // something this connector can route around.\n    return devices.map((device, index) => ({\n      connectId: `keystone-usb:${device.serialNumber ?? index}`,\n      deviceId: '',\n      name: device.productName ?? 'Keystone',\n      connectionType: 'usb',\n      capabilities: { persistentDeviceIdentity: true },\n    }));\n  }\n\n  async connect(deviceId?: string): Promise<ConnectorSession> {\n    this.emitter.emit('ui-event', {\n      type: EConnectorInteraction.Searching,\n      payload: { sessionId: '' },\n    });\n    const transport = await this.transportClass.connect({ timeout: this.timeoutMs });\n    try {\n      const config = await this._readAppConfig(transport);\n      if (deviceId && config.mfp && config.mfp.toLowerCase() !== deviceId.toLowerCase()) {\n        throw createHwkError({\n          code: HardwareErrorCode.DeviceMismatch,\n          message: `Connected Keystone wallet (mfp ${config.mfp}) does not match the requested device (${deviceId})`,\n        });\n      }\n      const sessionId = config.mfp || 'keystone-usb';\n      this.sessions.set(sessionId, { transport, mfp: config.mfp });\n      const device: ConnectorDevice = {\n        connectId: sessionId,\n        deviceId: config.mfp ?? '',\n        name: 'Keystone',\n        connectionType: 'usb',\n        capabilities: { persistentDeviceIdentity: true },\n      };\n      this.emitter.emit('device-connect', { device });\n      return { sessionId, deviceInfo: this._toDeviceInfo(device, config.version) };\n    } catch (err) {\n      throw mapKeystoneUsbError(err);\n    }\n  }\n\n  disconnect(sessionId: string): Promise<void> {\n    const session = this.sessions.get(sessionId);\n    this.sessions.delete(sessionId);\n    if (session) {\n      // No persistent claim to release (see class doc) — nothing to await\n      // here beyond letting the underlying transport's own per-call close\n      // run its course, which already happened on the last send().\n      this.emitter.emit('device-disconnect', { connectId: sessionId });\n    }\n    return Promise.resolve();\n  }\n\n  async call(sessionId: string, method: string, params: unknown): Promise<ConnectorCallResult> {\n    const session = this.sessions.get(sessionId);\n    if (!session) {\n      return {\n        success: false,\n        error: serializeConnectorError(\n          createHwkError({\n            code: HardwareErrorCode.DeviceNotFound,\n            message: `Unknown Keystone USB session: ${sessionId}`,\n          })\n        ),\n      };\n    }\n\n    try {\n      switch (method) {\n        case 'resolveUr': {\n          const { urType, urData } = params as KeystoneUr;\n          const encoded = toUrEncoded({ urType, urData });\n          const response = await session.transport.send<{ payload: string }>(\n            Actions.CMD_RESOLVE_UR,\n            encoded\n          );\n          return success(fromUrEncoded(response.payload));\n        }\n        case 'checkLockStatus': {\n          const response = await session.transport.send<{ payload: boolean }>(\n            Actions.CMD_CHECK_LOCK_STATUS,\n            ''\n          );\n          // Naming-only assumption (no positive-case fixture to confirm\n          // against) — `checkDeviceLockStatus`'s own name is the only\n          // evidence `true` means locked; verify against real hardware.\n          return success({ locked: response.payload });\n        }\n        case 'getAppConfig': {\n          const config = await this._readAppConfig(session.transport);\n          return success(config);\n        }\n        default:\n          return {\n            success: false,\n            error: serializeConnectorError(\n              createHwkError({\n                code: HardwareErrorCode.MethodNotSupported,\n                message: `Unknown Keystone USB connector method: ${method}`,\n              })\n            ),\n          };\n      }\n    } catch (err) {\n      return { success: false, error: serializeConnectorError(mapKeystoneUsbError(err)) };\n    }\n  }\n\n  // No protocol-level cancel exists over USB (verified: nothing in the SDK's\n  // public surface can interrupt an in-flight transferIn/transferOut) — the\n  // best this connector can do is stop waiting on its side; the underlying\n  // `send()` promise still settles (or times out) on its own.\n  cancel(_sessionId: string): Promise<void> {\n    return Promise.resolve();\n  }\n\n  // Keystone USB never relays PIN/passphrase through the host — entry always\n  // happens on the device's own touchscreen — so there is nothing to answer.\n  uiResponse(_response: UiResponseEvent): void {}\n\n  on<K extends ConnectorEventType>(event: K, handler: (data: ConnectorEventMap[K]) => void): void {\n    this.emitter.on(event, handler);\n  }\n\n  off<K extends ConnectorEventType>(event: K, handler: (data: ConnectorEventMap[K]) => void): void {\n    this.emitter.off(event, handler);\n  }\n\n  reset(): void {\n    this.sessions.clear();\n  }\n\n  private async _readAppConfig(\n    transport: TransportHID\n  ): Promise<{ version?: string; mfp?: string }> {\n    const response = await transport.send<Record<string, unknown>>(\n      Actions.CMD_GET_DEVICE_VERSION,\n      ''\n    );\n    return {\n      version: typeof response.firmwareVersion === 'string' ? response.firmwareVersion : undefined,\n      mfp: typeof response.walletMFP === 'string' ? response.walletMFP.toLowerCase() : undefined,\n    };\n  }\n\n  private _toDeviceInfo(device: ConnectorDevice, firmwareVersion?: string) {\n    return {\n      vendor: 'keystone' as const,\n      model: 'unknown',\n      firmwareVersion: firmwareVersion ?? '0.0.0',\n      deviceId: device.deviceId,\n      connectId: device.connectId,\n      connectionType: 'usb' as const,\n      capabilities: { persistentDeviceIdentity: true },\n    };\n  }\n}\n"]}

package/dist/index.d.mts

@@ -0,0 +1,84 @@
+import { IConnector, ConnectorSearchDevicesOptions, ConnectorDevice, ConnectorSession, ConnectorCallResult, UiResponseEvent, ConnectorEventType, ConnectorEventMap, HwkError } from '@onekeyfe/hwk-adapter-core';
+import { TransportConfig, TransportHID } from '@keystonehq/hw-transport-usb';
+
+/**
+ * The static surface both `TransportWebUSB` and `TransportNodeUSB` expose
+ * (verified against their real `.d.ts`/`.js` — both implement `TransportHID`
+ * identically, differing only in how they enumerate/open the underlying
+ * device). Parametrizing on this instead of importing either transport
+ * package directly is what lets `KeystoneUsbConnectorBase` stay
+ * platform-agnostic; `_subpath/webusb.ts` and `_subpath/nodeusb.ts` are the
+ * only files that actually import a concrete transport.
+ */
+interface KeystoneUsbTransportStatic {
+    connect(config?: TransportConfig): Promise<TransportHID>;
+    getKeystoneDevices(): Promise<ReadonlyArray<{
+        serialNumber?: string;
+        productName?: string;
+    }>>;
+    requestPermission?(): Promise<void>;
+    isSupported(): Promise<boolean>;
+}
+/**
+ * `IConnector` implementation for Keystone over USB. Every `TransportHID`
+ * call the underlying SDK exposes is its own self-contained
+ * open→claim→transfer→release→close cycle (verified in `TransportWebUSB`/
+ * `TransportNodeUSB` source — there is no persistent USB claim to hold
+ * across calls), so `connect()` just resolves one `TransportHID` instance
+ * and caches it; each `call()` reuses that same JS object, and the
+ * underlying SDK's own per-command open/close still happens on every send.
+ *
+ * USB carries the exact same UR payloads the QR channel does — `call()`'s
+ * `'resolveUr'` method is a generic `{urType, urData}` (hex CBOR, matching
+ * `hwk-keystone-adapter`'s `KeystoneUr` shape) in, `{urType, urData}` out.
+ * The caller (a future dual-channel `KeystoneAdapter`) can build the UR once
+ * via the same `KeystoneUrEngine` used for QR and send it down either
+ * channel — this connector has no chain-specific knowledge at all.
+ */
+declare class KeystoneUsbConnectorBase implements IConnector {
+    readonly connectionType: "usb";
+    private readonly transportClass;
+    private readonly timeoutMs;
+    private readonly emitter;
+    private readonly sessions;
+    constructor(transportClass: KeystoneUsbTransportStatic, options?: {
+        timeoutMs?: number;
+    });
+    searchDevices(_options?: ConnectorSearchDevicesOptions): Promise<ConnectorDevice[]>;
+    connect(deviceId?: string): Promise<ConnectorSession>;
+    disconnect(sessionId: string): Promise<void>;
+    call(sessionId: string, method: string, params: unknown): Promise<ConnectorCallResult>;
+    cancel(_sessionId: string): Promise<void>;
+    uiResponse(_response: UiResponseEvent): void;
+    on<K extends ConnectorEventType>(event: K, handler: (data: ConnectorEventMap[K]) => void): void;
+    off<K extends ConnectorEventType>(event: K, handler: (data: ConnectorEventMap[K]) => void): void;
+    reset(): void;
+    private _readAppConfig;
+    private _toDeviceInfo;
+}
+
+/**
+ * Maps a Keystone USB SDK failure to the shared `HardwareErrorCode`
+ * vocabulary. Every device-side rejection and client-side transport failure
+ * the SDK produces is a *thrown* `TransportError` with a numeric
+ * `transportErrorCode` (see `@keystonehq/hw-transport-error`) — this is
+ * called from every `catch` in `KeystoneUsbConnectorBase` to build the
+ * `ConnectorCallResult` data-not-exception shape `IConnector.call` requires.
+ *
+ * Idempotent: an error `KeystoneUsbConnectorBase` already built via
+ * `createHwkError` (e.g. its own `DeviceMismatch`/`DeviceNotFound` checks)
+ * carries a numeric `.code` already and passes straight through unchanged —
+ * without this it would fall through to the generic `TransportError`
+ * fallback below and silently lose the real code, since `HwkError` uses
+ * `.code`, not the raw SDK's `.transportErrorCode`.
+ *
+ * Reads `transportErrorCode` duck-typed rather than `instanceof
+ * TransportError` — cheap defense against the exact-same class of
+ * cross-package duplicate-module-instance bug already hit once in this
+ * integration (see docs/design/keystone-integration), where two copies of a
+ * `@keystonehq/*` package resolve to different physical files and
+ * `instanceof` silently fails across them.
+ */
+declare function mapKeystoneUsbError(err: unknown): HwkError;
+
+export { KeystoneUsbConnectorBase, type KeystoneUsbTransportStatic, mapKeystoneUsbError };

package/dist/index.d.ts

@@ -0,0 +1,84 @@
+import { IConnector, ConnectorSearchDevicesOptions, ConnectorDevice, ConnectorSession, ConnectorCallResult, UiResponseEvent, ConnectorEventType, ConnectorEventMap, HwkError } from '@onekeyfe/hwk-adapter-core';
+import { TransportConfig, TransportHID } from '@keystonehq/hw-transport-usb';
+
+/**
+ * The static surface both `TransportWebUSB` and `TransportNodeUSB` expose
+ * (verified against their real `.d.ts`/`.js` — both implement `TransportHID`
+ * identically, differing only in how they enumerate/open the underlying
+ * device). Parametrizing on this instead of importing either transport
+ * package directly is what lets `KeystoneUsbConnectorBase` stay
+ * platform-agnostic; `_subpath/webusb.ts` and `_subpath/nodeusb.ts` are the
+ * only files that actually import a concrete transport.
+ */
+interface KeystoneUsbTransportStatic {
+    connect(config?: TransportConfig): Promise<TransportHID>;
+    getKeystoneDevices(): Promise<ReadonlyArray<{
+        serialNumber?: string;
+        productName?: string;
+    }>>;
+    requestPermission?(): Promise<void>;
+    isSupported(): Promise<boolean>;
+}
+/**
+ * `IConnector` implementation for Keystone over USB. Every `TransportHID`
+ * call the underlying SDK exposes is its own self-contained
+ * open→claim→transfer→release→close cycle (verified in `TransportWebUSB`/
+ * `TransportNodeUSB` source — there is no persistent USB claim to hold
+ * across calls), so `connect()` just resolves one `TransportHID` instance
+ * and caches it; each `call()` reuses that same JS object, and the
+ * underlying SDK's own per-command open/close still happens on every send.
+ *
+ * USB carries the exact same UR payloads the QR channel does — `call()`'s
+ * `'resolveUr'` method is a generic `{urType, urData}` (hex CBOR, matching
+ * `hwk-keystone-adapter`'s `KeystoneUr` shape) in, `{urType, urData}` out.
+ * The caller (a future dual-channel `KeystoneAdapter`) can build the UR once
+ * via the same `KeystoneUrEngine` used for QR and send it down either
+ * channel — this connector has no chain-specific knowledge at all.
+ */
+declare class KeystoneUsbConnectorBase implements IConnector {
+    readonly connectionType: "usb";
+    private readonly transportClass;
+    private readonly timeoutMs;
+    private readonly emitter;
+    private readonly sessions;
+    constructor(transportClass: KeystoneUsbTransportStatic, options?: {
+        timeoutMs?: number;
+    });
+    searchDevices(_options?: ConnectorSearchDevicesOptions): Promise<ConnectorDevice[]>;
+    connect(deviceId?: string): Promise<ConnectorSession>;
+    disconnect(sessionId: string): Promise<void>;
+    call(sessionId: string, method: string, params: unknown): Promise<ConnectorCallResult>;
+    cancel(_sessionId: string): Promise<void>;
+    uiResponse(_response: UiResponseEvent): void;
+    on<K extends ConnectorEventType>(event: K, handler: (data: ConnectorEventMap[K]) => void): void;
+    off<K extends ConnectorEventType>(event: K, handler: (data: ConnectorEventMap[K]) => void): void;
+    reset(): void;
+    private _readAppConfig;
+    private _toDeviceInfo;
+}
+
+/**
+ * Maps a Keystone USB SDK failure to the shared `HardwareErrorCode`
+ * vocabulary. Every device-side rejection and client-side transport failure
+ * the SDK produces is a *thrown* `TransportError` with a numeric
+ * `transportErrorCode` (see `@keystonehq/hw-transport-error`) — this is
+ * called from every `catch` in `KeystoneUsbConnectorBase` to build the
+ * `ConnectorCallResult` data-not-exception shape `IConnector.call` requires.
+ *
+ * Idempotent: an error `KeystoneUsbConnectorBase` already built via
+ * `createHwkError` (e.g. its own `DeviceMismatch`/`DeviceNotFound` checks)
+ * carries a numeric `.code` already and passes straight through unchanged —
+ * without this it would fall through to the generic `TransportError`
+ * fallback below and silently lose the real code, since `HwkError` uses
+ * `.code`, not the raw SDK's `.transportErrorCode`.
+ *
+ * Reads `transportErrorCode` duck-typed rather than `instanceof
+ * TransportError` — cheap defense against the exact-same class of
+ * cross-package duplicate-module-instance bug already hit once in this
+ * integration (see docs/design/keystone-integration), where two copies of a
+ * `@keystonehq/*` package resolve to different physical files and
+ * `instanceof` silently fails across them.
+ */
+declare function mapKeystoneUsbError(err: unknown): HwkError;
+
+export { KeystoneUsbConnectorBase, type KeystoneUsbTransportStatic, mapKeystoneUsbError };

package/dist/index.js

@@ -0,0 +1,9 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunkLA3RVME7js = require('./chunk-LA3RVME7.js');
+
+
+
+exports.KeystoneUsbConnectorBase = _chunkLA3RVME7js.KeystoneUsbConnectorBase; exports.mapKeystoneUsbError = _chunkLA3RVME7js.mapKeystoneUsbError;
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/hardware-js-sdk/hardware-js-sdk/packages/hwk-keystone-connector-usb/dist/index.js"],"names":[],"mappings":"AAAA;AACE;AACA;AACF,sDAA4B;AAC5B;AACE;AACA;AACF,iJAAC","file":"/home/runner/work/hardware-js-sdk/hardware-js-sdk/packages/hwk-keystone-connector-usb/dist/index.js"}

package/dist/index.mjs

@@ -0,0 +1,9 @@
+import {
+  KeystoneUsbConnectorBase,
+  mapKeystoneUsbError
+} from "./chunk-5JU4E5XQ.mjs";
+export {
+  KeystoneUsbConnectorBase,
+  mapKeystoneUsbError
+};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/nodeusb.d.mts

@@ -0,0 +1,7 @@
+import { IConnector } from '@onekeyfe/hwk-adapter-core';
+
+declare function createKeystoneNodeUsbConnector(options?: {
+    timeoutMs?: number;
+}): IConnector;
+
+export { createKeystoneNodeUsbConnector };

package/dist/nodeusb.d.ts

@@ -0,0 +1,7 @@
+import { IConnector } from '@onekeyfe/hwk-adapter-core';
+
+declare function createKeystoneNodeUsbConnector(options?: {
+    timeoutMs?: number;
+}): IConnector;
+
+export { createKeystoneNodeUsbConnector };

package/dist/nodeusb.js

@@ -0,0 +1,13 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkLA3RVME7js = require('./chunk-LA3RVME7.js');
+
+// src/_subpath/nodeusb.ts
+var _hwtransportnodeusb = require('@keystonehq/hw-transport-nodeusb');
+function createKeystoneNodeUsbConnector(options) {
+  return new (0, _chunkLA3RVME7js.KeystoneUsbConnectorBase)(_hwtransportnodeusb.TransportNodeUSB, options);
+}
+
+
+exports.createKeystoneNodeUsbConnector = createKeystoneNodeUsbConnector;
+//# sourceMappingURL=nodeusb.js.map

package/dist/nodeusb.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/hardware-js-sdk/hardware-js-sdk/packages/hwk-keystone-connector-usb/dist/nodeusb.js","../src/_subpath/nodeusb.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACA;ACJA,sEAAiC;AAM1B,SAAS,8BAAA,CAA+B,OAAA,EAA8C;AAC3F,EAAA,OAAO,IAAI,8CAAA,CAAyB,oCAAA,EAAkB,OAAO,CAAA;AAC/D;ADCA;AACE;AACF,wEAAC","file":"/home/runner/work/hardware-js-sdk/hardware-js-sdk/packages/hwk-keystone-connector-usb/dist/nodeusb.js","sourcesContent":[null,"import { TransportNodeUSB } from '@keystonehq/hw-transport-nodeusb';\n\nimport { KeystoneUsbConnectorBase } from '../KeystoneUsbConnectorBase';\n\nimport type { IConnector } from '@onekeyfe/hwk-adapter-core';\n\nexport function createKeystoneNodeUsbConnector(options?: { timeoutMs?: number }): IConnector {\n  return new KeystoneUsbConnectorBase(TransportNodeUSB, options);\n}\n"]}

package/dist/nodeusb.mjs

@@ -0,0 +1,13 @@
+import {
+  KeystoneUsbConnectorBase
+} from "./chunk-5JU4E5XQ.mjs";
+
+// src/_subpath/nodeusb.ts
+import { TransportNodeUSB } from "@keystonehq/hw-transport-nodeusb";
+function createKeystoneNodeUsbConnector(options) {
+  return new KeystoneUsbConnectorBase(TransportNodeUSB, options);
+}
+export {
+  createKeystoneNodeUsbConnector
+};
+//# sourceMappingURL=nodeusb.mjs.map

package/dist/nodeusb.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/_subpath/nodeusb.ts"],"sourcesContent":["import { TransportNodeUSB } from '@keystonehq/hw-transport-nodeusb';\n\nimport { KeystoneUsbConnectorBase } from '../KeystoneUsbConnectorBase';\n\nimport type { IConnector } from '@onekeyfe/hwk-adapter-core';\n\nexport function createKeystoneNodeUsbConnector(options?: { timeoutMs?: number }): IConnector {\n  return new KeystoneUsbConnectorBase(TransportNodeUSB, options);\n}\n"],"mappings":";;;;;AAAA,SAAS,wBAAwB;AAM1B,SAAS,+BAA+B,SAA8C;AAC3F,SAAO,IAAI,yBAAyB,kBAAkB,OAAO;AAC/D;","names":[]}

package/dist/webusb.d.mts

@@ -0,0 +1,13 @@
+import { IConnector } from '@onekeyfe/hwk-adapter-core';
+
+declare function createKeystoneWebUsbConnector(options?: {
+    timeoutMs?: number;
+}): IConnector;
+/**
+ * Triggers the browser's WebUSB device picker. Must be called from a
+ * user-gesture handler (e.g. directly inside a button's `onclick`) — same
+ * requirement as any other WebUSB permission request.
+ */
+declare function requestKeystoneUsbPermission(): Promise<void>;
+
+export { createKeystoneWebUsbConnector, requestKeystoneUsbPermission };

package/dist/webusb.d.ts

@@ -0,0 +1,13 @@
+import { IConnector } from '@onekeyfe/hwk-adapter-core';
+
+declare function createKeystoneWebUsbConnector(options?: {
+    timeoutMs?: number;
+}): IConnector;
+/**
+ * Triggers the browser's WebUSB device picker. Must be called from a
+ * user-gesture handler (e.g. directly inside a button's `onclick`) — same
+ * requirement as any other WebUSB permission request.
+ */
+declare function requestKeystoneUsbPermission(): Promise<void>;
+
+export { createKeystoneWebUsbConnector, requestKeystoneUsbPermission };

package/dist/webusb.js

@@ -0,0 +1,17 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkLA3RVME7js = require('./chunk-LA3RVME7.js');
+
+// src/_subpath/webusb.ts
+var _hwtransportwebusb = require('@keystonehq/hw-transport-webusb');
+function createKeystoneWebUsbConnector(options) {
+  return new (0, _chunkLA3RVME7js.KeystoneUsbConnectorBase)(_hwtransportwebusb.TransportWebUSB, options);
+}
+async function requestKeystoneUsbPermission() {
+  await _hwtransportwebusb.TransportWebUSB.requestPermission();
+}
+
+
+
+exports.createKeystoneWebUsbConnector = createKeystoneWebUsbConnector; exports.requestKeystoneUsbPermission = requestKeystoneUsbPermission;
+//# sourceMappingURL=webusb.js.map

package/dist/webusb.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/hardware-js-sdk/hardware-js-sdk/packages/hwk-keystone-connector-usb/dist/webusb.js","../src/_subpath/webusb.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACA;ACJA,oEAAgC;AAMzB,SAAS,6BAAA,CAA8B,OAAA,EAA8C;AAC1F,EAAA,OAAO,IAAI,8CAAA,CAAyB,kCAAA,EAAiB,OAAO,CAAA;AAC9D;AAOA,MAAA,SAAsB,4BAAA,CAAA,EAA8C;AAClE,EAAA,MAAM,kCAAA,CAAgB,iBAAA,CAAkB,CAAA;AAC1C;ADLA;AACE;AACA;AACF,2IAAC","file":"/home/runner/work/hardware-js-sdk/hardware-js-sdk/packages/hwk-keystone-connector-usb/dist/webusb.js","sourcesContent":[null,"import { TransportWebUSB } from '@keystonehq/hw-transport-webusb';\n\nimport { KeystoneUsbConnectorBase } from '../KeystoneUsbConnectorBase';\n\nimport type { IConnector } from '@onekeyfe/hwk-adapter-core';\n\nexport function createKeystoneWebUsbConnector(options?: { timeoutMs?: number }): IConnector {\n  return new KeystoneUsbConnectorBase(TransportWebUSB, options);\n}\n\n/**\n * Triggers the browser's WebUSB device picker. Must be called from a\n * user-gesture handler (e.g. directly inside a button's `onclick`) — same\n * requirement as any other WebUSB permission request.\n */\nexport async function requestKeystoneUsbPermission(): Promise<void> {\n  await TransportWebUSB.requestPermission();\n}\n"]}

package/dist/webusb.mjs

@@ -0,0 +1,17 @@
+import {
+  KeystoneUsbConnectorBase
+} from "./chunk-5JU4E5XQ.mjs";
+
+// src/_subpath/webusb.ts
+import { TransportWebUSB } from "@keystonehq/hw-transport-webusb";
+function createKeystoneWebUsbConnector(options) {
+  return new KeystoneUsbConnectorBase(TransportWebUSB, options);
+}
+async function requestKeystoneUsbPermission() {
+  await TransportWebUSB.requestPermission();
+}
+export {
+  createKeystoneWebUsbConnector,
+  requestKeystoneUsbPermission
+};
+//# sourceMappingURL=webusb.mjs.map

package/dist/webusb.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/_subpath/webusb.ts"],"sourcesContent":["import { TransportWebUSB } from '@keystonehq/hw-transport-webusb';\n\nimport { KeystoneUsbConnectorBase } from '../KeystoneUsbConnectorBase';\n\nimport type { IConnector } from '@onekeyfe/hwk-adapter-core';\n\nexport function createKeystoneWebUsbConnector(options?: { timeoutMs?: number }): IConnector {\n  return new KeystoneUsbConnectorBase(TransportWebUSB, options);\n}\n\n/**\n * Triggers the browser's WebUSB device picker. Must be called from a\n * user-gesture handler (e.g. directly inside a button's `onclick`) — same\n * requirement as any other WebUSB permission request.\n */\nexport async function requestKeystoneUsbPermission(): Promise<void> {\n  await TransportWebUSB.requestPermission();\n}\n"],"mappings":";;;;;AAAA,SAAS,uBAAuB;AAMzB,SAAS,8BAA8B,SAA8C;AAC1F,SAAO,IAAI,yBAAyB,iBAAiB,OAAO;AAC9D;AAOA,eAAsB,+BAA8C;AAClE,QAAM,gBAAgB,kBAAkB;AAC1C;","names":[]}

package/package.json

@@ -0,0 +1,82 @@
+{
+  "name": "@onekeyfe/hwk-keystone-connector-usb",
+  "version": "1.2.2-alpha.100",
+  "description": "IConnector implementation for Keystone hardware wallets via USB (WebUSB + Node USB)",
+  "author": "OneKey",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    },
+    "./webusb": {
+      "import": {
+        "types": "./dist/webusb.d.mts",
+        "default": "./dist/webusb.mjs"
+      },
+      "require": {
+        "types": "./dist/webusb.d.ts",
+        "default": "./dist/webusb.js"
+      }
+    },
+    "./nodeusb": {
+      "import": {
+        "types": "./dist/nodeusb.d.mts",
+        "default": "./dist/nodeusb.mjs"
+      },
+      "require": {
+        "types": "./dist/nodeusb.d.ts",
+        "default": "./dist/nodeusb.js"
+      }
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "clean": "rimraf dist",
+    "test": "jest"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/OneKeyHQ/hardware-js-sdk.git",
+    "directory": "packages/hwk-keystone-connector-usb"
+  },
+  "keywords": [
+    "keystone",
+    "usb",
+    "webusb",
+    "hardware-wallet",
+    "onekey",
+    "connector"
+  ],
+  "dependencies": {
+    "@keystonehq/hw-transport-error": "0.0.2",
+    "@keystonehq/hw-transport-nodeusb": "0.2.0",
+    "@keystonehq/hw-transport-usb": "0.2.0",
+    "@keystonehq/hw-transport-webusb": "0.5.3",
+    "@ngraveio/bc-ur": "1.1.13",
+    "@onekeyfe/hwk-adapter-core": "1.2.2-alpha.100"
+  },
+  "devDependencies": {
+    "@keystonehq/bc-ur-registry-eth": "0.22.1",
+    "rimraf": "^5.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.4.0"
+  },
+  "gitHead": "c40dad085297b0e3cc2020bd218c146dff6ed3e1"
+}