@reclaimprotocol/attestor-core 5.0.1-beta.7 → 5.0.1

package/lib/browser/utils/redactions.js

@@ -1,135 +0,0 @@
-import { base64Encode } from "@bufbuild/protobuf/wire";
-import { concatenateUint8Arrays } from "../utils/tls-imports.js";
-const REDACTION_CHAR = "*";
-const REDACTION_CHAR_CODE = REDACTION_CHAR.charCodeAt(0);
-function isRedactionCongruent(redacted, original) {
-  for (let i = 0; i < redacted.length; i++) {
-    const element = redacted[i];
-    const areSame = element === original[i] || typeof element === "string" && element === REDACTION_CHAR || typeof element === "number" && element === REDACTION_CHAR_CODE;
-    if (!areSame) {
-      return false;
-    }
-  }
-  return true;
-}
-function isFullyRedacted(redacted) {
-  for (const element of redacted) {
-    if (element !== REDACTION_CHAR && element !== REDACTION_CHAR_CODE) {
-      return false;
-    }
-  }
-  return true;
-}
-async function getBlocksToReveal(blocks, redact, performOprf) {
-  const slicesWithReveal = blocks.map((block) => ({
-    block,
-    // copy the plaintext to avoid mutating the original
-    redactedPlaintext: new Uint8Array(block.plaintext)
-  }));
-  const total = concatenateUint8Arrays(blocks.map((b) => b.plaintext));
-  const redactions = redact(total);
-  if (!redactions.length) {
-    return "all";
-  }
-  let blockIdx = 0;
-  let cursorInBlock = 0;
-  let cursor = 0;
-  for (const redaction of redactions) {
-    await redactBlocks(redaction);
-  }
-  return slicesWithReveal.filter((s) => !isFullyRedacted(s.redactedPlaintext));
-  async function redactBlocks(slice) {
-    while (cursor < slice.fromIndex) {
-      advance();
-    }
-    if (slice.hash === "oprf-raw") {
-      const startBlockIdx = blockIdx;
-      const startCursorInBlock = cursorInBlock;
-      const totalLength = slice.toIndex - slice.fromIndex;
-      const block = slicesWithReveal[blockIdx];
-      block.oprfRawMarkers ||= [];
-      block.oprfRawMarkers.push({
-        dataLocation: {
-          fromIndex: startCursorInBlock,
-          length: totalLength
-        }
-      });
-      let overshootLen = 0;
-      while (cursor < slice.toIndex) {
-        if (blockIdx !== startBlockIdx) {
-          overshootLen += 1;
-        }
-        advance();
-      }
-      if (overshootLen) {
-        slicesWithReveal[blockIdx].overshotOprfRawFromPrevBlock = { length: overshootLen };
-      }
-      return;
-    }
-    if (slice.hash) {
-      const plaintext = total.slice(slice.fromIndex, slice.toIndex);
-      const { nullifier, responses, mask } = await performOprf(plaintext);
-      const toprf = {
-        nullifier,
-        responses,
-        dataLocation: {
-          fromIndex: cursorInBlock,
-          length: slice.toIndex - slice.fromIndex
-        },
-        mask,
-        plaintext
-      };
-      const startBlockIdx = blockIdx;
-      const block = slicesWithReveal[blockIdx];
-      block.toprfs ||= [];
-      block.toprfs.push(toprf);
-      const nullifierStr = binaryHashToStr(nullifier, toprf.dataLocation.length);
-      let i = 0;
-      let overshootLen = 0;
-      while (cursor < slice.toIndex) {
-        if (blockIdx !== startBlockIdx) {
-          overshootLen += 1;
-        }
-        slicesWithReveal[blockIdx].redactedPlaintext[cursorInBlock] = nullifierStr.charCodeAt(i);
-        advance();
-        i += 1;
-      }
-      if (overshootLen) {
-        slicesWithReveal[blockIdx].overshotToprfFromPrevBlock = { length: overshootLen };
-      }
-    }
-    while (cursor < slice.toIndex) {
-      slicesWithReveal[blockIdx].redactedPlaintext[cursorInBlock] = REDACTION_CHAR_CODE;
-      advance();
-    }
-  }
-  function advance() {
-    cursor += 1;
-    cursorInBlock += 1;
-    if (cursorInBlock >= blocks[blockIdx].plaintext.length) {
-      blockIdx += 1;
-      cursorInBlock = 0;
-    }
-  }
-}
-function redactSlices(total, slices) {
-  const redacted = new Uint8Array(total);
-  for (const slice of slices) {
-    for (let i = slice.fromIndex; i < slice.toIndex; i++) {
-      redacted[i] = REDACTION_CHAR_CODE;
-    }
-  }
-  return redacted;
-}
-function binaryHashToStr(hash, expLength) {
-  return base64Encode(hash).padEnd(expLength, "0").slice(0, expLength);
-}
-export {
-  REDACTION_CHAR,
-  REDACTION_CHAR_CODE,
-  binaryHashToStr,
-  getBlocksToReveal,
-  isFullyRedacted,
-  isRedactionCongruent,
-  redactSlices
-};

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

