@reclaimprotocol/attestor-core 5.0.1-beta.2 → 5.0.1-beta.3

package/lib/browser/utils/b64-json.d.ts

@@ -0,0 +1,2 @@
+export declare const B64_JSON_REPLACER: (key: string, value: any) => any;
+export declare const B64_JSON_REVIVER: (key: string, value: any) => any;

package/lib/browser/utils/b64-json.js

@@ -0,0 +1,17 @@
+import { decodeBase64, encodeBase64 } from "ethers";
+const B64_JSON_REPLACER = (key, value) => {
+  if (value instanceof Uint8Array || typeof value === "object" && value && "buffer" in value && value.buffer instanceof ArrayBuffer) {
+    return { type: "uint8array", value: encodeBase64(value) };
+  }
+  return value;
+};
+const B64_JSON_REVIVER = (key, value) => {
+  if (value?.type === "uint8array") {
+    return decodeBase64(value.value);
+  }
+  return value;
+};
+export {
+  B64_JSON_REPLACER,
+  B64_JSON_REVIVER
+};

package/lib/browser/utils/claims.d.ts

@@ -0,0 +1,33 @@
+import { ClaimTunnelResponse } from '#src/proto/api.ts';
+import type { ClaimID, ClaimInfo, CompleteClaimData, ProviderParams } from '#src/types/index.ts';
+/**
+ * Creates the standard string to sign for a claim.
+ * This data is what the attestor will sign when it successfully
+ * verifies a claim.
+ */
+export declare function createSignDataForClaim(data: CompleteClaimData): string;
+/**
+ * Verify the claim tunnel response from a attestor.
+ *
+ * If you'd only like to verify the claim signature, you can
+ * optionally only pass "claim" & "signatures.claimSignature"
+ * to this function.
+ *
+ * The successful run of this function means that the claim
+ * is valid, and the attestor that signed the claim is valid.
+ */
+export declare function assertValidClaimSignatures({ signatures, ...res }: Partial<ClaimTunnelResponse>, metadata?: import("#src/proto/api.ts").InitRequest): Promise<void>;
+/**
+ * Generates a unique identifier for given claim info
+ * @param info
+ * @returns
+ */
+export declare function getIdentifierFromClaimInfo(info: ClaimInfo): ClaimID;
+/**
+ * Canonically stringifies an object, so that the same object will always
+ * produce the same string despite the order of keys
+ */
+export declare function canonicalStringify(params: {
+    [key: string]: any;
+} | undefined): string;
+export declare function hashProviderParams(params: ProviderParams<'http'>): string;

package/lib/browser/utils/claims.js

@@ -0,0 +1,89 @@
+import canonicalize from "canonicalize";
+import { keccak256 } from "ethers";
+import { DEFAULT_METADATA } from "../../config/index.js";
+import { ClaimTunnelResponse } from "../../proto/api.js";
+import { SIGNATURES, strToUint8Array } from "../../utils/index.js";
+function createSignDataForClaim(data) {
+  const lines = [
+    getIdentifierFromClaimInfo(data),
+    // we lowercase the owner to ensure that the
+    // ETH addresses always serialize the same way
+    data.owner.toLowerCase(),
+    data.timestampS.toString(),
+    data.epoch.toString()
+  ];
+  return lines.join("\n");
+}
+async function assertValidClaimSignatures({
+  signatures,
+  ...res
+}, metadata = DEFAULT_METADATA) {
+  if (!signatures) {
+    throw new Error("No signatures provided");
+  }
+  const {
+    resultSignature,
+    claimSignature,
+    attestorAddress
+  } = signatures;
+  const { verify } = SIGNATURES[metadata.signatureType];
+  if (signatures?.resultSignature) {
+    const resBytes = ClaimTunnelResponse.encode(ClaimTunnelResponse.create(res)).finish();
+    const verified = await verify(resBytes, resultSignature, attestorAddress);
+    if (!verified) {
+      throw new Error("Invalid result signature");
+    }
+  }
+  if (!res.claim) {
+    return;
+  }
+  const signData = createSignDataForClaim(res.claim);
+  const verifiedClaim = await verify(
+    strToUint8Array(signData),
+    claimSignature,
+    attestorAddress
+  );
+  if (!verifiedClaim) {
+    throw new Error("Invalid claim signature");
+  }
+}
+function getIdentifierFromClaimInfo(info) {
+  if (info.context?.length > 0) {
+    try {
+      const ctx = JSON.parse(info.context);
+      info.context = canonicalStringify(ctx);
+    } catch {
+      throw new Error("unable to parse non-empty context. Must be JSON");
+    }
+  }
+  const str = `${info.provider}
+${info.parameters}
+${info.context || ""}`;
+  return keccak256(strToUint8Array(str)).toLowerCase();
+}
+function canonicalStringify(params) {
+  if (!params) {
+    return "";
+  }
+  return canonicalize(params) || "";
+}
+function hashProviderParams(params) {
+  const filteredParams = {
+    url: params.url,
+    method: params.method,
+    body: params.body,
+    responseMatches: params.responseMatches,
+    responseRedactions: params.responseRedactions
+  };
+  const serializedParams = canonicalStringify(filteredParams);
+  return keccak256(
+    strToUint8Array(serializedParams)
+  ).toLowerCase();
+}
+export {
+  assertValidClaimSignatures,
+  canonicalStringify,
+  createSignDataForClaim,
+  getIdentifierFromClaimInfo,
+  hashProviderParams
+};

