@reclaimprotocol/attestor-core 5.0.1-beta.9 → 5.0.2-beta.1

package/lib/browser/providers/http/utils.d.ts

@@ -1,77 +0,0 @@
-import '#src/providers/http/patch-parse5-tree.ts';
-import RE2 from 're2';
-import type { ArraySlice, CompleteTLSPacket, ProviderParams, Transcript } from '#src/types/index.ts';
-import type { HttpRequest, HttpResponse } from '#src/utils/index.ts';
-export type JSONIndex = {
-    start: number;
-    end: number;
-};
-type HTTPProviderParams = ProviderParams<'http'>;
-/**
- * Returns only first extracted element
- * @param html
- * @param xpathExpression
- * @param contentsOnly
- */
-export declare function extractHTMLElement(html: string, xpathExpression: string, contentsOnly: boolean): string;
-/**
- * Returns all extracted elements
- * @param html
- * @param xpathExpression
- * @param contentsOnly
- */
-export declare function extractHTMLElements(html: string, xpathExpression: string, contentsOnly: boolean): string[];
-/**
- * returns a single index of extracted element
- * @param html
- * @param xpathExpression
- * @param contentsOnly
- */
-export declare function extractHTMLElementIndex(html: string, xpathExpression: string, contentsOnly: boolean): {
-    start: number;
-    end: number;
-};
-/**
- * Returns indexes of all extracted elements
- * @param html
- * @param xpathExpression
- * @param contentsOnly indices of the start and end of the element's contents only,
- * 	not the whole tag
- */
-export declare function extractHTMLElementsIndexes(html: string, xpathExpression: string, contentsOnly: boolean): {
-    start: number;
-    end: number;
-}[];
-export declare function extractJSONValueIndex(json: string, jsonPath: string): {
-    start: number;
-    end: number;
-};
-export declare function extractJSONValueIndexes(json: string, jsonPath: string): {
-    start: number;
-    end: number;
-}[];
-export declare function buildHeaders(input: HTTPProviderParams['headers']): string[];
-/**
- * Converts position in HTTP response body to an absolute position in TLS transcript considering chunked encoding
- * @param pos
- * @param bodyStartIdx
- * @param chunks
- */
-export declare function convertResponsePosToAbsolutePos(pos: number, bodyStartIdx: number, chunks?: ArraySlice[]): number;
-/**
- * If this reveal spans the boundary of two chunks, we'll
- *
- */
-export declare function getRedactionsForChunkHeaders(from: number, to: number, chunks?: ArraySlice[]): ArraySlice[];
-export declare function parseHttpResponse(buff: Uint8Array): HttpResponse;
-export declare function makeRegex(str: string): RE2;
-/**
- * Try to match strings that contain templates like {{param}}
- * against redacted string that has *** instead of that param
- */
-export declare function matchRedactedStrings(templateString: Uint8Array, redactedString?: Uint8Array): boolean;
-export declare function generateRequstAndResponseFromTranscript(transcript: Transcript<CompleteTLSPacket>, tlsVersion: string): {
-    req: HttpRequest;
-    res: HttpResponse;
-};
-export {};

package/lib/browser/providers/http/utils.js

