@bytezhang/hardware-trezor-adapter 0.0.30 → 0.0.32

package/dist/index.js

@@ -20,739 +20,19 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  TrezorAdapter: () => TrezorAdapter,
-  TrezorProxyClient: () => TrezorProxyClient
+  TrezorService: () => TrezorService,
+  VERSION: () => VERSION
 });
 module.exports = __toCommonJS(index_exports);
-
-// src/TrezorAdapter.ts
-var import_hardware_wallet_core = require("@bytezhang/hardware-wallet-core");
-var TrezorAdapter = class {
-  constructor(connector) {
-    this.vendor = "trezor";
-    this.emitter = new import_hardware_wallet_core.TypedEventEmitter();
-    this._uiHandler = null;
-    // Device cache: tracks discovered devices from connector events
-    this._discoveredDevices = /* @__PURE__ */ new Map();
-    // Session tracking: maps connectId -> sessionId
-    this._sessions = /* @__PURE__ */ new Map();
-    // ─── Chain capability accessors ────────────────────────────
-    this._evmMethods = {
-      evmGetAddress: (connectId, deviceId, params) => this._evmGetAddress(connectId, deviceId, params),
-      evmGetAddresses: (connectId, deviceId, params, onProgress) => this._evmGetAddresses(connectId, deviceId, params, onProgress),
-      evmGetPublicKey: (connectId, deviceId, params) => this._evmGetPublicKey(connectId, deviceId, params),
-      evmSignTransaction: (connectId, deviceId, params) => this._evmSignTransaction(connectId, deviceId, params),
-      evmSignMessage: (connectId, deviceId, params) => this._evmSignMessage(connectId, deviceId, params),
-      evmSignTypedData: (connectId, deviceId, params) => this._evmSignTypedData(connectId, deviceId, params)
-    };
-    this._btcMethods = {
-      btcGetAddress: (connectId, deviceId, params) => this._btcGetAddress(connectId, deviceId, params),
-      btcGetAddresses: (connectId, deviceId, params, onProgress) => this._btcGetAddresses(connectId, deviceId, params, onProgress),
-      btcGetPublicKey: (connectId, deviceId, params) => this._btcGetPublicKey(connectId, deviceId, params),
-      btcSignTransaction: (connectId, deviceId, params) => this._btcSignTransaction(connectId, deviceId, params),
-      btcSignMessage: (connectId, deviceId, params) => this._btcSignMessage(connectId, deviceId, params),
-      btcGetMasterFingerprint: (connectId, deviceId) => this._btcGetMasterFingerprint(connectId, deviceId)
-    };
-    this._solMethods = {
-      solGetAddress: (connectId, deviceId, params) => this._solGetAddress(connectId, deviceId, params),
-      solGetAddresses: (connectId, deviceId, params, onProgress) => this._solGetAddresses(connectId, deviceId, params, onProgress),
-      solGetPublicKey: (connectId, deviceId, params) => this._solGetPublicKey(connectId, deviceId, params),
-      solSignTransaction: (connectId, deviceId, params) => this._solSignTransaction(connectId, deviceId, params),
-      solSignMessage: (connectId, deviceId, params) => this._solSignMessage(connectId, deviceId, params)
-    };
-    // ─── Event translation ────────────────────────────────────
-    this.deviceConnectHandler = (data) => {
-      const deviceInfo = this.connectorDeviceToDeviceInfo(data.device);
-      this._discoveredDevices.set(deviceInfo.connectId, deviceInfo);
-      this.emitter.emit(import_hardware_wallet_core.DEVICE.CONNECT, {
-        type: import_hardware_wallet_core.DEVICE.CONNECT,
-        payload: deviceInfo
-      });
-    };
-    this.deviceDisconnectHandler = (data) => {
-      this._discoveredDevices.delete(data.connectId);
-      this.emitter.emit(import_hardware_wallet_core.DEVICE.DISCONNECT, {
-        type: import_hardware_wallet_core.DEVICE.DISCONNECT,
-        payload: { connectId: data.connectId }
-      });
-    };
-    this.uiRequestHandler = (data) => {
-      this.handleUiEvent(data);
-    };
-    this.uiEventHandler = (data) => {
-      this.handleUiEvent(data);
-    };
-    this.connector = connector;
-    this.registerEventListeners();
-  }
-  // ─── Transport ──────────────────────────────────────────
-  // Transport is decided at connector creation time. These methods
-  // satisfy the IHardwareWallet interface with sensible defaults.
-  get activeTransport() {
-    return "usb";
-  }
-  getAvailableTransports() {
-    return ["usb"];
-  }
-  async switchTransport(_type) {
-  }
-  // ─── UI handler ────────────────────────────────────────────
-  setUiHandler(handler) {
-    this._uiHandler = handler;
-  }
-  // ─── Lifecycle ────────────────────────────────────────────
-  async init(_config) {
-  }
-  async dispose() {
-    this.unregisterEventListeners();
-    this.connector.reset();
-    this._uiHandler = null;
-    this._discoveredDevices.clear();
-    this._sessions.clear();
-    this.emitter.removeAllListeners();
-  }
-  // ─── Device management ────────────────────────────────────
-  async searchDevices() {
-    await this._ensureDevicePermission();
-    const devices = await this.connector.searchDevices();
-    for (const d of devices) {
-      if (d.connectId && !this._discoveredDevices.has(d.connectId)) {
-        this._discoveredDevices.set(d.connectId, this.connectorDeviceToDeviceInfo(d));
-      }
-    }
-    if (this._discoveredDevices.size === 0) {
-      await this._ensureDevicePermission();
-    }
-    return Array.from(this._discoveredDevices.values());
-  }
-  async connectDevice(connectId) {
-    try {
-      const session = await this.connector.connect(connectId);
-      this._sessions.set(connectId, session.sessionId);
-      if (session.deviceInfo) {
-        this._discoveredDevices.set(connectId, session.deviceInfo);
-      }
-      return (0, import_hardware_wallet_core.success)(connectId);
-    } catch (err) {
-      return this.errorToFailure(err);
-    }
-  }
-  async disconnectDevice(connectId) {
-    const sessionId = this._sessions.get(connectId);
-    if (sessionId) {
-      await this.connector.disconnect(sessionId);
-      this._sessions.delete(connectId);
-    }
-  }
-  async getDeviceInfo(connectId, deviceId) {
-    await this._ensureDevicePermission(connectId, deviceId);
-    const cached = this._discoveredDevices.get(connectId) ?? Array.from(this._discoveredDevices.values()).find(
-      (d) => d.deviceId === deviceId
-    );
-    if (cached) {
-      return (0, import_hardware_wallet_core.success)(cached);
-    }
-    return (0, import_hardware_wallet_core.failure)(
-      import_hardware_wallet_core.HardwareErrorCode.DeviceNotFound,
-      "Device not found in cache. Call searchDevices() or wait for a device-connected event first."
-    );
-  }
-  getSupportedChains() {
-    return ["evm", "btc", "sol"];
-  }
-  on(event, listener) {
-    this.emitter.on(event, listener);
-  }
-  off(event, listener) {
-    this.emitter.off(event, listener);
-  }
-  cancel(connectId) {
-    const sessionId = this._sessions.get(connectId) ?? connectId;
-    void this.connector.cancel(sessionId);
-  }
-  // ─── Chain fingerprint ────────────────────────────────────
-  /**
-   * For Trezor, the chain fingerprint is the hardware device_id from firmware.
-   * Trezor has a persistent device identity, so no address derivation is needed.
-   */
-  async getChainFingerprint(connectId, deviceId, _chain) {
-    await this._ensureDevicePermission(connectId, deviceId);
-    const cached = this._discoveredDevices.get(connectId) ?? Array.from(this._discoveredDevices.values()).find(
-      (d) => d.deviceId === deviceId
-    );
-    if (cached?.deviceId) {
-      return (0, import_hardware_wallet_core.success)(cached.deviceId);
-    }
-    try {
-      const result = await this.connectorCall(connectId, "getFeatures", {});
-      if (result.device_id) {
-        return (0, import_hardware_wallet_core.success)(result.device_id);
-      }
-    } catch {
-    }
-    return (0, import_hardware_wallet_core.failure)(
-      import_hardware_wallet_core.HardwareErrorCode.DeviceNotFound,
-      "Could not determine Trezor device identity. Ensure the device is connected."
-    );
-  }
-  evm() {
-    return this._evmMethods;
-  }
-  btc() {
-    return this._btcMethods;
-  }
-  sol() {
-    return this._solMethods;
-  }
-  tron() {
-    return null;
-  }
-  // ─── EVM methods (private) ────────────────────────────────
-  async _evmGetAddress(connectId, _deviceId, params) {
-    await this._ensureDevicePermission(connectId, _deviceId);
-    try {
-      const result = await this.connectorCall(connectId, "evmGetAddress", {
-        path: params.path,
-        showOnDevice: params.showOnDevice,
-        chainId: params.chainId
-      });
-      return (0, import_hardware_wallet_core.success)({
-        address: result.address,
-        path: params.path
-      });
-    } catch (err) {
-      return this.errorToFailure(err);
-    }
-  }
-  async _evmGetAddresses(connectId, deviceId, params, onProgress) {
-    return this.batchCall(
-      params,
-      (p) => this._evmGetAddress(connectId, deviceId, p),
-      onProgress
-    );
-  }
-  async _evmGetPublicKey(connectId, _deviceId, params) {
-    await this._ensureDevicePermission(connectId, _deviceId);
-    try {
-      const result = await this.connectorCall(connectId, "evmGetPublicKey", {
-        path: params.path,
-        showOnDevice: params.showOnDevice
-      });
-      return (0, import_hardware_wallet_core.success)({
-        publicKey: result.publicKey,
-        path: params.path
-      });
-    } catch (err) {
-      return this.errorToFailure(err);
-    }
-  }
-  async _evmSignTransaction(connectId, _deviceId, params) {
-    await this._ensureDevicePermission(connectId, _deviceId);
-    try {
-      const result = await this.connectorCall(connectId, "evmSignTransaction", {
-        path: params.path,
-        transaction: {
-          to: params.to,
-          value: params.value,
-          chainId: params.chainId,
-          nonce: params.nonce,
-          gasLimit: params.gasLimit,
-          gasPrice: params.gasPrice,
-          maxFeePerGas: params.maxFeePerGas,
-          maxPriorityFeePerGas: params.maxPriorityFeePerGas,
-          accessList: params.accessList,
-          data: params.data
-        }
-      });
-      return (0, import_hardware_wallet_core.success)({
-        v: this.ensure0x(result.v),
-        r: this.padHex64(result.r),
-        s: this.padHex64(result.s),
-        serializedTx: result.serializedTx
-      });
-    } catch (err) {
-      return this.errorToFailure(err);
-    }
-  }
-  async _evmSignMessage(connectId, _deviceId, params) {
-    await this._ensureDevicePermission(connectId, _deviceId);
-    try {
-      const result = await this.connectorCall(connectId, "evmSignMessage", {
-        path: params.path,
-        message: params.message,
-        hex: params.hex
-      });
-      return (0, import_hardware_wallet_core.success)({
-        signature: this.ensure0x(result.signature),
-        address: result.address
-      });
-    } catch (err) {
-      return this.errorToFailure(err);
-    }
-  }
-  async _evmSignTypedData(connectId, _deviceId, params) {
-    await this._ensureDevicePermission(connectId, _deviceId);
-    try {
-      const callParams = {
-        path: params.path
-      };
-      if (params.mode !== "hash") {
-        callParams["mode"] = params.mode ?? "full";
-        callParams["data"] = params.data;
-        callParams["metamaskV4Compat"] = params.metamaskV4Compat ?? true;
-      } else {
-        callParams["mode"] = "hash";
-        callParams["domainSeparatorHash"] = params.domainSeparatorHash;
-        callParams["messageHash"] = params.messageHash;
-      }
-      const result = await this.connectorCall(connectId, "evmSignTypedData", callParams);
-      return (0, import_hardware_wallet_core.success)({
-        signature: this.ensure0x(result.signature),
-        address: result.address
-      });
-    } catch (err) {
-      return this.errorToFailure(err);
-    }
-  }
-  // ─── BTC methods (private) ─────────────────────────────────
-  async _btcGetAddress(connectId, _deviceId, params) {
-    await this._ensureDevicePermission(connectId, _deviceId);
-    try {
-      const result = await this.connectorCall(connectId, "btcGetAddress", {
-        path: params.path,
-        coin: params.coin,
-        showOnDevice: params.showOnDevice,
-        scriptType: params.scriptType
-      });
-      return (0, import_hardware_wallet_core.success)({
-        address: result.address,
-        path: params.path
-      });
-    } catch (err) {
-      return this.errorToFailure(err);
-    }
-  }
-  async _btcGetAddresses(connectId, deviceId, params, onProgress) {
-    return this.batchCall(
-      params,
-      (p) => this._btcGetAddress(connectId, deviceId, p),
-      onProgress
-    );
-  }
-  async _btcGetPublicKey(connectId, _deviceId, params) {
-    await this._ensureDevicePermission(connectId, _deviceId);
-    try {
-      const result = await this.connectorCall(connectId, "btcGetPublicKey", {
-        path: params.path,
-        coin: params.coin,
-        showOnDevice: params.showOnDevice
-      });
-      return (0, import_hardware_wallet_core.success)({
-        xpub: result.xpub,
-        publicKey: result.publicKey,
-        fingerprint: result.fingerprint,
-        chainCode: result.chainCode,
-        path: params.path,
-        depth: result.depth
-      });
-    } catch (err) {
-      return this.errorToFailure(err);
-    }
-  }
-  async _btcSignTransaction(connectId, _deviceId, params) {
-    await this._ensureDevicePermission(connectId, _deviceId);
-    try {
-      const result = await this.connectorCall(connectId, "btcSignTransaction", {
-        inputs: params.inputs ?? [],
-        outputs: params.outputs ?? [],
-        refTxs: params.refTxs,
-        coin: params.coin,
-        locktime: params.locktime,
-        version: params.version
-      });
-      return (0, import_hardware_wallet_core.success)({
-        signatures: result.signatures,
-        serializedTx: result.serializedTx,
-        txid: result.txid
-      });
-    } catch (err) {
-      return this.errorToFailure(err);
-    }
-  }
-  async _btcSignMessage(connectId, _deviceId, params) {
-    await this._ensureDevicePermission(connectId, _deviceId);
-    try {
-      const result = await this.connectorCall(connectId, "btcSignMessage", {
-        path: params.path,
-        message: params.message,
-        coin: params.coin
-      });
-      return (0, import_hardware_wallet_core.success)({
-        signature: result.signature,
-        address: result.address
-      });
-    } catch (err) {
-      return this.errorToFailure(err);
-    }
-  }
-  async _btcGetMasterFingerprint(connectId, _deviceId) {
-    await this._ensureDevicePermission(connectId, _deviceId);
-    try {
-      const result = await this.connectorCall(connectId, "btcGetPublicKey", {
-        path: "m/0'"
-      });
-      const fp = result.fingerprint >>> 0;
-      const hex = fp.toString(16).padStart(8, "0");
-      return (0, import_hardware_wallet_core.success)({ masterFingerprint: hex });
-    } catch (err) {
-      return this.errorToFailure(err);
-    }
-  }
-  // ─── Solana methods (private) ──────────────────────────────
-  async _solGetAddress(connectId, _deviceId, params) {
-    await this._ensureDevicePermission(connectId, _deviceId);
-    try {
-      const result = await this.connectorCall(connectId, "solGetAddress", {
-        path: params.path,
-        showOnDevice: params.showOnDevice
-      });
-      return (0, import_hardware_wallet_core.success)({
-        address: result.address,
-        path: params.path
-      });
-    } catch (err) {
-      return this.errorToFailure(err);
-    }
-  }
-  async _solGetAddresses(connectId, deviceId, params, onProgress) {
-    return this.batchCall(
-      params,
-      (p) => this._solGetAddress(connectId, deviceId, p),
-      onProgress
-    );
-  }
-  async _solGetPublicKey(connectId, _deviceId, params) {
-    await this._ensureDevicePermission(connectId, _deviceId);
-    try {
-      const result = await this.connectorCall(connectId, "solGetAddress", {
-        path: params.path,
-        showOnDevice: params.showOnDevice
-      });
-      return (0, import_hardware_wallet_core.success)({
-        publicKey: result.address,
-        path: params.path
-      });
-    } catch (err) {
-      return this.errorToFailure(err);
-    }
-  }
-  async _solSignTransaction(connectId, _deviceId, params) {
-    await this._ensureDevicePermission(connectId, _deviceId);
-    try {
-      const result = await this.connectorCall(connectId, "solSignTransaction", {
-        path: params.path,
-        serializedTx: params.serializedTx,
-        additionalInfo: params.additionalInfo
-      });
-      return (0, import_hardware_wallet_core.success)({
-        signature: result.signature
-      });
-    } catch (err) {
-      return this.errorToFailure(err);
-    }
-  }
-  async _solSignMessage(_connectId, _deviceId, _params) {
-    return (0, import_hardware_wallet_core.failure)(
-      import_hardware_wallet_core.HardwareErrorCode.MethodNotSupported,
-      "Solana signMessage is not supported by Trezor Connect"
-    );
-  }
-  // ─── Private helpers ──────────────────────────────────────
-  /**
-   * Call the connector with session resolution.
-   * Looks up sessionId from connectId, falls back to connectId itself.
-   */
-  async connectorCall(connectId, method, params) {
-    const sessionId = this._sessions.get(connectId) ?? connectId;
-    return this.connector.call(sessionId, method, params);
-  }
-  /**
-   * Ensure device permission before proceeding.
-   * - No connectId (searchDevices): check environment-level permission
-   * - With connectId (business methods): check device-level permission
-   * If not granted, calls onDevicePermission so the consumer can request access.
-   */
-  async _ensureDevicePermission(connectId, deviceId) {
-    const transportType = "usb";
-    let granted = false;
-    let context;
-    if (this._uiHandler?.checkDevicePermission) {
-      try {
-        const result = await this._uiHandler.checkDevicePermission({ transportType, connectId, deviceId });
-        granted = result.granted;
-        context = result.context;
-      } catch {
-        granted = false;
-      }
-    }
-    if (!granted) {
-      try {
-        await this._uiHandler?.onDevicePermission?.({ transportType, context });
-      } catch {
-      }
-    }
-  }
-  /**
-   * Convert a thrown error to a Response failure.
-   * Parses TrezorConnect error strings to map to HardwareErrorCode values.
-   */
-  errorToFailure(err) {
-    const message = err instanceof Error ? err.message : String(err);
-    const code = this.parseErrorCode(message);
-    const enriched = this.enrichErrorMessage(code, message);
-    return (0, import_hardware_wallet_core.failure)(code, enriched);
-  }
-  /**
-   * Parse TrezorConnect error codes from error message strings.
-   * The connector throws errors with messages like "Trezor ethereumGetAddress failed: <error>".
-   * We also check for embedded code patterns.
-   */
-  parseErrorCode(message) {
-    if (message.includes("Failure_ActionCancelled") || message.includes("Failure_Cancel")) {
-      return import_hardware_wallet_core.HardwareErrorCode.UserRejected;
-    }
-    if (message.includes("Failure_PinInvalid") || message.includes("Failure_PinMismatch")) {
-      return import_hardware_wallet_core.HardwareErrorCode.PinInvalid;
-    }
-    if (message.includes("Failure_PinCancelled")) {
-      return import_hardware_wallet_core.HardwareErrorCode.PinCancelled;
-    }
-    if (message.includes("Failure_PassphraseRejected")) {
-      return import_hardware_wallet_core.HardwareErrorCode.PassphraseRejected;
-    }
-    if (message.includes("Device_UsedElsewhere")) {
-      return import_hardware_wallet_core.HardwareErrorCode.DeviceBusy;
-    }
-    if (message.includes("Device_NotFound")) {
-      return import_hardware_wallet_core.HardwareErrorCode.DeviceNotFound;
-    }
-    if (message.includes("Device_InvalidState")) {
-      return import_hardware_wallet_core.HardwareErrorCode.DeviceNotInitialized;
-    }
-    if (message.includes("Transport_Missing")) {
-      return import_hardware_wallet_core.HardwareErrorCode.TransportNotAvailable;
-    }
-    if (message.includes("Transport_DeviceDisconnected")) {
-      return import_hardware_wallet_core.HardwareErrorCode.DeviceDisconnected;
-    }
-    if (message.includes("Failure_FirmwareError")) {
-      return import_hardware_wallet_core.HardwareErrorCode.FirmwareTooOld;
-    }
-    if (message.includes("Method_InvalidParameter") || message.includes("Method_InvalidParams")) {
-      return import_hardware_wallet_core.HardwareErrorCode.InvalidParams;
-    }
-    if (message.includes("Method_NotAllowed")) {
-      return import_hardware_wallet_core.HardwareErrorCode.MethodNotSupported;
-    }
-    return import_hardware_wallet_core.HardwareErrorCode.UnknownError;
-  }
-  /**
-   * Enrich error messages with actionable recovery info for the caller.
-   */
-  enrichErrorMessage(code, originalMessage) {
-    switch (code) {
-      case import_hardware_wallet_core.HardwareErrorCode.PinInvalid:
-        return `${originalMessage}. Please re-enter your PIN.`;
-      case import_hardware_wallet_core.HardwareErrorCode.PinCancelled:
-        return `${originalMessage}. PIN entry was cancelled.`;
-      case import_hardware_wallet_core.HardwareErrorCode.DeviceBusy:
-        return `${originalMessage}. The device is in use by another application. Close other wallet apps and try again.`;
-      case import_hardware_wallet_core.HardwareErrorCode.DeviceDisconnected:
-        return `${originalMessage}. Please reconnect the device and try again.`;
-      case import_hardware_wallet_core.HardwareErrorCode.TransportNotAvailable:
-        return `${originalMessage}. Ensure Trezor Bridge is installed and running, or connect via USB.`;
-      case import_hardware_wallet_core.HardwareErrorCode.FirmwareTooOld:
-        return `${originalMessage}. Please update your Trezor firmware via Trezor Suite.`;
-      case import_hardware_wallet_core.HardwareErrorCode.DeviceNotInitialized:
-        return `${originalMessage}. The device may need to be set up first via Trezor Suite.`;
-      default:
-        return originalMessage;
-    }
-  }
-  /**
-   * Generic batch call with progress reporting.
-   * If any single call fails, returns the failure immediately.
-   */
-  async batchCall(params, callFn, onProgress) {
-    const results = [];
-    for (let i = 0; i < params.length; i++) {
-      const result = await callFn(params[i]);
-      if (!result.success) {
-        return result;
-      }
-      results.push(result.payload);
-      onProgress?.({ index: i, total: params.length });
-    }
-    return (0, import_hardware_wallet_core.success)(results);
-  }
-  // ─── Hex formatting ──────────────────────────────────────
-  /** Ensure a hex string has the `0x` prefix. */
-  ensure0x(hex) {
-    return hex.startsWith("0x") ? hex : `0x${hex}`;
-  }
-  /** Ensure a hex string is `0x`-prefixed and zero-padded to 64 hex chars (32 bytes). */
-  padHex64(hex) {
-    const stripped = hex.startsWith("0x") ? hex.slice(2) : hex;
-    return `0x${stripped.padStart(64, "0")}`;
-  }
-  registerEventListeners() {
-    this.connector.on("device-connect", this.deviceConnectHandler);
-    this.connector.on("device-disconnect", this.deviceDisconnectHandler);
-    this.connector.on("ui-request", this.uiRequestHandler);
-    this.connector.on("ui-event", this.uiEventHandler);
-  }
-  unregisterEventListeners() {
-    this.connector.off("device-connect", this.deviceConnectHandler);
-    this.connector.off("device-disconnect", this.deviceDisconnectHandler);
-    this.connector.off("ui-request", this.uiRequestHandler);
-    this.connector.off("ui-event", this.uiEventHandler);
-  }
-  handleUiEvent(event) {
-    if (!event.type) return;
-    const payload = event.payload;
-    const devicePayload = payload?.["device"] ?? payload;
-    const deviceInfo = devicePayload ? this.extractDeviceInfoFromPayload(devicePayload) : this.unknownDevice();
-    switch (event.type) {
-      case "ui-request_pin":
-        this.emitter.emit(import_hardware_wallet_core.UI_REQUEST.REQUEST_PIN, {
-          type: import_hardware_wallet_core.UI_REQUEST.REQUEST_PIN,
-          payload: { device: deviceInfo }
-        });
-        if (this._uiHandler?.onPinRequest) {
-          this._uiHandler.onPinRequest(deviceInfo).then((pin) => {
-            this.connector.uiResponse({
-              type: "receive-pin",
-              payload: pin
-            });
-          }).catch(() => {
-          });
-        }
-        break;
-      case "ui-request_passphrase":
-        this.emitter.emit(import_hardware_wallet_core.UI_REQUEST.REQUEST_PASSPHRASE, {
-          type: import_hardware_wallet_core.UI_REQUEST.REQUEST_PASSPHRASE,
-          payload: { device: deviceInfo }
-        });
-        if (this._uiHandler?.onPassphraseRequest) {
-          this._uiHandler.onPassphraseRequest(deviceInfo).then((result) => {
-            const response = typeof result === "string" ? { passphrase: result, onDevice: false } : result ?? { passphrase: "", onDevice: false };
-            if (response.onDevice) {
-              this.connector.uiResponse({
-                type: "receive-passphrase",
-                payload: {
-                  value: "",
-                  passphraseOnDevice: true,
-                  save: false
-                }
-              });
-            } else {
-              this.connector.uiResponse({
-                type: "receive-passphrase",
-                payload: {
-                  value: response.passphrase,
-                  passphraseOnDevice: false,
-                  save: false
-                }
-              });
-            }
-          }).catch(() => {
-          });
-        }
-        break;
-      case "ui-request_confirmation":
-        this.emitter.emit(import_hardware_wallet_core.UI_REQUEST.REQUEST_BUTTON, {
-          type: import_hardware_wallet_core.UI_REQUEST.REQUEST_BUTTON,
-          payload: { device: deviceInfo }
-        });
-        break;
-    }
-  }
-  connectorDeviceToDeviceInfo(device) {
-    return {
-      vendor: "trezor",
-      model: device.model ?? "unknown",
-      firmwareVersion: "",
-      deviceId: device.deviceId,
-      connectId: device.connectId,
-      label: device.name,
-      connectionType: "usb"
-    };
-  }
-  extractDeviceInfoFromPayload(payload) {
-    const features = payload["features"];
-    return {
-      vendor: "trezor",
-      model: features?.["model"] ?? payload["model"] ?? "unknown",
-      firmwareVersion: features ? `${features["major_version"] ?? 0}.${features["minor_version"] ?? 0}.${features["patch_version"] ?? 0}` : "",
-      deviceId: features?.["device_id"] ?? payload["id"] ?? "",
-      connectId: payload["path"] ?? "",
-      label: features?.["label"] ?? payload["label"],
-      connectionType: "usb"
-    };
-  }
-  unknownDevice() {
-    return {
-      vendor: "trezor",
-      model: "unknown",
-      firmwareVersion: "",
-      deviceId: "",
-      connectId: "",
-      connectionType: "usb"
-    };
-  }
-};
-
-// src/TrezorProxyClient.ts
-var import_hardware_transport_core = require("@bytezhang/hardware-transport-core");
-var TrezorProxyClient = class extends import_hardware_transport_core.AbstractProxyClient {
-  // ─── TrezorConnect method stubs — all delegate to call() ────
-  ethereumGetAddress(params) {
-    return this.call("ethereumGetAddress", params);
-  }
-  ethereumGetPublicKey(params) {
-    return this.call("ethereumGetPublicKey", params);
-  }
-  ethereumSignTransaction(params) {
-    return this.call("ethereumSignTransaction", params);
-  }
-  ethereumSignMessage(params) {
-    return this.call("ethereumSignMessage", params);
-  }
-  ethereumSignTypedData(params) {
-    return this.call("ethereumSignTypedData", params);
-  }
-  getAddress(params) {
-    return this.call("getAddress", params);
-  }
-  getPublicKey(params) {
-    return this.call("getPublicKey", params);
-  }
-  signTransaction(params) {
-    return this.call("signTransaction", params);
-  }
-  signMessage(params) {
-    return this.call("signMessage", params);
-  }
-  solanaGetAddress(params) {
-    return this.call("solanaGetAddress", params);
-  }
-  solanaSignTransaction(params) {
-    return this.call("solanaSignTransaction", params);
+var VERSION = "0.0.1";
+var TrezorService = class {
+  constructor() {
+    throw new Error("TrezorService not yet implemented");
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  TrezorAdapter,
-  TrezorProxyClient
+  TrezorService,
+  VERSION
 });
 //# sourceMappingURL=index.js.map