@@ -1,12 +0,0 @@
-import type { Logger } from '#src/types/index.ts';
-type RetryLoopOptions = {
-    maxRetries?: number;
-    logger: Logger;
-    shouldRetry: (error: Error) => boolean;
-};
-/**
- * Execute a function, and upon failure -- retry
- * based on specified options.
- */
-export declare function executeWithRetries<T>(code: (attempt: number) => Promise<T>, { maxRetries, shouldRetry, logger, }: RetryLoopOptions): Promise<T>;
-export {};

package/lib/browser/utils/retries.js

@@ -1,26 +0,0 @@
-async function executeWithRetries(code, {
-  maxRetries = 3,
-  shouldRetry,
-  logger
-}) {
-  let retries = 0;
-  while (retries < maxRetries) {
-    try {
-      const result = await code(retries);
-      return result;
-    } catch (err) {
-      retries += 1;
-      if (retries >= maxRetries) {
-        throw err;
-      }
-      if (!shouldRetry(err)) {
-        throw err;
-      }
-      logger.info({ err, retries }, "retrying failed operation");
-    }
-  }
-  throw new Error("retries exhausted");
-}
-export {
-  executeWithRetries
-};

package/lib/browser/utils/signatures/eth.d.ts

@@ -1,2 +0,0 @@
-import type { ServiceSignatureProvider } from '#src/types/index.ts';
-export declare const ETH_SIGNATURE_PROVIDER: ServiceSignatureProvider;

package/lib/browser/utils/signatures/eth.js

@@ -1,31 +0,0 @@
-import { computeAddress, getBytes, hexlify, SigningKey, verifyMessage, Wallet } from "ethers";
-const ETH_SIGNATURE_PROVIDER = {
-  getPublicKey(privateKey) {
-    const pub = SigningKey.computePublicKey(privateKey, true);
-    return getBytes(pub);
-  },
-  getAddress(publicKey) {
-    const pubKeyHex = typeof publicKey === "string" ? publicKey : hexlify(publicKey);
-    return computeAddress(pubKeyHex).toLowerCase();
-  },
-  async sign(data, privateKey) {
-    const wallet = getEthWallet(privateKey);
-    const signature = await wallet.signMessage(data);
-    return getBytes(signature);
-  },
-  async verify(data, signature, addressBytes) {
-    const address = typeof addressBytes === "string" ? addressBytes : hexlify(addressBytes);
-    const signatureHex = typeof signature === "string" ? signature : hexlify(signature);
-    const signerAddress = verifyMessage(data, signatureHex);
-    return signerAddress.toLowerCase() === address.toLowerCase();
-  }
-};
-function getEthWallet(privateKey) {
-  if (!privateKey) {
-    throw new Error("Private key missing");
-  }
-  return new Wallet(privateKey);
-}
-export {
-  ETH_SIGNATURE_PROVIDER
-};

package/lib/browser/utils/signatures/index.d.ts

@@ -1,5 +0,0 @@
-import { ServiceSignatureType } from '#src/proto/api.ts';
-import type { ServiceSignatureProvider } from '#src/types/index.ts';
-export declare const SIGNATURES: { [key in ServiceSignatureType]: ServiceSignatureProvider; };
-export declare const SelectedServiceSignatureType: 1;
-export declare const SelectedServiceSignature: ServiceSignatureProvider;

package/lib/browser/utils/signatures/index.js