@@ -1,283 +0,0 @@
-import "../../providers/http/patch-parse5-tree.js";
-import { concatenateUint8Arrays } from "../../utils/tls-imports.js";
-import {
-  ArrayExpression,
-  ExpressionStatement,
-  ObjectExpression,
-  parseScript,
-  Property,
-  Syntax
-} from "esprima-next";
-import { JSONPath } from "jsonpath-plus";
-import { parse } from "parse5";
-import { adapter as htmlAdapter } from "parse5-htmlparser2-tree-adapter";
-import RE2 from "re2";
-import xpath from "xpath";
-import { getHttpRequestDataFromTranscript, isApplicationData, makeHttpResponseParser, REDACTION_CHAR_CODE } from "../../utils/index.js";
-function extractHTMLElement(html, xpathExpression, contentsOnly) {
-  const { start, end } = extractHTMLElementIndex(html, xpathExpression, contentsOnly);
-  return html.slice(start, end);
-}
-function extractHTMLElements(html, xpathExpression, contentsOnly) {
-  const indexes = extractHTMLElementsIndexes(html, xpathExpression, contentsOnly);
-  const res = [];
-  for (const { start, end } of indexes) {
-    res.push(html.slice(start, end));
-  }
-  return res;
-}
-function extractHTMLElementIndex(html, xpathExpression, contentsOnly) {
-  return extractHTMLElementsIndexes(html, xpathExpression, contentsOnly)[0];
-}
-function extractHTMLElementsIndexes(html, xpathExpression, contentsOnly) {
-  return extractHTMLElementIndexesParse5(html, xpathExpression, contentsOnly);
-}
-function extractHTMLElementIndexesParse5(html, xpathExpression, contentsOnly) {
-  const domLight = parse(
-    html,
-    { treeAdapter: htmlAdapter, sourceCodeLocationInfo: true }
-  );
-  domLight["name"] = "root";
-  const parsedPath = xpath.parse(xpathExpression);
-  const nodes = parsedPath.select({
-    node: domLight,
-    allowAnyNamespaceForNoPrefix: true
-  });
-  if (!nodes.length) {
-    throw new Error(`Failed to find XPath: "${xpathExpression}"`);
-  }
-  return nodes.map((node) => getNodeRange(node, contentsOnly));
-}
-function getNodeRange(node, contentsOnly) {
-  if (!contentsOnly) {
-    return { start: node.startIndex, end: node.endIndex };
-  }
-  if (!("firstChild" in node) || !node.firstChild) {
-    throw new Error(`Node "${node["name"]}" has no children`);
-  }
-  return {
-    start: node.firstChild.startIndex,
-    end: node.lastChild.endIndex
-  };
-}
-function extractJSONValueIndex(json, jsonPath) {
-  return extractJSONValueIndexes(json, jsonPath)[0];
-}
-function extractJSONValueIndexes(json, jsonPath) {
-  const pointers = JSONPath({
-    path: jsonPath,
-    json: JSON.parse(json),
-    wrap: false,
-    resultType: "pointer",
-    eval: "safe",
-    // @ts-ignore
-    ignoreEvalErrors: true
-  });
-  if (!pointers) {
-    throw new Error("jsonPath not found");
-  }
-  const tree = parseScript("(" + json + ")", { range: true });
-  if (tree.body[0] instanceof ExpressionStatement && (tree.body[0].expression instanceof ObjectExpression || tree.body[0].expression instanceof ArrayExpression)) {
-    const traversePointers = Array.isArray(pointers) ? pointers : [pointers];
-    const res = [];
-    for (const pointer of traversePointers) {
-      const index = traverse(tree.body[0].expression, "", [pointer]);
-      if (index) {
-        res.push({
-          start: index.start - 1,
-          //account for '('
-          end: index.end - 1
-        });
-      }
-    }
-    return res;
-  }
-  throw new Error("jsonPath not found");
-}
-function traverse(o, path, pointers) {
-  if (o instanceof ObjectExpression) {
-    for (const p of o.properties) {
-      if (!(p instanceof Property)) {
-        continue;
-      }
-      const localPath = p.key.type === Syntax.Literal ? path + "/" + p.key.value : path;
-      if (pointers.includes(localPath) && "range" in p && Array.isArray(p.range)) {
-        return {
-          start: p.range[0],
-          end: p.range[1]
-        };
-      }
-      if (p.value instanceof ObjectExpression || p.value instanceof ArrayExpression) {
-        const res = traverse(p.value, localPath, pointers);
-        if (res) {
-          return res;
-        }
-      }
-    }
-  }
-  if (o instanceof ArrayExpression) {
-    for (let i = 0; i < o.elements.length; i++) {
-      const element = o.elements[i];
-      if (!element) {
-        continue;
-      }
-      const localPath = path + "/" + i;
-      if (pointers.includes(localPath) && "range" in element && Array.isArray(element.range)) {
-        return {
-          start: element.range[0],
-          end: element.range[1]
-        };
-      }
-      if (element instanceof ObjectExpression) {
-        const res = traverse(element, localPath, pointers);
-        if (res) {
-          return res;
-        }
-      }
-      if (element instanceof ArrayExpression) {
-        const res = traverse(element, localPath, pointers);
-        if (res) {
-          return res;
-        }
-      }
-    }
-  }
-  return null;
-}
-function buildHeaders(input) {
-  const headers = [];
-  for (const [key, value] of Object.entries(input || {})) {
-    headers.push(`${key}: ${value}`);
-  }
-  return headers;
-}
-function convertResponsePosToAbsolutePos(pos, bodyStartIdx, chunks) {
-  if (chunks?.length) {
-    let chunkBodyStart = 0;
-    for (const chunk of chunks) {
-      const chunkSize = chunk.toIndex - chunk.fromIndex;
-      if (pos >= chunkBodyStart && pos <= chunkBodyStart + chunkSize) {
-        return pos - chunkBodyStart + chunk.fromIndex;
-      }
-      chunkBodyStart += chunkSize;
-    }
-    throw new Error("position out of range");
-  }
-  return bodyStartIdx + pos;
-}
-function getRedactionsForChunkHeaders(from, to, chunks) {
-  const res = [];
-  if (!chunks?.length) {
-    return res;
-  }
-  for (let i = 1; i < chunks?.length; i++) {
-    const chunk = chunks[i];
-    if (chunk.fromIndex > from && chunk.fromIndex < to) {
-      res.push({
-        fromIndex: chunks[i - 1].toIndex,
-        toIndex: chunk.fromIndex
-      });
-    }
-  }
-  return res;
-}
-function parseHttpResponse(buff) {
-  const parser = makeHttpResponseParser();
-  parser.onChunk(buff);
-  parser.streamEnded();
-  return parser.res;
-}
-function makeRegex(str) {
-  return RE2(str, "sgiu");
-}
-const TEMPLATE_START_CHARCODE = "{".charCodeAt(0);
-const TEMPLATE_END_CHARCODE = "}".charCodeAt(0);
-function matchRedactedStrings(templateString, redactedString) {
-  if (templateString.length === 0 && redactedString?.length === 0) {
-    return true;
-  }
-  if (!redactedString) {
-    return false;
-  }
-  let ts = -1;
-  let rs = -1;
-  while (ts < templateString.length && rs < redactedString.length) {
-    let ct = getTChar();
-    let cr = getRChar();
-    if (ct !== cr) {
-      if (ct === TEMPLATE_START_CHARCODE && cr === REDACTION_CHAR_CODE) {
-        if (getTChar() !== TEMPLATE_START_CHARCODE) {
-          return false;
-        }
-        while ((ct = getTChar()) !== TEMPLATE_END_CHARCODE && ct !== -1) {
-        }
-        while ((ct = getTChar()) !== TEMPLATE_END_CHARCODE && ct !== -1) {
-        }
-        if (ct === -1) {
-          return false;
-        }
-        while ((cr = getRChar()) === REDACTION_CHAR_CODE && cr !== -1) {
-        }
-        if (cr === -1) {
-          return getTChar() === -1;
-        }
-        rs--;
-      } else {
-        return false;
-      }
-    }
-  }
-  function getTChar() {
-    ts++;
-    if (ts < templateString.length) {
-      return templateString[ts];
-    } else {
-      return -1;
-    }
-  }
-  function getRChar() {
-    if (!redactedString) {
-      return -1;
-    }
-    rs++;
-    if (rs < redactedString.length) {
-      return redactedString[rs];
-    } else {
-      return -1;
-    }
-  }
-  return ts === templateString.length && rs === redactedString.length;
-}
-function generateRequstAndResponseFromTranscript(transcript, tlsVersion) {
-  const allPackets = transcript;
-  const packets = [];
-  for (const b of allPackets) {
-    if (b.message.type !== "ciphertext" || !isApplicationData(b.message, tlsVersion)) {
-      continue;
-    }
-    const plaintext = tlsVersion === "TLS1_3" ? b.message.plaintext.slice(0, -1) : b.message.plaintext;
-    packets.push({
-      message: plaintext,
-      sender: b.sender
-    });
-  }
-  const req = getHttpRequestDataFromTranscript(packets);
-  const responsePackets = concatenateUint8Arrays(packets.filter((p) => p.sender === "server").map((p) => p.message).filter((b) => !b.every((b2) => b2 === REDACTION_CHAR_CODE)));
-  const res = parseHttpResponse(responsePackets);
-  return { req, res };
-}
-export {
-  buildHeaders,
-  convertResponsePosToAbsolutePos,
-  extractHTMLElement,
-  extractHTMLElementIndex,
-  extractHTMLElements,
-  extractHTMLElementsIndexes,
-  extractJSONValueIndex,
-  extractJSONValueIndexes,
-  generateRequstAndResponseFromTranscript,
-  getRedactionsForChunkHeaders,
-  makeRegex,
-  matchRedactedStrings,
-  parseHttpResponse
-};

