@reclaimprotocol/attestor-core 5.0.7 → 5.1.0-dev.1

package/lib/config/index.d.ts

@@ -10,10 +10,10 @@ export declare const API_SERVER_PORT = 8001;
 export declare const CONNECTION_TIMEOUT_MS = 10000;
 export declare const DNS_SERVERS: string[];
 export declare const MAX_CLAIM_TIMESTAMP_DIFF_S: number;
-export declare const CURRENT_ATTESTOR_VERSION: 6;
+export declare const CURRENT_ATTESTOR_VERSION: 7;
 export declare const DEFAULT_METADATA: InitRequest;
 export declare const PROVIDER_CTX: {
-    version: 6;
+    version: 7;
 };
 export declare const PING_INTERVAL_MS = 10000;
 /**

package/lib/external-rpc/index.js

@@ -2489,6 +2489,7 @@ var AttestorVersion = {
   ATTESTOR_VERSION_2_0_1: 4,
   ATTESTOR_VERSION_3_0_0: 5,
   ATTESTOR_VERSION_3_1_0: 6,
+  ATTESTOR_VERSION_3_2_0: 7,
   UNRECOGNIZED: -1
 };
 function attestorVersionFromJSON(object) {
@@ -2514,6 +2515,9 @@ function attestorVersionFromJSON(object) {
     case 6:
     case "ATTESTOR_VERSION_3_1_0":
       return AttestorVersion.ATTESTOR_VERSION_3_1_0;
+    case 7:
+    case "ATTESTOR_VERSION_3_2_0":
+      return AttestorVersion.ATTESTOR_VERSION_3_2_0;
     case -1:
     case "UNRECOGNIZED":
     default:
@@ -2536,6 +2540,8 @@ function attestorVersionToJSON(object) {
       return "ATTESTOR_VERSION_3_0_0";
     case AttestorVersion.ATTESTOR_VERSION_3_1_0:
       return "ATTESTOR_VERSION_3_1_0";
+    case AttestorVersion.ATTESTOR_VERSION_3_2_0:
+      return "ATTESTOR_VERSION_3_2_0";
     case AttestorVersion.UNRECOGNIZED:
     default:
       return "UNRECOGNIZED";
@@ -6901,7 +6907,7 @@ var WS_PATHNAME = "/ws";
 var BROWSER_RPC_PATHNAME = "/browser-rpc";
 var DEFAULT_REMOTE_FILE_FETCH_BASE_URL = `${BROWSER_RPC_PATHNAME}/resources`;
 var MAX_CLAIM_TIMESTAMP_DIFF_S = 10 * 60;
-var CURRENT_ATTESTOR_VERSION = AttestorVersion.ATTESTOR_VERSION_3_1_0;
+var CURRENT_ATTESTOR_VERSION = AttestorVersion.ATTESTOR_VERSION_3_2_0;
 var DEFAULT_METADATA = {
   signatureType: ServiceSignatureType.SERVICE_SIGNATURE_TYPE_ETH,
   clientVersion: CURRENT_ATTESTOR_VERSION,
@@ -8421,23 +8427,233 @@ import {
 } from "esprima-next";
 import { JSONPath } from "jsonpath-plus";
 import { parse } from "parse5";
-import { adapter as htmlAdapter } from "parse5-htmlparser2-tree-adapter";
+
+// node_modules/parse5-htmlparser2-tree-adapter/dist/index.js
+import { html } from "parse5";
+function enquoteDoctypeId(id) {
+  const quote = id.includes('"') ? "'" : '"';
+  return quote + id + quote;
+}
+function serializeDoctypeContent(name, publicId, systemId) {
+  let str = "!DOCTYPE ";
+  if (name) {
+    str += name;
+  }
+  if (publicId) {
+    str += ` PUBLIC ${enquoteDoctypeId(publicId)}`;
+  } else if (systemId) {
+    str += " SYSTEM";
+  }
+  if (systemId) {
+    str += ` ${enquoteDoctypeId(systemId)}`;
+  }
+  return str;
+}
+var adapter = {
+  // Re-exports from domhandler
+  isCommentNode: isComment,
+  isElementNode: isTag2,
+  isTextNode: isText,
+  //Node construction
+  createDocument() {
+    const node = new Document([]);
+    node["x-mode"] = html.DOCUMENT_MODE.NO_QUIRKS;
+    return node;
+  },
+  createDocumentFragment() {
+    return new Document([]);
+  },
+  createElement(tagName, namespaceURI, attrs) {
+    const attribs = /* @__PURE__ */ Object.create(null);
+    const attribsNamespace = /* @__PURE__ */ Object.create(null);
+    const attribsPrefix = /* @__PURE__ */ Object.create(null);
+    for (let i = 0; i < attrs.length; i++) {
+      const attrName = attrs[i].name;
+      attribs[attrName] = attrs[i].value;
+      attribsNamespace[attrName] = attrs[i].namespace;
+      attribsPrefix[attrName] = attrs[i].prefix;
+    }
+    const node = new Element(tagName, attribs, []);
+    node.namespace = namespaceURI;
+    node["x-attribsNamespace"] = attribsNamespace;
+    node["x-attribsPrefix"] = attribsPrefix;
+    return node;
+  },
+  createCommentNode(data) {
+    return new Comment2(data);
+  },
+  createTextNode(value) {
+    return new Text2(value);
+  },
+  //Tree mutation
+  appendChild(parentNode, newNode) {
+    const prev = parentNode.children[parentNode.children.length - 1];
+    if (prev) {
+      prev.next = newNode;
+      newNode.prev = prev;
+    }
+    parentNode.children.push(newNode);
+    newNode.parent = parentNode;
+  },
+  insertBefore(parentNode, newNode, referenceNode) {
+    const insertionIdx = parentNode.children.indexOf(referenceNode);
+    const { prev } = referenceNode;
+    if (prev) {
+      prev.next = newNode;
+      newNode.prev = prev;
+    }
+    referenceNode.prev = newNode;
+    newNode.next = referenceNode;
+    parentNode.children.splice(insertionIdx, 0, newNode);
+    newNode.parent = parentNode;
+  },
+  setTemplateContent(templateElement, contentElement) {
+    adapter.appendChild(templateElement, contentElement);
+  },
+  getTemplateContent(templateElement) {
+    return templateElement.children[0];
+  },
+  setDocumentType(document, name, publicId, systemId) {
+    const data = serializeDoctypeContent(name, publicId, systemId);
+    let doctypeNode = document.children.find((node) => isDirective(node) && node.name === "!doctype");
+    if (doctypeNode) {
+      doctypeNode.data = data !== null && data !== void 0 ? data : null;
+    } else {
+      doctypeNode = new ProcessingInstruction("!doctype", data);
+      adapter.appendChild(document, doctypeNode);
+    }
+    doctypeNode["x-name"] = name;
+    doctypeNode["x-publicId"] = publicId;
+    doctypeNode["x-systemId"] = systemId;
+  },
+  setDocumentMode(document, mode) {
+    document["x-mode"] = mode;
+  },
+  getDocumentMode(document) {
+    return document["x-mode"];
+  },
+  detachNode(node) {
+    if (node.parent) {
+      const idx = node.parent.children.indexOf(node);
+      const { prev, next } = node;
+      node.prev = null;
+      node.next = null;
+      if (prev) {
+        prev.next = next;
+      }
+      if (next) {
+        next.prev = prev;
+      }
+      node.parent.children.splice(idx, 1);
+      node.parent = null;
+    }
+  },
+  insertText(parentNode, text) {
+    const lastChild = parentNode.children[parentNode.children.length - 1];
+    if (lastChild && isText(lastChild)) {
+      lastChild.data += text;
+    } else {
+      adapter.appendChild(parentNode, adapter.createTextNode(text));
+    }
+  },
+  insertTextBefore(parentNode, text, referenceNode) {
+    const prevNode = parentNode.children[parentNode.children.indexOf(referenceNode) - 1];
+    if (prevNode && isText(prevNode)) {
+      prevNode.data += text;
+    } else {
+      adapter.insertBefore(parentNode, adapter.createTextNode(text), referenceNode);
+    }
+  },
+  adoptAttributes(recipient, attrs) {
+    for (let i = 0; i < attrs.length; i++) {
+      const attrName = attrs[i].name;
+      if (recipient.attribs[attrName] === void 0) {
+        recipient.attribs[attrName] = attrs[i].value;
+        recipient["x-attribsNamespace"][attrName] = attrs[i].namespace;
+        recipient["x-attribsPrefix"][attrName] = attrs[i].prefix;
+      }
+    }
+  },
+  //Tree traversing
+  getFirstChild(node) {
+    return node.children[0];
+  },
+  getChildNodes(node) {
+    return node.children;
+  },
+  getParentNode(node) {
+    return node.parent;
+  },
+  getAttrList(element) {
+    return element.attributes;
+  },
+  //Node data
+  getTagName(element) {
+    return element.name;
+  },
+  getNamespaceURI(element) {
+    return element.namespace;
+  },
+  getTextNodeContent(textNode) {
+    return textNode.data;
+  },
+  getCommentNodeContent(commentNode) {
+    return commentNode.data;
+  },
+  getDocumentTypeNodeName(doctypeNode) {
+    var _a;
+    return (_a = doctypeNode["x-name"]) !== null && _a !== void 0 ? _a : "";
+  },
+  getDocumentTypeNodePublicId(doctypeNode) {
+    var _a;
+    return (_a = doctypeNode["x-publicId"]) !== null && _a !== void 0 ? _a : "";
+  },
+  getDocumentTypeNodeSystemId(doctypeNode) {
+    var _a;
+    return (_a = doctypeNode["x-systemId"]) !== null && _a !== void 0 ? _a : "";
+  },
+  //Node types
+  isDocumentTypeNode(node) {
+    return isDirective(node) && node.name === "!doctype";
+  },
+  // Source code location
+  setNodeSourceCodeLocation(node, location) {
+    if (location) {
+      node.startIndex = location.startOffset;
+      node.endIndex = location.endOffset;
+    }
+    node.sourceCodeLocation = location;
+  },
+  getNodeSourceCodeLocation(node) {
+    return node.sourceCodeLocation;
+  },
+  updateNodeSourceCodeLocation(node, endLocation) {
+    if (endLocation.endOffset != null)
+      node.endIndex = endLocation.endOffset;
+    node.sourceCodeLocation = {
+      ...node.sourceCodeLocation,
+      ...endLocation
+    };
+  }
+};
+
+// src/providers/http/utils.ts
 import RE2 from "re2";
 import xpath from "xpath";