@@ -1,12 +0,0 @@
-import { ServiceSignatureType } from "../../proto/api.js";
-import { ETH_SIGNATURE_PROVIDER } from "../../utils/signatures/eth.js";
-const SIGNATURES = {
-  [ServiceSignatureType.SERVICE_SIGNATURE_TYPE_ETH]: ETH_SIGNATURE_PROVIDER
-};
-const SelectedServiceSignatureType = ServiceSignatureType.SERVICE_SIGNATURE_TYPE_ETH;
-const SelectedServiceSignature = SIGNATURES[SelectedServiceSignatureType];
-export {
-  SIGNATURES,
-  SelectedServiceSignature,
-  SelectedServiceSignatureType
-};

package/lib/browser/utils/socket-base.d.ts

@@ -1,23 +0,0 @@
-import type { WebSocket as WSWebSocket } from 'ws';
-import type { InitRequest, RPCMessage } from '#src/proto/api.ts';
-import { RPCMessages } from '#src/proto/api.ts';
-import type { IAttestorSocket, Logger, RPCEvent, RPCEventMap } from '#src/types/index.ts';
-/**
- * Common AttestorSocket class used on the client & server side as the
- * base for their respective socket implementations.
- */
-export declare class AttestorSocket implements IAttestorSocket {
-    private eventTarget;
-    protected socket: WebSocket | WSWebSocket;
-    readonly logger: Logger;
-    readonly metadata: InitRequest;
-    isInitialised: boolean;
-    constructor(socket: WebSocket | WSWebSocket, metadata: InitRequest, logger: Logger);
-    get isOpen(): boolean;
-    get isClosed(): boolean;
-    sendMessage(...msgs: Partial<RPCMessage>[]): Promise<RPCMessages>;
-    dispatchRPCEvent<K extends keyof RPCEventMap>(type: K, data: RPCEventMap[K]): void;
-    addEventListener<K extends keyof RPCEventMap>(type: K, listener: (data: RPCEvent<K>) => void): void;
-    removeEventListener<K extends keyof RPCEventMap>(type: K, listener: (data: RPCEvent<K>) => void): void;
-    terminateConnection(err?: Error): Promise<void>;
-}

package/lib/browser/utils/socket-base.js

@@ -1,96 +0,0 @@
-import { wsMessageHandler } from "../client/utils/message-handler.js";
-import { RPCMessages } from "../proto/api.js";
-import { AttestorError, makeRpcEvent, packRpcMessages } from "../utils/index.js";
-class AttestorSocket {
-  eventTarget = new EventTarget();
-  socket;
-  logger;
-  metadata;
-  isInitialised = false;
-  constructor(socket, metadata, logger) {
-    this.socket = socket;
-    this.metadata = metadata;
-    this.logger = logger;
-    socket.addEventListener("error", (event) => {
-      const witErr = AttestorError.fromError(
-        event.error || new Error(event.message),
-        "ERROR_NETWORK_ERROR"
-      );
-      this.dispatchRPCEvent("connection-terminated", witErr);
-    });
-    socket.addEventListener("close", () => this.dispatchRPCEvent(
-      "connection-terminated",
-      new AttestorError(
-        "ERROR_NO_ERROR",
-        "connection closed"
-      )
-    ));
-    socket.addEventListener("message", async (event) => {
-      try {
-        await wsMessageHandler.call(this, event.data);
-      } catch (err) {
-        this.logger.error({ err }, "error processing message");
-      }
-    });
-  }
-  get isOpen() {
-    return this.socket.readyState === this.socket.OPEN;
-  }
-  get isClosed() {
-    return this.socket.readyState === this.socket.CLOSED || this.socket.readyState === this.socket.CLOSING;
-  }
-  async sendMessage(...msgs) {
-    if (this.isClosed) {
-      throw new AttestorError(
-        "ERROR_NETWORK_ERROR",
-        "Connection closed, cannot send message"
-      );
-    }
-    if (!this.isOpen) {
-      throw new AttestorError(
-        "ERROR_NETWORK_ERROR",
-        "Wait for connection to open before sending message"
-      );
-    }
-    const msg = packRpcMessages(...msgs);
-    const bytes = RPCMessages.encode(msg).finish();
-    this.logger.trace({ msg }, "sending messages");
-    if ("sendPromise" in this.socket && this.socket.sendPromise) {
-      await this.socket.sendPromise(bytes);
-    } else {
-      this.socket.send(bytes);
-    }
-    return msg;
-  }
-  dispatchRPCEvent(type, data) {
-    const event = makeRpcEvent(type, data);
-    this.eventTarget.dispatchEvent(event);
-  }
-  addEventListener(type, listener) {
-    this.eventTarget.addEventListener(type, listener);
-  }
-  removeEventListener(type, listener) {
-    this.eventTarget.removeEventListener(type, listener);
-  }
-  async terminateConnection(err) {
-    if (this.isClosed) {
-      return;
-    }
-    try {
-      const witErr = err ? AttestorError.fromError(err) : new AttestorError("ERROR_NO_ERROR", "");
-      this.dispatchRPCEvent("connection-terminated", witErr);
-      if (this.isOpen) {
-        await this.sendMessage({
-          connectionTerminationAlert: witErr.toProto()
-        });
-      }
-    } catch (err2) {
-      this.logger?.error({ err: err2 }, "error terminating connection");
-    } finally {
-      this.socket.close();
-    }
-  }
-}
-export {
-  AttestorSocket
-};