package/lib/browser/providers/index.d.ts

@@ -1,4 +0,0 @@
-import type { Provider, ProviderName } from '#src/types/index.ts';
-export declare const providers: {
-    [T in ProviderName]: Provider<T>;
-};

package/lib/browser/providers/index.js

@@ -1,7 +0,0 @@
-import http from "../providers/http/index.js";
-const providers = {
-  http
-};
-export {
-  providers
-};

package/lib/browser/types/bgp.d.ts

@@ -1,11 +0,0 @@
-export type BGPAnnouncementOverlapData = {
-    prefix: string;
-};
-export type BGPListener = {
-    /**
-     * Add an IP to listen for overlap,
-     * @returns a function to remove the IP from the listener
-     */
-    onOverlap(ips: string[], callback: (event: BGPAnnouncementOverlapData) => void): (() => void);
-    close(): void;
-};

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

@@ -1,70 +0,0 @@
-import type { ProviderClaimData } from '#src/proto/api.ts';
-import type { IAttestorClient, IAttestorClientInitParams } from '#src/types/client.ts';
-import type { CompleteTLSPacket, Logger } from '#src/types/general.ts';
-import type { ProofGenerationStep, ProviderName, ProviderParams, ProviderSecretParams } from '#src/types/providers.ts';
-import type { Transcript } from '#src/types/tunnel.ts';
-import type { PrepareZKProofsBaseOpts } from '#src/types/zk.ts';
-/**
- * Uniquely identifies a claim.
- * Hash of claim info.
- * Utilise `getIdentifierFromClaimInfo` to obtain this.
- */
-export type ClaimID = ProviderClaimData['identifier'];
-export type ClaimInfo = Pick<ProviderClaimData, 'context' | 'provider' | 'parameters'>;
-export type CompleteClaimData = Pick<ProviderClaimData, 'owner' | 'timestampS' | 'epoch'> & ClaimInfo;
-export type CreateClaimOnAttestorOpts<N extends ProviderName> = {
-    /** name of the provider to generate signed receipt for */
-    name: N;
-    /**
-     * secrets that are used to make the API request;
-     * not included in the receipt & cannot be viewed by anyone
-     * outside this client
-     */
-    secretParams: ProviderSecretParams<N>;
-    params: ProviderParams<N>;
-    /**
-     * Some metadata context to be included in the claim
-     */
-    context?: {
-        [key: string]: any;
-    };
-    onStep?(step: ProofGenerationStep): void;
-    /**
-     * Private key in hex format,
-     * prefixed with '0x'
-     */
-    ownerPrivateKey: string;
-    /**
-     * Provide either the client or the URL
-     * to the server -- so a client can be created internally.
-     *
-     * The created client will go into the global client pool.
-     */
-    client: IAttestorClient | IAttestorClientInitParams;
-    /**
-     * Optionally set the timestamp of the claim
-     * in unix seconds. If not provided, the current
-     * time will be used.
-     */
-    timestampS?: number;
-    logger?: Logger;
-    /**
-     * Maximum number of retries to attempt
-     * @default 3
-     */
-    maxRetries?: number;
-    /**
-     * Optionally update the provider parameters
-     * based on the transcript
-     */
-    updateProviderParams?(transcript: Transcript<CompleteTLSPacket>, tlsVersion: string): Promise<{
-        params: Partial<ProviderParams<N>>;
-        secretParams: Partial<ProviderSecretParams<N>>;
-    }>;
-    /**
-     * Replaces paramValue with corresponding OPRF hash before proof is made
-     * Only if there's matching redaction exists
-     * For example: "domain.com" -> "dv4Nrgtr"
-     */
-    updateParametersFromOprfData?: boolean;
-} & PrepareZKProofsBaseOpts;

