@onekeyfe/hwk-trezor-connector 1.1.27-alpha.100

package/dist/index.js

@@ -0,0 +1,1671 @@
+"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, {
+  TrezorConnectorBase: () => TrezorConnectorBase
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/chains/btc.ts
+var import_hwk_adapter_core = require("@onekeyfe/hwk-adapter-core");
+
+// src/chains/utils.ts
+function parseBip32Path(path) {
+  const normalized = path.trim();
+  const parts = normalized.startsWith("m/") ? normalized.slice(2).split("/") : normalized === "m" ? [] : normalized.split("/");
+  if (parts.length === 0 || parts.some((part) => part.length === 0)) {
+    throw new Error(`Invalid BIP32 path: ${path}`);
+  }
+  return parts.map((part) => {
+    const match = part.match(/^(\d+)(['hH]?)$/);
+    if (!match) {
+      throw new Error(`Invalid BIP32 path segment: ${part}`);
+    }
+    const index = Number(match[1]);
+    if (!Number.isSafeInteger(index) || index < 0 || index > 2147483647) {
+      throw new Error(`BIP32 path segment out of range: ${part}`);
+    }
+    return match[2] ? index + 2147483648 : index;
+  });
+}
+function readString(value, key) {
+  const candidate = value[key];
+  return typeof candidate === "string" ? candidate : void 0;
+}
+function readNumber(value, key) {
+  const candidate = value[key];
+  return typeof candidate === "number" ? candidate : void 0;
+}
+
+// src/chains/btc.ts
+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 = {
+  btc: "Bitcoin",
+  bitcoin: "Bitcoin",
+  test: "Testnet",
+  tbtc: "Testnet",
+  testnet: "Testnet",
+  sbtc: "Signet",
+  signet: "Signet",
+  ltc: "Litecoin",
+  litecoin: "Litecoin",
+  doge: "Dogecoin",
+  dogecoin: "Dogecoin",
+  bch: "Bcash",
+  bcash: "Bcash",
+  dash: "Dash"
+};
+function normalizeBtcCoin(coin) {
+  if (!coin) return "Bitcoin";
+  return BTC_COIN_NAME_ALIASES[coin.toLowerCase()] ?? coin;
+}
+function deriveScriptTypeFromPath(path) {
+  if (path.includes("86'")) return "p2tr";
+  if (path.includes("84'")) return "p2wpkh";
+  if (path.includes("49'")) return "p2sh";
+  if (path.includes("44'")) return "p2pkh";
+  return "p2wpkh";
+}
+async function btcGetAddress(ctx, params) {
+  const request = readBtcGetAddressParams(params);
+  const response = await ctx.deviceSession.call("GetAddress", {
+    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)]
+  });
+  if (response.type !== "Address") {
+    throw new Error(`Expected Address response, received ${response.type}`);
+  }
+  const message = response.message;
+  const address = readString(message, "address");
+  if (!address) {
+    throw new Error("Address response did not include an address");
+  }
+  return {
+    address,
+    path: request.path
+  };
+}
+async function btcGetPublicKey(ctx, params) {
+  const request = readBtcGetPublicKeyParams(params);
+  const response = await ctx.deviceSession.call("GetPublicKey", {
+    address_n: parseBip32Path(request.path),
+    coin_name: normalizeBtcCoin(request.coin),
+    show_display: request.showOnDevice ?? false
+  });
+  if (response.type !== "PublicKey") {
+    throw new Error(`Expected PublicKey response, received ${response.type}`);
+  }
+  return mapPublicKey(response.message, request.path);
+}
+async function btcSignMessage(ctx, params) {
+  const request = readBtcSignMessageParams(params);
+  const response = await ctx.deviceSession.call("SignMessage", {
+    address_n: parseBip32Path(request.path),
+    message: request.message,
+    coin_name: normalizeBtcCoin(request.coin)
+  });
+  if (response.type !== "MessageSignature") {
+    throw new Error(`Expected MessageSignature response, received ${response.type}`);
+  }
+  const msg = response.message;
+  const signature = readString(msg, "signature");
+  if (!signature) {
+    throw new Error("MessageSignature response did not include a signature");
+  }
+  return {
+    signature,
+    address: readString(msg, "address")
+  };
+}
+async function btcGetMasterFingerprint(ctx) {
+  const response = await ctx.deviceSession.call("GetPublicKey", {
+    address_n: parseBip32Path("m/44'/0'/0'"),
+    coin_name: "Bitcoin",
+    show_display: false
+  });
+  if (response.type !== "PublicKey") {
+    throw new Error(`Expected PublicKey response, received ${response.type}`);
+  }
+  const root = readNumber(response.message, "root_fingerprint");
+  if (root === void 0) {
+    throw new Error(
+      "btcGetMasterFingerprint: Trezor PublicKey response omitted root_fingerprint \u2014 firmware too old?"
+    );
+  }
+  return { masterFingerprint: root.toString(16).padStart(8, "0") };
+}
+async function btcSignTransaction(ctx, params) {
+  const request = readBtcSignTxParams(params);
+  const { inputs, outputs } = request;
+  const refTxs = indexRefTxs(request.refTxs ?? []);
+  const serializedParts = [];
+  const signatures = [];
+  const initial = {
+    coin_name: normalizeBtcCoin(request.coin),
+    inputs_count: inputs.length,
+    outputs_count: outputs.length,
+    version: request.version ?? 1
+  };
+  if (request.locktime !== void 0) {
+    initial.lock_time = request.locktime;
+  }
+  let response = await ctx.deviceSession.call("SignTx", initial);
+  const maxRounds = (inputs.length + outputs.length + 1) * 8 + 64;
+  for (let round = 0; round < maxRounds; round += 1) {
+    if (response.type !== "TxRequest") {
+      throw new Error(`Expected TxRequest during SignTx, received ${response.type}`);
+    }
+    const txRequest = response.message;
+    saveTxSignatures(txRequest.serialized, serializedParts, signatures);
+    const requestType = readString(txRequest, "request_type");
+    if (requestType === "TXFINISHED") {
+      return { serializedTx: serializedParts.join(""), signatures };
+    }
+    const details = txRequest.details ?? {};
+    const requestIndex = readNumber(details, "request_index") ?? 0;
+    const txHash = readString(details, "tx_hash");
+    response = await sendTxAck(
+      ctx,
+      requestType,
+      requestIndex,
+      txHash,
+      inputs,
+      outputs,
+      refTxs
+    );
+  }
+  throw new Error("btcSignTransaction: device exceeded the expected number of TxRequest rounds");
+}
+function saveTxSignatures(serialized, serializedParts, signatures) {
+  if (!serialized || typeof serialized !== "object") return;
+  const s = serialized;
+  const chunk = readString(s, "serialized_tx");
+  if (chunk) serializedParts.push(chunk);
+  const index = readNumber(s, "signature_index");
+  const signature = readString(s, "signature");
+  if (index !== void 0 && signature) {
+    signatures[index] = signature;
+  }
+}
+async function sendTxAck(ctx, requestType, requestIndex, txHash, inputs, outputs, refTxs) {
+  switch (requestType) {
+    case "TXINPUT": {
+      if (txHash) {
+        const prev = lookupRefTx(refTxs, txHash);
+        const input2 = prev.inputs[requestIndex];
+        if (!input2) {
+          throw new Error(`SignTx requested prev input ${requestIndex} missing in ${txHash}`);
+        }
+        return ctx.deviceSession.call("TxAckPrevInput", {
+          tx: {
+            input: {
+              prev_hash: input2.prevHash,
+              prev_index: input2.prevIndex,
+              script_sig: input2.script,
+              sequence: input2.sequence
+            }
+          }
+        });
+      }
+      const input = inputs[requestIndex];
+      if (!input) throw new Error(`SignTx requested input ${requestIndex} out of range`);
+      return ctx.deviceSession.call("TxAckInput", {
+        tx: { input: inputToTrezor(input) }
+      });
+    }
+    case "TXOUTPUT": {
+      if (txHash) {
+        const prev = lookupRefTx(refTxs, txHash);
+        const output2 = prev.outputs[requestIndex];
+        if (!output2) {
+          throw new Error(`SignTx requested prev output ${requestIndex} missing in ${txHash}`);
+        }
+        return ctx.deviceSession.call("TxAckPrevOutput", {
+          tx: { output: { amount: output2.amount, script_pubkey: output2.scriptPubKey } }
+        });
+      }
+      const output = outputs[requestIndex];
+      if (!output) throw new Error(`SignTx requested output ${requestIndex} out of range`);
+      return ctx.deviceSession.call("TxAckOutput", {
+        tx: { output: outputToTrezor(output) }
+      });
+    }
+    case "TXMETA": {
+      if (!txHash) throw new Error("SignTx TXMETA request missing tx_hash");
+      const prev = lookupRefTx(refTxs, txHash);
+      return ctx.deviceSession.call("TxAckPrevMeta", {
+        tx: {
+          version: prev.version,
+          lock_time: prev.locktime,
+          inputs_count: prev.inputs.length,
+          outputs_count: prev.outputs.length
+        }
+      });
+    }
+    case "TXEXTRADATA":
+      throw Object.assign(
+        new Error(
+          "btcSignTransaction: device requested extra_data, but the adapter params carry none (Zcash/Dash not supported)"
+        ),
+        { code: import_hwk_adapter_core.HardwareErrorCode.MethodNotSupported }
+      );
+    default:
+      throw new Error(`btcSignTransaction: unsupported TxRequest type "${requestType}"`);
+  }
+}
+function inputToTrezor(input) {
+  const result = {
+    address_n: parseBip32Path(input.path),
+    prev_hash: input.prevHash,
+    prev_index: input.prevIndex,
+    amount: input.amount,
+    script_type: BTC_SCRIPT_TYPE_MAP[input.scriptType ?? deriveScriptTypeFromPath(input.path)]
+  };
+  if (input.sequence !== void 0) result.sequence = input.sequence;
+  return result;
+}
+function outputToTrezor(output) {
+  if (output.address) {
+    return {
+      address: output.address,
+      amount: output.amount,
+      script_type: "PAYTOADDRESS"
+    };
+  }
+  if (output.path) {
+    return {
+      address_n: parseBip32Path(output.path),
+      amount: output.amount,
+      script_type: BTC_CHANGE_OUTPUT_SCRIPT_TYPE_MAP[output.scriptType ?? deriveScriptTypeFromPath(output.path)]
+    };
+  }
+  throw new Error("btcSignTransaction output requires either an address or a change path");
+}
+function indexRefTxs(refTxs) {
+  const map = /* @__PURE__ */ new Map();
+  for (const tx of refTxs) {
+    map.set(tx.hash.toLowerCase(), tx);
+  }
+  return map;
+}
+function lookupRefTx(map, txHash) {
+  const tx = map.get(txHash.toLowerCase());
+  if (!tx) {
+    throw new Error(`btcSignTransaction: device requested unknown previous tx ${txHash}`);
+  }
+  return tx;
+}
+function readBtcSignTxParams(params) {
+  if (!params || typeof params !== "object") {
+    throw new Error("btcSignTransaction params must be an object");
+  }
+  const p = params;
+  if (!Array.isArray(p.inputs) || p.inputs.length === 0) {
+    throw new Error("btcSignTransaction requires a non-empty inputs array");
+  }
+  if (!Array.isArray(p.outputs) || p.outputs.length === 0) {
+    throw new Error("btcSignTransaction requires a non-empty outputs array");
+  }
+  return p;
+}
+async function btcSignPsbt(_ctx, _params) {
+  throw Object.assign(
+    new Error(
+      "btcSignPsbt is not wired for Trezor \u2014 stock Trezor firmware has no SignPsbt message; PSBT signing requires host-side decode \u2192 SignTx \u2192 re-embed (not yet implemented)"
+    ),
+    { code: import_hwk_adapter_core.HardwareErrorCode.MethodNotSupported }
+  );
+}
+function readBtcGetPublicKeyParams(params) {
+  if (!params || typeof params !== "object") {
+    throw new Error("btcGetPublicKey params must be an object");
+  }
+  const path = params.path;
+  if (typeof path !== "string" || path.trim().length === 0) {
+    throw new Error("btcGetPublicKey requires a non-empty path");
+  }
+  const coin = params.coin;
+  if (coin !== void 0 && typeof coin !== "string") {
+    throw new Error("btcGetPublicKey coin must be a string when provided");
+  }
+  const showOnDevice = params.showOnDevice;
+  if (showOnDevice !== void 0 && typeof showOnDevice !== "boolean") {
+    throw new Error("btcGetPublicKey showOnDevice must be a boolean when provided");
+  }
+  return { path, coin, showOnDevice };
+}
+function readBtcSignMessageParams(params) {
+  if (!params || typeof params !== "object") {
+    throw new Error("btcSignMessage params must be an object");
+  }
+  const path = params.path;
+  if (typeof path !== "string" || path.trim().length === 0) {
+    throw new Error("btcSignMessage requires a non-empty path");
+  }
+  const message = params.message;
+  if (typeof message !== "string") {
+    throw new Error("btcSignMessage requires message as a string");
+  }
+  const coin = params.coin;
+  if (coin !== void 0 && typeof coin !== "string") {
+    throw new Error("btcSignMessage coin must be a string when provided");
+  }
+  return { path, message, coin };
+}
+function mapPublicKey(msg, path) {
+  const xpub = readString(msg, "xpub");
+  if (!xpub) {
+    throw new Error("PublicKey response did not include xpub");
+  }
+  const node = msg.node;
+  if (!node || typeof node !== "object") {
+    throw new Error("PublicKey response did not include a node");
+  }
+  const publicKey = readString(node, "public_key");
+  const chainCode = readString(node, "chain_code");
+  const fingerprint = readNumber(node, "fingerprint");
+  const depth = readNumber(node, "depth");
+  if (!publicKey || !chainCode || fingerprint === void 0 || depth === void 0) {
+    throw new Error("PublicKey node missing required fields (public_key / chain_code / fingerprint / depth)");
+  }
+  return {
+    xpub,
+    publicKey,
+    fingerprint,
+    chainCode,
+    path,
+    depth
+  };
+}
+function readBtcGetAddressParams(params) {
+  if (!params || typeof params !== "object") {
+    throw new Error("btcGetAddress params must be an object");
+  }
+  const path = params.path;
+  if (typeof path !== "string" || path.trim().length === 0) {
+    throw new Error("btcGetAddress requires a non-empty path");
+  }
+  const coin = params.coin;
+  if (coin !== void 0 && typeof coin !== "string") {
+    throw new Error("btcGetAddress coin must be a string when provided");
+  }
+  const showOnDevice = params.showOnDevice;
+  if (showOnDevice !== void 0 && typeof showOnDevice !== "boolean") {
+    throw new Error("btcGetAddress showOnDevice must be a boolean when provided");
+  }
+  const scriptType = params.scriptType;
+  if (scriptType !== void 0 && typeof scriptType !== "string") {
+    throw new Error("btcGetAddress scriptType must be a string when provided");
+  }
+  if (scriptType !== void 0 && !Object.prototype.hasOwnProperty.call(BTC_SCRIPT_TYPE_MAP, scriptType)) {
+    throw new Error("btcGetAddress scriptType is unsupported");
+  }
+  return {
+    path,
+    coin,
+    showOnDevice,
+    scriptType
+  };
+}
+
+// src/chains/eip712.ts
+var import_buffer = require("buffer");
+var EthereumDataType = {
+  UINT: 1,
+  INT: 2,
+  BYTES: 3,
+  STRING: 4,
+  BOOL: 5,
+  ADDRESS: 6,
+  ARRAY: 7,
+  STRUCT: 8
+};
+var paramTypeArray = /^(.*)\[([0-9]*)\]$/;
+var paramTypeBytes = /^bytes([0-9]*)$/;
+var paramTypeNumber = /^(u?int)([0-9]*)$/;
+var simpleTypesMap = {
+  string: EthereumDataType.STRING,
+  bool: EthereumDataType.BOOL,
+  address: EthereumDataType.ADDRESS
+};
+function parseArrayType(arrayTypeName) {
+  const match = paramTypeArray.exec(arrayTypeName);
+  if (!match) {
+    throw new Error(`Type ${arrayTypeName} is not an EIP-712 array`);
+  }
+  const [, entryTypeName, arraySize] = match;
+  return {
+    entryTypeName,
+    arraySize: parseInt(arraySize, 10) || null
+  };
+}
+function getFieldType(typeName, types) {
+  const arrayMatch = paramTypeArray.exec(typeName);
+  if (arrayMatch) {
+    const [, entryTypeName, arraySize] = arrayMatch;
+    return {
+      data_type: EthereumDataType.ARRAY,
+      size: parseInt(arraySize, 10) || void 0,
+      entry_type: getFieldType(entryTypeName, types)
+    };
+  }
+  const numberMatch = paramTypeNumber.exec(typeName);
+  if (numberMatch) {
+    const [, intType, bits] = numberMatch;
+    return {
+      data_type: intType === "uint" ? EthereumDataType.UINT : EthereumDataType.INT,
+      size: Math.floor(parseInt(bits, 10) / 8)
+    };
+  }
+  const bytesMatch = paramTypeBytes.exec(typeName);
+  if (bytesMatch) {
+    const [, size] = bytesMatch;
+    return {
+      data_type: EthereumDataType.BYTES,
+      size: parseInt(size, 10) || void 0
+    };
+  }
+  const simple = simpleTypesMap[typeName];
+  if (simple !== void 0) {
+    return { data_type: simple };
+  }
+  if (typeName in types) {
+    return {
+      data_type: EthereumDataType.STRUCT,
+      size: types[typeName].length,
+      struct_name: typeName
+    };
+  }
+  throw new Error(`EIP-712: type "${typeName}" is not defined`);
+}
+function encodeData(typeName, value) {
+  if (paramTypeBytes.test(typeName) || typeName === "address") {
+    if (typeof value !== "string") {
+      throw new Error(`EIP-712 encodeData ${typeName}: expected hex string`);
+    }
+    return formatHex(value);
+  }
+  if (typeName === "string") {
+    if (typeof value !== "string") {
+      throw new Error("EIP-712 encodeData string: expected string value");
+    }
+    return import_buffer.Buffer.from(value, "utf-8").toString("hex");
+  }
+  const numberMatch = paramTypeNumber.exec(typeName);
+  if (numberMatch) {
+    const [, intType, bits] = numberMatch;
+    const bytes = Math.ceil(parseInt(bits, 10) / 8);
+    return intToHex(value, bytes, intType === "int");
+  }
+  if (typeName === "bool") {
+    return value ? "01" : "00";
+  }
+  throw new Error(`EIP-712 encodeData: unsupported atomic type "${typeName}"`);
+}
+function formatHex(value) {
+  let v = value.startsWith("0x") || value.startsWith("0X") ? value.slice(2) : value;
+  if (v.length % 2 !== 0) v = `0${v}`;
+  return v;
+}
+function intToHex(value, bytes, signed) {
+  let bn;
+  if (typeof value === "bigint") {
+    bn = value;
+  } else if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new Error(`EIP-712 intToHex: invalid number ${value}`);
+    bn = BigInt(Math.trunc(value));
+  } else if (typeof value === "boolean") {
+    bn = BigInt(value ? 1 : 0);
+  } else if (typeof value === "string") {
+    bn = BigInt(value);
+  } else {
+    throw new Error(`EIP-712 intToHex: cannot encode value of type ${typeof value}`);
+  }
+  const range = 1n << BigInt(bytes * 8);
+  if (signed) {
+    const halfRange = range >> 1n;
+    if (bn < -halfRange || bn >= halfRange) {
+      throw new Error(
+        `EIP-712 intToHex: value out of range for ${bytes * 8}-bit int`
+      );
+    }
+    if (bn < 0n) {
+      bn = range + bn;
+    }
+  } else if (bn < 0n || bn >= range) {
+    throw new Error(`EIP-712 intToHex: value out of range for ${bytes * 8}-bit uint`);
+  }
+  return bn.toString(16).padStart(bytes * 2, "0");
+}
+
+// src/chains/evm.ts
+var MAX_DATA_CHUNK_BYTES = 1024;
+async function evmGetAddress(ctx, params) {
+  const request = readEvmGetAddressParams(params);
+  const response = await ctx.deviceSession.call("EthereumGetAddress", {
+    address_n: parseBip32Path(request.path),
+    show_display: request.showOnDevice ?? false
+  });
+  if (response.type !== "EthereumAddress") {
+    throw new Error(`Expected EthereumAddress response, received ${response.type}`);
+  }
+  const message = response.message;
+  const address = readString(message, "address");
+  if (!address) {
+    throw new Error("EthereumAddress response did not include an address");
+  }
+  return {
+    address,
+    path: request.path
+  };
+}
+async function evmSignTransaction(ctx, params) {
+  const tx = readEvmSignTxParams(params);
+  const addressN = parseBip32Path(tx.path);
+  const isEip1559 = tx.maxFeePerGas !== void 0 || tx.maxPriorityFeePerGas !== void 0;
+  if (isEip1559) {
+    return signEip1559(ctx, addressN, tx);
+  }
+  return signLegacy(ctx, addressN, tx);
+}
+async function signLegacy(ctx, addressN, tx) {
+  if (tx.chainId === void 0) {
+    throw new Error("evmSignTransaction: chainId is required for legacy transactions");
+  }
+  const dataHex = stripHexPrefix(tx.data ?? "");
+  const dataByteLength = dataHex.length / 2;
+  const [firstChunk, rest] = sliceHex(dataHex, MAX_DATA_CHUNK_BYTES * 2);
+  const message = {
+    address_n: addressN,
+    nonce: trezorHexAmount(tx.nonce),
+    gas_price: trezorHexAmount(tx.gasPrice),
+    gas_limit: trezorHexAmount(tx.gasLimit),
+    to: tx.to ?? "",
+    value: trezorHexAmount(tx.value),
+    chain_id: tx.chainId
+  };
+  if (dataByteLength > 0) {
+    message.data_length = dataByteLength;
+    message.data_initial_chunk = firstChunk;
+  }
+  const initial = await ctx.deviceSession.call("EthereumSignTx", message);
+  return processTxRequest(ctx, initial, rest, tx.chainId);
+}
+async function signEip1559(ctx, addressN, tx) {
+  if (tx.chainId === void 0) {
+    throw new Error("evmSignTransaction: chainId is required for EIP-1559 transactions");
+  }
+  if (tx.maxFeePerGas === void 0 || tx.maxPriorityFeePerGas === void 0) {
+    throw new Error(
+      "evmSignTransaction: EIP-1559 requires both maxFeePerGas and maxPriorityFeePerGas"
+    );
+  }
+  const dataHex = stripHexPrefix(tx.data ?? "");
+  const dataByteLength = dataHex.length / 2;
+  const [firstChunk, rest] = sliceHex(dataHex, MAX_DATA_CHUNK_BYTES * 2);
+  const message = {
+    address_n: addressN,
+    nonce: trezorHexAmount(tx.nonce),
+    max_gas_fee: trezorHexAmount(tx.maxFeePerGas),
+    max_priority_fee: trezorHexAmount(tx.maxPriorityFeePerGas),
+    gas_limit: trezorHexAmount(tx.gasLimit),
+    to: tx.to ?? "",
+    value: trezorHexAmount(tx.value),
+    data_length: dataByteLength,
+    data_initial_chunk: firstChunk,
+    chain_id: tx.chainId,
+    access_list: (tx.accessList ?? []).map((entry) => ({
+      address: entry.address,
+      storage_keys: entry.storageKeys
+    }))
+  };
+  const initial = await ctx.deviceSession.call("EthereumSignTxEIP1559", message);
+  return processTxRequest(ctx, initial, rest, void 0);
+}
+async function processTxRequest(ctx, initialResponse, remainingData, chainIdForLegacyV) {
+  let response = initialResponse;
+  let remaining = remainingData;
+  while (true) {
+    if (response.type !== "EthereumTxRequest") {
+      throw new Error(`Expected EthereumTxRequest, received ${response.type}`);
+    }
+    const req = response.message;
+    const dataLength = readNumber(req, "data_length");
+    if (!dataLength) {
+      return buildSignedTx(req, chainIdForLegacyV);
+    }
+    const [chunk, nextRest] = sliceHex(remaining, dataLength * 2);
+    response = await ctx.deviceSession.call("EthereumTxAck", { data_chunk: chunk });
+    remaining = nextRest;
+  }
+}
+function buildSignedTx(req, chainIdForLegacyV) {
+  let v = readNumber(req, "signature_v");
+  const r = readString(req, "signature_r");
+  const s = readString(req, "signature_s");
+  if (v === void 0 || r === void 0 || s === void 0) {
+    throw new Error("EthereumTxRequest missing signature fields (v, r, or s)");
+  }
+  if (chainIdForLegacyV !== void 0 && v <= 1) {
+    v += 2 * chainIdForLegacyV + 35;
+  }
+  return {
+    v: `0x${v.toString(16)}`,
+    r: `0x${r}`,
+    s: `0x${s}`
+  };
+}
+function readEvmSignTxParams(params) {
+  if (!params || typeof params !== "object") {
+    throw new Error("evmSignTransaction params must be an object");
+  }
+  const path = params.path;
+  if (typeof path !== "string" || path.trim().length === 0) {
+    throw new Error("evmSignTransaction requires a non-empty path");
+  }
+  return params;
+}
+function stripHexPrefix(value) {
+  return value.startsWith("0x") || value.startsWith("0X") ? value.slice(2) : value;
+}
+function trezorHexAmount(value) {
+  if (value === void 0) return "";
+  let v = stripHexPrefix(value);
+  while (v.startsWith("00")) v = v.slice(2);
+  return v;
+}
+function sliceHex(hex, charsInFirstChunk) {
+  if (hex.length <= charsInFirstChunk) return [hex, ""];
+  return [hex.slice(0, charsInFirstChunk), hex.slice(charsInFirstChunk)];
+}
+async function evmSignTypedData(ctx, params) {
+  const request = readEvmSignTypedDataParams(params);
+  if (request.mode === "hash") {
+    return signTypedHash(ctx, request);
+  }
+  return signTypedDataFull(ctx, request);
+}
+async function signTypedDataFull(ctx, request) {
+  const addressN = parseBip32Path(request.path);
+  const { types, primaryType, domain, message } = request.data;
+  const typedTypes = types;
+  const metamaskV4Compat = request.metamaskV4Compat ?? true;
+  let response = await ctx.deviceSession.call("EthereumSignTypedData", {
+    address_n: addressN,
+    primary_type: primaryType,
+    metamask_v4_compat: metamaskV4Compat
+  });
+  while (response.type === "EthereumTypedDataStructRequest") {
+    const reqMsg = response.message;
+    const typeName = readString(reqMsg, "name");
+    if (!typeName) {
+      throw new Error("EthereumTypedDataStructRequest missing `name`");
+    }
+    const typeDef = typedTypes[typeName];
+    if (!typeDef) {
+      throw new Error(`EIP-712: type "${typeName}" requested by device but not in types`);
+    }
+    response = await ctx.deviceSession.call("EthereumTypedDataStructAck", {
+      members: typeDef.map(({ name, type }) => ({
+        name,
+        type: getFieldType(type, typedTypes)
+      }))
+    });
+  }
+  while (response.type === "EthereumTypedDataValueRequest") {
+    const reqMsg = response.message;
+    const memberPath = reqMsg.member_path;
+    if (!Array.isArray(memberPath) || memberPath.length === 0) {
+      throw new Error("EthereumTypedDataValueRequest missing member_path");
+    }
+    let memberData;
+    let memberTypeName;
+    const [rootIndex, ...nested] = memberPath;
+    if (rootIndex === 0) {
+      memberData = domain;
+      memberTypeName = "EIP712Domain";
+    } else if (rootIndex === 1) {
+      memberData = message;
+      memberTypeName = primaryType;
+    } else {
+      throw new Error(`EIP-712 member_path root index must be 0 or 1, got ${rootIndex}`);
+    }
+    for (const index of nested) {
+      if (Array.isArray(memberData)) {
+        memberTypeName = parseArrayType(memberTypeName).entryTypeName;
+        memberData = memberData[index];
+      } else if (memberData !== null && typeof memberData === "object") {
+        const def = typedTypes[memberTypeName]?.[index];
+        if (!def) {
+          throw new Error(
+            `EIP-712 member_path: no member at index ${index} of type "${memberTypeName}"`
+          );
+        }
+        memberTypeName = def.type;
+        memberData = memberData[def.name];
+      } else {
+        throw new Error("EIP-712 member_path: cannot traverse into a leaf value");
+      }
+    }
+    const value = Array.isArray(memberData) ? encodeData("uint16", memberData.length) : encodeData(memberTypeName, memberData);
+    response = await ctx.deviceSession.call("EthereumTypedDataValueAck", { value });
+  }
+  if (response.type !== "EthereumTypedDataSignature") {
+    throw new Error(`Expected EthereumTypedDataSignature, received ${response.type}`);
+  }
+  const msg = response.message;
+  const signature = readString(msg, "signature");
+  if (!signature) {
+    throw new Error("EthereumTypedDataSignature response did not include a signature");
+  }
+  return {
+    signature: signature.startsWith("0x") ? signature : `0x${signature}`,
+    address: readString(msg, "address")
+  };
+}
+async function signTypedHash(ctx, params) {
+  const response = await ctx.deviceSession.call("EthereumSignTypedHash", {
+    address_n: parseBip32Path(params.path),
+    domain_separator_hash: stripHexPrefix(params.domainSeparatorHash),
+    message_hash: stripHexPrefix(params.messageHash)
+  });
+  if (response.type !== "EthereumTypedDataSignature") {
+    throw new Error(
+      `Expected EthereumTypedDataSignature response, received ${response.type}`
+    );
+  }
+  const message = response.message;
+  const signature = readString(message, "signature");
+  if (!signature) {
+    throw new Error("EthereumTypedDataSignature response did not include a signature");
+  }
+  return {
+    signature: signature.startsWith("0x") ? signature : `0x${signature}`,
+    address: readString(message, "address")
+  };
+}
+function readEvmSignTypedDataParams(params) {
+  if (!params || typeof params !== "object") {
+    throw new Error("evmSignTypedData params must be an object");
+  }
+  const path = params.path;
+  if (typeof path !== "string" || path.trim().length === 0) {
+    throw new Error("evmSignTypedData requires a non-empty path");
+  }
+  const mode = params.mode;
+  if (mode === "hash") {
+    const dsh = params.domainSeparatorHash;
+    const mh = params.messageHash;
+    if (typeof dsh !== "string") {
+      throw new Error("evmSignTypedData (mode 'hash') requires domainSeparatorHash");
+    }
+    if (typeof mh !== "string") {
+      throw new Error("evmSignTypedData (mode 'hash') requires messageHash");
+    }
+    return { path, mode: "hash", domainSeparatorHash: dsh, messageHash: mh };
+  }
+  return params;
+}
+async function evmSignMessage(ctx, params) {
+  const request = readEvmSignMessageParams(params);
+  const response = await ctx.deviceSession.call("EthereumSignMessage", {
+    address_n: parseBip32Path(request.path),
+    message: normalizeEthMessage(request.message, request.hex ?? false)
+  });
+  if (response.type !== "EthereumMessageSignature") {
+    throw new Error(`Expected EthereumMessageSignature response, received ${response.type}`);
+  }
+  const message = response.message;
+  const signature = readString(message, "signature");
+  if (!signature) {
+    throw new Error("EthereumMessageSignature response did not include a signature");
+  }
+  return {
+    signature: signature.startsWith("0x") ? signature : `0x${signature}`,
+    address: readString(message, "address")
+  };
+}
+function readEvmGetAddressParams(params) {
+  if (!params || typeof params !== "object") {
+    throw new Error("evmGetAddress params must be an object");
+  }
+  const path = params.path;
+  if (typeof path !== "string" || path.trim().length === 0) {
+    throw new Error("evmGetAddress requires a non-empty path");
+  }
+  const showOnDevice = params.showOnDevice;
+  if (showOnDevice !== void 0 && typeof showOnDevice !== "boolean") {
+    throw new Error("evmGetAddress showOnDevice must be a boolean when provided");
+  }
+  return {
+    path,
+    showOnDevice
+  };
+}
+function readEvmSignMessageParams(params) {
+  if (!params || typeof params !== "object") {
+    throw new Error("evmSignMessage params must be an object");
+  }
+  const path = params.path;
+  if (typeof path !== "string" || path.trim().length === 0) {
+    throw new Error("evmSignMessage requires a non-empty path");
+  }
+  const message = params.message;
+  if (typeof message !== "string") {
+    throw new Error("evmSignMessage requires message as a string");
+  }
+  const hex = params.hex;
+  if (hex !== void 0 && typeof hex !== "boolean") {
+    throw new Error("evmSignMessage hex must be a boolean when provided");
+  }
+  return { path, message, hex };
+}
+function normalizeEthMessage(message, isHex) {
+  if (!isHex) return message;
+  let stripped = message.startsWith("0x") || message.startsWith("0X") ? message.slice(2) : message;
+  if (stripped.length % 2 !== 0) stripped = `0${stripped}`;
+  if (!/^[0-9a-fA-F]*$/.test(stripped)) {
+    throw new Error("evmSignMessage: hex message contains non-hex characters");
+  }
+  return stripped;
+}
+
+// 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", {
+    address_n: parseBip32Path(request.path),
+    show_display: request.showOnDevice ?? false
+  });
+  if (response.type !== "SolanaAddress") {
+    throw new Error(`Expected SolanaAddress response, received ${response.type}`);
+  }
+  const address = readString(response.message, "address");
+  if (!address) {
+    throw new Error("SolanaAddress response did not include an address");
+  }
+  return { address, path: request.path };
+}
+async function solSignTransaction(ctx, params) {
+  const request = readSolSignTxParams(params);
+  const data = {
+    address_n: parseBip32Path(request.path),
+    serialized_tx: stripHexPrefix2(request.serializedTx)
+  };
+  if (request.additionalInfo?.tokenAccountsInfos?.length) {
+    data.additional_info = {
+      token_accounts_infos: request.additionalInfo.tokenAccountsInfos.map((info) => ({
+        base_address: info.baseAddress,
+        token_program: info.tokenProgram,
+        token_mint: info.tokenMint,
+        token_account: info.tokenAccount
+      }))
+    };
+  }
+  const response = await ctx.deviceSession.call("SolanaSignTx", data);
+  if (response.type !== "SolanaTxSignature") {
+    throw new Error(`Expected SolanaTxSignature response, received ${response.type}`);
+  }
+  const signature = readString(response.message, "signature");
+  if (!signature) {
+    throw new Error("SolanaTxSignature response did not include a signature");
+  }
+  return { signature };
+}
+async function solSignMessage(_ctx, _params) {
+  throw Object.assign(
+    new Error(
+      "Trezor firmware does not support Solana message signing \u2014 only solSignTransaction is available"
+    ),
+    { code: import_hwk_adapter_core2.HardwareErrorCode.MethodNotSupported }
+  );
+}
+function readSolGetAddressParams(params) {
+  if (!params || typeof params !== "object") {
+    throw new Error("solGetAddress params must be an object");
+  }
+  const path = params.path;
+  if (typeof path !== "string" || path.trim().length === 0) {
+    throw new Error("solGetAddress requires a non-empty path");
+  }
+  const showOnDevice = params.showOnDevice;
+  if (showOnDevice !== void 0 && typeof showOnDevice !== "boolean") {
+    throw new Error("solGetAddress showOnDevice must be a boolean when provided");
+  }
+  return { path, showOnDevice };
+}
+function readSolSignTxParams(params) {
+  if (!params || typeof params !== "object") {
+    throw new Error("solSignTransaction params must be an object");
+  }
+  const path = params.path;
+  if (typeof path !== "string" || path.trim().length === 0) {
+    throw new Error("solSignTransaction requires a non-empty path");
+  }
+  const serializedTx = params.serializedTx;
+  if (typeof serializedTx !== "string" || serializedTx.length === 0) {
+    throw new Error("solSignTransaction requires serializedTx as a hex string");
+  }
+  return params;
+}
+function stripHexPrefix2(value) {
+  return value.startsWith("0x") || value.startsWith("0X") ? value.slice(2) : value;
+}
+
+// src/chains/tron.ts
+var import_hwk_adapter_core3 = require("@onekeyfe/hwk-adapter-core");
+var import_hwk_trezor_protobuf = require("@onekeyfe/hwk-trezor-protobuf");
+async function tronGetAddress(ctx, params) {
+  const request = readTronGetAddressParams(params);
+  const response = await ctx.deviceSession.call("TronGetAddress", {
+    address_n: parseBip32Path(request.path),
+    show_display: request.showOnDevice ?? false
+  });
+  if (response.type !== "TronAddress") {
+    throw new Error(`Expected TronAddress response, received ${response.type}`);
+  }
+  const address = readString(response.message, "address");
+  if (!address) {
+    throw new Error("TronAddress response did not include an address");
+  }
+  return { address, path: request.path };
+}
+async function tronSignTransaction(ctx, params) {
+  const request = readTronSignTxParams(params);
+  const ownerAddress = normalizeTronAddress(request.ownerAddress, "ownerAddress");
+  const { messageName, value } = buildContractMessage(request.contract, ownerAddress);
+  const header = {
+    address_n: parseBip32Path(request.path),
+    ref_block_bytes: request.refBlockBytes,
+    ref_block_hash: request.refBlockHash,
+    expiration: request.expiration,
+    timestamp: request.timestamp
+  };
+  if (request.feeLimit !== void 0) {
+    header.fee_limit = assertSafeInt(request.feeLimit, "feeLimit");
+  }
+  if (request.data !== void 0) header.data = stripHexPrefix3(request.data);
+  const ack = await ctx.deviceSession.call("TronSignTx", header);
+  if (ack.type !== "TronContractRequest") {
+    throw new Error(`Expected TronContractRequest, received ${ack.type}`);
+  }
+  const response = await ctx.deviceSession.call(messageName, value);
+  if (response.type !== "TronSignature") {
+    throw new Error(`Expected TronSignature, received ${response.type}`);
+  }
+  const signature = readString(response.message, "signature");
+  if (!signature) {
+    throw new Error("TronSignature response did not include a signature");
+  }
+  const serializedTx = reconstructTronRawData(request, messageName, value);
+  return serializedTx ? { signature, serializedTx } : { signature };
+}
+var TRON_RAW_CONTRACT = {
+  TronTransferContract: {
+    typeValue: 1,
+    typeUrl: "type.googleapis.com/protocol.TransferContract",
+    includeFeeLimit: false
+  },
+  TronTriggerSmartContract: {
+    typeValue: 31,
+    typeUrl: "type.googleapis.com/protocol.TriggerSmartContract",
+    includeFeeLimit: true
+  }
+};
+function reconstructTronRawData(request, contractMessageName, contractValue) {
+  const info = TRON_RAW_CONTRACT[contractMessageName];
+  if (!info) return void 0;
+  const innerBytes = import_hwk_trezor_protobuf.protobufManager.encode(contractMessageName, contractValue).message;
+  const rawData = {
+    ref_block_bytes: request.refBlockBytes,
+    ref_block_hash: request.refBlockHash,
+    expiration: request.expiration,
+    timestamp: request.timestamp,
+    contract: [
+      {
+        type: info.typeValue,
+        parameter: { type_url: info.typeUrl, value: innerBytes.toString("hex") }
+      }
+    ]
+  };
+  if (info.includeFeeLimit && request.feeLimit !== void 0) {
+    rawData.fee_limit = request.feeLimit;
+  }
+  if (request.data) {
+    rawData.data = stripHexPrefix3(request.data);
+  }
+  return import_hwk_trezor_protobuf.protobufManager.encode("TronRawTransaction", rawData).message.toString("hex");
+}
+async function tronSignMessage(_ctx, _params) {
+  throw Object.assign(
+    new Error(
+      "Trezor firmware does not support TRON message signing \u2014 only tronGetAddress is available"
+    ),
+    { code: import_hwk_adapter_core3.HardwareErrorCode.MethodNotSupported }
+  );
+}
+function buildContractMessage(contract, ownerAddress) {
+  if (contract.transferContract) {
+    const c = contract.transferContract;
+    return {
+      messageName: "TronTransferContract",
+      value: {
+        owner_address: ownerAddress,
+        to_address: normalizeTronAddress(c.toAddress, "transferContract.toAddress"),
+        amount: toUintString(c.amount, "transferContract.amount")
+      }
+    };
+  }
+  if (contract.triggerSmartContract) {
+    const c = contract.triggerSmartContract;
+    return {
+      messageName: "TronTriggerSmartContract",
+      value: {
+        owner_address: ownerAddress,
+        contract_address: normalizeTronAddress(
+          c.contractAddress,
+          "triggerSmartContract.contractAddress"
+        ),
+        data: stripHexPrefix3(c.data)
+      }
+    };
+  }
+  if (contract.freezeBalanceV2Contract) {
+    const c = contract.freezeBalanceV2Contract;
+    const value = {
+      owner_address: ownerAddress,
+      balance: assertSafeInt(c.balance, "freezeBalanceV2Contract.balance")
+    };
+    if (c.resource !== void 0) value.resource = c.resource;
+    return { messageName: "TronFreezeBalanceV2Contract", value };
+  }
+  if (contract.unfreezeBalanceV2Contract) {
+    const c = contract.unfreezeBalanceV2Contract;
+    const value = {
+      owner_address: ownerAddress,
+      balance: assertSafeInt(c.balance, "unfreezeBalanceV2Contract.balance")
+    };
+    if (c.resource !== void 0) value.resource = c.resource;
+    return { messageName: "TronUnfreezeBalanceV2Contract", value };
+  }
+  if (contract.voteWitnessContract) {
+    const c = contract.voteWitnessContract;
+    return {
+      messageName: "TronVoteWitnessContract",
+      value: {
+        owner_address: ownerAddress,
+        votes: c.votes.map((vote, i) => ({
+          address: normalizeTronAddress(vote.voteAddress, `voteWitnessContract.votes[${i}]`),
+          count: assertSafeInt(vote.voteCount, `voteWitnessContract.votes[${i}].voteCount`)
+        }))
+      }
+    };
+  }
+  if (contract.withdrawExpireUnfreezeContract) {
+    return { messageName: "TronWithdrawUnfreeze", value: { owner_address: ownerAddress } };
+  }
+  throw new Error(
+    "tronSignTransaction: contract must specify exactly one supported contract type (transfer / triggerSmart / freezeBalanceV2 / unfreezeBalanceV2 / voteWitness / withdrawExpireUnfreeze)"
+  );
+}
+function normalizeTronAddress(address, field) {
+  if (typeof address !== "string") {
+    throw new Error(`tronSignTransaction: ${field} must be a string`);
+  }
+  const hex = stripHexPrefix3(address);
+  if (!/^41[0-9a-fA-F]{40}$/.test(hex)) {
+    throw new Error(
+      `tronSignTransaction: ${field} must be hex 0x41-prefixed (41 + 20 bytes), got "${address}"`
+    );
+  }
+  return hex.toLowerCase();
+}
+function stripHexPrefix3(value) {
+  return value.startsWith("0x") || value.startsWith("0X") ? value.slice(2) : value;
+}
+function toUintString(value, field) {
+  if (typeof value === "string") {
+    if (!/^\d+$/.test(value)) {
+      throw new Error(`tronSignTransaction: ${field} must be a non-negative decimal string`);
+    }
+    return value;
+  }
+  if (typeof value === "number") {
+    if (!Number.isSafeInteger(value) || value < 0) {
+      throw new Error(
+        `tronSignTransaction: ${field}=${value} is not a safe integer \u2014 pass it as a decimal string to avoid precision loss`
+      );
+    }
+    return String(value);
+  }
+  throw new Error(`tronSignTransaction: ${field} must be a string or number`);
+}
+function assertSafeInt(value, field) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+    throw new Error(
+      `tronSignTransaction: ${field}=${value} must be a non-negative safe integer (< 2^53)`
+    );
+  }
+  return value;
+}
+function readTronGetAddressParams(params) {
+  if (!params || typeof params !== "object") {
+    throw new Error("tronGetAddress params must be an object");
+  }
+  const path = params.path;
+  if (typeof path !== "string" || path.trim().length === 0) {
+    throw new Error("tronGetAddress requires a non-empty path");
+  }
+  const showOnDevice = params.showOnDevice;
+  if (showOnDevice !== void 0 && typeof showOnDevice !== "boolean") {
+    throw new Error("tronGetAddress showOnDevice must be a boolean when provided");
+  }
+  return { path, showOnDevice };
+}
+function readTronSignTxParams(params) {
+  if (!params || typeof params !== "object") {
+    throw new Error("tronSignTransaction params must be an object");
+  }
+  const p = params;
+  if (typeof p.path !== "string" || p.path.trim().length === 0) {
+    throw new Error("tronSignTransaction requires a non-empty path");
+  }
+  if (typeof p.ownerAddress !== "string" || p.ownerAddress.length === 0) {
+    throw new Error("tronSignTransaction requires ownerAddress (hex 0x41-prefixed)");
+  }
+  if (typeof p.refBlockBytes !== "string" || typeof p.refBlockHash !== "string") {
+    throw new Error("tronSignTransaction requires refBlockBytes and refBlockHash as hex strings");
+  }
+  if (typeof p.expiration !== "number" || typeof p.timestamp !== "number") {
+    throw new Error("tronSignTransaction requires numeric expiration and timestamp");
+  }
+  if (!p.contract || typeof p.contract !== "object") {
+    throw new Error("tronSignTransaction requires a contract object");
+  }
+  return p;
+}
+
+// src/index.ts
+var import_hwk_adapter_core4 = require("@onekeyfe/hwk-adapter-core");
+var import_hwk_trezor_core = require("@onekeyfe/hwk-trezor-core");
+var TrezorConnectorBase = class {
+  connectionType;
+  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.
+  knownCredentials = [];
+  deviceSessionFactory;
+  eventHandlers = /* @__PURE__ */ new Map();
+  uiRequests = new import_hwk_adapter_core4.UiRequestRegistry();
+  devices = /* @__PURE__ */ new Map();
+  sessions = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    this.connectionType = options.connectionType ?? "usb";
+    this.chunkSize = options.chunkSize ?? 64;
+    this.thp = options.thp;
+    if (options.thp?.knownCredentials?.length) {
+      this.knownCredentials.push(...options.thp.knownCredentials);
+    }
+    this.deviceSessionFactory = options.deviceSessionFactory ?? ((params) => new import_hwk_trezor_core.TrezorDeviceSession({
+      transport: params.transport,
+      connectionType: params.connectionType,
+      chunkSize: params.chunkSize,
+      thp: params.thp
+    }));
+  }
+  /**
+   * Replace the in-memory THP pairing credential list. Caller (host) reads
+   * persisted credentials from storage and pushes them in here before the
+   * first connect; the device sees them via `ThpHandshakeInitRequest` and
+   * routes through the autoconnect path instead of CodeEntry.
+   *
+   * Empty list = "no credentials known" = fresh pairing on next connect.
+   * The internal array is reused so any in-flight TrezorThpSession picks up
+   * the change too — we mutate, not replace.
+   */
+  setKnownCredentials(credentials) {
+    this.knownCredentials.length = 0;
+    if (credentials?.length) {
+      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 exists = this.knownCredentials.some(
+        (existing) => existing.credential === blob
+      );
+      if (!exists) this.knownCredentials.push(cred);
+    }
+  }
+  resolveUnlistedDevice(_deviceId) {
+    return void 0;
+  }
+  async searchDevices() {
+    this.log("info", "connector.search.start");
+    const devices = await this.enumerateDevices();
+    this.devices.clear();
+    for (const device of devices) {
+      this.devices.set(device.connectId, device);
+    }
+    this.log("info", "connector.search.done", {
+      count: devices.length,
+      devices: devices.map((device) => ({
+        connectId: device.connectId,
+        deviceId: device.deviceId,
+        name: device.name,
+        model: device.model
+      }))
+    });
+    for (const device of devices) {
+      const source = device.connectionType ?? this.connectionType;
+      this.log("info", `[TREZOR_VERIFY][${source}] scan.device`, {
+        source,
+        connectionType: source,
+        connectId: device.connectId,
+        deviceId: device.deviceId,
+        serialNumber: device.serialNumber,
+        name: device.name,
+        model: device.model,
+        rssi: device.rssi,
+        isConnectable: device.isConnectable,
+        raw: device.raw
+      });
+    }
+    return devices;
+  }
+  async connect(deviceId) {
+    this.log("info", "connector.connect.start", { deviceId });
+    const device = await this.resolveDevice(deviceId);
+    this.log("info", "connector.connect.deviceResolved", {
+      connectId: device.connectId,
+      deviceId: device.deviceId,
+      name: device.name,
+      model: device.model
+    });
+    let transport;
+    try {
+      this.log("info", "connector.connect.transport.start", { connectId: device.connectId });
+      transport = await this.createByteTransport(device);
+      this.log("info", "connector.connect.transport.done", { connectId: device.connectId });
+    } catch (error) {
+      this.log("error", "connector.connect.transport.error", {
+        connectId: device.connectId,
+        error: errorToLog(error)
+      });
+      throw error;
+    }
+    const deviceSession = this.deviceSessionFactory({
+      transport,
+      connectionType: this.connectionType,
+      chunkSize: this.chunkSize,
+      thp: this.createThpOptions(device)
+    });
+    let features;
+    try {
+      this.log("info", "connector.connect.sessionInitialize.start", { connectId: device.connectId });
+      features = await deviceSession.initialize();
+      this.log("info", "connector.connect.sessionInitialize.done", {
+        connectId: device.connectId,
+        featureKeys: Object.keys(features)
+      });
+    } catch (error) {
+      this.log("error", "connector.connect.sessionInitialize.error", {
+        connectId: device.connectId,
+        error: errorToLog(error)
+      });
+      await transport.close?.().catch(() => void 0);
+      throw error;
+    }
+    const sessionId = device.connectId;
+    const session = {
+      sessionId,
+      device,
+      transport,
+      deviceSession,
+      features
+    };
+    this.sessions.set(sessionId, session);
+    session.unsubscribeDisconnect = transport.onDisconnect?.(() => {
+      if (this.sessions.get(sessionId) !== session) return;
+      this.sessions.delete(sessionId);
+      session.unsubscribeDisconnect?.();
+      this.emit("device-disconnect", { connectId: device.connectId });
+    });
+    const connectorSession = {
+      sessionId,
+      deviceInfo: {
+        vendor: "trezor",
+        connectId: device.connectId,
+        deviceId: readString(features, "device_id") ?? device.deviceId,
+        model: readString(features, "model") ?? device.model ?? "unknown",
+        firmwareVersion: buildFirmwareVersion(features),
+        label: readString(features, "label") ?? device.name,
+        connectionType: this.connectionType,
+        serialNumber: device.serialNumber,
+        capabilities: device.capabilities,
+        raw: {
+          features,
+          discoveryRaw: device.raw
+        }
+      }
+    };
+    this.emit("device-connect", { device: connectorSessionToDevice(connectorSession) });
+    this.log("info", `[TREZOR_VERIFY][${this.connectionType}] connect.device`, {
+      source: this.connectionType,
+      connectionType: this.connectionType,
+      scanConnectId: device.connectId,
+      scanDeviceId: device.deviceId,
+      scanSerialNumber: device.serialNumber,
+      featuresDeviceId: readString(features, "device_id"),
+      deviceInfo: connectorSession.deviceInfo
+    });
+    this.log("info", "connector.connect.done", { sessionId });
+    return connectorSession;
+  }
+  async disconnect(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return;
+    session.unsubscribeDisconnect?.();
+    this.sessions.delete(sessionId);
+    await session.transport.close?.();
+    this.emit("device-disconnect", { connectId: session.device.connectId });
+  }
+  async call(sessionId, method, params) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      throw new Error(`Trezor session not found: ${sessionId}`);
+    }
+    const ctx = { deviceSession: session.deviceSession };
+    switch (method) {
+      case "getFeatures": {
+        const p = params ?? {};
+        if (p.refresh) {
+          await session.deviceSession.call("GetFeatures", {});
+        }
+        return session.deviceSession.features ?? session.features;
+      }
+      // --- THP application-session control (Trezor-specific, driven by the
+      // adapter to align the active passphrase session before a chain call).
+      // The session deals only in session ids; the adapter owns the
+      // XFP↔sessionId map. For v1 devices these are no-ops that report
+      // `protocol: 'v1'` so the adapter falls back to the reactive flow.
+      case "__thpCreateSession": {
+        if (!session.deviceSession.isThp) {
+          return { protocol: "v1", thpSessionId: null };
+        }
+        const p = params ?? {};
+        const thpSessionId = await session.deviceSession.createThpAppSession(p.deriveCardano);
+        return { protocol: "thp", thpSessionId };
+      }
+      case "__thpSelectSession": {
+        if (!session.deviceSession.isThp) {
+          return { protocol: "v1", thpSessionId: null };
+        }
+        const p = params ?? {};
+        if (!p.thpSessionId) {
+          throw new Error("__thpSelectSession requires a thpSessionId");
+        }
+        session.deviceSession.selectThpAppSession(p.thpSessionId);
+        return { protocol: "thp", thpSessionId: p.thpSessionId };
+      }
+      case "__thpActiveSession":
+        return {
+          protocol: session.deviceSession.isThp ? "thp" : "v1",
+          thpSessionId: session.deviceSession.getThpAppSessionId() ?? null
+        };
+      case "btcGetAddress":
+        return btcGetAddress(ctx, params);
+      case "btcGetPublicKey":
+        return btcGetPublicKey(ctx, params);
+      case "btcSignMessage":
+        return btcSignMessage(ctx, params);
+      case "btcSignTransaction":
+        return btcSignTransaction(ctx, params);
+      case "btcSignPsbt":
+        return btcSignPsbt(ctx, params);
+      case "btcGetMasterFingerprint":
+        return btcGetMasterFingerprint(ctx);
+      case "evmGetAddress":
+        return evmGetAddress(ctx, params);
+      case "evmSignMessage":
+        return evmSignMessage(ctx, params);
+      case "evmSignTransaction":
+        return evmSignTransaction(ctx, params);
+      case "evmSignTypedData":
+        return evmSignTypedData(ctx, params);
+      case "solGetAddress":
+        return solGetAddress(ctx, params);
+      case "solSignTransaction":
+        return solSignTransaction(ctx, params);
+      case "solSignMessage":
+        return solSignMessage(ctx, params);
+      case "tronGetAddress":
+        return tronGetAddress(ctx, params);
+      case "tronSignTransaction":
+        return tronSignTransaction(ctx, params);
+      case "tronSignMessage":
+        return tronSignMessage(ctx, params);
+      default:
+        throw Object.assign(
+          new Error(`TrezorConnector: method "${method}" is not implemented`),
+          { code: import_hwk_adapter_core4.HardwareErrorCode.MethodNotSupported }
+        );
+    }
+  }
+  async cancel(_sessionId) {
+  }
+  uiResponse(_response) {
+    if (_response.type === import_hwk_adapter_core4.UI_RESPONSE.CANCEL) {
+      this.uiRequests.cancel();
+      return;
+    }
+    this.uiRequests.resolve(_response.type, _response.payload);
+  }
+  on(event, handler) {
+    if (!this.eventHandlers.has(event)) {
+      this.eventHandlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this.eventHandlers.get(event).add(handler);
+  }
+  off(event, handler) {
+    this.eventHandlers.get(event)?.delete(handler);
+  }
+  reset() {
+    for (const session of this.sessions.values()) {
+      void session.transport.close?.();
+    }
+    this.sessions.clear();
+    this.devices.clear();
+    this.uiRequests.reset();
+    this.eventHandlers.clear();
+  }
+  emit(event, data) {
+    for (const handler of this.eventHandlers.get(event) ?? []) {
+      handler(data);
+    }
+  }
+  async resolveDevice(deviceId) {
+    if (deviceId && this.devices.has(deviceId)) {
+      return this.devices.get(deviceId);
+    }
+    const devices = await this.searchDevices();
+    const device = deviceId ? devices.find((d) => d.connectId === deviceId || d.deviceId === deviceId) : devices[0];
+    if (device) {
+      return device;
+    }
+    if (deviceId) {
+      const unlistedDevice = this.resolveUnlistedDevice(deviceId);
+      if (unlistedDevice) {
+        this.devices.set(unlistedDevice.connectId, unlistedDevice);
+        return unlistedDevice;
+      }
+    }
+    if (!device) {
+      throw new Error(deviceId ? `Trezor device not found: ${deviceId}` : "No Trezor device found");
+    }
+    return device;
+  }
+  createThpOptions(device) {
+    if (this.connectionType !== "ble" && !this.thp) return this.thp;
+    return {
+      ...this.thp,
+      // Override caller's knownCredentials (if any) with our managed array.
+      // The session reads .length and individual entries at handshake-time,
+      // so mutating this array between sessions is sufficient — no rebuild.
+      knownCredentials: this.knownCredentials,
+      onPairingRequest: async (payload) => {
+        if (this.thp?.onPairingRequest) {
+          return this.thp.onPairingRequest(payload);
+        }
+        this.emit("ui-request", {
+          type: import_hwk_adapter_core4.UI_REQUEST.REQUEST_TREZOR_THP_PAIRING,
+          payload: {
+            connectId: device.connectId,
+            availableMethods: payload.availableMethods,
+            selectedMethod: payload.selectedMethod,
+            nfcData: payload.nfcData
+          }
+        });
+        return this.uiRequests.wait(import_hwk_adapter_core4.UI_REQUEST.REQUEST_TREZOR_THP_PAIRING);
+      },
+      onButtonRequest: async (payload) => {
+        await this.thp?.onButtonRequest?.(payload);
+        this.emit("ui-request", {
+          type: import_hwk_adapter_core4.UI_REQUEST.REQUEST_BUTTON,
+          payload: {
+            connectId: device.connectId,
+            ...payload
+          }
+        });
+      },
+      onPinMatrixRequest: async (payload) => {
+        if (this.thp?.onPinMatrixRequest) {
+          return this.thp.onPinMatrixRequest(payload);
+        }
+        this.emit("ui-request", {
+          type: import_hwk_adapter_core4.UI_REQUEST.REQUEST_PIN,
+          payload: {
+            connectId: device.connectId,
+            type: payload.type
+          }
+        });
+        return this.uiRequests.wait(import_hwk_adapter_core4.UI_REQUEST.REQUEST_PIN);
+      },
+      onPassphraseRequest: async (payload) => {
+        if (this.thp?.onPassphraseRequest) {
+          return this.thp.onPassphraseRequest(payload);
+        }
+        const passphrasePromise = this.uiRequests.wait(import_hwk_adapter_core4.UI_REQUEST.REQUEST_PASSPHRASE);
+        this.emit("ui-request", {
+          type: import_hwk_adapter_core4.UI_REQUEST.REQUEST_PASSPHRASE,
+          payload: {
+            connectId: device.connectId,
+            ...payload
+          }
+        });
+        const res = await passphrasePromise;
+        return res?.passphraseOnDevice ? { on_device: true } : { passphrase: res?.value ?? "" };
+      },
+      onPairingCredentialsChanged: async (payload) => {
+        this.mergeKnownCredentials(payload.credentials);
+        await this.thp?.onPairingCredentialsChanged?.(payload);
+        this.emit("device-trezor-thp-credentials-changed", {
+          connectId: device.connectId,
+          deviceId: device.deviceId,
+          credentials: payload.credentials
+        });
+      }
+    };
+  }
+  log(level, event, data) {
+    try {
+      this.thp?.logger?.({ level, scope: "trezor-connector", event, data });
+    } catch {
+    }
+  }
+};
+function connectorSessionToDevice(session) {
+  return {
+    connectId: session.deviceInfo.connectId,
+    deviceId: session.deviceInfo.deviceId,
+    name: session.deviceInfo.label ?? "Trezor",
+    model: session.deviceInfo.model,
+    serialNumber: session.deviceInfo.serialNumber,
+    capabilities: session.deviceInfo.capabilities,
+    raw: session.deviceInfo.raw
+  };
+}
+function buildFirmwareVersion(features) {
+  const major = readNumber(features, "major_version");
+  const minor = readNumber(features, "minor_version");
+  const patch = readNumber(features, "patch_version");
+  if (major === void 0 || minor === void 0 || patch === void 0) {
+    return "";
+  }
+  return `${major}.${minor}.${patch}`;
+}
+function errorToLog(error) {
+  if (error instanceof Error) {
+    const extra = {};
+    const maybeError = error;
+    if (maybeError.errorCode !== void 0) extra.errorCode = maybeError.errorCode;
+    if (maybeError.reason !== void 0) extra.reason = maybeError.reason;
+    if (maybeError.attErrorCode !== void 0) extra.attErrorCode = maybeError.attErrorCode;
+    return {
+      name: error.name,
+      message: error.message,
+      stack: error.stack,
+      ...extra
+    };
+  }
+  return String(error);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TrezorConnectorBase
+});
+//# sourceMappingURL=index.js.map