package/lib/browser/utils/tls-imports.d.ts

@@ -1 +0,0 @@
-export { areUint8ArraysEqual, asciiToUint8Array, concatenateUint8Arrays, crypto, decryptWrappedRecord, encryptWrappedRecord, generateIV, makeTLSClient, setCryptoImplementation, uint8ArrayToBinaryStr, uint8ArrayToDataView, CONTENT_TYPE_MAP, PACKET_TYPE, SUPPORTED_CIPHER_SUITE_MAP, SUPPORTED_NAMED_CURVES, } from '@reclaimprotocol/tls';

package/lib/browser/utils/tls-imports.js

@@ -1,34 +0,0 @@
-import {
-  areUint8ArraysEqual,
-  asciiToUint8Array,
-  concatenateUint8Arrays,
-  crypto,
-  decryptWrappedRecord,
-  encryptWrappedRecord,
-  generateIV,
-  makeTLSClient,
-  setCryptoImplementation,
-  uint8ArrayToBinaryStr,
-  uint8ArrayToDataView,
-  CONTENT_TYPE_MAP,
-  PACKET_TYPE,
-  SUPPORTED_CIPHER_SUITE_MAP,
-  SUPPORTED_NAMED_CURVES
-} from "@reclaimprotocol/tls";
-export {
-  CONTENT_TYPE_MAP,
-  PACKET_TYPE,
-  SUPPORTED_CIPHER_SUITE_MAP,
-  SUPPORTED_NAMED_CURVES,
-  areUint8ArraysEqual,
-  asciiToUint8Array,
-  concatenateUint8Arrays,
-  crypto,
-  decryptWrappedRecord,
-  encryptWrappedRecord,
-  generateIV,
-  makeTLSClient,
-  setCryptoImplementation,
-  uint8ArrayToBinaryStr,
-  uint8ArrayToDataView
-};

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

@@ -1,2 +0,0 @@
-import type { TLSConnectionOptions } from '@reclaimprotocol/tls';
-export declare function getDefaultTlsOptions(): TLSConnectionOptions;

package/lib/browser/utils/tls.js