package/lib/browser/utils/env.d.ts

@@ -0,0 +1,3 @@
+export type TransportType = 'node' | 'react-native' | 'browser';
+export declare function detectEnvironment(): TransportType;
+export declare function getEnvVariable(name: string): string | undefined;

package/lib/browser/utils/env.js

@@ -0,0 +1,19 @@
+function detectEnvironment() {
+  if (typeof navigator !== "undefined" && navigator.product === "ReactNative") {
+    return "react-native";
+  }
+  if (typeof window !== "undefined") {
+    return "browser";
+  }
+  return "node";
+}
+function getEnvVariable(name) {
+  if (typeof process === "undefined") {
+    return void 0;
+  }
+  return process?.env[name];
+}
+export {
+  detectEnvironment,
+  getEnvVariable
+};

package/lib/browser/utils/error.d.ts

@@ -0,0 +1,26 @@
+import { ErrorCode, ErrorData } from '#src/proto/api.ts';
+/**
+ * Represents an error that can be thrown by the Attestor Core
+ * or server. Provides a code, and optional data
+ * to pass along with the error.
+ */
+export declare class AttestorError extends Error {
+    readonly name = "AttestorError";
+    readonly code: keyof typeof ErrorCode;
+    readonly data: {
+        [_: string]: any;
+    } | undefined;
+    constructor(code: keyof typeof ErrorCode, message: string, data?: {
+        [_: string]: any;
+    });
+    /**
+     * Encodes the error as a ErrorData
+     * protobuf message
+     */
+    toProto(): ErrorData;
+    static fromProto(data?: ErrorData): AttestorError;
+    static fromError(err: Error, code?: keyof typeof ErrorCode): AttestorError;
+    static badRequest(message: string, data?: {
+        [_: string]: any;
+    }): AttestorError;
+}

package/lib/browser/utils/error.js

@@ -0,0 +1,54 @@
+import { ErrorCode, ErrorData } from "../../proto/api.js";
+const PROTO_ERROR = ErrorData.fromJSON({});
+class AttestorError extends Error {
+  name = "AttestorError";
+  code;
+  data;
+  constructor(code, message, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+  }
+  /**
+   * Encodes the error as a ErrorData
+   * protobuf message
+   */
+  toProto() {
+    return ErrorData.create({
+      code: ErrorCode[this.code],
+      message: this.message,
+      data: JSON.stringify(this.data)
+    });
+  }
+  static fromProto(data = PROTO_ERROR) {
+    return new AttestorError(
+      typeof data.code === "number" ? getKeyForValue(ErrorCode, data.code) || "UNRECOGNIZED" : data.code,
+      data.message,
+      data.data ? JSON.parse(data.data) : void 0
+    );
+  }
+  static fromError(err, code = "ERROR_INTERNAL") {
+    if (err instanceof AttestorError) {
+      return err;
+    }
+    return new AttestorError(code, err.message);
+  }
+  static badRequest(message, data) {
+    return new AttestorError(
+      "ERROR_BAD_REQUEST",
+      message,
+      data
+    );
+  }
+}
+function getKeyForValue(obj, value) {
+  for (const key in obj) {
+    if (obj[key] === value) {
+      return key;
+    }
+  }
+  return void 0;
+}
+export {
+  AttestorError
+};

