@onekeyfe/hwk-trezor-connector 1.2.8-alpha.4 → 1.2.8-alpha.50

package/dist/index.d.mts

@@ -44,12 +44,6 @@ 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,12 +44,6 @@ 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_core2 = require("@onekeyfe/hwk-adapter-core");
+var import_hwk_adapter_core3 = require("@onekeyfe/hwk-adapter-core");
 var import_hwk_trezor_core = require("@onekeyfe/hwk-trezor-core");
 
 // src/chains/utils.ts
@@ -89,14 +89,12 @@ 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 = {
@@ -120,7 +118,8 @@ function normalizeBtcCoin(coin) {
   return BTC_COIN_NAME_ALIASES[coin.toLowerCase()] ?? coin;
 }
 function deriveScriptTypeFromPath(path) {
-  const normalized = path.startsWith("m/") ? path.slice(2) : path;
+  const trimmed = path.trim();
+  const normalized = /^m\//i.test(trimmed) ? trimmed.slice(2) : trimmed;
   const purpose = normalized.split("/")[0]?.replace(/['hH]$/, "");
   switch (purpose) {
     case "86":
@@ -132,8 +131,22 @@ function deriveScriptTypeFromPath(path) {
     case "44":
       return "p2pkh";
     default:
-      return "p2wpkh";
+      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 map[resolved];
 }
 async function btcGetAddress(ctx, params) {
   const request = readBtcGetAddressParams(params);
@@ -141,7 +154,7 @@ async function btcGetAddress(ctx, params) {
     address_n: parseBip32Path(request.path),
     coin_name: normalizeBtcCoin(request.coin),
     show_display: request.showOnDevice ?? false,
-    script_type: BTC_SCRIPT_TYPE_MAP[request.scriptType ?? deriveScriptTypeFromPath(request.path)]
+    script_type: resolveScriptType(BTC_SCRIPT_TYPE_MAP, request.scriptType, request.path)
   });
   if (response.type !== "Address") {
     throw new Error(`Expected Address response, received ${response.type}`);
@@ -174,7 +187,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: BTC_SCRIPT_TYPE_MAP[deriveScriptTypeFromPath(request.path)]
+    script_type: resolveScriptType(BTC_SCRIPT_TYPE_MAP, void 0, request.path)
   };
   if (request.noScriptType) {
     message.no_script_type = true;
@@ -419,7 +432,7 @@ function inputToTrezor(input) {
     prev_hash: input.prevHash,
     prev_index: input.prevIndex,
     amount: input.amount,
-    script_type: BTC_SCRIPT_TYPE_MAP[input.scriptType ?? deriveScriptTypeFromPath(input.path)]
+    script_type: resolveScriptType(BTC_SCRIPT_TYPE_MAP, input.scriptType, input.path)
   };
   if (input.sequence !== void 0) result.sequence = input.sequence;
   if (input.origHash !== void 0) result.orig_hash = input.origHash;
@@ -471,7 +484,11 @@ function outputToTrezor(output2) {
     return withOutputMetadata({
       address_n: parseBip32Path(output2.path),
       amount: output2.amount,
-      script_type: BTC_CHANGE_OUTPUT_SCRIPT_TYPE_MAP[output2.scriptType ?? deriveScriptTypeFromPath(output2.path)]
+      script_type: resolveScriptType(
+        BTC_CHANGE_OUTPUT_SCRIPT_TYPE_MAP,
+        output2.scriptType,
+        output2.path
+      )
     });
   }
   throw createInvalidParamsError(
@@ -662,6 +679,12 @@ 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");
@@ -2666,6 +2689,7 @@ 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", {
@@ -2712,10 +2736,37 @@ async function solSignTransaction(ctx, params) {
   }
   return { signature };
 }
-async function solSignMessage(_ctx, _params) {
-  throw createMethodNotSupportedError(
-    "Trezor firmware does not support Solana message signing \u2014 only solSignTransaction is available"
-  );
+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() };
 }
 function readSolGetAddressParams(params) {
   if (!params || typeof params !== "object") {
@@ -2746,6 +2797,25 @@ 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;
 }
@@ -7668,8 +7738,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_core2.createHwkError)({
-    code: import_hwk_adapter_core2.HardwareErrorCode.InvalidParams,
+  throw (0, import_hwk_adapter_core3.createHwkError)({
+    code: import_hwk_adapter_core3.HardwareErrorCode.InvalidParams,
     message: `Invalid Trezor passphrase mode: ${String(passphraseMode)}`
   });
 }
@@ -7685,8 +7755,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_core2.createHwkError)({
-      code: import_hwk_adapter_core2.HardwareErrorCode.UnknownError,
+    throw (0, import_hwk_adapter_core3.createHwkError)({
+      code: import_hwk_adapter_core3.HardwareErrorCode.UnknownError,
       message: `Invalid Trezor authenticity proof part size: ${String(size)}`
     });
   }
@@ -7714,15 +7784,15 @@ var readAuthenticityProofPart = async ({
       request
     );
     if (response.type !== "AuthenticityProofChunk") {
-      throw (0, import_hwk_adapter_core2.createHwkError)({
-        code: import_hwk_adapter_core2.HardwareErrorCode.UnknownError,
+      throw (0, import_hwk_adapter_core3.createHwkError)({
+        code: import_hwk_adapter_core3.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_core2.createHwkError)({
-        code: import_hwk_adapter_core2.HardwareErrorCode.UnknownError,
+      throw (0, import_hwk_adapter_core3.createHwkError)({
+        code: import_hwk_adapter_core3.HardwareErrorCode.UnknownError,
         message: "Trezor returned an invalid authenticity proof chunk"
       });
     }
@@ -7734,14 +7804,14 @@ var readAuthenticityProofPart = async ({
 var readAuthenticityProofStream = async (deviceSession, sizes) => {
   const readCertificates = async (proofType, values) => {
     if (!Array.isArray(values)) {
-      throw (0, import_hwk_adapter_core2.createHwkError)({
-        code: import_hwk_adapter_core2.HardwareErrorCode.UnknownError,
+      throw (0, import_hwk_adapter_core3.createHwkError)({
+        code: import_hwk_adapter_core3.HardwareErrorCode.UnknownError,
         message: "Trezor returned invalid authenticity certificate sizes"
       });
     }
     if (values.length > MAX_AUTHENTICITY_CERTIFICATE_COUNT) {
-      throw (0, import_hwk_adapter_core2.createHwkError)({
-        code: import_hwk_adapter_core2.HardwareErrorCode.UnknownError,
+      throw (0, import_hwk_adapter_core3.createHwkError)({
+        code: import_hwk_adapter_core3.HardwareErrorCode.UnknownError,
         message: `Trezor authenticity proof contains too many certificates: ${values.length}`
       });
     }
@@ -7790,13 +7860,13 @@ var TrezorConnectorBase = class {
   chunkSize;
   thp;
   // Single owned array — passed by reference into every TrezorThpSession via
-  // `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.
+  // `createThpOptions`. Both host updates and authoritative device updates
+  // replace its contents in-place so the next handshake sees fresh credentials
+  // without a connector rebuild.
   knownCredentials = [];
   deviceSessionFactory;
   eventHandlers = /* @__PURE__ */ new Map();
-  uiRequests = new import_hwk_adapter_core2.UiRequestRegistry();
+  uiRequests = new import_hwk_adapter_core3.UiRequestRegistry();
   devices = /* @__PURE__ */ new Map();
   sessions = /* @__PURE__ */ new Map();
   constructor(options = {}) {
@@ -7829,21 +7899,6 @@ 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;
   }
@@ -7979,14 +8034,14 @@ var TrezorConnectorBase = class {
         durationMs: Date.now() - startedAt,
         error: errorToLog(error)
       });
-      return { success: false, error: (0, import_hwk_adapter_core2.serializeConnectorError)(error) };
+      return { success: false, error: (0, import_hwk_adapter_core3.serializeConnectorError)(error) };
     }
   }
   async dispatchCall(sessionId, method, params) {
     const session = this.sessions.get(sessionId);
     if (!session) {
-      throw (0, import_hwk_adapter_core2.createHwkError)({
-        code: import_hwk_adapter_core2.HardwareErrorCode.DeviceNotFound,
+      throw (0, import_hwk_adapter_core3.createHwkError)({
+        code: import_hwk_adapter_core3.HardwareErrorCode.DeviceNotFound,
         message: `Trezor session not found: ${sessionId}`
       });
     }
@@ -8039,8 +8094,8 @@ var TrezorConnectorBase = class {
           return getTrezorResponseMessage(response);
         }
         if (response.type !== "AuthenticityProofSizes") {
-          throw (0, import_hwk_adapter_core2.createHwkError)({
-            code: import_hwk_adapter_core2.HardwareErrorCode.UnknownError,
+          throw (0, import_hwk_adapter_core3.createHwkError)({
+            code: import_hwk_adapter_core3.HardwareErrorCode.UnknownError,
             message: `Expected Trezor authenticity proof, received ${response.type}`
           });
         }
@@ -8072,8 +8127,8 @@ var TrezorConnectorBase = class {
         }
         const p = params ?? {};
         if (!p.thpSessionId) {
-          throw (0, import_hwk_adapter_core2.createHwkError)({
-            code: import_hwk_adapter_core2.HardwareErrorCode.InvalidParams,
+          throw (0, import_hwk_adapter_core3.createHwkError)({
+            code: import_hwk_adapter_core3.HardwareErrorCode.InvalidParams,
             message: "__thpSelectSession requires a thpSessionId"
           });
         }
@@ -8118,8 +8173,8 @@ var TrezorConnectorBase = class {
       case "tronSignMessage":
         return tronSignMessage(ctx, params);
       default:
-        throw (0, import_hwk_adapter_core2.createHwkError)({
-          code: import_hwk_adapter_core2.HardwareErrorCode.MethodNotSupported,
+        throw (0, import_hwk_adapter_core3.createHwkError)({
+          code: import_hwk_adapter_core3.HardwareErrorCode.MethodNotSupported,
           message: `TrezorConnector: method "${method}" is not implemented`
         });
     }
@@ -8143,8 +8198,8 @@ var TrezorConnectorBase = class {
     };
     this.log(hasAllRequired ? "info" : "warn", "capability.check", checkPayload);
     if (hasAllRequired) return;
-    throw (0, import_hwk_adapter_core2.createHwkError)({
-      code: import_hwk_adapter_core2.HardwareErrorCode.MethodNotSupported,
+    throw (0, import_hwk_adapter_core3.createHwkError)({
+      code: import_hwk_adapter_core3.HardwareErrorCode.MethodNotSupported,
       message: `Trezor device is missing required capability for ${method}: ${required.map((capability) => capability.name).join(", ")}`,
       params: {
         method,
@@ -8156,7 +8211,7 @@ var TrezorConnectorBase = class {
   async cancel(_sessionId) {
   }
   uiResponse(_response) {
-    if (_response.type === import_hwk_adapter_core2.UI_RESPONSE.CANCEL) {
+    if (_response.type === import_hwk_adapter_core3.UI_RESPONSE.CANCEL) {
       this.uiRequests.cancel();
       return;
     }
@@ -8202,8 +8257,8 @@ var TrezorConnectorBase = class {
       return device;
     }
     if (!device) {
-      throw (0, import_hwk_adapter_core2.createHwkError)({
-        code: import_hwk_adapter_core2.HardwareErrorCode.DeviceNotFound,
+      throw (0, import_hwk_adapter_core3.createHwkError)({
+        code: import_hwk_adapter_core3.HardwareErrorCode.DeviceNotFound,
         message: deviceId ? `Trezor device not found: ${deviceId}` : "No Trezor device found"
       });
     }
@@ -8221,8 +8276,9 @@ 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_core2.UI_REQUEST.REQUEST_TREZOR_THP_PAIRING,
+          type: import_hwk_adapter_core3.UI_REQUEST.REQUEST_TREZOR_THP_PAIRING,
           payload: {
             connectId: device.connectId,
             availableMethods: payload.availableMethods,
@@ -8230,12 +8286,12 @@ var TrezorConnectorBase = class {
             nfcData: payload.nfcData
           }
         });
-        return this.uiRequests.wait(import_hwk_adapter_core2.UI_REQUEST.REQUEST_TREZOR_THP_PAIRING);
+        return pairingPromise;
       },
       onButtonRequest: async (payload) => {
         await this.thp?.onButtonRequest?.(payload);
         this.emit("ui-request", {
-          type: import_hwk_adapter_core2.UI_REQUEST.REQUEST_BUTTON,
+          type: import_hwk_adapter_core3.UI_REQUEST.REQUEST_BUTTON,
           payload: {
             connectId: device.connectId,
             ...payload
@@ -8244,20 +8300,19 @@ var TrezorConnectorBase = class {
       },
       onButtonRequestComplete: async (payload) => {
         await this.thp?.onButtonRequestComplete?.(payload);
+        if (payload.responseType === "ButtonRequest") return;
         this.emit("ui-event", {
-          type: import_hwk_adapter_core2.EConnectorInteraction.InteractionComplete,
-          payload: {
-            sessionId: device.connectId
-          }
+          type: import_hwk_adapter_core3.EConnectorInteraction.InteractionComplete,
+          payload: { sessionId: "" }
         });
       },
       onPinMatrixRequest: async (payload) => {
         if (this.thp?.onPinMatrixRequest) {
           return this.thp.onPinMatrixRequest(payload);
         }
-        const pinPromise = this.uiRequests.wait(import_hwk_adapter_core2.UI_REQUEST.REQUEST_PIN);
+        const pinPromise = this.uiRequests.wait(import_hwk_adapter_core3.UI_REQUEST.REQUEST_PIN);
         this.emit("ui-request", {
-          type: import_hwk_adapter_core2.UI_REQUEST.REQUEST_PIN,
+          type: import_hwk_adapter_core3.UI_REQUEST.REQUEST_PIN,
           payload: {
             connectId: device.connectId,
             type: payload.type
@@ -8269,9 +8324,9 @@ var TrezorConnectorBase = class {
         if (this.thp?.onPassphraseRequest) {
           return this.thp.onPassphraseRequest(payload);
         }
-        const passphrasePromise = this.uiRequests.wait(import_hwk_adapter_core2.UI_REQUEST.REQUEST_PASSPHRASE);
+        const passphrasePromise = this.uiRequests.wait(import_hwk_adapter_core3.UI_REQUEST.REQUEST_PASSPHRASE);
         this.emit("ui-request", {
-          type: import_hwk_adapter_core2.UI_REQUEST.REQUEST_PASSPHRASE,
+          type: import_hwk_adapter_core3.UI_REQUEST.REQUEST_PASSPHRASE,
           payload: {
             connectId: device.connectId,
             ...payload
@@ -8281,12 +8336,21 @@ var TrezorConnectorBase = class {
         return res?.passphraseOnDevice ? { on_device: true } : { passphrase: res?.value ?? "" };
       },
       onPairingCredentialsChanged: async (payload) => {
-        this.mergeKnownCredentials(payload.credentials);
+        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);
         await this.thp?.onPairingCredentialsChanged?.(payload);
         this.emit("device-trezor-thp-credentials-changed", {
           connectId: device.connectId,
           deviceId: device.deviceId,
-          credentials: payload.credentials
+          credentials: payload.credentials,
+          removed: payload.removed
         });
       }
     };
@@ -8302,7 +8366,7 @@ var TrezorConnectorBase = class {
   emitSupportFeatures(session) {
     const features = session.deviceSession.features ?? session.features;
     session.features = features;
-    this.emit(import_hwk_adapter_core2.DEVICE.FEATURES, {
+    this.emit(import_hwk_adapter_core3.DEVICE.FEATURES, {
       device: {
         ...session.device,
         deviceId: readString(features, "device_id") ?? session.device.deviceId,
@@ -8325,9 +8389,9 @@ function connectorSessionToDevice(session) {
   };
 }
 function rejectKnownNonTrezorDevice(features) {
-  if (!(0, import_hwk_adapter_core2.isKnownNonTargetHardwareVendor)(features, "trezor")) return;
-  throw (0, import_hwk_adapter_core2.createHwkError)({
-    code: import_hwk_adapter_core2.HardwareErrorCode.DeviceMismatch,
+  if (!(0, import_hwk_adapter_core3.isKnownNonTargetHardwareVendor)(features, "trezor")) return;
+  throw (0, import_hwk_adapter_core3.createHwkError)({
+    code: import_hwk_adapter_core3.HardwareErrorCode.DeviceMismatch,
     message: "Selected device is not a supported Trezor device.",
     params: {
       vendor: features.vendor,