@@ -1,58 +0,0 @@
-import { SUPPORTED_NAMED_CURVES } from "../utils/tls-imports.js";
-import { detectEnvironment } from "../utils/env.js";
-const ZK_CIPHER_SUITES = [
-  // chacha-20
-  "TLS_CHACHA20_POLY1305_SHA256",
-  "TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256",
-  "TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256",
-  // aes-256
-  "TLS_AES_256_GCM_SHA384",
-  "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384",
-  "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384",
-  // aes-128
-  "TLS_AES_128_GCM_SHA256",
-  "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256",
-  "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256",
-  "TLS_RSA_WITH_AES_128_GCM_SHA256"
-];
-const NAMED_CURVE_LIST = detectEnvironment() === "node" ? SUPPORTED_NAMED_CURVES : SUPPORTED_NAMED_CURVES.filter((c) => c !== "X25519");
-TLS_ADDITIONAL_ROOT_CA_LIST.push(
-  `-----BEGIN CERTIFICATE-----
-MIIEszCCA5ugAwIBAgIQCyWUIs7ZgSoVoE6ZUooO+jANBgkqhkiG9w0BAQsFADBh
-MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3
-d3cuZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBH
-MjAeFw0xNzExMDIxMjI0MzNaFw0yNzExMDIxMjI0MzNaMGAxCzAJBgNVBAYTAlVT
-MRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5j
-b20xHzAdBgNVBAMTFlJhcGlkU1NMIFRMUyBSU0EgQ0EgRzEwggEiMA0GCSqGSIb3
-DQEBAQUAA4IBDwAwggEKAoIBAQC/uVklRBI1FuJdUEkFCuDL/I3aJQiaZ6aibRHj
-ap/ap9zy1aYNrphe7YcaNwMoPsZvXDR+hNJOo9gbgOYVTPq8gXc84I75YKOHiVA4
-NrJJQZ6p2sJQyqx60HkEIjzIN+1LQLfXTlpuznToOa1hyTD0yyitFyOYwURM+/CI
-8FNFMpBhw22hpeAQkOOLmsqT5QZJYeik7qlvn8gfD+XdDnk3kkuuu0eG+vuyrSGr
-5uX5LRhFWlv1zFQDch/EKmd163m6z/ycx/qLa9zyvILc7cQpb+k7TLra9WE17YPS
-n9ANjG+ECo9PDW3N9lwhKQCNvw1gGoguyCQu7HE7BnW8eSSFAgMBAAGjggFmMIIB
-YjAdBgNVHQ4EFgQUDNtsgkkPSmcKuBTuesRIUojrVjgwHwYDVR0jBBgwFoAUTiJU
-IBiV5uNu5g/6+rkS7QYXjzkwDgYDVR0PAQH/BAQDAgGGMB0GA1UdJQQWMBQGCCsG
-AQUFBwMBBggrBgEFBQcDAjASBgNVHRMBAf8ECDAGAQH/AgEAMDQGCCsGAQUFBwEB
-BCgwJjAkBggrBgEFBQcwAYYYaHR0cDovL29jc3AuZGlnaWNlcnQuY29tMEIGA1Ud
-HwQ7MDkwN6A1oDOGMWh0dHA6Ly9jcmwzLmRpZ2ljZXJ0LmNvbS9EaWdpQ2VydEds
-b2JhbFJvb3RHMi5jcmwwYwYDVR0gBFwwWjA3BglghkgBhv1sAQEwKjAoBggrBgEF
-BQcCARYcaHR0cHM6Ly93d3cuZGlnaWNlcnQuY29tL0NQUzALBglghkgBhv1sAQIw
-CAYGZ4EMAQIBMAgGBmeBDAECAjANBgkqhkiG9w0BAQsFAAOCAQEAGUSlOb4K3Wtm
-SlbmE50UYBHXM0SKXPqHMzk6XQUpCheF/4qU8aOhajsyRQFDV1ih/uPIg7YHRtFi
-CTq4G+zb43X1T77nJgSOI9pq/TqCwtukZ7u9VLL3JAq3Wdy2moKLvvC8tVmRzkAe
-0xQCkRKIjbBG80MSyDX/R4uYgj6ZiNT/Zg6GI6RofgqgpDdssLc0XIRQEotxIZcK
-zP3pGJ9FCbMHmMLLyuBd+uCWvVcF2ogYAawufChS/PT61D9rqzPRS5I2uqa3tmIT
-44JhJgWhBnFMb7AGQkvNq9KNS9dd3GWc17H/dXa1enoxzWjE0hBdFjxPhUb0W3wi
-8o34/m8Fxw==
------END CERTIFICATE-----`
-  //RapidSSL TLS RSA CA G1
-);
-function getDefaultTlsOptions() {
-  return {
-    cipherSuites: ZK_CIPHER_SUITES,
-    namedCurves: NAMED_CURVE_LIST
-  };
-}
-export {
-  getDefaultTlsOptions
-};

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

@@ -1,7 +0,0 @@
-import type { WebSocket as WSWebSocket } from 'ws';
-export declare function makeWebSocket(url: string): WebSocket;
-/**
- * Adds the "sendPromise" fn to the given WebSocket instance,
- * if not already present.
- */
-export declare function promisifySend(ws: WSWebSocket): WSWebSocket;

package/lib/browser/utils/ws.js

@@ -1,22 +0,0 @@
-function makeWebSocket(url) {
-  return new WebSocket(url);
-}
-function promisifySend(ws) {
-  if (ws.sendPromise) {
-    return ws;
-  }
-  ws.sendPromise = (data) => new Promise((resolve, reject) => {
-    ws.send(data, (err) => {
-      if (err) {
-        reject(err);
-        return;
-      }
-      resolve();
-    });
-  });
-  return ws;
-}
-export {
-  makeWebSocket,
-  promisifySend
-};

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

