@onekeyfe/hwk-trezor-connector 1.2.8-alpha.1 → 1.2.8-alpha.2

package/dist/index.d.mts

@@ -44,6 +44,12 @@ declare abstract class TrezorConnectorBase implements IConnector {
      * the change too — we mutate, not replace.
      */
     setKnownCredentials(credentials: TrezorThpCredentials[]): void;
+    /**
+     * Push new credentials minted during pairing into the in-memory array.
+     * Deduplicates by the device-minted `credential` blob — the host has no
+     * other stable identity for a credential.
+     */
+    private mergeKnownCredentials;
     protected abstract enumerateDevices(): Promise<ConnectorDevice[]>;
     protected abstract createByteTransport(device: ConnectorDevice): Promise<TrezorConnectorByteTransport>;
     protected resolveUnlistedDevice(_deviceId: string): ConnectorDevice | undefined;

package/dist/index.d.ts

@@ -44,6 +44,12 @@ declare abstract class TrezorConnectorBase implements IConnector {
      * the change too — we mutate, not replace.
      */
     setKnownCredentials(credentials: TrezorThpCredentials[]): void;
+    /**
+     * Push new credentials minted during pairing into the in-memory array.
+     * Deduplicates by the device-minted `credential` blob — the host has no
+     * other stable identity for a credential.
+     */
+    private mergeKnownCredentials;
     protected abstract enumerateDevices(): Promise<ConnectorDevice[]>;
     protected abstract createByteTransport(device: ConnectorDevice): Promise<TrezorConnectorByteTransport>;
     protected resolveUnlistedDevice(_deviceId: string): ConnectorDevice | undefined;

package/dist/index.js

@@ -26,7 +26,7 @@ __export(index_exports, {
   shouldLogTrezorDebugEntry: () => import_hwk_trezor_core2.shouldLogTrezorDebugEntry
 });
 module.exports = __toCommonJS(index_exports);
-var import_hwk_adapter_core3 = require("@onekeyfe/hwk-adapter-core");
+var import_hwk_adapter_core2 = require("@onekeyfe/hwk-adapter-core");
 var import_hwk_trezor_core = require("@onekeyfe/hwk-trezor-core");
 
 // src/chains/utils.ts
@@ -89,12 +89,14 @@ var BTC_SCRIPT_TYPE_MAP = {
   p2pkh: "SPENDADDRESS",
   p2sh: "SPENDP2SHWITNESS",
   p2wpkh: "SPENDWITNESS",
+  p2wsh: "SPENDWITNESS",
   p2tr: "SPENDTAPROOT"
 };
 var BTC_CHANGE_OUTPUT_SCRIPT_TYPE_MAP = {
   p2pkh: "PAYTOADDRESS",
   p2sh: "PAYTOP2SHWITNESS",
   p2wpkh: "PAYTOWITNESS",
+  p2wsh: "PAYTOWITNESS",
   p2tr: "PAYTOTAPROOT"
 };
 var BTC_COIN_NAME_ALIASES = {
@@ -118,8 +120,7 @@ function normalizeBtcCoin(coin) {
   return BTC_COIN_NAME_ALIASES[coin.toLowerCase()] ?? coin;
 }
 function deriveScriptTypeFromPath(path) {
-  const trimmed = path.trim();
-  const normalized = /^m\//i.test(trimmed) ? trimmed.slice(2) : trimmed;
+  const normalized = path.startsWith("m/") ? path.slice(2) : path;
   const purpose = normalized.split("/")[0]?.replace(/['hH]$/, "");
   switch (purpose) {
     case "86":
@@ -131,22 +132,8 @@ function deriveScriptTypeFromPath(path) {
     case "44":
       return "p2pkh";
     default:
-      return void 0;
-  }
-}
-function resolveScriptType(map, scriptType, path) {
-  const resolved = scriptType ?? deriveScriptTypeFromPath(path);
-  if (!resolved) {
-    throw createInvalidParamsError(
-      `Cannot infer the BTC script type from ${path}; pass scriptType`
-    );
-  }
-  if (resolved === "p2wsh") {
-    throw createInvalidParamsError(
-      "BTC p2wsh needs a multisig script; a single key has no p2wsh form"
-    );
+      return "p2wpkh";
   }
-  return map[resolved];
 }
 async function btcGetAddress(ctx, params) {
   const request = readBtcGetAddressParams(params);
@@ -154,7 +141,7 @@ async function btcGetAddress(ctx, params) {
     address_n: parseBip32Path(request.path),
     coin_name: normalizeBtcCoin(request.coin),
     show_display: request.showOnDevice ?? false,
-    script_type: resolveScriptType(BTC_SCRIPT_TYPE_MAP, request.scriptType, request.path)
+    script_type: BTC_SCRIPT_TYPE_MAP[request.scriptType ?? deriveScriptTypeFromPath(request.path)]
   });
   if (response.type !== "Address") {
     throw new Error(`Expected Address response, received ${response.type}`);
@@ -187,7 +174,7 @@ async function btcSignMessage(ctx, params) {
     address_n: parseBip32Path(request.path),
     message: normalizeBtcMessage(request.message, request.hex ?? false),
     coin_name: normalizeBtcCoin(request.coin),
-    script_type: resolveScriptType(BTC_SCRIPT_TYPE_MAP, void 0, request.path)
+    script_type: BTC_SCRIPT_TYPE_MAP[deriveScriptTypeFromPath(request.path)]
   };
   if (request.noScriptType) {
     message.no_script_type = true;
@@ -432,7 +419,7 @@ function inputToTrezor(input) {
     prev_hash: input.prevHash,
     prev_index: input.prevIndex,
     amount: input.amount,
-    script_type: resolveScriptType(BTC_SCRIPT_TYPE_MAP, input.scriptType, input.path)
+    script_type: BTC_SCRIPT_TYPE_MAP[input.scriptType ?? deriveScriptTypeFromPath(input.path)]
   };
   if (input.sequence !== void 0) result.sequence = input.sequence;
   if (input.origHash !== void 0) result.orig_hash = input.origHash;
@@ -484,11 +471,7 @@ function outputToTrezor(output2) {
     return withOutputMetadata({
       address_n: parseBip32Path(output2.path),
       amount: output2.amount,
-      script_type: resolveScriptType(
-        BTC_CHANGE_OUTPUT_SCRIPT_TYPE_MAP,
-        output2.scriptType,
-        output2.path
-      )
+      script_type: BTC_CHANGE_OUTPUT_SCRIPT_TYPE_MAP[output2.scriptType ?? deriveScriptTypeFromPath(output2.path)]
     });
   }
   throw createInvalidParamsError(
@@ -679,12 +662,6 @@ function readBtcGetAddressParams(params) {
   if (typeof path !== "string" || path.trim().length === 0) {
     throw createInvalidParamsError("btcGetAddress requires a non-empty path");
   }
-  const { addressIndex, change } = params;
-  if (addressIndex !== void 0 || change !== void 0) {
-    throw createInvalidParamsError(
-      "Trezor btcGetAddress takes the full address path; addressIndex and change are not supported"
-    );
-  }
   const { coin } = params;
   if (coin !== void 0 && typeof coin !== "string") {
     throw createInvalidParamsError("btcGetAddress coin must be a string when provided");
@@ -2689,7 +2666,6 @@ function normalizeEthMessage(message, isHex) {
 }
 
 // src/chains/sol.ts
-var import_hwk_adapter_core2 = require("@onekeyfe/hwk-adapter-core");
 async function solGetAddress(ctx, params) {
   const request = readSolGetAddressParams(params);
   const response = await ctx.deviceSession.call("SolanaGetAddress", {
@@ -2736,37 +2712,10 @@ async function solSignTransaction(ctx, params) {
   }
   return { signature };
 }
-async function solSignMessage(ctx, params) {
-  const request = readSolSignMsgParams(params);
-  if (request.messageVersion !== 1) {
-    throw createMethodNotSupportedError(
-      "Trezor supports finalized Solana off-chain message version 1 only"
-    );
-  }
-  const preparedMessage = (0, import_hwk_adapter_core2.prepareSolanaOffchainMessageV1)({
-    message: (0, import_hwk_adapter_core2.hexToBytes)(request.message),
-    requiredSigners: request.requiredSigners
-  });
-  const response = await ctx.deviceSession.call("SolanaSignMessage", {
-    address_n: parseBip32Path(request.path),
-    message: {
-      message: preparedMessage.messageText,
-      signers: preparedMessage.requiredSigners
-    }
-  });
-  if (response.type !== "SolanaMessageSignature") {
-    throw new Error(`Expected SolanaMessageSignature response, received ${response.type}`);
-  }
-  const signature = readString(response.message, "signature");
-  if (!signature) {
-    throw new Error("SolanaMessageSignature response did not include a signature");
-  }
-  const signedData = readString(response.message, "signed_data");
-  const expectedSignedData = (0, import_hwk_adapter_core2.bytesToHex)(preparedMessage.serializedMessage);
-  if (!signedData || stripHexPrefix2(signedData).toLowerCase() !== expectedSignedData) {
-    throw new Error("Trezor signed data does not match the requested Solana off-chain message");
-  }
-  return { signature: stripHexPrefix2(signature).toLowerCase() };
+async function solSignMessage(_ctx, _params) {
+  throw createMethodNotSupportedError(
+    "Trezor firmware does not support Solana message signing \u2014 only solSignTransaction is available"
+  );
 }
 function readSolGetAddressParams(params) {
   if (!params || typeof params !== "object") {
@@ -2797,25 +2746,6 @@ function readSolSignTxParams(params) {
   assertHexString("serializedTx", serializedTx);
   return params;
 }
-function readSolSignMsgParams(params) {
-  if (!params || typeof params !== "object") {
-    throw createInvalidParamsError("solSignMessage params must be an object");
-  }
-  const request = params;
-  if (typeof request.path !== "string" || request.path.trim().length === 0) {
-    throw createInvalidParamsError("solSignMessage requires a non-empty path");
-  }
-  if (typeof request.message !== "string" || request.message.length === 0) {
-    throw createInvalidParamsError("solSignMessage requires message as a hex string");
-  }
-  assertHexString("message", request.message);
-  if (request.messageVersion === 1 && !Array.isArray(request.requiredSigners)) {
-    throw createInvalidParamsError(
-      "Solana off-chain message version 1 requires signer public keys"
-    );
-  }
-  return request;
-}
 function stripHexPrefix2(value) {
   return value.startsWith("0x") || value.startsWith("0X") ? value.slice(2) : value;
 }
@@ -7738,8 +7668,8 @@ var REQUIRED_DEVICE_CAPABILITIES = {
 function normalizePassphraseMode(passphraseMode) {
   if (passphraseMode === void 0) return "prompt";
   if (passphraseMode === "prompt" || passphraseMode === "empty") return passphraseMode;
-  throw (0, import_hwk_adapter_core3.createHwkError)({
-    code: import_hwk_adapter_core3.HardwareErrorCode.InvalidParams,
+  throw (0, import_hwk_adapter_core2.createHwkError)({
+    code: import_hwk_adapter_core2.HardwareErrorCode.InvalidParams,
     message: `Invalid Trezor passphrase mode: ${String(passphraseMode)}`
   });
 }
@@ -7755,8 +7685,8 @@ var MAX_AUTHENTICITY_PROOF_PART_SIZE = 64 * 1024;
 var MAX_AUTHENTICITY_CERTIFICATE_COUNT = 4;
 var validateAuthenticityProofPartSize = (size) => {
   if (typeof size !== "number" || !Number.isSafeInteger(size) || size < 0 || size > MAX_AUTHENTICITY_PROOF_PART_SIZE) {
-    throw (0, import_hwk_adapter_core3.createHwkError)({
-      code: import_hwk_adapter_core3.HardwareErrorCode.UnknownError,
+    throw (0, import_hwk_adapter_core2.createHwkError)({
+      code: import_hwk_adapter_core2.HardwareErrorCode.UnknownError,
       message: `Invalid Trezor authenticity proof part size: ${String(size)}`
     });
   }
@@ -7784,15 +7714,15 @@ var readAuthenticityProofPart = async ({
       request
     );
     if (response.type !== "AuthenticityProofChunk") {
-      throw (0, import_hwk_adapter_core3.createHwkError)({
-        code: import_hwk_adapter_core3.HardwareErrorCode.UnknownError,
+      throw (0, import_hwk_adapter_core2.createHwkError)({
+        code: import_hwk_adapter_core2.HardwareErrorCode.UnknownError,
         message: `Expected AuthenticityProofChunk, received ${response.type}`
       });
     }
     const chunk = response.message?.chunk;
     if (typeof chunk !== "string" || chunk.length !== requestedSize * 2) {
-      throw (0, import_hwk_adapter_core3.createHwkError)({
-        code: import_hwk_adapter_core3.HardwareErrorCode.UnknownError,
+      throw (0, import_hwk_adapter_core2.createHwkError)({
+        code: import_hwk_adapter_core2.HardwareErrorCode.UnknownError,
         message: "Trezor returned an invalid authenticity proof chunk"
       });
     }
@@ -7804,14 +7734,14 @@ var readAuthenticityProofPart = async ({
 var readAuthenticityProofStream = async (deviceSession, sizes) => {
   const readCertificates = async (proofType, values) => {
     if (!Array.isArray(values)) {
-      throw (0, import_hwk_adapter_core3.createHwkError)({
-        code: import_hwk_adapter_core3.HardwareErrorCode.UnknownError,
+      throw (0, import_hwk_adapter_core2.createHwkError)({
+        code: import_hwk_adapter_core2.HardwareErrorCode.UnknownError,
         message: "Trezor returned invalid authenticity certificate sizes"
       });
     }
     if (values.length > MAX_AUTHENTICITY_CERTIFICATE_COUNT) {
-      throw (0, import_hwk_adapter_core3.createHwkError)({
-        code: import_hwk_adapter_core3.HardwareErrorCode.UnknownError,
+      throw (0, import_hwk_adapter_core2.createHwkError)({
+        code: import_hwk_adapter_core2.HardwareErrorCode.UnknownError,
         message: `Trezor authenticity proof contains too many certificates: ${values.length}`
       });
     }
@@ -7860,13 +7790,13 @@ var TrezorConnectorBase = class {
   chunkSize;
   thp;
   // Single owned array — passed by reference into every TrezorThpSession via
-  // `createThpOptions`. Both host updates and authoritative device updates
-  // replace its contents in-place so the next handshake sees fresh credentials
-  // without a connector rebuild.
+  // `createThpOptions`. setKnownCredentials() and the auto-merge inside
+  // onPairingCredentialsChanged both mutate this array in-place so the next
+  // handshake sees fresh credentials without a connector rebuild.
   knownCredentials = [];
   deviceSessionFactory;
   eventHandlers = /* @__PURE__ */ new Map();
-  uiRequests = new import_hwk_adapter_core3.UiRequestRegistry();
+  uiRequests = new import_hwk_adapter_core2.UiRequestRegistry();
   devices = /* @__PURE__ */ new Map();
   sessions = /* @__PURE__ */ new Map();
   constructor(options = {}) {
@@ -7899,6 +7829,21 @@ var TrezorConnectorBase = class {
       this.knownCredentials.push(...credentials);
     }
   }
+  /**
+   * Push new credentials minted during pairing into the in-memory array.
+   * Deduplicates by the device-minted `credential` blob — the host has no
+   * other stable identity for a credential.
+   */
+  mergeKnownCredentials(incoming) {
+    for (const cred of incoming) {
+      const blob = cred.credential;
+      if (!blob) continue;
+      const exists2 = this.knownCredentials.some(
+        (existing) => existing.credential === blob
+      );
+      if (!exists2) this.knownCredentials.push(cred);
+    }
+  }
   resolveUnlistedDevice(_deviceId) {
     return void 0;
   }
@@ -8034,14 +7979,14 @@ var TrezorConnectorBase = class {
         durationMs: Date.now() - startedAt,
         error: errorToLog(error)
       });
-      return { success: false, error: (0, import_hwk_adapter_core3.serializeConnectorError)(error) };
+      return { success: false, error: (0, import_hwk_adapter_core2.serializeConnectorError)(error) };
     }
   }
   async dispatchCall(sessionId, method, params) {
     const session = this.sessions.get(sessionId);
     if (!session) {
-      throw (0, import_hwk_adapter_core3.createHwkError)({
-        code: import_hwk_adapter_core3.HardwareErrorCode.DeviceNotFound,
+      throw (0, import_hwk_adapter_core2.createHwkError)({
+        code: import_hwk_adapter_core2.HardwareErrorCode.DeviceNotFound,
         message: `Trezor session not found: ${sessionId}`
       });
     }
@@ -8094,8 +8039,8 @@ var TrezorConnectorBase = class {
           return getTrezorResponseMessage(response);
         }
         if (response.type !== "AuthenticityProofSizes") {
-          throw (0, import_hwk_adapter_core3.createHwkError)({
-            code: import_hwk_adapter_core3.HardwareErrorCode.UnknownError,
+          throw (0, import_hwk_adapter_core2.createHwkError)({
+            code: import_hwk_adapter_core2.HardwareErrorCode.UnknownError,
             message: `Expected Trezor authenticity proof, received ${response.type}`
           });
         }
@@ -8127,8 +8072,8 @@ var TrezorConnectorBase = class {
         }
         const p = params ?? {};
         if (!p.thpSessionId) {
-          throw (0, import_hwk_adapter_core3.createHwkError)({
-            code: import_hwk_adapter_core3.HardwareErrorCode.InvalidParams,
+          throw (0, import_hwk_adapter_core2.createHwkError)({
+            code: import_hwk_adapter_core2.HardwareErrorCode.InvalidParams,
             message: "__thpSelectSession requires a thpSessionId"
           });
         }
@@ -8173,8 +8118,8 @@ var TrezorConnectorBase = class {
       case "tronSignMessage":
         return tronSignMessage(ctx, params);
       default:
-        throw (0, import_hwk_adapter_core3.createHwkError)({
-          code: import_hwk_adapter_core3.HardwareErrorCode.MethodNotSupported,
+        throw (0, import_hwk_adapter_core2.createHwkError)({
+          code: import_hwk_adapter_core2.HardwareErrorCode.MethodNotSupported,
           message: `TrezorConnector: method "${method}" is not implemented`
         });
     }
@@ -8198,8 +8143,8 @@ var TrezorConnectorBase = class {
     };
     this.log(hasAllRequired ? "info" : "warn", "capability.check", checkPayload);
     if (hasAllRequired) return;
-    throw (0, import_hwk_adapter_core3.createHwkError)({
-      code: import_hwk_adapter_core3.HardwareErrorCode.MethodNotSupported,
+    throw (0, import_hwk_adapter_core2.createHwkError)({
+      code: import_hwk_adapter_core2.HardwareErrorCode.MethodNotSupported,
       message: `Trezor device is missing required capability for ${method}: ${required.map((capability) => capability.name).join(", ")}`,
       params: {
         method,
@@ -8211,7 +8156,7 @@ var TrezorConnectorBase = class {
   async cancel(_sessionId) {
   }
   uiResponse(_response) {
-    if (_response.type === import_hwk_adapter_core3.UI_RESPONSE.CANCEL) {
+    if (_response.type === import_hwk_adapter_core2.UI_RESPONSE.CANCEL) {
       this.uiRequests.cancel();
       return;
     }
@@ -8257,8 +8202,8 @@ var TrezorConnectorBase = class {
       return device;
     }
     if (!device) {
-      throw (0, import_hwk_adapter_core3.createHwkError)({
-        code: import_hwk_adapter_core3.HardwareErrorCode.DeviceNotFound,
+      throw (0, import_hwk_adapter_core2.createHwkError)({
+        code: import_hwk_adapter_core2.HardwareErrorCode.DeviceNotFound,
         message: deviceId ? `Trezor device not found: ${deviceId}` : "No Trezor device found"
       });
     }
@@ -8276,9 +8221,8 @@ var TrezorConnectorBase = class {
         if (this.thp?.onPairingRequest) {
           return this.thp.onPairingRequest(payload);
         }
-        const pairingPromise = this.uiRequests.wait(import_hwk_adapter_core3.UI_REQUEST.REQUEST_TREZOR_THP_PAIRING);
         this.emit("ui-request", {
-          type: import_hwk_adapter_core3.UI_REQUEST.REQUEST_TREZOR_THP_PAIRING,
+          type: import_hwk_adapter_core2.UI_REQUEST.REQUEST_TREZOR_THP_PAIRING,
           payload: {
             connectId: device.connectId,
             availableMethods: payload.availableMethods,
@@ -8286,12 +8230,12 @@ var TrezorConnectorBase = class {
             nfcData: payload.nfcData
           }
         });
-        return pairingPromise;
+        return this.uiRequests.wait(import_hwk_adapter_core2.UI_REQUEST.REQUEST_TREZOR_THP_PAIRING);
       },
       onButtonRequest: async (payload) => {
         await this.thp?.onButtonRequest?.(payload);
         this.emit("ui-request", {
-          type: import_hwk_adapter_core3.UI_REQUEST.REQUEST_BUTTON,
+          type: import_hwk_adapter_core2.UI_REQUEST.REQUEST_BUTTON,
           payload: {
             connectId: device.connectId,
             ...payload
@@ -8300,19 +8244,20 @@ var TrezorConnectorBase = class {
       },
       onButtonRequestComplete: async (payload) => {
         await this.thp?.onButtonRequestComplete?.(payload);
-        if (payload.responseType === "ButtonRequest") return;
         this.emit("ui-event", {
-          type: import_hwk_adapter_core3.EConnectorInteraction.InteractionComplete,
-          payload: { sessionId: "" }
+          type: import_hwk_adapter_core2.EConnectorInteraction.InteractionComplete,
+          payload: {
+            sessionId: device.connectId
+          }
         });
       },
       onPinMatrixRequest: async (payload) => {
         if (this.thp?.onPinMatrixRequest) {
           return this.thp.onPinMatrixRequest(payload);
         }
-        const pinPromise = this.uiRequests.wait(import_hwk_adapter_core3.UI_REQUEST.REQUEST_PIN);
+        const pinPromise = this.uiRequests.wait(import_hwk_adapter_core2.UI_REQUEST.REQUEST_PIN);
         this.emit("ui-request", {
-          type: import_hwk_adapter_core3.UI_REQUEST.REQUEST_PIN,
+          type: import_hwk_adapter_core2.UI_REQUEST.REQUEST_PIN,
           payload: {
             connectId: device.connectId,
             type: payload.type
@@ -8324,9 +8269,9 @@ var TrezorConnectorBase = class {
         if (this.thp?.onPassphraseRequest) {
           return this.thp.onPassphraseRequest(payload);
         }
-        const passphrasePromise = this.uiRequests.wait(import_hwk_adapter_core3.UI_REQUEST.REQUEST_PASSPHRASE);
+        const passphrasePromise = this.uiRequests.wait(import_hwk_adapter_core2.UI_REQUEST.REQUEST_PASSPHRASE);
         this.emit("ui-request", {
-          type: import_hwk_adapter_core3.UI_REQUEST.REQUEST_PASSPHRASE,
+          type: import_hwk_adapter_core2.UI_REQUEST.REQUEST_PASSPHRASE,
           payload: {
             connectId: device.connectId,
             ...payload
@@ -8336,15 +8281,7 @@ var TrezorConnectorBase = class {
         return res?.passphraseOnDevice ? { on_device: true } : { passphrase: res?.value ?? "" };
       },
       onPairingCredentialsChanged: async (payload) => {
-        const blob = (cred) => cred.credential;
-        const rejected = new Set((payload.removed ?? []).map(blob));
-        const merged = this.knownCredentials.filter((cred) => !rejected.has(blob(cred)));
-        for (const cred of payload.credentials) {
-          if (blob(cred) && !merged.some((existing) => blob(existing) === blob(cred))) {
-            merged.push(cred);
-          }
-        }
-        this.setKnownCredentials(merged);
+        this.mergeKnownCredentials(payload.credentials);
         await this.thp?.onPairingCredentialsChanged?.(payload);
         this.emit("device-trezor-thp-credentials-changed", {
           connectId: device.connectId,
@@ -8365,7 +8302,7 @@ var TrezorConnectorBase = class {
   emitSupportFeatures(session) {
     const features = session.deviceSession.features ?? session.features;
     session.features = features;
-    this.emit(import_hwk_adapter_core3.DEVICE.FEATURES, {
+    this.emit(import_hwk_adapter_core2.DEVICE.FEATURES, {
       device: {
         ...session.device,
         deviceId: readString(features, "device_id") ?? session.device.deviceId,
@@ -8388,9 +8325,9 @@ function connectorSessionToDevice(session) {
   };
 }
 function rejectKnownNonTrezorDevice(features) {
-  if (!(0, import_hwk_adapter_core3.isKnownNonTargetHardwareVendor)(features, "trezor")) return;
-  throw (0, import_hwk_adapter_core3.createHwkError)({
-    code: import_hwk_adapter_core3.HardwareErrorCode.DeviceMismatch,
+  if (!(0, import_hwk_adapter_core2.isKnownNonTargetHardwareVendor)(features, "trezor")) return;
+  throw (0, import_hwk_adapter_core2.createHwkError)({
+    code: import_hwk_adapter_core2.HardwareErrorCode.DeviceMismatch,
     message: "Selected device is not a supported Trezor device.",
     params: {
       vendor: features.vendor,