@dynamic-labs-wallet/forward-mpc-client 0.9.0 → 0.10.1

package/dist/index.cjs

@@ -42,6 +42,96 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 var ATTESTATION_CONSTANTS = {
   // Maximum age of attestation document in milliseconds
   MAX_ATTESTATION_AGE: 5 * 60 * 1e3};
+
+// src/attestation/attestationDocReader.ts
+var PCRS_LABEL_AND_MAP_HEADER = new Uint8Array([
+  100,
+  112,
+  99,
+  114,
+  115,
+  176
+]);
+var BSTR_48_PREFIX = new Uint8Array([
+  88,
+  48
+]);
+var PCR_VALUE_BYTES = 48;
+var PCR_ENTRIES = 16;
+var TRACKED_PCRS = /* @__PURE__ */ new Set([
+  0,
+  1,
+  2,
+  8
+]);
+function decodeBase64ToBytes(base64) {
+  if (typeof atob !== "undefined") {
+    const binary = atob(base64);
+    const out = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+      out[i] = binary.codePointAt(i) ?? 0;
+    }
+    return out;
+  }
+  return new Uint8Array(Buffer.from(base64, "base64"));
+}
+__name(decodeBase64ToBytes, "decodeBase64ToBytes");
+function bytesToHex(bytes) {
+  let out = "";
+  for (const b of bytes) {
+    out += b.toString(16).padStart(2, "0");
+  }
+  return out;
+}
+__name(bytesToHex, "bytesToHex");
+function findMarker(haystack, needle) {
+  outer: for (let i = 0; i <= haystack.length - needle.length; i++) {
+    for (let j = 0; j < needle.length; j++) {
+      if (haystack[i + j] !== needle[j]) continue outer;
+    }
+    return i;
+  }
+  return -1;
+}
+__name(findMarker, "findMarker");
+function extractPcrsFromAttestationDoc(attestationDocBase64) {
+  const pcrs = {};
+  if (!attestationDocBase64) return pcrs;
+  try {
+    const bytes = decodeBase64ToBytes(attestationDocBase64);
+    const markerIdx = findMarker(bytes, PCRS_LABEL_AND_MAP_HEADER);
+    if (markerIdx < 0) return pcrs;
+    let pos = markerIdx + PCRS_LABEL_AND_MAP_HEADER.length;
+    for (let i = 0; i < PCR_ENTRIES; i++) {
+      if (pos + 1 + BSTR_48_PREFIX.length + PCR_VALUE_BYTES > bytes.length) {
+        break;
+      }
+      const key = bytes[pos++];
+      if (bytes[pos] !== BSTR_48_PREFIX[0] || bytes[pos + 1] !== BSTR_48_PREFIX[1]) {
+        break;
+      }
+      pos += BSTR_48_PREFIX.length;
+      const value = bytes.subarray(pos, pos + PCR_VALUE_BYTES);
+      pos += PCR_VALUE_BYTES;
+      if (TRACKED_PCRS.has(key)) {
+        pcrs[key] = bytesToHex(value);
+      }
+    }
+  } catch {
+  }
+  return pcrs;
+}
+__name(extractPcrsFromAttestationDoc, "extractPcrsFromAttestationDoc");
+function formatPcrMismatchDetail(expectedPcr8, receivedPcrs) {
+  const receivedParts = [];
+  if (receivedPcrs[8] !== void 0) receivedParts.push(`pcr8=${receivedPcrs[8]}`);
+  if (receivedPcrs[0] !== void 0) receivedParts.push(`pcr0=${receivedPcrs[0]}`);
+  if (receivedPcrs[1] !== void 0) receivedParts.push(`pcr1=${receivedPcrs[1]}`);
+  if (receivedPcrs[2] !== void 0) receivedParts.push(`pcr2=${receivedPcrs[2]}`);
+  const received = receivedParts.length > 0 ? receivedParts.join(", ") : "unavailable";
+  return `expected pcr8=${expectedPcr8}; received ${received}`;
+}
+__name(formatPcrMismatchDetail, "formatPcrMismatchDetail");
 var NitroAttestationVerifier = class {
   static {
     __name(this, "NitroAttestationVerifier");
@@ -111,10 +201,12 @@ var NitroAttestationVerifier = class {
         expectedPcrs
       ]);
       if (!isValid) {
+        const receivedPcrs = extractPcrsFromAttestationDoc(attestationDocBase64);
+        const detail = formatPcrMismatchDetail(this.config.expectedPcr8, receivedPcrs);
         return {
           valid: false,
           errors: [
-            "Attestation document PCR verification failed"
+            `Attestation document PCR verification failed (${detail})`
           ],
           timestamp: Date.now()
         };
@@ -617,6 +709,8 @@ var ForwardMPCClient = class extends EventEmitter2.EventEmitter {
     }
   }
 };
