@onekeyfe/hwk-trezor-connector 1.2.1 → 1.2.2-alpha.1

package/dist/index.js

@@ -7273,7 +7273,7 @@ var transformSchemaFields = (operation, schema, sourceData) => {
     } else if (schemaField.fieldKind === "scalar") {
       transformedData[schemaField.name] = transformField(schemaField, fieldValue);
     } else if (schemaField.fieldKind === "enum") {
-      transformedData[schemaField.name] = fieldValue;
+      transformedData[schemaField.name] = transformField(schemaField, fieldValue);
     } else {
       transformedData[schemaField.name] = fieldValue;
     }
@@ -7383,8 +7383,10 @@ var ProtobufManager = () => {
   const decode = (type, data) => {
     const { schema, messageName } = findSchema(type);
     const binaryPayload = Buffer.isBuffer(data) ? data : Buffer.from(data);
-    const patchedPayload = messageName === "Failure" && binaryPayload.subarray(0, 2).compare(Buffer.from("0811", "hex")) === 0 ? binaryPayload.subarray(0, 2) : binaryPayload;
-    const decoded = fromBinary(schema, patchedPayload, { readUnknownFields: false });
+    const patchedPayload = messageName === "Failure" && binaryPayload[0] === 8 && binaryPayload[1] === 17 ? binaryPayload.subarray(0, 2) : binaryPayload;
+    const decoded = fromBinary(schema, Uint8Array.from(patchedPayload), {
+      readUnknownFields: false
+    });
     const json = toJson(schema, decoded, { useProtoFieldName: true });
     const message = transformSchemaFields("decode", schema, json);
     return {
@@ -7678,6 +7680,111 @@ function getTrezorResponseMessage(response) {
   }
   return {};
 }
+var AUTHENTICITY_PROOF_CHUNK_SIZE = 500;
+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,
+      message: `Invalid Trezor authenticity proof part size: ${String(size)}`
+    });
+  }
+  return size;
+};
+var readAuthenticityProofPart = async ({
+  deviceSession,
+  proofType,
+  index,
+  size
+}) => {
+  const expectedSize = validateAuthenticityProofPartSize(size);
+  let offset = 0;
+  let result = "";
+  while (offset < expectedSize) {
+    const requestedSize = Math.min(AUTHENTICITY_PROOF_CHUNK_SIZE, expectedSize - offset);
+    const request = {
+      proof_type: proofType,
+      offset,
+      size: requestedSize
+    };
+    if (index !== void 0) request.index = index;
+    const response = await deviceSession.call(
+      "GetAuthenticityProofChunk",
+      request
+    );
+    if (response.type !== "AuthenticityProofChunk") {
+      throw (0, import_hwk_adapter_core2.createHwkError)({
+        code: import_hwk_adapter_core2.HardwareErrorCode.UnknownError,
+        message: `Expected AuthenticityProofChunk, received ${response.type}`
+      });
+    }
+    const chunk = response.message?.chunk;
+    if (typeof chunk !== "string" || chunk.length !== requestedSize * 2) {
+      throw (0, import_hwk_adapter_core2.createHwkError)({
+        code: import_hwk_adapter_core2.HardwareErrorCode.UnknownError,
+        message: "Trezor returned an invalid authenticity proof chunk"
+      });
+    }
+    result += chunk;
+    offset += requestedSize;
+  }
+  return result;
+};
+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,
+        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,
+        message: `Trezor authenticity proof contains too many certificates: ${values.length}`
+      });
+    }
+    const certificates = [];
+    for (let index = 0; index < values.length; index += 1) {
+      certificates.push(
+        await readAuthenticityProofPart({
+          deviceSession,
+          proofType,
+          index,
+          size: validateAuthenticityProofPartSize(values[index])
+        })
+      );
+    }
+    return certificates;
+  };
+  const readSignature = async (proofType, size) => {
+    if (size === void 0 || size === null || size === 0) return void 0;
+    return readAuthenticityProofPart({
+      deviceSession,
+      proofType,
+      size: validateAuthenticityProofPartSize(size)
+    });
+  };
+  try {
+    const optigaCertificates = await readCertificates(0, sizes.optiga_certificates ?? []);
+    const optigaSignature = await readSignature(0, sizes.optiga_signature);
+    const tropicCertificates = await readCertificates(1, sizes.tropic_certificates ?? []);
+    const tropicSignature = await readSignature(1, sizes.tropic_signature);
+    const mcuCertificates = await readCertificates(2, sizes.mcu_certificates ?? []);
+    const mcuSignature = await readSignature(2, sizes.mcu_signature);
+    return {
+      optiga_certificates: optigaCertificates,
+      optiga_signature: optigaSignature,
+      tropic_certificates: tropicCertificates,
+      tropic_signature: tropicSignature,
+      mcu_certificates: mcuCertificates,
+      mcu_signature: mcuSignature
+    };
+  } finally {
+    await deviceSession.call("GetAuthenticityProofChunk", { offset: 0, size: 0 });
+  }
+};
 var TrezorConnectorBase = class {
   connectionType;
   chunkSize;
@@ -7922,6 +8029,26 @@ var TrezorConnectorBase = class {
         );
       case "wipeDevice":
         return getTrezorResponseMessage(await session.deviceSession.call("WipeDevice", {}));
+      case "authenticateDevice": {
+        const p = params ?? {};
+        const response = await session.deviceSession.call("AuthenticateDevice", {
+          challenge: p.challenge,
+          stream: true
+        });
+        if (response.type === "AuthenticityProof") {
+          return getTrezorResponseMessage(response);
+        }
+        if (response.type !== "AuthenticityProofSizes") {
+          throw (0, import_hwk_adapter_core2.createHwkError)({
+            code: import_hwk_adapter_core2.HardwareErrorCode.UnknownError,
+            message: `Expected Trezor authenticity proof, received ${response.type}`
+          });
+        }
+        return readAuthenticityProofStream(
+          session.deviceSession,
+          response.message
+        );
+      }
       // --- THP application-session control (Trezor-specific, driven by the
       // adapter to align the active passphrase session before a chain call).
       // The connector deals only in session ids; wallet identity belongs to the