package/lib/browser/utils/generics.d.ts

@@ -0,0 +1,114 @@
+import type { CipherSuite, TLSProtocolVersion } from '@reclaimprotocol/tls';
+import { uint8ArrayToBinaryStr } from '@reclaimprotocol/tls';
+import { RPCMessage, RPCMessages } from '#src/proto/api.ts';
+import type { CompleteTLSPacket, IDecryptedTranscript, IDecryptedTranscriptMessage, ProviderField, RPCEvent, RPCEventMap, RPCEventType, RPCType, Transcript } from '#src/types/index.ts';
+export { uint8ArrayToBinaryStr };
+/**
+ * Decodes a Uint8Array to a UTF-8 string.
+ */
+export declare function uint8ArrayToStr(arr: Uint8Array): string;
+/**
+ * Encodes a UTF-8 string to a Uint8Array.
+ */
+export declare function strToUint8Array(str: string): Uint8Array;
+export declare function getTranscriptString(receipt: IDecryptedTranscript): string;
+export declare const unixTimestampSeconds: () => number;
+/**
+ * Find index of needle in haystack
+ */
+export declare function findIndexInUint8Array(haystack: Uint8Array, needle: Uint8Array): number;
+/**
+ * Fetch the ZK algorithm for the specified cipher suite
+ */
+export declare function getZkAlgorithmForCipherSuite(cipherSuite: CipherSuite): "aes-256-ctr" | "aes-128-ctr" | "chacha20";
+/**
+ * Get the pure ciphertext without any MAC,
+ * or authentication tag,
+ * @param content content w/o header
+ * @param cipherSuite
+ */
+export declare function getPureCiphertext(content: Uint8Array, cipherSuite: CipherSuite): Uint8Array<ArrayBufferLike>;
+/**
+ * Get the 8 byte IV part that's stored in the record for some cipher suites
+ * @param content content w/o header
+ * @param cipherSuite
+ */
+export declare function getRecordIV(content: Uint8Array, cipherSuite: CipherSuite): Uint8Array<ArrayBuffer>;
+export declare function getProviderValue<P, S, T>(params: P, fn: ProviderField<P, S, T>, secretParams?: S): T;
+export declare function generateRpcMessageId(): number;
+/**
+ * Random session ID for a WebSocket client.
+ */
+export declare function generateSessionId(): number;
+/**
+ * Random ID for a tunnel.
+ */
+export declare function generateTunnelId(): number;
+export declare function makeRpcEvent<T extends RPCEventType>(type: T, data: RPCEventMap[T]): RPCEvent<T>;
+/**
+ * Get the RPC type from the key.
+ * For eg. "claimTunnelRequest" ->
+ *    { type: 'claimTunnel', direction: 'request' }
+ */
+export declare function getRpcTypeFromKey(key: string): {
+    type: RPCType;
+    direction: "request";
+} | {
+    type: RPCType;
+    direction: "response";
+} | undefined;
+/**
+ * Get the RPC response type from the RPC type.
+ * For eg. "claimTunnel" -> "claimTunnelResponse"
+ */
+export declare function getRpcResponseType<T extends RPCType>(type: T): `${T}Response`;
+/**
+ * Get the RPC request type from the RPC type.
+ * For eg. "claimTunnel" -> "claimTunnelRequest"
+ */
+export declare function getRpcRequestType<T extends RPCType>(type: T): `${T}Request`;
+export declare function isApplicationData(packet: CompleteTLSPacket, tlsVersion: string | undefined): boolean;
+/**
+ * Convert the received data from a WS to a Uint8Array
+ */
+export declare function extractArrayBufferFromWsData(data: unknown): Promise<Uint8Array>;
+/**
+ * Check if the RPC message is a request or a response.
+ */
+export declare function getRpcRequest(msg: RPCMessage): {
+    type: RPCType;
+    direction: "request";
+} | {
+    type: RPCType;
+    direction: "response";
+} | {
+    direction: "response";
+    type: "error";
+} | undefined;
+/**
+ * Finds all application data messages in a transcript
+ * and returns them. Removes the "contentType" suffix from the message.
+ * in TLS 1.3
+ */
+export declare function extractApplicationDataFromTranscript({ transcript, tlsVersion }: IDecryptedTranscript): Transcript<Uint8Array<ArrayBufferLike>>;
+export type HandshakeTranscript<T> = {
+    sender: 'client' | 'server';
+    index: number;
+    message: T;
+}[];
+export declare function extractHandshakeFromTranscript({ transcript, tlsVersion }: {
+    transcript: IDecryptedTranscriptMessage[];
+    tlsVersion: TLSProtocolVersion;
+}): HandshakeTranscript<Uint8Array<ArrayBufferLike>>;
+export declare function decryptDirect(directReveal: any, cipherSuite: CipherSuite, recordHeader: Uint8Array, serverTlsVersion: TLSProtocolVersion, content: Uint8Array): Promise<{
+    plaintext: Uint8Array<ArrayBufferLike>;
+    iv: Uint8Array<ArrayBufferLike>;
+}>;
+export declare function packRpcMessages(...msgs: Partial<RPCMessage>[]): RPCMessages;
+/**
+ * Converts an Ethers struct (an array w named keys) to
+ * a plain object. Recursively converts all structs inside.
+ * Required to correctly JSON.stringify the struct.
+ */
+export declare function ethersStructToPlainObject<T>(struct: T): T;
+export declare function isTls13Suite(suite: CipherSuite): suite is "TLS_CHACHA20_POLY1305_SHA256" | "TLS_AES_256_GCM_SHA384" | "TLS_AES_128_GCM_SHA256";