+
+// src/client-v2/errors.ts
 var ErrorCode = {
   // Transport
   CONNECTION_FAILED: "CONNECTION_FAILED",
@@ -823,6 +917,21 @@ var ClientSessionEstablishFailedError = class extends ClientError {
     super("Failed to establish session", ErrorCode.SESSION_ESTABLISH_FAILED, context);
   }
 };
+var FORWARD_MPC_ERROR_NAMES = /* @__PURE__ */ new Set([
+  "TransportConnectionError",
+  "TransportConnectionTimeoutError",
+  "TransportNotConnectedError",
+  "SessionHandshakeError",
+  "SessionHandshakeInvalidResponseError",
+  "SessionAttestationError",
+  "SessionRequestTimeoutError",
+  "SessionDisposedError",
+  "SessionServerError",
+  "SessionMessageParseError",
+  "SessionRemoteError",
+  "ClientUnsupportedAlgorithmError",
+  "ClientSessionEstablishFailedError"
+]);
 
 // src/client-v2/transport.ts
 var ForwardMPCTransport = class extends EventEmitter2__default.default {
@@ -1450,8 +1559,22 @@ var ForwardMPCClientSingleton = class extends ForwardMPCClientV2 {
 };
 
 // src/client-v2/error-classification.ts
+function matchesForwardMpcErrorClass(error, ctor, name) {
+  if (error instanceof ctor) {
+    return true;
+  }
+  return error instanceof Error && error.name === name && typeof error.code === "string";
+}
+__name(matchesForwardMpcErrorClass, "matchesForwardMpcErrorClass");
+function matchesAnyForwardMpcError(error) {
+  if (error instanceof ForwardMPCError) {
+    return true;
+  }
+  return error instanceof Error && FORWARD_MPC_ERROR_NAMES.has(error.name) && typeof error.code === "string";
+}
+__name(matchesAnyForwardMpcError, "matchesAnyForwardMpcError");
 function classifyForwardMpcError(error) {
-  if (error instanceof SessionAttestationError) {
+  if (matchesForwardMpcErrorClass(error, SessionAttestationError, "SessionAttestationError")) {
     return {
       errorType: "ATTESTATION_FAILURE",
       errorCode: error.code,
@@ -1461,22 +1584,22 @@ function classifyForwardMpcError(error) {
       shouldFallback: true
     };
   }
-  if (error instanceof SessionRequestTimeoutError) {
+  if (matchesForwardMpcErrorClass(error, SessionRequestTimeoutError, "SessionRequestTimeoutError")) {
     return {
       errorType: "FORWARD_MPC_TIMEOUT",
       errorCode: error.code,
       errorMessage: error.message,
       sessionEstablished: true,
-      shouldFallback: false
+      shouldFallback: true
     };
   }
-  if (error instanceof ForwardMPCError) {
+  if (matchesAnyForwardMpcError(error)) {
     return {
       errorType: "FORWARD_MPC_ERROR",
       errorCode: error.code,
       errorMessage: error.message,
       sessionEstablished: true,
-      shouldFallback: false
+      shouldFallback: true
     };
   }
   return {
@@ -1484,16 +1607,16 @@ function classifyForwardMpcError(error) {
     errorCode: void 0,
     errorMessage: error instanceof Error ? error.message : String(error),
     sessionEstablished: false,
-    shouldFallback: false
+    shouldFallback: true
   };
 }
 __name(classifyForwardMpcError, "classifyForwardMpcError");
 function isForwardMpcError(error) {
-  return error instanceof ForwardMPCError;
+  return matchesAnyForwardMpcError(error);
 }
 __name(isForwardMpcError, "isForwardMpcError");
 function isAttestationError(error) {
-  return error instanceof SessionAttestationError;
+  return matchesForwardMpcErrorClass(error, SessionAttestationError, "SessionAttestationError");
 }
 __name(isAttestationError, "isAttestationError");