@onekeyfe/hwk-adapter-core 1.2.8-alpha.13 → 1.2.8-alpha.131

package/dist/index.mjs

@@ -10,7 +10,7 @@ import {
   UI_REQUEST_TIMEOUT_TAG,
   UI_RESPONSE,
   UiRequestRegistry
-} from "./chunk-3D45OEC2.mjs";
+} from "./chunk-Z574MVAT.mjs";
 import {
   HardwareErrorCode,
   ORPHAN_ELIGIBLE_ERROR_CODES,
@@ -19,7 +19,7 @@ import {
   defaultRecoveryForCode,
   isHwkRecoveryHint,
   operationMayHaveCompletedParams
-} from "./chunk-KTRQZ5AJ.mjs";
+} from "./chunk-V2OHL2JS.mjs";
 
 // src/types/response.ts
 function success(payload) {
@@ -358,11 +358,9 @@ var OperationRegistry = class {
       (operation) => operation.connectionKeys.includes(connectionKey)
     );
   }
-  /** Map a job queue key (an operation id or a connection key) to its live operation id. */
+  /** Only an explicitly supplied operation job key owns the call's UI requests. */
   findOperationIdByJobKey(jobKey) {
-    if (!jobKey) return void 0;
-    if (isHardwareOperationId(jobKey)) return jobKey;
-    return this.findActiveByConnectionKey(jobKey)?.operationId;
+    return isHardwareOperationId(jobKey) ? jobKey : void 0;
   }
   /**
    * End an operation on the caller's explicit release. Throws for an unknown id; returns undefined
@@ -565,6 +563,15 @@ function rehydrateConnectorError(error) {
     ...params ?? {}
   });
 }
+function withChildConnectionType(event, data, connectionType) {
+  if (event !== "device-connect" && event !== "features") return data;
+  const { device } = data;
+  if (device.connectionType) return data;
+  return {
+    ...data,
+    device: { ...device, connectionType }
+  };
+}
 function isDeviceUnavailableError(error) {
   const typed = error;
   if (typed.code === 10100 /* DeviceNotFound */ || typed.code === 10101 /* DeviceDisconnected */) {
@@ -763,7 +770,7 @@ function createCombinedConnector(connectors) {
     },
     on: (event, handler) => {
       const attached = connectors.map((child) => {
-        const forward = (data) => handler(data);
+        const forward = (data) => handler(withChildConnectionType(event, data, child.connectionType));
         child.on(event, forward);
         return { child, handler: forward };
       });
@@ -1132,6 +1139,346 @@ function prepareSolanaOffchainMessageV1({
   };
 }
 
+// src/utils/logSummary.ts
+import { sha256 as sha2562 } from "@noble/hashes/sha256";
+import { bytesToHex as bytesToHex4, utf8ToBytes as utf8ToBytes2 } from "@noble/hashes/utils";
+var MAX_DEPTH = 6;
+var MAX_ARRAY_ITEMS = 20;
+var MAX_PLAIN_STRING = 64;
+var MAX_ERROR_STRING = 500;
+var normalizeKey = (key) => key.replace(/[_-]/g, "").toLowerCase();
+var keySet = (keys) => new Set(keys.map(normalizeKey));
+var KEEP_KEYS = keySet([
+  "path",
+  "paths",
+  "derivationPath",
+  "fullPath",
+  "basePath",
+  "method",
+  "methodName",
+  "chainId",
+  "coin",
+  "network",
+  "networkName",
+  "scriptType",
+  "template",
+  "appName",
+  "_tag",
+  "code",
+  "errorCode",
+  "statusCode"
+]);
+var ERROR_TEXT_KEYS = keySet(["message", "error", "errorMessage", "originalMessage"]);
+var ERROR_CONTEXT_KEYS = keySet(["error", "err", "originalError", "cause"]);
+var SECRET_KEYS = keySet([
+  "ufvk",
+  "orchardFvk",
+  "fvk",
+  "viewingKey",
+  "passphraseState",
+  "passphrase",
+  "password",
+  "pin",
+  "mnemonic",
+  "mnemonics",
+  "word",
+  "words",
+  "seed",
+  "entropy",
+  "privateKey",
+  "xprv",
+  "mac",
+  // THP pairing and channel material.
+  "credential",
+  "credentials",
+  "hostStaticKey",
+  "trezorStaticPublicKey",
+  // Wallet sessions and host connection records.
+  "session",
+  "sessionId",
+  "knownConnections",
+  "extra"
+]);
+var KEY_MATERIAL_KEYS = keySet([
+  "xpub",
+  "ypub",
+  "zpub",
+  "tpub",
+  "extendedPublicKey",
+  "publicKey",
+  "pubkey",
+  "pub",
+  "chainCode",
+  "tapInternalKey"
+]);
+var SIGNATURE_KEYS = keySet(["signature", "signatures", "sig", "r", "s", "v", "partialSig"]);
+var SIGNED_TX_KEYS = keySet(["signedTx", "signedTransaction", "signedTxHex"]);
+var SIGNED_PSBT_KEYS = keySet(["signedPsbt"]);
+var PAYLOAD_KEYS = keySet([
+  "serializedTx",
+  "rawTx",
+  "rawTxHex",
+  "txHex",
+  "tx",
+  "transaction",
+  "psbt",
+  "message",
+  "messageHex",
+  "data",
+  "dataJson",
+  "typedData",
+  "hex",
+  "bytes",
+  "apdu",
+  "domainSeparatorHash",
+  "messageHash",
+  "encodedNetwork",
+  "encodedToken",
+  "refBlockBytes",
+  "refBlockHash",
+  "opReturnData",
+  "scriptSig",
+  "witness",
+  "extraData",
+  // Structured transaction contents (Trezor-style and Tron params).
+  "contract",
+  "inputs",
+  "outputs",
+  "refTxs",
+  "paymentRequest",
+  "paymentRequests",
+  "additionalInfo",
+  "accessList",
+  "memos"
+]);
+var ADDRESS_KEYS = keySet([
+  "to",
+  "from",
+  "recipient",
+  "verifyingContract",
+  "requiredSigners",
+  "tokenMint",
+  "tokenAccount",
+  "tokenProgram"
+]);
+var TX_IN_RESULT_KEYS = keySet(["serializedTx", "rawTx", "rawTxHex", "txHex", "tx"]);
+var AMOUNT_KEYS = keySet(["value", "amount", "amounts", "fee", "fees", "tokenAmount"]);
+var ERROR_FIELDS = ["_tag", "code", "errorCode", "statusCode", "originalError"];
+var XPUB_RE = /^[a-zA-Z]pub[1-9A-HJ-NP-Za-km-z]{90,}$/;
+var HEX_RE = /^(0x)?[0-9a-fA-F]*$/;
+var EVM_TX_TYPES = {
+  1: "eip2930",
+  2: "eip1559",
+  3: "eip4844",
+  4: "eip7702"
+};
+function sha256Short(input) {
+  return bytesToHex4(sha2562(typeof input === "string" ? utf8ToBytes2(input) : input)).slice(0, 16);
+}
+function toBytes(value) {
+  if (value instanceof Uint8Array) return value;
+  if (value instanceof ArrayBuffer) return new Uint8Array(value);
+  if (ArrayBuffer.isView(value)) {
+    return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  }
+  if (value && typeof value === "object" && value.type === "Buffer" && Array.isArray(value.data)) {
+    return Uint8Array.from(value.data);
+  }
+  return void 0;
+}
+function isPlainHex(value) {
+  return value.length > 0 && HEX_RE.test(value) && value !== "0x";
+}
+function stripHexPrefix(value) {
+  return value.startsWith("0x") || value.startsWith("0X") ? value.slice(2) : value;
+}
+function maskAddress(value) {
+  if (value.length <= 12) return `<addr len=${value.length}>`;
+  return `${value.slice(0, 6)}\u2026${value.slice(-4)}`;
+}
+function summarizeKeyMaterial(value) {
+  const bytes = toBytes(value);
+  if (bytes) return `\u2026 len=${bytes.length}`;
+  const text = String(value);
+  return XPUB_RE.test(text) ? `${text.slice(0, 4)}\u2026 len=${text.length}` : `\u2026 len=${text.length}`;
+}
+function lengthOf(value) {
+  const bytes = toBytes(value);
+  if (bytes) return bytes.length;
+  if (typeof value === "string") return value.length;
+  const json = safeJson(value);
+  return json === void 0 ? 0 : json.length;
+}
+function safeJson(value) {
+  try {
+    return JSON.stringify(value, (_k, v) => typeof v === "bigint" ? `${v}n` : v);
+  } catch {
+    return void 0;
+  }
+}
+function evmTxType(hex) {
+  const body = stripHexPrefix(hex);
+  if (body.length < 2) return void 0;
+  const first = parseInt(body.slice(0, 2), 16);
+  if (first >= 192) return "legacy";
+  return EVM_TX_TYPES[first];
+}
+function describe(key, value, ctx) {
+  if (!ctx.describePayload) return void 0;
+  try {
+    const hint = ctx.describePayload(key, value, { method: ctx.method, role: ctx.role });
+    return typeof hint === "string" && hint.length > 0 ? hint : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function jsonSummary(json, parsed) {
+  const primaryType = parsed && typeof parsed === "object" ? parsed.primaryType : void 0;
+  const hint = typeof primaryType === "string" && primaryType.length <= MAX_PLAIN_STRING ? ` primaryType=${primaryType}` : "";
+  return `<json len=${json.length} sha256=${sha256Short(json)}${hint}>`;
+}
+function summarizePayload(key, value, ctx) {
+  if (value === null || value === void 0 || typeof value === "boolean") return value;
+  if (typeof value === "number") return value;
+  const bytes = toBytes(value);
+  if (bytes) {
+    const hint = describe(key, bytes, ctx);
+    return `<hex len=${bytes.length} sha256=${sha256Short(bytes)}${hint ? ` ${hint}` : ""}>`;
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+      try {
+        return jsonSummary(value, JSON.parse(value));
+      } catch {
+      }
+    }
+    const hints = [];
+    if (key === "serializedtx" && ctx.method.startsWith("evm") && isPlainHex(value)) {
+      const type = evmTxType(value);
+      if (type) hints.push(`type=${type}`);
+    }
+    const extra = describe(key, value, ctx);
+    if (extra) hints.push(extra);
+    const kind = isPlainHex(value) ? "hex" : "str";
+    const suffix = hints.length ? ` ${hints.join(" ")}` : "";
+    return `<${kind} len=${value.length} sha256=${sha256Short(value)}${suffix}>`;
+  }
+  const json = safeJson(value);
+  if (json === void 0) return "<object unhashable>";
+  return jsonSummary(json, value);
+}
+function summarizeString(value, key, ctx) {
+  if (key && KEEP_KEYS.has(key)) return value;
+  if (key && ctx.inError && ERROR_TEXT_KEYS.has(key)) {
+    return value.length > MAX_ERROR_STRING ? `${value.slice(0, MAX_ERROR_STRING)}\u2026` : value;
+  }
+  if (XPUB_RE.test(value)) return summarizeKeyMaterial(value);
+  if (value.length <= MAX_PLAIN_STRING) return value;
+  const kind = isPlainHex(value) ? "hex" : "str";
+  return `<${kind} len=${value.length} sha256=${sha256Short(value)}>`;
+}
+function summarizeError(err, depth, ctx) {
+  const e = err;
+  const out = {
+    name: err.name,
+    message: summarizeString(err.message, "message", ctx)
+  };
+  for (const field of ERROR_FIELDS) {
+    if (e[field] !== void 0) {
+      out[field] = summarizeValue(e[field], normalizeKey(field), depth + 1, ctx);
+    }
+  }
+  return out;
+}
+function summarizeByKey(rawKey, value, depth, ctx) {
+  const k = normalizeKey(rawKey);
+  if (value === void 0 || value === null) return value;
+  if (SECRET_KEYS.has(k)) return `<redacted len=${lengthOf(value)}>`;
+  if (KEY_MATERIAL_KEYS.has(k)) {
+    if (typeof value === "string" || toBytes(value)) return summarizeKeyMaterial(value);
+  }
+  if (SIGNATURE_KEYS.has(k)) {
+    if (Array.isArray(value)) return `<signatures count=${value.length}>`;
+    return `<signature len=${lengthOf(value)}>`;
+  }
+  if (SIGNED_PSBT_KEYS.has(k)) return `<psbt len=${lengthOf(value)}>`;
+  if (SIGNED_TX_KEYS.has(k) || ctx.role === "result" && TX_IN_RESULT_KEYS.has(k)) {
+    return `<signedTx len=${lengthOf(value)}>`;
+  }
+  if (AMOUNT_KEYS.has(k)) return "<amount>";
+  if (ctx.inError && ERROR_TEXT_KEYS.has(k) && typeof value === "string") {
+    return summarizeString(value, k, ctx);
+  }
+  if (PAYLOAD_KEYS.has(k)) return summarizePayload(k, value, ctx);
+  if (ADDRESS_KEYS.has(k) || k.endsWith("address") || k.endsWith("addresses")) {
+    if (typeof value === "string") return maskAddress(value);
+    if (Array.isArray(value)) {
+      return capArray(value, (item) => typeof item === "string" ? maskAddress(item) : "<addr>");
+    }
+  }
+  const inError = ERROR_CONTEXT_KEYS.has(k);
+  const childCtx = inError === ctx.inError ? ctx : { ...ctx, inError };
+  return summarizeValue(value, k, depth, childCtx);
+}
+function capArray(items, map) {
+  const out = items.slice(0, MAX_ARRAY_ITEMS).map(map);
+  if (items.length > MAX_ARRAY_ITEMS) out.push(`\u2026+${items.length - MAX_ARRAY_ITEMS} more`);
+  return out;
+}
+function summarizeValue(value, key, depth, ctx) {
+  switch (typeof value) {
+    case "undefined":
+    case "boolean":
+      return value;
+    case "number":
+      return Number.isFinite(value) ? value : String(value);
+    case "bigint":
+      return `${value}n`;
+    case "string":
+      return summarizeString(value, key, ctx);
+    case "function":
+      return "<function>";
+    case "symbol":
+      return "<symbol>";
+    default:
+      break;
+  }
+  if (value === null) return null;
+  const bytes = toBytes(value);
+  if (bytes) return `<hex len=${bytes.length} sha256=${sha256Short(bytes)}>`;
+  const obj = value;
+  if (ctx.ancestors.has(obj)) return "<circular>";
+  if (depth >= MAX_DEPTH) return "<depth>";
+  ctx.ancestors.add(obj);
+  try {
+    if (value instanceof Error) return summarizeError(value, depth, { ...ctx, inError: true });
+    if (Array.isArray(value)) {
+      return capArray(value, (item) => summarizeValue(item, key, depth + 1, ctx));
+    }
+    const out = {};
+    for (const [childKey, child] of Object.entries(value)) {
+      out[childKey] = summarizeByKey(childKey, child, depth + 1, ctx);
+    }
+    return out;
+  } finally {
+    ctx.ancestors.delete(obj);
+  }
+}
+function summarizeForLog(value, options = {}) {
+  try {
+    return summarizeValue(value, void 0, 0, {
+      method: options.method ?? "",
+      role: options.role ?? "params",
+      describePayload: options.describePayload,
+      inError: false,
+      ancestors: /* @__PURE__ */ new Set()
+    });
+  } catch {
+    return "<unloggable>";
+  }
+}
+
 // src/utils/deviceIdentity.ts
 var ONEKEY_BLE_SERVICE_UUID = "00000001-0000-1000-8000-00805f9b34fb";
 var TREZOR_BLE_SERVICE_UUID = "8c000001-a59b-4d58-a9ad-073df69fa1b1";
@@ -1433,6 +1780,7 @@ export {
   serializeConnectorError,
   stripHex,
   success,
+  summarizeForLog,
   toPhysicalDeviceSearchTarget
 };
 //# sourceMappingURL=index.mjs.map