package/lib/browser/utils/generics.js

@@ -0,0 +1,268 @@
+import {
+  areUint8ArraysEqual,
+  CONTENT_TYPE_MAP,
+  crypto,
+  decryptWrappedRecord,
+  PACKET_TYPE,
+  SUPPORTED_CIPHER_SUITE_MAP,
+  uint8ArrayToBinaryStr,
+  uint8ArrayToDataView
+} from "@reclaimprotocol/tls";
+import { REDACTION_CHAR_CODE } from "@reclaimprotocol/zk-symmetric-crypto";
+import { RPCMessage, RPCMessages } from "../../proto/api.js";
+const DEFAULT_REDACTION_DATA = new Uint8Array(4).fill(REDACTION_CHAR_CODE);
+function uint8ArrayToStr(arr) {
+  return new TextDecoder().decode(arr);
+}
+function strToUint8Array(str) {
+  return new TextEncoder().encode(str);
+}
+function getTranscriptString(receipt) {
+  const applMsgs = extractApplicationDataFromTranscript(receipt);
+  const strList = [];
+  for (const { message, sender } of applMsgs) {
+    const content = uint8ArrayToStr(message);
+    if (strList[strList.length - 1]?.startsWith(sender)) {
+      strList[strList.length - 1] += content;
+    } else {
+      strList.push(`${sender}: ${content}`);
+    }
+  }
+  return strList.join("\n");
+}
+const unixTimestampSeconds = () => Math.floor(Date.now() / 1e3);
+function findIndexInUint8Array(haystack, needle) {
+  for (let i = 0; i < haystack.length; i++) {
+    if (areUint8ArraysEqual(haystack.slice(i, i + needle.length), needle)) {
+      return i;
+    }
+  }
+  return -1;
+}
+function getZkAlgorithmForCipherSuite(cipherSuite) {
+  if (cipherSuite.includes("CHACHA20")) {
+    return "chacha20";
+  }
+  if (cipherSuite.includes("AES_256_GCM")) {
+    return "aes-256-ctr";
+  }
+  if (cipherSuite.includes("AES_128_GCM")) {
+    return "aes-128-ctr";
+  }
+  throw new Error(`${cipherSuite} not supported for ZK ops`);
+}
+function getPureCiphertext(content, cipherSuite) {
+  getZkAlgorithmForCipherSuite(cipherSuite);
+  content = content.slice(0, -16);
+  const {
+    ivLength: fixedIvLength
+  } = SUPPORTED_CIPHER_SUITE_MAP[cipherSuite];
+  const recordIvLength = 12 - fixedIvLength;
+  content = content.slice(recordIvLength);
+  return content;
+}
+function getRecordIV(content, cipherSuite) {
+  getZkAlgorithmForCipherSuite(cipherSuite);
+  const {
+    ivLength: fixedIvLength
+  } = SUPPORTED_CIPHER_SUITE_MAP[cipherSuite];
+  const recordIvLength = 12 - fixedIvLength;
+  return content.slice(0, recordIvLength);
+}
+function getProviderValue(params, fn, secretParams) {
+  return typeof fn === "function" ? fn(params, secretParams) : fn;
+}
+function generateRpcMessageId() {
+  return uint8ArrayToDataView(crypto.randomBytes(4)).getUint32(0);
+}
+function generateSessionId() {
+  return generateRpcMessageId();
+}
+function generateTunnelId() {
+  return generateRpcMessageId();
+}
+function makeRpcEvent(type, data) {
+  const ev = new Event(type);
+  ev.data = data;
+  return ev;
+}
+function getRpcTypeFromKey(key) {
+  if (key.endsWith("Request")) {
+    return {
+      type: key.slice(0, -7),
+      direction: "request"
+    };
+  }
+  if (key.endsWith("Response")) {
+    return {
+      type: key.slice(0, -8),
+      direction: "response"
+    };
+  }
+}
+function getRpcResponseType(type) {
+  return `${type}Response`;
+}
+function getRpcRequestType(type) {
+  return `${type}Request`;
+}
+function isApplicationData(packet, tlsVersion) {
+  return packet.type === "ciphertext" && (packet.contentType === "APPLICATION_DATA" || packet.data[0] === PACKET_TYPE.WRAPPED_RECORD && tlsVersion === "TLS1_2");
+}
+async function extractArrayBufferFromWsData(data) {
+  if (data instanceof ArrayBuffer) {
+    return new Uint8Array(data);
+  }
+  if (data instanceof Uint8Array || typeof data === "object" && data && "buffer" in data) {
+    return data;
+  }
+  if (typeof data === "string") {
+    return strToUint8Array(data);
+  }
+  if (typeof Blob !== "undefined" && data instanceof Blob) {
+    return new Uint8Array(await data.arrayBuffer());
+  }
+  throw new Error("unsupported data: " + String(data));
+}
+function getRpcRequest(msg) {
+  if (msg.requestError) {
+    return {
+      direction: "response",
+      type: "error"
+    };
+  }
+  for (const key in msg) {
+    if (!msg[key]) {
+      continue;
+    }
+    const rpcType = getRpcTypeFromKey(key);
+    if (!rpcType) {
+      continue;
+    }
+    return rpcType;
+  }
+}
+function extractApplicationDataFromTranscript({ transcript, tlsVersion }) {
+  const msgs = [];
+  for (const m of transcript) {
+    let message;
+    if (m.redacted) {
+      if (!m.plaintextLength) {
+        message = DEFAULT_REDACTION_DATA;
+      } else {
+        const len = tlsVersion === "TLS1_3" ? m.plaintextLength - 1 : m.plaintextLength;
+        message = new Uint8Array(len).fill(REDACTION_CHAR_CODE);
+      }
+    } else if (tlsVersion === "TLS1_3") {
+      const contentType = m.message[m.message.length - 1];
+      if (contentType !== CONTENT_TYPE_MAP["APPLICATION_DATA"]) {
+        continue;
+      }
+      message = m.message.slice(0, -1);
+    } else if (m.recordHeader[0] === PACKET_TYPE.WRAPPED_RECORD) {
+      message = m.message;
+    } else {
+      continue;
+    }
+    msgs.push({ message, sender: m.sender });
+  }
+  return msgs;
+}
+function extractHandshakeFromTranscript({ transcript, tlsVersion }) {
+  const msgs = [];
+  for (const [i, m] of transcript.entries()) {
+    if (m.redacted) {
+      break;
+    }
+    let message;
+    if (m.recordHeader[0] === PACKET_TYPE.HELLO) {
+      message = m.message;
+    } else if (m.recordHeader[0] === PACKET_TYPE.WRAPPED_RECORD) {
+      if (tlsVersion === "TLS1_3") {
+        const contentType = m.message[m.message.length - 1];
+        if (contentType !== CONTENT_TYPE_MAP["HANDSHAKE"]) {
+          break;
+        }
+        message = m.message.slice(0, -1);
+      } else {
+        break;
+      }
+    } else {
+      continue;
+    }
+    if (!message.length) {
+      throw new Error("unsupported handshake message");
+    }
+    msgs.push({ message, sender: m.sender, index: i });
+  }
+  return msgs;
+}
+async function decryptDirect(directReveal, cipherSuite, recordHeader, serverTlsVersion, content) {
+  const { key, iv, recordNumber } = directReveal;
+  const { cipher } = SUPPORTED_CIPHER_SUITE_MAP[cipherSuite];
+  const importedKey = await crypto.importKey(cipher, key);
+  return await decryptWrappedRecord(
+    content,
+    {
+      iv,
+      key: importedKey,
+      recordHeader,
+      recordNumber,
+      version: serverTlsVersion,
+      cipherSuite
+    }
+  );
+}
+function packRpcMessages(...msgs) {
+  return RPCMessages.create({
+    messages: msgs.map((msg) => RPCMessage.create({
+      ...msg,
+      id: msg.id || generateRpcMessageId()
+    }))
+  });
+}
+function ethersStructToPlainObject(struct) {
+  if (!Array.isArray(struct)) {
+    return struct;
+  }
+  const namedKeys = Object.keys(struct).filter((key) => isNaN(Number(key)));
+  if (!namedKeys.length) {
+    return struct.map(ethersStructToPlainObject);
+  }
+  const obj = {};
+  for (const key of namedKeys) {
+    obj[key] = ethersStructToPlainObject(struct[key]);
+  }
+  return obj;
+}
+function isTls13Suite(suite) {
+  return suite === "TLS_AES_128_GCM_SHA256" || suite === "TLS_AES_256_GCM_SHA384" || suite === "TLS_CHACHA20_POLY1305_SHA256";
+}
+export {
+  decryptDirect,
+  ethersStructToPlainObject,
+  extractApplicationDataFromTranscript,
+  extractArrayBufferFromWsData,
+  extractHandshakeFromTranscript,
+  findIndexInUint8Array,
+  generateRpcMessageId,
+  generateSessionId,
+  generateTunnelId,
+  getProviderValue,
+  getPureCiphertext,
+  getRecordIV,
+  getRpcRequest,
+  getRpcRequestType,
+  getRpcResponseType,
+  getRpcTypeFromKey,
+  getTranscriptString,
+  getZkAlgorithmForCipherSuite,
+  isApplicationData,
+  isTls13Suite,
+  makeRpcEvent,
+  packRpcMessages,
+  strToUint8Array,
+  uint8ArrayToBinaryStr,
+  uint8ArrayToStr,
+  unixTimestampSeconds
+};