package/lib/browser/types/client.d.ts

@@ -1,163 +0,0 @@
-import type { IncomingMessage } from 'http';
-import type { WebSocket as WSWebSocket } from 'ws';
-import type { AuthenticationRequest, InitRequest, InitResponse, RPCMessage, RPCMessages, ServiceSignatureType, TunnelMessage } from '#src/proto/api.ts';
-import type { BGPListener } from '#src/types/bgp.ts';
-import type { Logger } from '#src/types/general.ts';
-import type { RPCEvent, RPCEventMap, RPCEventType, RPCRequestData, RPCResponseData, RPCType } from '#src/types/rpc.ts';
-import type { TCPSocketProperties, Tunnel } from '#src/types/tunnel.ts';
-/**
- * Any WebSocket implementation -- either the native
- * WebSocket or the WebSocket from the `ws` package.
- */
-export type AnyWebSocket = WebSocket | WSWebSocket;
-export type MakeWebSocket = (url: string | URL) => AnyWebSocket;
-export type AcceptNewConnectionOpts = {
-    req: IncomingMessage;
-    logger: Logger;
-    bgpListener?: BGPListener;
-};
-export type IAttestorClientInitParams = {
-    /**
-     * Attestor WS URL
-     */
-    url: string | URL;
-    /**
-     * If the attestor being connected to has authentication
-     * enabled, provide the authentication request here, or a
-     * function that will return the authentication request.
-     */
-    authRequest?: AuthenticationRequest | (() => Promise<AuthenticationRequest>);
-};
-export type IAttestorClientCreateOpts = {
-    /**
-     * Attestor WS URL
-     */
-    url: string | URL;
-    authRequest?: AuthenticationRequest;
-    signatureType?: ServiceSignatureType;
-    logger?: Logger;
-    /**
-     * Initial messages to send to the server
-     * in the query parameter used to establish
-     * the connection.
-     */
-    initMessages?: Partial<RPCMessage>[];
-    /**
-     * Provide a custom WebSocket implementation,
-     * will use the native WebSocket if not provided.
-     */
-    makeWebSocket?: MakeWebSocket;
-};
-/**
- * Base layer for the WebSocket connection on
- * the client and server.
- */
-export declare class IAttestorSocket {
-    metadata: InitRequest;
-    logger: Logger;
-    /**
-     * Is the WebSocket connection open?
-     */
-    isOpen: boolean;
-    /**
-     * Has the WebSocket connection been closed
-     */
-    isClosed: boolean;
-    /**
-     * Whether the WebSocket has been initialised
-     * by receiving an "init-response" message.
-     */
-    isInitialised: boolean;
-    /**
-     * Sends RPC messages to the server in a single packet.
-     * If the ID is not provided, it will be generated.
-     *
-     * Promisify the `send` method if using the `ws` package's
-     * WebSocket implementation.
-     */
-    sendMessage(...msgs: Partial<RPCMessage>[]): Promise<RPCMessages>;
-    /**
-     * Sends a "terminateConnectionAlert" message to the server
-     * with the specified error (if any), if the connection is
-     * still open and then closes the connection.
-     */
-    terminateConnection(err?: Error): Promise<void>;
-    /**
-     * Use this to listen to events on the WebSocket.
-     */
-    addEventListener<K extends RPCEventType>(type: K, listener: (data: RPCEvent<K>) => void): void;
-    removeEventListener<K extends RPCEventType>(type: K, listener: (data: RPCEvent<K>) => void): void;
-    /**
-     * Syntactic sugar for emitting events on the WebSocket.
-     * Wraps the `makeRpcEvent` call internally
-     */
-    dispatchRPCEvent<K extends RPCEventType>(type: K, data: RPCEventMap[K]): void;
-    /**
-     * Starts processing RPC messages from the WebSocket
-     * & emits events for each message type. These can be
-     * captured by the `addEventListener` method.
-     *
-     * Will also listen to "error" & "close" events on the WebSocket
-     * and emit a "attestor-error" event with the error.
-     * So, you only need to listen to the "attestor-error"
-     * event to capture anything you're interested in.
-     */
-    constructor(ws: WebSocket, metadata: InitRequest, logger: Logger);
-}
-export declare class IAttestorServerSocket extends IAttestorSocket {
-    /**
-     * Unique identifier for this WebSocket connection
-     */
-    sessionId: number;
-    /**
-     * Set of tunnels this client created. Only available
-     * when WS is created by the server
-     */
-    tunnels: {
-        [id: TunnelMessage['tunnelId']]: Tunnel<TCPSocketProperties>;
-    };
-    /**
-     * Fetches a tunnel by its ID.
-     * If the tunnel does not exist, it will throw an error.
-     */
-    getTunnel(tunnelId: TunnelMessage['tunnelId']): Tunnel<TCPSocketProperties>;
-    removeTunnel(tunnelId: TunnelMessage['tunnelId']): void;
-    bgpListener?: BGPListener;
-}
-export declare class IAttestorClient extends IAttestorSocket {
-    initResponse?: InitResponse;
-    constructor(opts: IAttestorClientCreateOpts);
-    /**
-     * Waits for a particular message to come in.
-     * If the connection is closed before the message is received,
-     * the promise will reject.
-     */
-    waitForResponse<T extends RPCType>(id: number, timeoutMs?: number): Promise<RPCResponseData<T>>;
-    /**
-     * Make an RPC request to the other end of the WebSocket.
-     */
-    rpc<T extends RPCType>(type: T, request: Partial<RPCRequestData<T>>, timeoutMs?: number): Promise<RPCResponseData<T>>;
-    /**
-     * Waits for the "init" request to be responded to
-     */
-    waitForInit(): Promise<void>;
-}
-interface WebSocketWithServerSocket {
-    /**
-     * Our RPC socket instance
-     */
-    serverSocket?: IAttestorServerSocket;
-    /**
-     * Just promisified send
-     */
-    sendPromise?: (data: Uint8Array) => Promise<void>;
-}
-declare module 'ws' {
-    namespace WebSocket {
-        interface WebSocket extends WebSocketWithServerSocket {
-        }
-    }
-    interface WebSocket extends WebSocketWithServerSocket {
-    }
-}
-export {};