@reclaimprotocol/attestor-core 3.0.1

package/lib/utils/tls.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultTlsOptions = getDefaultTlsOptions;
+const tls_1 = require("@reclaimprotocol/tls");
+const env_1 = require("src/utils/env");
+// we only support the following cipher suites
+// for ZK proof generation
+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',
+];
+const NAMED_CURVE_LIST = (0, env_1.detectEnvironment)() === 'node'
+    ? tls_1.SUPPORTED_NAMED_CURVES
+    // X25519 is not supported in the browser
+    : tls_1.SUPPORTED_NAMED_CURVES.filter(c => c !== 'X25519');
+function getDefaultTlsOptions() {
+    return {
+        cipherSuites: ZK_CIPHER_SUITES,
+        namedCurves: NAMED_CURVE_LIST,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGxzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3V0aWxzL3Rscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQXlCQSxvREFLQztBQTlCRCw4Q0FBZ0c7QUFDaEcsdUNBQWlEO0FBRWpELDhDQUE4QztBQUM5QywwQkFBMEI7QUFDMUIsTUFBTSxnQkFBZ0IsR0FBa0I7SUFDdkMsWUFBWTtJQUNaLDhCQUE4QjtJQUM5Qiw2Q0FBNkM7SUFDN0MsK0NBQStDO0lBQy9DLFVBQVU7SUFDVix3QkFBd0I7SUFDeEIseUNBQXlDO0lBQ3pDLHVDQUF1QztJQUN2QyxVQUFVO0lBQ1Ysd0JBQXdCO0lBQ3hCLHlDQUF5QztJQUN6Qyx1Q0FBdUM7Q0FDdkMsQ0FBQTtBQUVELE1BQU0sZ0JBQWdCLEdBQUcsSUFBQSx1QkFBaUIsR0FBRSxLQUFLLE1BQU07SUFDdEQsQ0FBQyxDQUFDLDRCQUFzQjtJQUN4Qix5Q0FBeUM7SUFDekMsQ0FBQyxDQUFDLDRCQUFzQixDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsS0FBSyxRQUFRLENBQUMsQ0FBQTtBQUVyRCxTQUFnQixvQkFBb0I7SUFDbkMsT0FBTztRQUNOLFlBQVksRUFBRSxnQkFBZ0I7UUFDOUIsV0FBVyxFQUFFLGdCQUFnQjtLQUM3QixDQUFBO0FBQ0YsQ0FBQyJ9

package/lib/utils/validation.d.ts

@@ -0,0 +1,2 @@
+import { ProviderName, ProviderParams } from 'src/types';
+export declare function assertValidateProviderParams<T extends ProviderName>(name: T, params: unknown): asserts params is ProviderParams<T>;

package/lib/utils/validation.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertValidateProviderParams = assertValidateProviderParams;
+const ajv_1 = __importDefault(require("ajv"));
+const providers_gen_1 = require("src/types/providers.gen");
+const error_1 = require("src/utils/error");
+const PROVIDER_VALIDATOR_MAP = {};
+const AJV = new ajv_1.default({
+    allErrors: true,
+    strict: true,
+    strictRequired: false,
+    formats: {
+        binary(data) {
+            return data instanceof Uint8Array
+                || (typeof Buffer !== 'undefined'
+                    && Buffer.isBuffer(data));
+        },
+        url(data) {
+            try {
+                new URL(data);
+                return true;
+            }
+            catch (_a) {
+                return false;
+            }
+        }
+    }
+});
+function assertValidateProviderParams(name, params) {
+    var _a;
+    let validate = PROVIDER_VALIDATOR_MAP[name];
+    if (!validate) {
+        const schema = (_a = providers_gen_1.PROVIDER_SCHEMAS[name]) === null || _a === void 0 ? void 0 : _a.parameters;
+        if (!schema) {
+            throw new error_1.AttestorError('ERROR_BAD_REQUEST', `Invalid provider name "${name}"`);
+        }
+        validate = AJV.compile(schema);
+    }
+    if (!validate(params)) {
+        throw new error_1.AttestorError('ERROR_BAD_REQUEST', 'Params validation failed', { errors: JSON.stringify(validate.errors) });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsaWRhdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlscy92YWxpZGF0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBOEJBLG9FQXdCQztBQXRERCw4Q0FBMkM7QUFFM0MsMkRBQTBEO0FBQzFELDJDQUErQztBQUUvQyxNQUFNLHNCQUFzQixHQUErQyxFQUFFLENBQUE7QUFFN0UsTUFBTSxHQUFHLEdBQUcsSUFBSSxhQUFHLENBQUM7SUFDbkIsU0FBUyxFQUFFLElBQUk7SUFDZixNQUFNLEVBQUUsSUFBSTtJQUNaLGNBQWMsRUFBRSxLQUFLO0lBQ3JCLE9BQU8sRUFBRTtRQUNSLE1BQU0sQ0FBQyxJQUFhO1lBQ25CLE9BQU8sSUFBSSxZQUFZLFVBQVU7bUJBQzdCLENBQ0YsT0FBTyxNQUFNLEtBQUssV0FBVzt1QkFDMUIsTUFBTSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsQ0FDeEIsQ0FBQTtRQUNILENBQUM7UUFDRCxHQUFHLENBQUMsSUFBYTtZQUNoQixJQUFJLENBQUM7Z0JBQ0osSUFBSSxHQUFHLENBQUMsSUFBYyxDQUFDLENBQUE7Z0JBQ3ZCLE9BQU8sSUFBSSxDQUFBO1lBQ1osQ0FBQztZQUFDLFdBQUssQ0FBQztnQkFDUCxPQUFPLEtBQUssQ0FBQTtZQUNiLENBQUM7UUFDRixDQUFDO0tBQ0Q7Q0FDRCxDQUFDLENBQUE7QUFFRixTQUFnQiw0QkFBNEIsQ0FDM0MsSUFBTyxFQUNQLE1BQWU7O0lBRWYsSUFBSSxRQUFRLEdBQUcsc0JBQXNCLENBQUMsSUFBSSxDQUFDLENBQUE7SUFDM0MsSUFBRyxDQUFDLFFBQVEsRUFBRSxDQUFDO1FBQ2QsTUFBTSxNQUFNLEdBQUcsTUFBQSxnQ0FBZ0IsQ0FBQyxJQUFJLENBQUMsMENBQUUsVUFBVSxDQUFBO1FBQ2pELElBQUcsQ0FBQyxNQUFNLEVBQUUsQ0FBQztZQUNaLE1BQU0sSUFBSSxxQkFBYSxDQUN0QixtQkFBbUIsRUFDbkIsMEJBQTBCLElBQUksR0FBRyxDQUNqQyxDQUFBO1FBQ0YsQ0FBQztRQUVELFFBQVEsR0FBRyxHQUFHLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxDQUFBO0lBQy9CLENBQUM7SUFFRCxJQUFHLENBQUMsUUFBUSxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUM7UUFDdEIsTUFBTSxJQUFJLHFCQUFhLENBQ3RCLG1CQUFtQixFQUNuQiwwQkFBMEIsRUFDMUIsRUFBRSxNQUFNLEVBQUUsSUFBSSxDQUFDLFNBQVMsQ0FBQyxRQUFRLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FDM0MsQ0FBQTtJQUNGLENBQUM7QUFDRixDQUFDIn0=

package/lib/utils/ws.d.ts

@@ -0,0 +1,12 @@
+import { AnyWebSocketConstructor } from 'src/types';
+/**
+ * Default WebSocket implementation, uses `ws` package
+ * for Node.js and the native WebSocket for the browser & other
+ * environments.
+ */
+export declare let Websocket: AnyWebSocketConstructor;
+/**
+ * Replace the default WebSocket implementation utilised
+ * by the Attestor client.
+ */
+export declare function setWebsocket(ws: AnyWebSocketConstructor): void;

package/lib/utils/ws.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Websocket = void 0;
+exports.setWebsocket = setWebsocket;
+const env_1 = require("src/utils/env");
+/**
+ * Default WebSocket implementation, uses `ws` package
+ * for Node.js and the native WebSocket for the browser & other
+ * environments.
+ */
+exports.Websocket = ((0, env_1.detectEnvironment)() === 'node'
+    ? require('ws').WebSocket
+    : WebSocket);
+/**
+ * Replace the default WebSocket implementation utilised
+ * by the Attestor client.
+ */
+function setWebsocket(ws) {
+    exports.Websocket = ws;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid3MuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvd3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBa0JBLG9DQUVDO0FBbkJELHVDQUFpRDtBQUVqRDs7OztHQUlHO0FBQ1EsUUFBQSxTQUFTLEdBQTRCLENBQy9DLElBQUEsdUJBQWlCLEdBQUUsS0FBSyxNQUFNO0lBQzdCLENBQUMsQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMsU0FBUztJQUN6QixDQUFDLENBQUMsU0FBUyxDQUNaLENBQUE7QUFFRDs7O0dBR0c7QUFDSCxTQUFnQixZQUFZLENBQUMsRUFBMkI7SUFDdkQsaUJBQVMsR0FBRyxFQUFFLENBQUE7QUFDZixDQUFDIn0=

package/lib/utils/zk.d.ts

@@ -0,0 +1,50 @@
+import { EncryptionAlgorithm, PrivateInput, PublicInput, ZKOperator } from '@reclaimprotocol/circom-symmetric-crypto';
+import { CipherSuite } from '@reclaimprotocol/tls';
+import { MessageReveal_MessageRevealZk as ZKReveal, MessageReveal_ZKProof as ZKProof } from 'src/proto/api';
+import { CompleteTLSPacket, Logger, PrepareZKProofsBaseOpts, ZKEngine, ZKOperators, ZKRevealInfo } from 'src/types';
+type PrepareZKProofsOpts = {
+    logger?: Logger;
+    cipherSuite: CipherSuite;
+} & PrepareZKProofsBaseOpts;
+type ZKVerifyOpts = {
+    cipherSuite: CipherSuite;
+    ciphertext: Uint8Array;
+    zkReveal: ZKReveal;
+    logger?: Logger;
+    /** get ZK operator for specified algorithm */
+    zkOperators?: ZKOperators;
+    zkEngine?: ZKEngine;
+    iv: Uint8Array;
+    recordNumber: number;
+};
+type ZKProofToGenerate = {
+    startIdx: number;
+    redactedPlaintext: Uint8Array;
+    privateInput: PrivateInput;
+    publicInput: PublicInput;
+};
+type ZKPacketToProve = {
+    onGeneratedProofs(proofs: ZKProof[]): void;
+    algorithm: EncryptionAlgorithm;
+    proofsToGenerate: ZKProofToGenerate[];
+    iv: Uint8Array;
+};
+export declare function makeZkProofGenerator({ zkOperators, logger, zkProofConcurrency, maxZkChunks, 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, reveal: ZKRevealInfo, onGeneratedProofs: ZKPacketToProve["onGeneratedProofs"]): Promise<void>;
+    getTotalChunksToProve(): number;
+    generateProofs(onChunkDone?: () => void): Promise<void>;
+}>;
+/**
+ * Verify the given ZK proof
+ */
+export declare function verifyZkPacket({ cipherSuite, ciphertext, zkReveal, zkOperators, logger, zkEngine, iv, recordNumber }: ZKVerifyOpts): Promise<{
+    redactedPlaintext: Uint8Array;
+}>;
+export declare function makeDefaultZkOperator(algorithm: EncryptionAlgorithm, zkEngine: ZKEngine, logger: Logger): Promise<ZKOperator>;
+export {};

package/lib/utils/zk.js

@@ -0,0 +1,282 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeZkProofGenerator = makeZkProofGenerator;
+exports.verifyZkPacket = verifyZkPacket;
+exports.makeDefaultZkOperator = makeDefaultZkOperator;
+const circom_symmetric_crypto_1 = require("@reclaimprotocol/circom-symmetric-crypto");
+const gnark_1 = require("@reclaimprotocol/circom-symmetric-crypto/lib/gnark");
+const tls_1 = require("@reclaimprotocol/tls");
+const config_1 = require("src/config");
+const env_1 = require("src/utils/env");
+const error_1 = require("src/utils/error");
+const generics_1 = require("src/utils/generics");
+const logger_1 = require("src/utils/logger");
+const redactions_1 = require("src/utils/redactions");
+const retries_1 = require("src/utils/retries");
+const ZK_CONCURRENCY = +((0, env_1.getEnvVariable)('ZK_CONCURRENCY')
+    || config_1.DEFAULT_ZK_CONCURRENCY);
+async function makeZkProofGenerator({ zkOperators, logger = logger_1.logger, zkProofConcurrency = ZK_CONCURRENCY, maxZkChunks = config_1.MAX_ZK_CHUNKS, 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 zkChunksToProve = 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, reveal, 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 { redactedPlaintext } = reveal;
+            const key = await tls_1.crypto.exportKey(packet.encKey);
+            const iv = packet.iv;
+            const ciphertext = (0, generics_1.getPureCiphertext)(packet.ciphertext, cipherSuite);
+            const chunks = Math.ceil(ciphertext.length / chunkSizeBytes);
+            const packetToProve = {
+                onGeneratedProofs,
+                algorithm: alg,
+                proofsToGenerate: [],
+                iv: packet.fixedIv
+            };
+            for (let i = 0; i < chunks; i++) {
+                const proof = getProofGenerationParamsForChunk(alg, {
+                    key,
+                    iv,
+                    ciphertext,
+                    redactedPlaintext,
+                    offsetChunks: i,
+                });
+                if (!proof) {
+                    continue;
+                }
+                packetToProve.proofsToGenerate.push(proof);
+                zkChunksToProve += 1;
+                if (zkChunksToProve > maxZkChunks) {
+                    throw new Error(`Too many chunks to prove: ${zkChunksToProve} > ${maxZkChunks}`);
+                }
+            }
+            packetsToProve.push(packetToProve);
+        },
+        getTotalChunksToProve() {
+            return zkChunksToProve;
+        },
+        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,
+                chunks: zkChunksToProve,
+            }, 'generated ZK proofs');
+            // reset the packets to prove
+            packetsToProve.splice(0, packetsToProve.length);
+            zkChunksToProve = 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 }) {
+        const operator = await getZkOperatorForAlgorithm(algorithm);
+        const proof = await (0, circom_symmetric_crypto_1.generateProof)({
+            algorithm,
+            privateInput,
+            publicInput,
+            operator,
+            logger
+        });
+        logger === null || logger === void 0 ? void 0 : logger.debug({ startIdx }, 'generated proof for chunk');
+        return {
+            proofJson: proof.proofJson,
+            decryptedRedactedCiphertext: proof.plaintext,
+            redactedPlaintext,
+            startIdx
+        };
+    }
+    async function getZkOperatorForAlgorithm(algorithm) {
+        return (zkOperators === null || zkOperators === void 0 ? void 0 : zkOperators[algorithm])
+            || await makeDefaultZkOperator(algorithm, zkEngine, logger);
+    }
+}
+/**
+ * Verify the given ZK proof
+ */
+async function verifyZkPacket({ cipherSuite, ciphertext, zkReveal, zkOperators, 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 operator = (zkOperators === null || zkOperators === void 0 ? void 0 : zkOperators[algorithm])
+        || await makeDefaultZkOperator(algorithm, zkEngine, logger);
+    const recordIV = (0, generics_1.getRecordIV)(ciphertext, cipherSuite);
+    ciphertext = (0, generics_1.getPureCiphertext)(ciphertext, cipherSuite);
+    /**
+     * 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
+     */
+    const realRedactedPlaintext = new Uint8Array(ciphertext.length).fill(redactions_1.REDACTION_CHAR_CODE);
+    const alg = (0, generics_1.getZkAlgorithmForCipherSuite)(cipherSuite);
+    const chunkSizeBytes = getChunkSizeBytes(alg);
+    const { blocksPerChunk } = circom_symmetric_crypto_1.CONFIG[algorithm];
+    await Promise.all(proofs.map(async ({ proofJson, decryptedRedactedCiphertext, redactedPlaintext, startIdx }, i) => {
+        // 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;
+            }
+        }
+        if (!(0, redactions_1.isRedactionCongruent)(redactedPlaintext, decryptedRedactedCiphertext)) {
+            throw new Error(`redacted ciphertext (${i}) not congruent`);
+        }
+        const chunkIndex = startIdx / chunkSizeBytes * blocksPerChunk;
+        let nonce = (0, tls_1.concatenateUint8Arrays)([iv, recordIV]);
+        if (!recordIV.length) {
+            nonce = (0, tls_1.generateIV)(nonce, recordNumber);
+        }
+        await (0, circom_symmetric_crypto_1.verifyProof)({
+            proof: {
+                algorithm,
+                proofJson,
+                plaintext: decryptedRedactedCiphertext,
+            },
+            publicInput: { ciphertext: ciphertextChunk, iv: nonce, offset: chunkIndex },
+            operator,
+            logger,
+        });
+        logger === null || logger === void 0 ? void 0 : logger.debug({ startIdx, endIdx: startIdx + redactedPlaintext.length }, 'verified proof');
+        realRedactedPlaintext.set(redactedPlaintext, startIdx);
+    }));
+    return { redactedPlaintext: realRedactedPlaintext };
+}
+function getChunkSizeBytes(alg) {
+    const { chunkSize, bitsPerWord } = circom_symmetric_crypto_1.CONFIG[alg];
+    return chunkSize * bitsPerWord / 8;
+}
+const zkEngines = {};
+const operatorMakers = {
+    'snarkJS': snarkJSOperator,
+    'gnark': gnark_1.makeLocalGnarkZkOperator
+};
+function makeDefaultZkOperator(algorithm, zkEngine, logger) {
+    const engine = zkEngine || 'snarkJS';
+    let zkOperators = zkEngines[engine];
+    if (!zkOperators) {
+        zkEngines[engine] = {};
+        zkOperators = zkEngines[engine];
+    }
+    if (!zkOperators[algorithm]) {
+        zkOperators[algorithm] = operatorMakers[engine](algorithm, logger);
+    }
+    return zkOperators[algorithm];
+}
+function snarkJSOperator(algorithm, logger) {
+    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');
+    if (isNode) {
+        return (0, circom_symmetric_crypto_1.makeLocalSnarkJsZkOperator)(algorithm);
+    }
+    else {
+        const { zkeyUrl, circuitWasmUrl } = config_1.DEFAULT_REMOTE_ZK_PARAMS;
+        const operator = makeRemoteSnarkJsZkOperator(zkeyUrl.replace('{algorithm}', algorithm), circuitWasmUrl.replace('{algorithm}', algorithm), logger);
+        return Promise.resolve(operator);
+    }
+}
+function makeRemoteSnarkJsZkOperator(zkeyUrl, wasmUrl, logger) {
+    return (0, circom_symmetric_crypto_1.makeSnarkJsZKOperator)({
+        getCircuitWasm: () => fetchArrayBuffer('wasm', wasmUrl),
+        getZkey: () => (fetchArrayBuffer('zkey', zkeyUrl)
+            .then(data => ({ data }))),
+    });
+    async function fetchArrayBuffer(type, url) {
+        const res = await (0, retries_1.executeWithRetries)(async () => {
+            const res = await fetch(url);
+            if (!res.ok) {
+                throw new error_1.AttestorError('ERROR_NETWORK_ERROR', `${type} fetch failed with code: ${res.status}`, { url, status: res.status });
+            }
+            return await res.arrayBuffer();
+        }, {
+            logger: logger.child({ type }),
+            maxRetries: 3,
+            shouldRetry(error) {
+                // network errors are TypeErrors
+                // in fetch
+                // https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API#concepts_and_usage
+                return error instanceof TypeError;
+            },
+        });
+        return new Uint8Array(res);
+    }
+}
+function getProofGenerationParamsForChunk(algorithm, { key, iv, ciphertext, redactedPlaintext, offsetChunks, }) {
+    const chunkSize = getChunkSizeBytes(algorithm);
+    const startIdx = offsetChunks * chunkSize;
+    const endIdx = (offsetChunks + 1) * chunkSize;
+    const ciphertextChunk = ciphertext
+        .slice(startIdx, endIdx);
+    const plaintextChunk = redactedPlaintext
+        .slice(startIdx, endIdx);
+    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;
+        }
+    }
+    return {
+        startIdx,
+        redactedPlaintext: plaintextChunk,
+        privateInput: { key },
+        publicInput: { ciphertext: ciphertextChunk, iv, offset: offsetChunks }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"zk.js","sourceRoot":"","sources":["../../src/utils/zk.ts"],"names":[],"mappings":"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"}

package/lib/window-rpc/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './setup-window-rpc';
+export * from './utils';

package/lib/window-rpc/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./setup-window-rpc"), exports);
+__exportStar(require("./utils"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvd2luZG93LXJwYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsMENBQXVCO0FBQ3ZCLHFEQUFrQztBQUNsQywwQ0FBdUIifQ==

package/lib/window-rpc/setup-window-rpc.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Sets up the current window to listen for RPC requests
+ * from React Native or other windows
+ */
+export declare function setupWindowRpc(): void;