@@ -1,71 +0,0 @@
-import type { CipherSuite } from '@reclaimprotocol/tls';
-import type { EncryptionAlgorithm, OPRFOperator, PrivateInput, PublicInput, ZKEngine, ZKOperator } from '@reclaimprotocol/zk-symmetric-crypto';
-import type { MessageReveal_MessageRevealZk as ZKReveal, MessageReveal_TOPRFProof as TOPRFProof, MessageReveal_ZKProof as ZKProof } from '#src/proto/api.ts';
-import { ZKProofEngine } from '#src/proto/api.ts';
-import type { CompleteTLSPacket, Logger, OPRFOperators, PrepareZKProofsBaseOpts, TOPRFProofParams, ZKOperators, ZKRevealInfo } from '#src/types/index.ts';
-type PrepareZKProofsOpts = {
-    logger?: Logger;
-    cipherSuite: CipherSuite;
-} & PrepareZKProofsBaseOpts;
-type ZKVerifyOpts = {
-    cipherSuite: CipherSuite;
-    ciphertext: Uint8Array;
-    zkReveal: ZKReveal;
-    iv: Uint8Array;
-    recordNumber: number;
-    toprfOvershotNullifier?: Uint8Array;
-    /**
-     * Get the ciphertext of the next packet.
-     * @param overshotNullifier The TOPRF nullifier that overshoots into
-     * the next packet. This should be passed into the verifyZkPacket function
-     * of the next packet.
-     */
-    getNextPacket: (overshotNullifier: Uint8Array) => (Uint8Array | undefined);
-    logger?: Logger;
-    /** get ZK operator for specified algorithm */
-    zkOperators?: ZKOperators;
-    oprfOperators?: OPRFOperators;
-    zkEngine?: ZKEngine;
-};
-type ZKProofToGenerate = {
-    startIdx: number;
-    redactedPlaintext: Uint8Array;
-    privateInput: PrivateInput;
-    publicInput: PublicInput;
-};
-type TOPRFProofToGenerate = {
-    privateInput: PrivateInput;
-    publicInput: PublicInput;
-    toprf: TOPRFProofParams;
-    startIdx: number;
-};
-type ZKPacketToProve = {
-    onGeneratedProofs(proofs: ZKProof[], toprfs: TOPRFProof[]): void;
-    algorithm: EncryptionAlgorithm;
-    proofsToGenerate: ZKProofToGenerate[];
-    toprfsToGenerate: TOPRFProofToGenerate[];
-    iv: Uint8Array;
-};
-export declare function makeZkProofGenerator({ zkOperators, oprfOperators, logger, zkProofConcurrency, cipherSuite, zkEngine }: PrepareZKProofsOpts): Promise<{
-    /**
-     * Adds the given packet to the list of packets to
-     * generate ZK proofs for.
-     *
-     * Call `generateProofs()` to finally generate the proofs
-     */
-    addPacketToProve(packet: CompleteTLSPacket, { redactedPlaintext, toprfs, overshotToprfFromPrevBlock }: ZKRevealInfo, onGeneratedProofs: ZKPacketToProve["onGeneratedProofs"], getNextPacket: () => CompleteTLSPacket | undefined): Promise<void>;
-    getTotalChunksToProve(): number;
-    generateProofs(onChunkDone?: () => void): Promise<void>;
-}>;
-/**
- * Verify the given ZK proof
- */
-export declare function verifyZkPacket({ cipherSuite, ciphertext, zkReveal, zkOperators, oprfOperators, logger, zkEngine, iv, recordNumber, toprfOvershotNullifier, getNextPacket }: ZKVerifyOpts): Promise<{
-    redactedPlaintext: Uint8Array<ArrayBuffer>;
-    oprfRawMarkers: import("#src/proto/api.ts").MessageReveal_OPRFRawMarker[];
-}>;
-export declare function makeDefaultZkOperator(algorithm: EncryptionAlgorithm, zkEngine: ZKEngine, logger: Logger): ZKOperator;
-export declare function makeDefaultOPRFOperator(algorithm: EncryptionAlgorithm, zkEngine: ZKEngine, logger: Logger): OPRFOperator;
-export declare function getEngineString(engine: ZKProofEngine): "snarkjs" | "gnark" | "stwo";
-export declare function getEngineProto(engine: ZKEngine): 0 | 1 | 2;
-export {};