@bytezhang/hardware-trezor-adapter 0.0.1

package/dist/index.js

@@ -0,0 +1,697 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  TrezorAdapter: () => TrezorAdapter,
+  TrezorProxyClient: () => TrezorProxyClient
+});
+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();
+    // ─── 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);
+  }
+  // ─── EVM methods ──────────────────────────────────────────
+  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 ──────────────────────────────────────────
+  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 ───────────────────────────────────────
+  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);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TrezorAdapter,
+  TrezorProxyClient
+});
+//# sourceMappingURL=index.js.map