-function extractHTMLElement(html, xpathExpression, contentsOnly) {
-  const { start, end } = extractHTMLElementIndex(html, xpathExpression, contentsOnly);
-  return html.slice(start, end);
+function extractHTMLElement(html2, xpathExpression, contentsOnly) {
+  const { start, end } = extractHTMLElementIndex(html2, xpathExpression, contentsOnly);
+  return html2.slice(start, end);
 }
-function extractHTMLElementIndex(html, xpathExpression, contentsOnly) {
-  return extractHTMLElementsIndexes(html, xpathExpression, contentsOnly)[0];
+function extractHTMLElementIndex(html2, xpathExpression, contentsOnly) {
+  return extractHTMLElementsIndexes(html2, xpathExpression, contentsOnly)[0];
 }
-function extractHTMLElementsIndexes(html, xpathExpression, contentsOnly) {
-  return extractHTMLElementIndexesParse5(html, xpathExpression, contentsOnly);
+function extractHTMLElementsIndexes(html2, xpathExpression, contentsOnly) {
+  return extractHTMLElementIndexesParse5(html2, xpathExpression, contentsOnly);
 }
-function extractHTMLElementIndexesParse5(html, xpathExpression, contentsOnly) {
+function extractHTMLElementIndexesParse5(html2, xpathExpression, contentsOnly) {
   const domLight = parse(
-    html,
-    { treeAdapter: htmlAdapter, sourceCodeLocationInfo: true }
+    html2,
+    { treeAdapter: adapter, sourceCodeLocationInfo: true }
   );
   domLight["name"] = "root";
   const parsedPath = xpath.parse(xpathExpression);
@@ -8798,6 +9014,7 @@ var HTTP_PROVIDER = {
       logger2.error({ response: encodeBase643(response) });
       throw new Error("Failed to find response body");
     }
+    const revealFraming = shouldRevealChunkFraming(ctx.version);
     const reveals = [
       { fromIndex: 0, toIndex: headerEndIndex }
     ];
@@ -8814,6 +9031,9 @@ var HTTP_PROVIDER = {
     if (res.headerIndices["date"]) {
       reveals.push(res.headerIndices["date"]);
     }
+    if (revealFraming && res.headerIndices["transfer-encoding"]) {
+      reveals.push(res.headerIndices["transfer-encoding"]);
+    }
     const body = uint8ArrayToBinaryStr2(res.body);
     const redactions = [];
     for (const rs of params.responseRedactions || []) {
@@ -8821,23 +9041,34 @@ var HTTP_PROVIDER = {
         body,
         rs,
         bodyStartIdx,
-        res.chunks
+        res.chunks,
+        revealFraming
       );
       for (const { reveal, redactions: reds } of processor) {
         reveals.push(reveal);
         redactions.push(...reds);
       }
     }
-    reveals.sort((a, b) => a.toIndex - b.toIndex);
+    if (revealFraming && res.chunks?.length) {
+      let prev = res.headerEndIdx + 4;
+      for (const chunk of res.chunks) {
+        reveals.push({ fromIndex: prev, toIndex: chunk.fromIndex });
+        prev = chunk.toIndex;
+      }
+      reveals.push({ fromIndex: prev, toIndex: response.length });
+    }
+    reveals.sort((a, b) => a.fromIndex - b.fromIndex);
     if (reveals.length > 1) {
       let currentIndex = 0;
       for (const r of reveals) {
         if (currentIndex < r.fromIndex) {
           redactions.push({ fromIndex: currentIndex, toIndex: r.fromIndex });
         }
-        currentIndex = r.toIndex;
+        currentIndex = Math.max(currentIndex, r.toIndex);
+      }
+      if (currentIndex < response.length) {
+        redactions.push({ fromIndex: currentIndex, toIndex: response.length });
       }
-      redactions.push({ fromIndex: currentIndex, toIndex: response.length });
     }
     for (const r of reveals) {
       if (!r.hash) {
@@ -8887,7 +9118,9 @@ var HTTP_PROVIDER = {
     if (connectionHeader !== "close") {
       throw new Error(`Connection header must be "close", got "${connectionHeader}"`);
     }
-    const serverBlocks = receipt.filter((s) => s.sender === "server").map((r) => r.message).filter((b) => !b.every((b2) => b2 === REDACTION_CHAR_CODE2));
+    const allServerBlocks = receipt.filter((s) => s.sender === "server").map((r) => r.message);
+    const firstRealIdx = allServerBlocks.findIndex((b) => !b.every((x) => x === REDACTION_CHAR_CODE2));
+    const serverBlocks = firstRealIdx === -1 ? [] : allServerBlocks.slice(firstRealIdx);
     const response = concatArrays(...serverBlocks);
     let res;
     res = uint8ArrayToStr(response);
@@ -8930,8 +9163,11 @@ var HTTP_PROVIDER = {
     if (paramBody.length > 0 && !matchRedactedStrings(paramBody, req.body)) {
       throw new Error("request body mismatch");
     }
-    if (!secretParams) {
-      res = res.slice(bodyStart).replace(/(\*){3,}/g, "");
+    if (shouldRevealChunkFraming(clientVersion)) {
+      const headersStr = res.slice(0, bodyStart);
+      res = /transfer-encoding:\s*chunked/i.test(headersStr) ? headersStr + dechunkResponseBody(res.slice(bodyStart)) : res;
+    } else if (!secretParams) {
+      res = res.slice(bodyStart).replace(/\*{3,}/g, "");
     }
     for (const { type, value, invert } of params.responseMatches || []) {
       const inv = Boolean(invert);
@@ -9018,6 +9254,16 @@ function assertNoSmuggle(reqBuffer, params) {
 function shouldRevealCrlf({ version }) {
   return version >= AttestorVersion.ATTESTOR_VERSION_2_0_1;
 }
+function shouldRevealChunkFraming(version) {
+  return version >= AttestorVersion.ATTESTOR_VERSION_3_2_0;
+}
+function dechunkResponseBody(body) {
+  const parser = makeHttpResponseParser();
+  parser.onChunk(
+    strToUint8Array("HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n" + body)
+  );
+  return uint8ArrayToStr(parser.res.body ?? new Uint8Array());
+}
 function getHostPort(params, secretParams) {
   const { host } = new URL(getURL(params, secretParams));
   if (!host) {
@@ -9031,7 +9277,7 @@ function getHostHeaderString(url) {
   return port && +port !== DEFAULT_HTTPS_PORT ? `${host}:${port}` : host;
 }
 var paramsRegex = /{{([^{}]+)}}/sgi;
-function* processRedactionRequest(body, rs, bodyStartIdx, resChunks) {
+function* processRedactionRequest(body, rs, bodyStartIdx, resChunks, revealFraming) {
   let element = body;
   let elementIdx = 0;
   let elementLength = -1;
@@ -9121,19 +9367,13 @@ function* processRedactionRequest(body, rs, bodyStartIdx, resChunks) {
     elementLength = element.length;
     yield* addRedaction(null);
   }
-  function* addRedaction(hash = rs.hash, _resChunks = resChunks) {
+  function* addRedaction(hash = rs.hash) {
     if (elementIdx < 0 || !elementLength) {
       return;
     }
     const reveal = getReveal(elementIdx, elementLength, hash || void 0);
-    yield {
-      reveal,
-      redactions: getRedactionsForChunkHeaders(
-        reveal.fromIndex,
-        reveal.toIndex,
-        _resChunks
-      )
-    };
+    const redactions = revealFraming ? [] : getRedactionsForChunkHeaders(reveal.fromIndex, reveal.toIndex, resChunks);
+    yield { reveal, redactions };
   }
   function getReveal(startIdx, len, hash) {
     const from = convertResponsePosToAbsolutePos(
@@ -9692,13 +9932,25 @@ async function _createClaimOnAttestor({
       }
       revealedPackets.push(...packets.filter((p) => p.sender === "server"));
     } else {
-      for (const {
-        block,
-        redactedPlaintext,
-        overshotToprfFromPrevBlock,
-        toprfs,
-        oprfRawMarkers
-      } of serverPacketsToReveal) {
+      const revealByBlock = new Map(
+        serverPacketsToReveal.map((r) => [r.block, r])
+      );
+      for (const sb of serverBlocks) {
+        const reveal = revealByBlock.get(sb);
+        if (!reveal) {
+          revealedPackets.push({
+            sender: "server",
+            message: new Uint8Array(sb.plaintext.length).fill(REDACTION_CHAR_CODE2)
+          });
+          continue;
+        }
+        const {
+          block,
+          redactedPlaintext,
+          overshotToprfFromPrevBlock,
+          toprfs,
+          oprfRawMarkers
+        } = reveal;
         setRevealOfMessage(block.message, {
           type: "zk",
           redactedPlaintext,