package/lib/browser/utils/http-parser.d.ts

@@ -0,0 +1,59 @@
+import type { IncomingHttpHeaders } from 'http';
+import type { ArraySlice, Transcript } from '#src/types/index.ts';
+export type HttpRequest = {
+    method: string;
+    url: string;
+    protocol: string;
+    headers: IncomingHttpHeaders;
+    body?: Uint8Array;
+};
+export type HttpResponse = {
+    statusCode: number;
+    statusMessage: string;
+    headers: IncomingHttpHeaders;
+    body: Uint8Array;
+    headersComplete: boolean;
+    complete: boolean;
+    /**
+     * Index of the first byte of the status line
+     */
+    statusLineEndIndex?: number;
+    /**
+     * Index of the first byte of the body
+     * in the complete response
+     */
+    bodyStartIndex?: number;
+    /**
+     * If using chunked transfer encoding,
+     * this will be set & contain indices of each
+     * chunk in the complete response
+     */
+    chunks?: ArraySlice[];
+    headerIndices: Map<string, ArraySlice>;
+    /**
+     * index of separator \r\n\r\n between headers and body
+     */
+    headerEndIdx: number;
+};
+/**
+ * parses http/1.1 responses
+ */
+export declare function makeHttpResponseParser(): {
+    res: HttpResponse;
+    /**
+     * Parse the next chunk of data
+     * @param data the data to parse
+     */
+    onChunk(data: Uint8Array): void;
+    /**
+     * Call to prevent further parsing; indicating the end of the request
+     * Checks that the response is valid & complete, otherwise throws an error
+     */
+    streamEnded(): void;
+};
+/**
+ * Read the HTTP request from a TLS receipt transcript.
+ * @param receipt the transcript to read from or application messages if they were extracted beforehand
+ * @returns the parsed HTTP request
+ */
+export declare function getHttpRequestDataFromTranscript(receipt: Transcript<Uint8Array>): HttpRequest;