@reclaimprotocol/attestor-core 4.0.3 → 5.0.1-beta.10

package/lib/utils/zk.js

@@ -1,444 +1,625 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeZkProofGenerator = makeZkProofGenerator;
-exports.verifyZkPacket = verifyZkPacket;
-exports.makeDefaultZkOperator = makeDefaultZkOperator;
-exports.makeDefaultOPRFOperator = makeDefaultOPRFOperator;
-exports.getEngineString = getEngineString;
-exports.getEngineProto = getEngineProto;
-const tls_1 = require("@reclaimprotocol/tls");
-const zk_symmetric_crypto_1 = require("@reclaimprotocol/zk-symmetric-crypto");
-const config_1 = require("../config");
-const api_1 = require("../proto/api");
-const env_1 = require("../utils/env");
-const error_1 = require("../utils/error");
-const generics_1 = require("../utils/generics");
-const logger_1 = require("../utils/logger");
-const redactions_1 = require("../utils/redactions");
-const ZK_CONCURRENCY = +((0, env_1.getEnvVariable)('ZK_CONCURRENCY')
-    || config_1.DEFAULT_ZK_CONCURRENCY);
-async function makeZkProofGenerator({ zkOperators, oprfOperators, logger = logger_1.logger, zkProofConcurrency = ZK_CONCURRENCY, cipherSuite, zkEngine = 'snarkjs' }) {
-    const { default: PQueue } = await import('p-queue');
-    const zkQueue = new PQueue({
-        concurrency: zkProofConcurrency,
-        autoStart: true,
-    });
-    const packetsToProve = [];
-    logger = (logger || logger_1.logger).child({ module: 'zk', zkEngine: zkEngine });
-    let zkProofsToGen = 0;
-    return {
-        /**
-         * Adds the given packet to the list of packets to
-         * generate ZK proofs for.
-         *
-         * Call `generateProofs()` to finally generate the proofs
-         */
-        async addPacketToProve(packet, { redactedPlaintext, toprfs }, onGeneratedProofs) {
-            if (packet.type === 'plaintext') {
-                throw new Error('Cannot generate proof for plaintext');
-            }
-            const alg = (0, generics_1.getZkAlgorithmForCipherSuite)(cipherSuite);
-            const chunkSizeBytes = getChunkSizeBytes(alg);
-            const key = await tls_1.crypto.exportKey(packet.encKey);
-            const iv = packet.iv;
-            const ciphertext = (0, generics_1.getPureCiphertext)(packet.ciphertext, cipherSuite);
-            const packetToProve = {
-                onGeneratedProofs,
-                algorithm: alg,
-                proofsToGenerate: [],
-                iv: packet.fixedIv,
-            };
-            const slicesDone = [];
-            // first we'll handle all TOPRF blocks
-            // we do these first, because they can span multiple chunks
-            // & we need to be able to span the right chunks
-            for (const toprf of toprfs || []) {
-                const fromIndex = getIdealOffsetForToprfBlock(alg, toprf);
-                const toIndex = Math.min(fromIndex + chunkSizeBytes, ciphertext.length);
-                // ensure this OPRF block doesn't overlap with any other OPRF block
-                const slice = { fromIndex, toIndex };
-                assertNoOverlapOprf(slice);
-                addProofsToGenerate(slice, {
-                    ...toprf,
-                    dataLocation: {
-                        ...toprf.dataLocation,
-                        fromIndex: toprf.dataLocation.fromIndex - fromIndex
-                    }
-                });
-            }
-            // now we'll go through the rest of the ciphertext, and add proofs
-            // for the sections that haven't been covered by the TOPRF blocks
-            const slicesCp = sortSlices(slicesDone.slice());
-            let fromIndex = 0;
-            for (const done of slicesCp) {
-                if (done.fromIndex > fromIndex) {
-                    addProofsToGenerate({
-                        fromIndex,
-                        toIndex: done.fromIndex
-                    });
-                }
-                fromIndex = done.toIndex;
-            }
-            if (fromIndex < ciphertext.length) {
-                addProofsToGenerate({
-                    fromIndex,
-                    toIndex: ciphertext.length
-                });
-            }
-            // generate proofs in order of start index
-            packetToProve.proofsToGenerate
-                .sort((a, b) => a.startIdx - b.startIdx);
-            packetsToProve.push(packetToProve);
-            function assertNoOverlapOprf(slice) {
-                for (const done of slicesDone) {
-                    if (
-                    // 1d box overlap
-                    slice.fromIndex < done.toIndex
-                        && slice.toIndex > done.fromIndex) {
-                        throw new error_1.AttestorError('ERROR_BAD_REQUEST', 'Single chunk has multiple OPRFs');
-                    }
-                }
-            }
-            function addProofsToGenerate({ fromIndex, toIndex }, toprf) {
-                for (let i = fromIndex; i < toIndex; i += chunkSizeBytes) {
-                    const slice = {
-                        fromIndex: i,
-                        toIndex: Math.min(i + chunkSizeBytes, toIndex)
-                    };
-                    slicesDone.push(slice);
-                    const proofParams = getProofGenerationParamsForSlice({
-                        key,
-                        iv,
-                        ciphertext,
-                        redactedPlaintext,
-                        slice,
-                        toprf,
-                    });
-                    if (!proofParams) {
-                        continue;
-                    }
-                    packetToProve.proofsToGenerate.push(proofParams);
-                    zkProofsToGen += 1;
-                }
-            }
-        },
-        getTotalChunksToProve() {
-            return zkProofsToGen;
-        },
-        async generateProofs(onChunkDone) {
-            var _a;
-            if (!packetsToProve.length) {
-                return;
-            }
-            const start = Date.now();
-            const tasks = [];
-            for (const { onGeneratedProofs, algorithm, proofsToGenerate } of packetsToProve) {
-                const proofs = [];
-                let proofsLeft = proofsToGenerate.length;
-                for (const proofToGen of proofsToGenerate) {
-                    tasks.push(zkQueue.add(async () => {
-                        const proof = await generateProofForChunk(algorithm, proofToGen);
-                        onChunkDone === null || onChunkDone === void 0 ? void 0 : onChunkDone();
-                        proofs.push(proof);
-                        proofsLeft -= 1;
-                        if (proofsLeft === 0) {
-                            onGeneratedProofs(proofs);
-                        }
-                    }, { throwOnTimeout: true }));
-                }
-            }
-            await Promise.all(tasks);
-            logger === null || logger === void 0 ? void 0 : logger.info({ durationMs: Date.now() - start, zkProofsToGen }, 'generated ZK proofs');
-            // reset the packets to prove
-            packetsToProve.splice(0, packetsToProve.length);
-            zkProofsToGen = 0;
-            // release ZK resources to free up memory
-            const alg = (0, generics_1.getZkAlgorithmForCipherSuite)(cipherSuite);
-            const zkOperator = await getZkOperatorForAlgorithm(alg);
-            (_a = zkOperator.release) === null || _a === void 0 ? void 0 : _a.call(zkOperator);
-        },
-    };
-    async function generateProofForChunk(algorithm, { startIdx, redactedPlaintext, privateInput, publicInput, toprf, }) {
-        const operator = toprf
-            ? getOprfOperatorForAlgorithm(algorithm)
-            : getZkOperatorForAlgorithm(algorithm);
-        const proof = await (0, zk_symmetric_crypto_1.generateProof)({
-            algorithm,
-            privateInput,
-            publicInput,
-            operator,
-            logger,
-            ...(toprf
-                ? {
-                    toprf: {
-                        pos: toprf.dataLocation.fromIndex,
-                        len: toprf.dataLocation.length,
-                        output: toprf.nullifier,
-                        responses: toprf.responses,
-                        domainSeparator: config_1.TOPRF_DOMAIN_SEPARATOR
-                    },
-                    mask: toprf.mask,
-                }
-                : {})
-        });
-        logger === null || logger === void 0 ? void 0 : logger.debug({ startIdx }, 'generated proof for chunk');
-        return {
-            // backwards compatibility
-            proofJson: '',
-            proofData: typeof proof.proofData === 'string'
-                ? (0, tls_1.strToUint8Array)(proof.proofData)
-                : proof.proofData,
-            toprf,
-            decryptedRedactedCiphertext: proof.plaintext,
-            redactedPlaintext,
-            startIdx
-        };
-    }
-    function getZkOperatorForAlgorithm(algorithm) {
-        return (zkOperators === null || zkOperators === void 0 ? void 0 : zkOperators[algorithm])
-            || makeDefaultZkOperator(algorithm, zkEngine, logger);
-    }
-    function getOprfOperatorForAlgorithm(algorithm) {
-        return (oprfOperators === null || oprfOperators === void 0 ? void 0 : oprfOperators[algorithm])
-            || makeDefaultOPRFOperator(algorithm, zkEngine, logger);
-    }
-}
-/**
- * Verify the given ZK proof
- */
-async function verifyZkPacket({ cipherSuite, ciphertext, zkReveal, zkOperators, oprfOperators, logger = logger_1.logger, zkEngine = 'snarkjs', iv, recordNumber }) {
-    if (!zkReveal) {
-        throw new Error('No ZK reveal');
-    }
-    const { proofs } = zkReveal;
-    const algorithm = (0, generics_1.getZkAlgorithmForCipherSuite)(cipherSuite);
-    const recordIV = (0, generics_1.getRecordIV)(ciphertext, cipherSuite);
-    ciphertext = (0, generics_1.getPureCiphertext)(ciphertext, cipherSuite);
+import { concatenateUint8Arrays, crypto, generateIV } from "../utils/tls-imports.js";
+import {
+  ceilToBlockSizeMultiple,
+  CONFIG as ZK_CONFIG,
+  generateProof,
+  getBlockSizeBytes,
+  makeLocalFileFetch,
+  makeRemoteFileFetch,
+  verifyProof
+} from "@reclaimprotocol/zk-symmetric-crypto";
+import { makeGnarkOPRFOperator, makeGnarkZkOperator } from "@reclaimprotocol/zk-symmetric-crypto/gnark";
+import { makeSnarkJsZKOperator } from "@reclaimprotocol/zk-symmetric-crypto/snarkjs";
+import { makeStwoZkOperator } from "@reclaimprotocol/zk-symmetric-crypto/stwo";
+import PQueue from "p-queue";
+import {
+  DEFAULT_REMOTE_FILE_FETCH_BASE_URL,
+  DEFAULT_ZK_CONCURRENCY,
+  TOPRF_DOMAIN_SEPARATOR
+} from "../config/index.js";
+import { ZKProofEngine } from "../proto/api.js";
+import { detectEnvironment, getEnvVariable } from "../utils/env.js";
+import { AttestorError } from "../utils/error.js";
+import {
+  getPureCiphertext,
+  getRecordIV,
+  getZkAlgorithmForCipherSuite,
+  isTls13Suite,
+  strToUint8Array
+} from "../utils/generics.js";
+import { logger as LOGGER } from "../utils/logger.js";
+import { binaryHashToStr, isFullyRedacted, isRedactionCongruent, REDACTION_CHAR_CODE } from "../utils/redactions.js";
+const ZK_CONCURRENCY = +(getEnvVariable("ZK_CONCURRENCY") || DEFAULT_ZK_CONCURRENCY);
+async function makeZkProofGenerator({
+  zkOperators,
+  oprfOperators,
+  logger = LOGGER,
+  zkProofConcurrency = ZK_CONCURRENCY,
+  cipherSuite,
+  zkEngine = "snarkjs"
+}) {
+  const zkQueue = new PQueue({ concurrency: zkProofConcurrency, autoStart: true });
+  const packetsToProve = [];
+  logger = logger.child({ module: "zk", zkEngine });
+  let zkProofsToGen = 0;
+  return {
     /**
-     * to verify if the user has given us the correct redacted plaintext,
-     * and isn't providing plaintext that they haven't proven they have
-     * we start with a fully redacted plaintext, and then replace the
-     * redacted parts with the plaintext that the user has provided
-     * in the proofs
+     * Adds the given packet to the list of packets to
+     * generate ZK proofs for.
+     *
+     * Call `generateProofs()` to finally generate the proofs
      */
-    const realRedactedPlaintext = new Uint8Array(ciphertext.length).fill(redactions_1.REDACTION_CHAR_CODE);
-    await Promise.all(proofs.map(async (proof, i) => {
-        try {
-            await verifyProofPacket(proof);
+    async addPacketToProve(packet, {
+      redactedPlaintext,
+      toprfs = [],
+      overshotToprfFromPrevBlock
+    }, onGeneratedProofs, getNextPacket) {
+      if (packet.type === "plaintext") {
+        throw new Error("Cannot generate proof for plaintext");
+      }
+      const alg = getZkAlgorithmForCipherSuite(cipherSuite);
+      const chunkSizeBytes = getChunkSizeBytes(alg);
+      const key = await crypto.exportKey(packet.encKey);
+      const iv = packet.iv;
+      const ciphertext = getPureCiphertext(packet.ciphertext, cipherSuite);
+      if (overshotToprfFromPrevBlock) {
+        redactedPlaintext.set(
+          new Uint8Array(overshotToprfFromPrevBlock.length).fill(REDACTION_CHAR_CODE)
+        );
+      }
+      const trueCiphertextLength = isTls13Suite(cipherSuite) ? ciphertext.length - 1 : ciphertext.length;
+      const packetToProve = {
+        onGeneratedProofs,
+        algorithm: alg,
+        proofsToGenerate: [],
+        toprfsToGenerate: [],
+        iv: packet.fixedIv
+      };
+      for (const toprf of toprfs) {
+        const toprfDistFromEnd = trueCiphertextLength - (toprf.dataLocation.fromIndex + toprf.dataLocation.length);
+        if (toprfDistFromEnd < 0) {
+          const nextPacket = getNextPacket();
+          if (nextPacket?.type !== "ciphertext") {
+            throw new AttestorError(
+              "ERROR_INTERNAL",
+              "TOPRF data overshoots ciphertext length, but no next ciphertext packet found"
+            );
+          }
+          if (nextPacket.encKey !== packet.encKey) {
+            throw new AttestorError(
+              "ERROR_INTERNAL",
+              "TOPRF data overshoots ciphertext length, but next packet has different encryption key"
+            );
+          }
+          const nextCiphertext = nextPacket.ciphertext.slice(0, Math.abs(toprfDistFromEnd));
+          const iv2 = nextPacket.iv;
+          toprf.overshoot = {
+            ciphertext: nextCiphertext,
+            iv: iv2,
+            recordNumber: nextPacket.recordNumber
+          };
         }
-        catch (e) {
-            e.message += ` (chunk ${i}, startIdx ${proof.startIdx})`;
-            throw e;
-        }
-    }));
-    return { redactedPlaintext: realRedactedPlaintext };
-    async function verifyProofPacket({ proofData, proofJson, decryptedRedactedCiphertext, redactedPlaintext, startIdx, toprf, }) {
-        var _a, _b, _c;
-        // get the ciphertext chunk we received from the server
-        // the ZK library, will verify that the decrypted redacted
-        // ciphertext matches the ciphertext received from the server
-        const ciphertextChunk = ciphertext.slice(startIdx, startIdx + redactedPlaintext.length);
-        // redact ciphertext if plaintext is redacted
-        // to prepare for decryption in ZK circuit
-        // the ZK circuit will take in the redacted ciphertext,
-        // which shall produce the redacted plaintext
-        for (let i = 0; i < ciphertextChunk.length; i++) {
-            if (redactedPlaintext[i] === redactions_1.REDACTION_CHAR_CODE) {
-                ciphertextChunk[i] = redactions_1.REDACTION_CHAR_CODE;
+        const fromIndex = getIdealOffsetForToprfBlock(alg, toprf);
+        const toIndex = Math.min(fromIndex + chunkSizeBytes, ciphertext.length);
+        const slice = { fromIndex, toIndex };
+        packetToProve.toprfsToGenerate.push(getTOPRFProofGenerationParamsForSlice({
+          key,
+          iv,
+          ciphertext,
+          slice,
+          toprf: {
+            ...toprf,
+            dataLocation: {
+              ...toprf.dataLocation,
+              fromIndex: toprf.dataLocation.fromIndex - fromIndex
             }
+          }
+        }));
+        zkProofsToGen += 1;
+        const pktToIndex = Math.min(
+          trueCiphertextLength,
+          toprf.dataLocation.fromIndex + toprf.dataLocation.length
+        );
+        const pktFromIndex = toprf.dataLocation.fromIndex;
+        for (let i = pktFromIndex; i < pktToIndex; i++) {
+          redactedPlaintext[i] = REDACTION_CHAR_CODE;
         }
-        // redact OPRF indices -- because they'll incorrectly
-        // be marked as incongruent
-        let comparePlaintext = redactedPlaintext;
-        if (toprf) {
-            comparePlaintext = new Uint8Array(redactedPlaintext);
-            for (let i = 0; i < toprf.dataLocation.length; i++) {
-                comparePlaintext[i + toprf.dataLocation.fromIndex] = redactions_1.REDACTION_CHAR_CODE;
-            }
-            // the transcript will contain only the stringified
-            // nullifier. So here, we'll compare the provable
-            // binary nullifier with the stringified nullifier
-            // that the user has provided
-            const nulliferStr = (0, redactions_1.binaryHashToStr)(toprf.nullifier, toprf.dataLocation.length);
-            const txtHash = redactedPlaintext.slice((_a = toprf.dataLocation) === null || _a === void 0 ? void 0 : _a.fromIndex, ((_b = toprf.dataLocation) === null || _b === void 0 ? void 0 : _b.fromIndex)
-                + ((_c = toprf.dataLocation) === null || _c === void 0 ? void 0 : _c.length));
-            if ((0, generics_1.uint8ArrayToStr)(txtHash) !== nulliferStr
-                .slice(0, txtHash.length)) {
-                throw new Error('OPRF nullifier not congruent');
+      }
+      for (let i = 0; i < ciphertext.length; i += chunkSizeBytes) {
+        const slice = {
+          fromIndex: i,
+          toIndex: Math.min(i + chunkSizeBytes, ciphertext.length)
+        };
+        const proofParams = getProofGenerationParamsForSlice(
+          { key, iv, ciphertext, redactedPlaintext, slice }
+        );
+        if (!proofParams) {
+          continue;
+        }
+        packetToProve.proofsToGenerate.push(proofParams);
+        zkProofsToGen += 1;
+      }
+      packetsToProve.push(packetToProve);
+    },
+    getTotalChunksToProve() {
+      return zkProofsToGen;
+    },
+    async generateProofs(onChunkDone) {
+      if (!packetsToProve.length) {
+        return;
+      }
+      const start = Date.now();
+      const tasks = [];
+      for (const {
+        onGeneratedProofs,
+        algorithm,
+        proofsToGenerate,
+        toprfsToGenerate
+      } of packetsToProve) {
+        const proofs = [];
+        const toprfs = [];
+        let proofsLeft = proofsToGenerate.length + toprfsToGenerate.length;
+        for (const proofToGen of proofsToGenerate) {
+          tasks.push(zkQueue.add(async () => {
+            const proof = await generateZkProofForChunk(algorithm, proofToGen);
+            onChunkDone?.();
+            proofs.push(proof);
+            proofsLeft -= 1;
+            if (proofsLeft === 0) {
+              onGeneratedProofs(proofs, toprfs);
             }
+          }, { throwOnTimeout: true }));
         }
-        if (!(0, redactions_1.isRedactionCongruent)(comparePlaintext, decryptedRedactedCiphertext)) {
-            throw new Error('redacted ciphertext not congruent');
+        for (const toprfToGen of toprfsToGenerate) {
+          tasks.push(zkQueue.add(async () => {
+            const toprf = await generateOprfProofForChunk(algorithm, toprfToGen);
+            onChunkDone?.();
+            toprfs.push(toprf);
+            proofsLeft -= 1;
+            if (proofsLeft === 0) {
+              onGeneratedProofs(proofs, toprfs);
+            }
+          }, { throwOnTimeout: true }));
         }
-        let nonce = (0, tls_1.concatenateUint8Arrays)([iv, recordIV]);
-        if (!recordIV.length) {
-            nonce = (0, tls_1.generateIV)(nonce, recordNumber);
+      }
+      await Promise.all(tasks);
+      logger?.info(
+        { durationMs: Date.now() - start, zkProofsToGen },
+        "generated ZK proofs"
+      );
+      packetsToProve.splice(0, packetsToProve.length);
+      zkProofsToGen = 0;
+      const alg = getZkAlgorithmForCipherSuite(cipherSuite);
+      const zkOperator = await getZkOperatorForAlgorithm(alg);
+      zkOperator.release?.();
+    }
+  };
+  async function generateZkProofForChunk(algorithm, {
+    startIdx,
+    redactedPlaintext,
+    privateInput,
+    publicInput
+  }) {
+    const operator = getZkOperatorForAlgorithm(algorithm);
+    const proof = await generateProof(
+      { algorithm, privateInput, publicInput, operator, logger }
+    );
+    logger?.debug({ startIdx }, "generated proof for chunk");
+    return {
+      proofData: typeof proof.proofData === "string" ? strToUint8Array(proof.proofData) : proof.proofData,
+      decryptedRedactedCiphertext: proof.plaintext || new Uint8Array(),
+      redactedPlaintext,
+      startIdx
+    };
+  }
+  async function generateOprfProofForChunk(algorithm, { startIdx, privateInput, publicInput, toprf }) {
+    const operator = getOprfOperatorForAlgorithm(algorithm);
+    const toprfLocations = [];
+    if (toprf?.overshoot) {
+      const { dataLocation, overshoot: { ciphertext } } = toprf;
+      toprfLocations.push(
+        {
+          pos: dataLocation.fromIndex,
+          len: dataLocation.length - ciphertext.length
+        },
+        {
+          pos: ceilToBlockSizeMultiple(
+            dataLocation.fromIndex + dataLocation.length,
+            algorithm
+          ),
+          len: ciphertext.length
         }
-        await (0, zk_symmetric_crypto_1.verifyProof)({
-            proof: {
-                algorithm,
-                proofData: proofData.length
-                    ? proofData
-                    : (0, tls_1.strToUint8Array)(proofJson),
-                plaintext: decryptedRedactedCiphertext,
-            },
-            publicInput: {
-                ciphertext: ciphertextChunk,
-                iv: nonce,
-                offsetBytes: startIdx
-            },
-            logger,
-            ...(toprf
-                ? {
-                    operator: getOprfOperator(),
-                    toprf: {
-                        pos: toprf.dataLocation.fromIndex,
-                        len: toprf.dataLocation.length,
-                        domainSeparator: config_1.TOPRF_DOMAIN_SEPARATOR,
-                        output: toprf.nullifier,
-                        responses: toprf.responses,
-                    }
-                }
-                : { operator: getZkOperator() })
-        });
-        logger === null || logger === void 0 ? void 0 : logger.debug({ startIdx, endIdx: startIdx + redactedPlaintext.length }, 'verified proof');
-        realRedactedPlaintext.set(redactedPlaintext, startIdx);
+      );
+    } else if (toprf) {
+      toprfLocations.push({
+        pos: toprf.dataLocation.fromIndex,
+        len: toprf.dataLocation.length
+      });
     }
-    function getZkOperator() {
-        return (zkOperators === null || zkOperators === void 0 ? void 0 : zkOperators[algorithm])
-            || makeDefaultZkOperator(algorithm, zkEngine, logger);
+    const proof = await generateProof(
+      {
+        algorithm,
+        privateInput,
+        publicInput,
+        operator,
+        logger,
+        ...toprf ? {
+          toprf: {
+            locations: toprfLocations,
+            output: toprf.nullifier,
+            responses: toprf.responses,
+            domainSeparator: TOPRF_DOMAIN_SEPARATOR
+          },
+          mask: toprf.mask
+        } : {}
+      }
+    );
+    logger?.debug({ toprfLocations }, "generated TOPRF proof for chunk");
+    return {
+      startIdx,
+      proofData: typeof proof.proofData === "string" ? strToUint8Array(proof.proofData) : proof.proofData,
+      payload: toprf
+    };
+  }
+  function getZkOperatorForAlgorithm(algorithm) {
+    return zkOperators?.[algorithm] || makeDefaultZkOperator(algorithm, zkEngine, logger);
+  }
+  function getOprfOperatorForAlgorithm(algorithm) {
+    return oprfOperators?.[algorithm] || makeDefaultOPRFOperator(algorithm, zkEngine, logger);
+  }
+}
+async function verifyZkPacket({
+  cipherSuite,
+  ciphertext,
+  zkReveal,
+  zkOperators,
+  oprfOperators,
+  logger = LOGGER,
+  zkEngine = "snarkjs",
+  iv,
+  recordNumber,
+  toprfOvershotNullifier,
+  getNextPacket
+}) {
+  const { proofs, toprfs, oprfRawMarkers } = zkReveal;
+  const algorithm = getZkAlgorithmForCipherSuite(cipherSuite);
+  const recordIV = getRecordIV(ciphertext, cipherSuite);
+  ciphertext = new Uint8Array(getPureCiphertext(ciphertext, cipherSuite));
+  const realRedactedPlaintext = new Uint8Array(ciphertext.length).fill(REDACTION_CHAR_CODE);
+  const replacements = await Promise.all(toprfs.map(async (toprf, i) => {
+    try {
+      return await verifyToprfProofPacket(toprf);
+    } catch (e) {
+      e.message += ` (TOPRF proof ${i}, from ${toprf.payload?.dataLocation?.fromIndex}, record ${recordNumber})`;
+      throw e;
     }
-    function getOprfOperator() {
-        return (oprfOperators === null || oprfOperators === void 0 ? void 0 : oprfOperators[algorithm])
-            || makeDefaultOPRFOperator(algorithm, zkEngine, logger);
+  }));
+  await Promise.all(proofs.map(async (proof, i) => {
+    try {
+      await verifyZkProofPacket(proof);
+    } catch (e) {
+      e.message += ` (ZK proof ${i}, startIdx ${proof.startIdx}, record ${recordNumber})`;
+      throw e;
     }
+  }));
+  for (const { set, startIdx } of replacements) {
+    realRedactedPlaintext.set(set, startIdx);
+  }
+  if (toprfOvershotNullifier) {
+    realRedactedPlaintext.set(toprfOvershotNullifier);
+  }
+  return { redactedPlaintext: realRedactedPlaintext, oprfRawMarkers };
+  async function verifyZkProofPacket({
+    proofData,
+    decryptedRedactedCiphertext,
+    redactedPlaintext,
+    startIdx
+  }) {
+    const ciphertextChunkEnd = startIdx + redactedPlaintext.length;
+    const ciphertextChunk = ciphertext.slice(startIdx, ciphertextChunkEnd);
+    for (let i = 0; i < ciphertextChunk.length; i++) {
+      if (redactedPlaintext[i] === REDACTION_CHAR_CODE) {
+        ciphertextChunk[i] = REDACTION_CHAR_CODE;
+      }
+    }
+    let nonce = concatenateUint8Arrays([iv, recordIV]);
+    if (!recordIV.length) {
+      nonce = generateIV(nonce, recordNumber);
+    }
+    const ciphertextInput = {
+      ciphertext: ciphertextChunk,
+      iv: nonce,
+      offsetBytes: startIdx
+    };
+    if (!isRedactionCongruent(redactedPlaintext, decryptedRedactedCiphertext)) {
+      throw new Error("redacted ciphertext not congruent");
+    }
+    await verifyProof(
+      {
+        proof: {
+          algorithm,
+          proofData,
+          plaintext: decryptedRedactedCiphertext
+        },
+        publicInput: ciphertextInput,
+        logger,
+        operator: getZkOperator()
+      }
+    );
+    logger?.debug(
+      { startIdx, endIdx: startIdx + redactedPlaintext.length },
+      "verified proof"
+    );
+    realRedactedPlaintext.set(redactedPlaintext, startIdx);
+  }
+  async function verifyToprfProofPacket({ startIdx, proofData, payload: toprf }) {
+    if (!toprf?.dataLocation || !toprf.responses || !toprf.nullifier) {
+      throw new Error("invalid TOPRF proof payload");
+    }
+    const { dataLocation, nullifier } = toprf;
+    const ciphertextChunkEnd = Math.min(ciphertext.length, getChunkSizeBytes(algorithm) + startIdx);
+    const isLastChunk = ciphertextChunkEnd >= ciphertext.length;
+    const ciphertextChunk = ciphertext.slice(startIdx, ciphertextChunkEnd);
+    let nonce = concatenateUint8Arrays([iv, recordIV]);
+    if (!recordIV.length) {
+      nonce = generateIV(nonce, recordNumber);
+    }
+    const ciphertextInput = {
+      ciphertext: ciphertextChunk,
+      iv: nonce,
+      offsetBytes: startIdx
+    };
+    let pubInput = ciphertextInput;
+    const nulliferStr = binaryHashToStr(nullifier, dataLocation.length);
+    const locations = [];
+    const toprfEndIdx = dataLocation.fromIndex + dataLocation.length;
+    const trueCiphLen = isLastChunk && isTls13Suite(cipherSuite) ? ciphertextChunk.length - 1 : ciphertextChunk.length;
+    const overshoot = toprfEndIdx - trueCiphLen;
+    if (overshoot > 0) {
+      const nextPkt = getNextPacket(
+        strToUint8Array(nulliferStr.slice(dataLocation.length - overshoot))
+      );
+      if (!nextPkt) {
+        throw new Error("OPRF data overshot, but no next packet found");
+      }
+      const nextRecordIV = getRecordIV(ciphertext, cipherSuite);
+      let nextNonce = concatenateUint8Arrays([iv, nextRecordIV]);
+      if (!nextRecordIV.length) {
+        nextNonce = generateIV(nextNonce, recordNumber + 1);
+      }
+      pubInput = [
+        ciphertextInput,
+        {
+          ciphertext: nextPkt.slice(0, overshoot),
+          iv: nextNonce,
+          offsetBytes: 0
+        }
+      ];
+      locations.push(
+        {
+          pos: dataLocation.fromIndex,
+          len: dataLocation.length - overshoot
+        },
+        {
+          pos: ceilToBlockSizeMultiple(
+            dataLocation.fromIndex + dataLocation.length,
+            algorithm
+          ),
+          len: overshoot
+        }
+      );
+    } else {
+      locations.push({
+        pos: dataLocation.fromIndex,
+        len: dataLocation.length
+      });
+    }
+    await verifyProof(
+      {
+        proof: { algorithm, proofData, plaintext: void 0 },
+        publicInput: pubInput,
+        logger,
+        operator: getOprfOperator(),
+        toprf: {
+          locations,
+          domainSeparator: TOPRF_DOMAIN_SEPARATOR,
+          output: nullifier,
+          responses: toprf.responses
+        }
+      }
+    );
+    logger?.debug({ locations }, "verified TOPRF proof");
+    return {
+      set: strToUint8Array(
+        nulliferStr.slice(0, locations[0].len)
+      ),
+      startIdx: locations[0].pos + startIdx
+    };
+  }
+  function getZkOperator() {
+    return zkOperators?.[algorithm] || makeDefaultZkOperator(algorithm, zkEngine, logger);
+  }
+  function getOprfOperator() {
+    return oprfOperators?.[algorithm] || makeDefaultOPRFOperator(algorithm, zkEngine, logger);
+  }
 }
-// the chunk size of the ZK circuit in bytes
-// this will be >= the block size
 function getChunkSizeBytes(alg) {
-    const { chunkSize, bitsPerWord } = zk_symmetric_crypto_1.CONFIG[alg];
-    return chunkSize * bitsPerWord / 8;
+  const { chunkSize, bitsPerWord } = ZK_CONFIG[alg];
+  return chunkSize * bitsPerWord / 8;
 }
 const zkEngines = {};
 const oprfEngines = {};
 const operatorMakers = {
-    'snarkjs': zk_symmetric_crypto_1.makeSnarkJsZKOperator,
-    'gnark': zk_symmetric_crypto_1.makeGnarkZkOperator,
+  "snarkjs": makeSnarkJsZKOperator,
+  "gnark": makeGnarkZkOperator,
+  "stwo": makeStwoZkOperator
 };
 const OPRF_OPERATOR_MAKERS = {
-    'gnark': zk_symmetric_crypto_1.makeGnarkOPRFOperator
+  "gnark": makeGnarkOPRFOperator
 };
 function makeDefaultZkOperator(algorithm, zkEngine, logger) {
-    let zkOperators = zkEngines[zkEngine];
-    if (!zkOperators) {
-        zkEngines[zkEngine] = {};
-        zkOperators = zkEngines[zkEngine];
-    }
-    if (!zkOperators[algorithm]) {
-        const isNode = (0, env_1.detectEnvironment)() === 'node';
-        const opType = isNode ? 'local' : 'remote';
-        logger === null || logger === void 0 ? void 0 : logger.info({ type: opType, algorithm }, 'fetching zk operator');
-        const fetcher = opType === 'local'
-            ? (0, zk_symmetric_crypto_1.makeLocalFileFetch)()
-            : (0, zk_symmetric_crypto_1.makeRemoteFileFetch)({
-                baseUrl: config_1.DEFAULT_REMOTE_FILE_FETCH_BASE_URL,
-            });
-        const maker = operatorMakers[zkEngine];
-        if (!maker) {
-            throw new Error(`No ZK operator maker for ${zkEngine}`);
-        }
-        zkOperators[algorithm] = maker({ algorithm, fetcher });
+  let zkOperators = zkEngines[zkEngine];
+  if (!zkOperators) {
+    zkEngines[zkEngine] = {};
+    zkOperators = zkEngines[zkEngine];
+  }
+  if (!zkOperators[algorithm]) {
+    const opType = getOperatorType();
+    const zkBaseUrl = opType === "remote" ? getZkResourcesBaseUrl() : void 0;
+    logger?.info({ type: opType, algorithm, zkBaseUrl }, "fetching zk operator");
+    const fetcher = opType === "local" ? makeLocalFileFetch() : makeRemoteFileFetch({ baseUrl: zkBaseUrl, logger });
+    const maker = operatorMakers[zkEngine];
+    if (!maker) {
+      throw new Error(`No ZK operator maker for ${zkEngine}`);
     }
-    return zkOperators[algorithm];
+    zkOperators[algorithm] = maker({ algorithm, fetcher });
+  }
+  return zkOperators[algorithm];
+}
+function getOperatorType() {
+  const envop = getEnvVariable("ZK_OPERATOR_TYPE");
+  if (envop === "local" || envop === "remote") {
+    return envop;
+  }
+  return detectEnvironment() === "node" ? "local" : "remote";
 }
 function makeDefaultOPRFOperator(algorithm, zkEngine, logger) {
-    let operators = oprfEngines[zkEngine];
-    if (!operators) {
-        oprfEngines[zkEngine] = {};
-        operators = oprfEngines[zkEngine];
-    }
-    if (!operators[algorithm]) {
-        const isNode = (0, env_1.detectEnvironment)() === 'node';
-        const type = isNode ? 'local' : 'remote';
-        logger === null || logger === void 0 ? void 0 : logger.info({ type, algorithm }, 'fetching oprf operator');
-        const fetcher = type === 'local'
-            ? (0, zk_symmetric_crypto_1.makeLocalFileFetch)()
-            : (0, zk_symmetric_crypto_1.makeRemoteFileFetch)({
-                baseUrl: config_1.DEFAULT_REMOTE_FILE_FETCH_BASE_URL,
-            });
-        const maker = OPRF_OPERATOR_MAKERS[zkEngine];
-        if (!maker) {
-            throw new Error(`No OPRF operator maker for ${zkEngine}`);
-        }
-        operators[algorithm] = maker({ algorithm, fetcher });
+  let operators = oprfEngines[zkEngine];
+  if (!operators) {
+    oprfEngines[zkEngine] = {};
+    operators = oprfEngines[zkEngine];
+  }
+  if (!operators[algorithm]) {
+    const type = getOperatorType();
+    const zkBaseUrl = type === "remote" ? getZkResourcesBaseUrl() : void 0;
+    logger?.info({ type, algorithm, zkBaseUrl }, "fetching oprf operator");
+    const fetcher = type === "local" ? makeLocalFileFetch() : makeRemoteFileFetch({ baseUrl: zkBaseUrl, logger });
+    const maker = OPRF_OPERATOR_MAKERS[zkEngine];
+    if (!maker) {
+      throw new Error(`No OPRF operator maker for ${zkEngine}`);
     }
-    return operators[algorithm];
+    operators[algorithm] = maker({ algorithm, fetcher });
+  }
+  return operators[algorithm];
 }
 function getEngineString(engine) {
-    if (engine === api_1.ZKProofEngine.ZK_ENGINE_GNARK) {
-        return 'gnark';
-    }
-    if (engine === api_1.ZKProofEngine.ZK_ENGINE_SNARKJS) {
-        return 'snarkjs';
-    }
-    throw new Error(`Unknown ZK engine: ${engine}`);
+  if (engine === ZKProofEngine.ZK_ENGINE_GNARK) {
+    return "gnark";
+  }
+  if (engine === ZKProofEngine.ZK_ENGINE_SNARKJS) {
+    return "snarkjs";
+  }
+  if (engine === ZKProofEngine.ZK_ENGINE_STWO) {
+    return "stwo";
+  }
+  throw new Error(`Unknown ZK engine: ${engine}`);
 }
 function getEngineProto(engine) {
-    if (engine === 'gnark') {
-        return api_1.ZKProofEngine.ZK_ENGINE_GNARK;
-    }
-    if (engine === 'snarkjs') {
-        return api_1.ZKProofEngine.ZK_ENGINE_SNARKJS;
-    }
-    throw new Error(`Unknown ZK engine: ${engine}`);
+  if (engine === "gnark") {
+    return ZKProofEngine.ZK_ENGINE_GNARK;
+  }
+  if (engine === "snarkjs") {
+    return ZKProofEngine.ZK_ENGINE_SNARKJS;
+  }
+  if (engine === "stwo") {
+    return ZKProofEngine.ZK_ENGINE_STWO;
+  }
+  throw new Error(`Unknown ZK engine: ${engine}`);
 }
-function getProofGenerationParamsForSlice({ key, iv, ciphertext, redactedPlaintext, slice: { fromIndex, toIndex }, toprf, }) {
-    const ciphertextChunk = ciphertext.slice(fromIndex, toIndex);
-    const plaintextChunk = redactedPlaintext.slice(fromIndex, toIndex);
-    if ((0, redactions_1.isFullyRedacted)(plaintextChunk)) {
-        return;
-    }
-    // redact ciphertext if plaintext is redacted
-    // to prepare for decryption in ZK circuit
-    // the ZK circuit will take in the redacted ciphertext,
-    // which shall produce the redacted plaintext
-    for (let i = 0; i < ciphertextChunk.length; i++) {
-        if (plaintextChunk[i] === redactions_1.REDACTION_CHAR_CODE) {
-            ciphertextChunk[i] = redactions_1.REDACTION_CHAR_CODE;
-        }
+function getProofGenerationParamsForSlice({
+  key,
+  iv,
+  ciphertext,
+  redactedPlaintext,
+  slice: { fromIndex, toIndex }
+}) {
+  const ciphertextChunk = ciphertext.slice(fromIndex, toIndex);
+  const plaintextChunk = redactedPlaintext.slice(fromIndex, toIndex);
+  if (isFullyRedacted(plaintextChunk)) {
+    return;
+  }
+  for (let i = 0; i < ciphertextChunk.length; i++) {
+    if (plaintextChunk[i] === REDACTION_CHAR_CODE) {
+      ciphertextChunk[i] = REDACTION_CHAR_CODE;
     }
+  }
+  return {
+    startIdx: fromIndex,
+    redactedPlaintext: plaintextChunk,
+    privateInput: { key },
+    publicInput: { ciphertext: ciphertextChunk, iv, offsetBytes: fromIndex }
+  };
+}
+function getTOPRFProofGenerationParamsForSlice({
+  key,
+  iv,
+  ciphertext,
+  slice: { fromIndex, toIndex },
+  toprf
+}) {
+  const ciphertextChunk = ciphertext.slice(fromIndex, toIndex);
+  if (toprf?.overshoot) {
+    const {
+      overshoot: { ciphertext: overshootCiphertext, iv: overshootIv }
+    } = toprf;
     return {
-        startIdx: fromIndex,
-        redactedPlaintext: plaintextChunk,
-        privateInput: { key },
-        publicInput: { ciphertext: ciphertextChunk, iv, offsetBytes: fromIndex },
-        toprf
+      privateInput: { key },
+      publicInput: [
+        {
+          ciphertext: ciphertextChunk,
+          iv,
+          offsetBytes: fromIndex
+        },
+        { ciphertext: overshootCiphertext, iv: overshootIv }
+      ],
+      toprf,
+      startIdx: fromIndex
     };
+  }
+  return {
+    privateInput: { key },
+    publicInput: { ciphertext: ciphertextChunk, iv, offsetBytes: fromIndex },
+    toprf,
+    startIdx: fromIndex
+  };
 }
-/**
- * Get the ideal location to generate a ZK proof for a TOPRF block.
- * Ideally it should be put into a slice that's a divisor of the chunk size,
- * as that'll minimize the number of proofs that need to be generated.
- * @returns the offset in bytes
- */
-function getIdealOffsetForToprfBlock(alg, { dataLocation }) {
-    const chunkSizeBytes = getChunkSizeBytes(alg);
-    const offsetChunks = Math.floor(dataLocation.fromIndex / chunkSizeBytes) * chunkSizeBytes;
-    const endOffsetChunks = Math.floor((dataLocation.fromIndex + dataLocation.length) / chunkSizeBytes);
-    // happy case -- the OPRF block fits into a single chunk, that's a
-    // divisor of the chunk size
-    if (endOffsetChunks === offsetChunks) {
-        return offsetChunks * chunkSizeBytes;
+function getIdealOffsetForToprfBlock(alg, { dataLocation, overshoot }) {
+  const chunkSizeBytes = getChunkSizeBytes(alg);
+  const blockSizeBytes = getBlockSizeBytes(alg);
+  const offsetChunks = Math.floor(dataLocation.fromIndex / chunkSizeBytes);
+  const endOffsetChunks = Math.floor((dataLocation.fromIndex + dataLocation.length) / chunkSizeBytes);
+  if (endOffsetChunks === offsetChunks) {
+    const start = offsetChunks * chunkSizeBytes;
+    if (overshoot) {
+      const overshootBlocks = Math.ceil(overshoot.ciphertext.length / blockSizeBytes);
+      return start + overshootBlocks * blockSizeBytes;
     }
-    const blockSizeBytes = (0, zk_symmetric_crypto_1.getBlockSizeBytes)(alg);
-    const offsetBytes = Math.floor(dataLocation.fromIndex / blockSizeBytes) * blockSizeBytes;
-    if ((dataLocation.fromIndex + dataLocation.length) - offsetBytes
-        > chunkSizeBytes) {
-        throw new error_1.AttestorError('ERROR_BAD_REQUEST', 'OPRF data cannot fit into a single chunk');
-    }
-    return offsetBytes;
+    return start;
+  }
+  const offsetBytes = Math.floor(dataLocation.fromIndex / blockSizeBytes) * blockSizeBytes;
+  const endOffsetBytes = Math.ceil((dataLocation.fromIndex + dataLocation.length) / blockSizeBytes);
+  if (endOffsetBytes - offsetBytes > chunkSizeBytes) {
+    throw new AttestorError(
+      "ERROR_BAD_REQUEST",
+      "OPRF data cannot fit into a single chunk"
+    );
+  }
+  return offsetBytes;
 }
-function sortSlices(slices) {
-    return slices.sort((a, b) => a.fromIndex - b.fromIndex);
+function getZkResourcesBaseUrl() {
+  if (typeof ATTESTOR_BASE_URL !== "string") {
+    return DEFAULT_REMOTE_FILE_FETCH_BASE_URL;
+  }
+  return new URL(
+    DEFAULT_REMOTE_FILE_FETCH_BASE_URL,
+    ATTESTOR_BASE_URL
+  ).toString();
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"zk.js","sourceRoot":"","sources":["../../src/utils/zk.ts"],"names":[],"mappings":"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"}
+export {
+  getEngineProto,
+  getEngineString,
+  makeDefaultOPRFOperator,
+  makeDefaultZkOperator,
+  makeZkProofGenerator,
+  verifyZkPacket
+};