@reclaimprotocol/attestor-core 3.0.1

package/lib/utils/index.d.ts

@@ -0,0 +1,10 @@
+export * from './generics';
+export * from './logger';
+export * from './redactions';
+export * from './http-parser';
+export * from './zk';
+export * from './claims';
+export * from './error';
+export * from './prepare-packets';
+export * from './validation';
+export * from './signatures';

package/lib/utils/index.js

@@ -0,0 +1,27 @@
+"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("./generics"), exports);
+__exportStar(require("./logger"), exports);
+__exportStar(require("./redactions"), exports);
+__exportStar(require("./http-parser"), exports);
+__exportStar(require("./zk"), exports);
+__exportStar(require("./claims"), exports);
+__exportStar(require("./error"), exports);
+__exportStar(require("./prepare-packets"), exports);
+__exportStar(require("./validation"), exports);
+__exportStar(require("./signatures"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDZDQUEwQjtBQUMxQiwyQ0FBd0I7QUFDeEIsK0NBQTRCO0FBQzVCLGdEQUE2QjtBQUM3Qix1Q0FBb0I7QUFDcEIsMkNBQXdCO0FBQ3hCLDBDQUF1QjtBQUN2QixvREFBaUM7QUFDakMsK0NBQTRCO0FBQzVCLCtDQUE0QiJ9

package/lib/utils/logger.d.ts

@@ -0,0 +1,13 @@
+import type { LogLevel } from 'src/types';
+export declare let logger: import("pino").Logger<never, boolean>;
+/**
+ * Creates a logger instance with optional redaction of PII.
+ * Replaces default logger
+ * See PII_PROPERTIES for the list of properties that will be redacted.
+ *
+ * @param redactPii - whether to redact PII from logs
+ * @param level - the log level to use
+ * @param onLog - a callback to call when a log is written
+ */
+export declare function makeLogger(redactPii: boolean, level?: LogLevel, onLog?: (level: LogLevel, log: any) => void): import("pino").Logger<never, boolean>;
+export declare function redact(json: any): any;

package/lib/utils/logger.js

@@ -0,0 +1,100 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+exports.makeLogger = makeLogger;
+exports.redact = redact;
+const pino_1 = __importDefault(require("pino"));
+const env_1 = require("src/utils/env");
+const PII_PROPERTIES = ['ownerPrivateKey', 'secretParams'];
+const redactedText = '[REDACTED]';
+const envLevel = (0, env_1.getEnvVariable)('LOG_LEVEL');
+exports.logger = (0, pino_1.default)();
+makeLogger(false, envLevel);
+/**
+ * Creates a logger instance with optional redaction of PII.
+ * Replaces default logger
+ * See PII_PROPERTIES for the list of properties that will be redacted.
+ *
+ * @param redactPii - whether to redact PII from logs
+ * @param level - the log level to use
+ * @param onLog - a callback to call when a log is written
+ */
+function makeLogger(redactPii, level, onLog) {
+    const opts = {
+        // Log human readable time stamps instead of epoch time
+        timestamp: pino_1.default.stdTimeFunctions.isoTime,
+    };
+    if (redactPii) {
+        opts.formatters = { log: redact };
+        opts.serializers = { redact };
+        opts.browser = {
+            write: {
+                fatal: log => writeLog('fatal', log),
+                error: log => writeLog('error', log),
+                warn: log => writeLog('warn', log),
+                info: log => writeLog('info', log),
+                debug: log => writeLog('debug', log),
+                trace: log => writeLog('trace', log),
+            }
+        };
+    }
+    const pLogger = (0, pino_1.default)(opts);
+    pLogger.level = level || 'info';
+    exports.logger = pLogger;
+    return pLogger;
+    function writeLog(level, log) {
+        log = redact(log);
+        const { msg, ...obj } = log;
+        if (console[level]) {
+            console[level](obj, msg);
+        }
+        else {
+            console.log(obj, msg);
+        }
+        onLog === null || onLog === void 0 ? void 0 : onLog(level, log);
+    }
+}
+function isObjectProperty(property) {
+    return (typeof property) === 'object'
+        && !Array.isArray(property)
+        && property !== null;
+}
+function getReplacer() {
+    // Store references to previously visited objects
+    const references = new WeakSet();
+    return function (key, value) {
+        const isObject = (typeof value) === 'object' && value !== null;
+        if (isObject) {
+            if (references.has(value)) {
+                return '[CIRCULAR]';
+            }
+            references.add(value);
+        }
+        return value;
+    };
+}
+function redact(json) {
+    const isObject = isObjectProperty(json);
+    if (!isObject && !Array.isArray(json)) {
+        return json;
+    }
+    const redacted = JSON.parse(JSON.stringify(json, getReplacer()));
+    for (const prop in redacted) {
+        if (PII_PROPERTIES.includes(prop)) {
+            redacted[prop] = redactedText;
+        }
+        if (Array.isArray(redacted[prop])) {
+            for (const [index, value] of redacted[prop].entries()) {
+                redacted[prop][index] = redact(value);
+            }
+        }
+        else if (isObjectProperty(redacted[prop])) {
+            redacted[prop] = redact(redacted[prop]);
+        }
+    }
+    return redacted;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/utils/prepare-packets.d.ts

@@ -0,0 +1,16 @@
+import { CipherSuite, TLSPacketContext } from '@reclaimprotocol/tls';
+import { ClaimTunnelRequest_TranscriptMessage as TranscriptMessage } from 'src/proto/api';
+import { CompleteTLSPacket, Logger, MessageRevealInfo, PrepareZKProofsBaseOpts, Transcript } from 'src/types';
+export type PreparePacketsForRevealOpts = {
+    cipherSuite: CipherSuite;
+    logger: Logger;
+    /**
+     * Progress of Zk proof generation
+     */
+    onZkProgress?(blocksDone: number, totalBlocks: number): void;
+} & PrepareZKProofsBaseOpts;
+/**
+ * Prepares the packets for reveal to the server
+ * according to the specified reveal type
+ */
+export declare function preparePacketsForReveal(tlsTranscript: Transcript<CompleteTLSPacket>, reveals: Map<TLSPacketContext, MessageRevealInfo>, { onZkProgress, ...opts }: PreparePacketsForRevealOpts): Promise<TranscriptMessage[]>;

package/lib/utils/prepare-packets.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preparePacketsForReveal = preparePacketsForReveal;
+const tls_1 = require("@reclaimprotocol/tls");
+const api_1 = require("src/proto/api");
+const zk_1 = require("src/utils/zk");
+/**
+ * Prepares the packets for reveal to the server
+ * according to the specified reveal type
+ */
+async function preparePacketsForReveal(tlsTranscript, reveals, { onZkProgress, ...opts }) {
+    const transcript = [];
+    const proofGenerator = await (0, zk_1.makeZkProofGenerator)(opts);
+    let zkPacketsDone = 0;
+    await Promise.all(tlsTranscript.map(async ({ message, sender }) => {
+        const msg = {
+            sender: sender === 'client'
+                ? api_1.TranscriptMessageSenderType.TRANSCRIPT_MESSAGE_SENDER_TYPE_CLIENT
+                : api_1.TranscriptMessageSenderType.TRANSCRIPT_MESSAGE_SENDER_TYPE_SERVER,
+            message: message.data,
+            reveal: undefined
+        };
+        transcript.push(msg);
+        const reveal = reveals.get(message);
+        if (!reveal || message.type === 'plaintext') {
+            return;
+        }
+        switch (reveal === null || reveal === void 0 ? void 0 : reveal.type) {
+            case 'complete':
+                msg.reveal = {
+                    directReveal: {
+                        key: await tls_1.crypto.exportKey(message.encKey),
+                        iv: message.fixedIv,
+                        recordNumber: message.recordNumber,
+                    },
+                };
+                break;
+            case 'zk':
+                // the redacted section can be smaller than the actual
+                // plaintext encrypted, in case of TLS1.3 as it has a
+                // content type suffix
+                reveal.redactedPlaintext = (0, tls_1.concatenateUint8Arrays)([
+                    reveal.redactedPlaintext,
+                    message.plaintext.slice(reveal.redactedPlaintext.length)
+                ]);
+                await proofGenerator.addPacketToProve(message, reveal, proofs => (msg.reveal = { zkReveal: { proofs } }));
+                break;
+            default:
+                // no reveal
+                break;
+        }
+    }));
+    const zkPacketsTotal = proofGenerator.getTotalChunksToProve();
+    onZkProgress === null || onZkProgress === void 0 ? void 0 : onZkProgress(zkPacketsDone, zkPacketsTotal);
+    await proofGenerator.generateProofs(() => {
+        zkPacketsDone += 1;
+        onZkProgress === null || onZkProgress === void 0 ? void 0 : onZkProgress(zkPacketsDone, zkPacketsTotal);
+    });
+    return transcript;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/utils/redactions.d.ts

@@ -0,0 +1,41 @@
+import type { ArraySlice } from 'src/types';
+export declare const REDACTION_CHAR = "*";
+export declare const REDACTION_CHAR_CODE: number;
+/**
+ * Check if a redacted string is congruent with the original string.
+ * @param redacted the redacted content, redacted content is replaced by '*'
+ * @param original the original content
+ */
+export declare function isRedactionCongruent<T extends string | Uint8Array>(redacted: T, original: T): boolean;
+/**
+ * Is the string fully redacted?
+ */
+export declare function isFullyRedacted<T extends string | Uint8Array>(redacted: T): boolean;
+/**
+ * Given some plaintext blocks and a redaction function, return the blocks that
+ * need to be revealed to the other party
+ *
+ * Use case: we get the response for a request in several blocks, and want to redact
+ * pieces that go through multiple blocks. We can use this function to get the
+ * blocks that need to be revealed to the other party
+ *
+ * @example if we received ["secret is 12","345","678. Thanks"]. We'd want
+ * to redact the "12345678" and reveal the rest. We'd pass in the blocks and
+ * the redact function will return the redactions, namely [10,19].
+ * The function will return the blocks ["secret is **","***. Thanks"].
+ * The middle block is fully redacted, so it's not returned
+ *
+ * @param blocks blocks to reveal
+ * @param redact function that returns the redactions
+ * @returns blocks to reveal
+ */
+export declare function getBlocksToReveal<T extends {
+    plaintext: Uint8Array;
+}>(blocks: T[], redact: (total: Uint8Array) => ArraySlice[]): {
+    block: T;
+    redactedPlaintext: Uint8Array;
+}[] | "all";
+/**
+ * Redact the following slices from the total
+ */
+export declare function redactSlices(total: Uint8Array, slices: ArraySlice[]): Uint8Array;

package/lib/utils/redactions.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REDACTION_CHAR_CODE = exports.REDACTION_CHAR = void 0;
+exports.isRedactionCongruent = isRedactionCongruent;
+exports.isFullyRedacted = isFullyRedacted;
+exports.getBlocksToReveal = getBlocksToReveal;
+exports.redactSlices = redactSlices;
+const tls_1 = require("@reclaimprotocol/tls");
+exports.REDACTION_CHAR = '*';
+exports.REDACTION_CHAR_CODE = exports.REDACTION_CHAR.charCodeAt(0);
+/**
+ * Check if a redacted string is congruent with the original string.
+ * @param redacted the redacted content, redacted content is replaced by '*'
+ * @param original the original content
+ */
+function isRedactionCongruent(redacted, original) {
+    // eslint-disable-next-line unicorn/no-for-loop
+    for (let i = 0; i < redacted.length; i++) {
+        const element = redacted[i];
+        const areSame = element === original[i]
+            || (typeof element === 'string' && element === exports.REDACTION_CHAR)
+            || (typeof element === 'number' && element === exports.REDACTION_CHAR_CODE);
+        if (!areSame) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Is the string fully redacted?
+ */
+function isFullyRedacted(redacted) {
+    for (const element of redacted) {
+        if (element !== exports.REDACTION_CHAR
+            && element !== exports.REDACTION_CHAR_CODE) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Given some plaintext blocks and a redaction function, return the blocks that
+ * need to be revealed to the other party
+ *
+ * Use case: we get the response for a request in several blocks, and want to redact
+ * pieces that go through multiple blocks. We can use this function to get the
+ * blocks that need to be revealed to the other party
+ *
+ * @example if we received ["secret is 12","345","678. Thanks"]. We'd want
+ * to redact the "12345678" and reveal the rest. We'd pass in the blocks and
+ * the redact function will return the redactions, namely [10,19].
+ * The function will return the blocks ["secret is **","***. Thanks"].
+ * The middle block is fully redacted, so it's not returned
+ *
+ * @param blocks blocks to reveal
+ * @param redact function that returns the redactions
+ * @returns blocks to reveal
+ */
+function getBlocksToReveal(blocks, redact) {
+    const slicesWithReveal = blocks.map(block => ({
+        block,
+        // copy the plaintext to avoid mutating the original
+        redactedPlaintext: new Uint8Array(block.plaintext)
+    }));
+    const total = (0, tls_1.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) {
+        redactBlocks(redaction);
+    }
+    // only reveal blocks that have some data to reveal,
+    // or are completely plaintext
+    return slicesWithReveal
+        .filter(s => !isFullyRedacted(s.redactedPlaintext));
+    function redactBlocks(slice) {
+        while (cursor < slice.fromIndex) {
+            advance();
+        }
+        while (cursor < slice.toIndex) {
+            slicesWithReveal[blockIdx]
+                .redactedPlaintext[cursorInBlock] = exports.REDACTION_CHAR_CODE;
+            advance();
+        }
+    }
+    function advance() {
+        cursor += 1;
+        cursorInBlock += 1;
+        if (cursorInBlock >= blocks[blockIdx].plaintext.length) {
+            blockIdx += 1;
+            cursorInBlock = 0;
+        }
+    }
+}
+/**
+ * Redact the following slices from the total
+ */
+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] = exports.REDACTION_CHAR_CODE;
+        }
+    }
+    return redacted;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/utils/retries.d.ts

@@ -0,0 +1,12 @@
+import { Logger } from 'src/types';
+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/utils/retries.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeWithRetries = executeWithRetries;
+/**
+ * Execute a function, and upon failure -- retry
+ * based on specified options.
+ */
+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');
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmV0cmllcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlscy9yZXRyaWVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBWUEsZ0RBNEJDO0FBaENEOzs7R0FHRztBQUNJLEtBQUssVUFBVSxrQkFBa0IsQ0FDdkMsSUFBcUMsRUFDckMsRUFDQyxVQUFVLEdBQUcsQ0FBQyxFQUNkLFdBQVcsRUFDWCxNQUFNLEdBQ1k7SUFFbkIsSUFBSSxPQUFPLEdBQUcsQ0FBQyxDQUFBO0lBQ2YsT0FBTSxPQUFPLEdBQUcsVUFBVSxFQUFFLENBQUM7UUFDNUIsSUFBSSxDQUFDO1lBQ0osTUFBTSxNQUFNLEdBQUcsTUFBTSxJQUFJLENBQUMsT0FBTyxDQUFDLENBQUE7WUFDbEMsT0FBTyxNQUFNLENBQUE7UUFDZCxDQUFDO1FBQUMsT0FBTSxHQUFHLEVBQUUsQ0FBQztZQUNiLE9BQU8sSUFBSSxDQUFDLENBQUE7WUFDWixJQUFHLE9BQU8sSUFBSSxVQUFVLEVBQUUsQ0FBQztnQkFDMUIsTUFBTSxHQUFHLENBQUE7WUFDVixDQUFDO1lBRUQsSUFBRyxDQUFDLFdBQVcsQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDO2dCQUN0QixNQUFNLEdBQUcsQ0FBQTtZQUNWLENBQUM7WUFFRCxNQUFNLENBQUMsSUFBSSxDQUFDLEVBQUUsR0FBRyxFQUFFLE9BQU8sRUFBRSxFQUFFLDJCQUEyQixDQUFDLENBQUE7UUFDM0QsQ0FBQztJQUNGLENBQUM7SUFFRCxNQUFNLElBQUksS0FBSyxDQUFDLG1CQUFtQixDQUFDLENBQUE7QUFDckMsQ0FBQyJ9

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

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

package/lib/utils/signatures/eth.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ETH_SIGNATURE_PROVIDER = void 0;
+const ethers_1 = require("ethers");
+const utils_1 = require("ethers/lib/utils");
+exports.ETH_SIGNATURE_PROVIDER = {
+    getPublicKey(privateKey) {
+        const pub = (0, utils_1.computePublicKey)(privateKey, true);
+        return ethers_1.utils.arrayify(pub);
+    },
+    getAddress(publicKey) {
+        return (0, utils_1.computeAddress)(publicKey).toLowerCase();
+    },
+    async sign(data, privateKey) {
+        const wallet = getEthWallet(privateKey);
+        const signature = await wallet.signMessage(data);
+        return ethers_1.utils.arrayify(signature);
+    },
+    async verify(data, signature, addressBytes) {
+        const address = typeof addressBytes === 'string'
+            ? addressBytes
+            : ethers_1.utils.hexlify(addressBytes);
+        const signerAddress = ethers_1.utils.verifyMessage(data, signature);
+        return signerAddress.toLowerCase() === address.toLowerCase();
+    }
+};
+function getEthWallet(privateKey) {
+    if (!privateKey) {
+        throw new Error('Private key missing');
+    }
+    return new ethers_1.Wallet(privateKey);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXRoLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3V0aWxzL3NpZ25hdHVyZXMvZXRoLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLG1DQUFzQztBQUN0Qyw0Q0FBbUU7QUFHdEQsUUFBQSxzQkFBc0IsR0FBNkI7SUFDL0QsWUFBWSxDQUFDLFVBQVU7UUFDdEIsTUFBTSxHQUFHLEdBQUcsSUFBQSx3QkFBZ0IsRUFBQyxVQUFVLEVBQUUsSUFBSSxDQUFDLENBQUE7UUFDOUMsT0FBTyxjQUFLLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBQyxDQUFBO0lBQzNCLENBQUM7SUFDRCxVQUFVLENBQUMsU0FBUztRQUNuQixPQUFPLElBQUEsc0JBQWMsRUFBQyxTQUFTLENBQUMsQ0FBQyxXQUFXLEVBQUUsQ0FBQTtJQUMvQyxDQUFDO0lBQ0QsS0FBSyxDQUFDLElBQUksQ0FBQyxJQUFJLEVBQUUsVUFBVTtRQUMxQixNQUFNLE1BQU0sR0FBRyxZQUFZLENBQUMsVUFBVSxDQUFDLENBQUE7UUFDdkMsTUFBTSxTQUFTLEdBQUcsTUFBTSxNQUFNLENBQUMsV0FBVyxDQUFDLElBQUksQ0FBQyxDQUFBO1FBQ2hELE9BQU8sY0FBSyxDQUFDLFFBQVEsQ0FBQyxTQUFTLENBQUMsQ0FBQTtJQUNqQyxDQUFDO0lBQ0QsS0FBSyxDQUFDLE1BQU0sQ0FBQyxJQUFJLEVBQUUsU0FBUyxFQUFFLFlBQVk7UUFDekMsTUFBTSxPQUFPLEdBQUcsT0FBTyxZQUFZLEtBQUssUUFBUTtZQUMvQyxDQUFDLENBQUMsWUFBWTtZQUNkLENBQUMsQ0FBQyxjQUFLLENBQUMsT0FBTyxDQUFDLFlBQVksQ0FBQyxDQUFBO1FBQzlCLE1BQU0sYUFBYSxHQUFHLGNBQUssQ0FBQyxhQUFhLENBQUMsSUFBSSxFQUFFLFNBQVMsQ0FBQyxDQUFBO1FBQzFELE9BQU8sYUFBYSxDQUFDLFdBQVcsRUFBRSxLQUFLLE9BQU8sQ0FBQyxXQUFXLEVBQUUsQ0FBQTtJQUM3RCxDQUFDO0NBQ0QsQ0FBQTtBQUVELFNBQVMsWUFBWSxDQUFDLFVBQWtCO0lBQ3ZDLElBQUcsQ0FBQyxVQUFVLEVBQUUsQ0FBQztRQUNoQixNQUFNLElBQUksS0FBSyxDQUFDLHFCQUFxQixDQUFDLENBQUE7SUFDdkMsQ0FBQztJQUVELE9BQU8sSUFBSSxlQUFNLENBQUMsVUFBVSxDQUFDLENBQUE7QUFDOUIsQ0FBQyJ9

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

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

package/lib/utils/signatures/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelectedServiceSignature = exports.SelectedServiceSignatureType = exports.SIGNATURES = void 0;
+const api_1 = require("src/proto/api");
+const eth_1 = require("src/utils/signatures/eth");
+exports.SIGNATURES = {
+    [api_1.ServiceSignatureType.SERVICE_SIGNATURE_TYPE_ETH]: eth_1.ETH_SIGNATURE_PROVIDER,
+};
+exports.SelectedServiceSignatureType = api_1.ServiceSignatureType.SERVICE_SIGNATURE_TYPE_ETH;
+exports.SelectedServiceSignature = exports.SIGNATURES[exports.SelectedServiceSignatureType];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdXRpbHMvc2lnbmF0dXJlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSx1Q0FBb0Q7QUFFcEQsa0RBQWlFO0FBRXBELFFBQUEsVUFBVSxHQUFHO0lBQ3pCLENBQUMsMEJBQW9CLENBQUMsMEJBQTBCLENBQUMsRUFBRSw0QkFBc0I7Q0FDVixDQUFBO0FBRW5ELFFBQUEsNEJBQTRCLEdBQUcsMEJBQW9CLENBQUMsMEJBQTBCLENBQUE7QUFFOUUsUUFBQSx3QkFBd0IsR0FBRyxrQkFBVSxDQUFDLG9DQUE0QixDQUFDLENBQUEifQ==

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

@@ -0,0 +1,21 @@
+import { InitRequest, RPCMessage, RPCMessages } from 'src/proto/api';
+import { IAttestorSocket, Logger, RPCEvent, RPCEventMap } from 'src/types';
+/**
+ * Common AttestorSocket class used on the client & server side as the
+ * base for their respective socket implementations.
+ */
+export declare class AttestorSocket implements IAttestorSocket {
+    protected socket: WebSocket;
+    metadata: InitRequest;
+    logger: Logger;
+    private eventTarget;
+    isInitialised: boolean;
+    constructor(socket: WebSocket, 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/utils/socket-base.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AttestorSocket = void 0;
+const message_handler_1 = require("src/client/utils/message-handler");
+const api_1 = require("src/proto/api");
+const utils_1 = require("src/utils");
+/**
+ * Common AttestorSocket class used on the client & server side as the
+ * base for their respective socket implementations.
+ */
+class AttestorSocket {
+    constructor(socket, metadata, logger) {
+        this.socket = socket;
+        this.metadata = metadata;
+        this.logger = logger;
+        this.eventTarget = new EventTarget();
+        this.isInitialised = false;
+        socket.addEventListener('error', (event) => {
+            const witErr = utils_1.AttestorError.fromError(event.error
+                || new Error(event.message));
+            witErr.code = 'ERROR_NETWORK_ERROR';
+            this.dispatchRPCEvent('connection-terminated', witErr);
+        });
+        socket.addEventListener('close', () => (this.dispatchRPCEvent('connection-terminated', new utils_1.AttestorError('ERROR_NO_ERROR', 'connection closed'))));
+        socket.addEventListener('message', async ({ data }) => {
+            try {
+                await message_handler_1.wsMessageHandler.call(this, 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 utils_1.AttestorError('ERROR_NETWORK_ERROR', 'Connection closed, cannot send message');
+        }
+        if (!this.isOpen) {
+            throw new utils_1.AttestorError('ERROR_NETWORK_ERROR', 'Wait for connection to open before sending message');
+        }
+        const msg = (0, utils_1.packRpcMessages)(...msgs);
+        const bytes = api_1.RPCMessages.encode(msg).finish();
+        await this.socket.send(bytes);
+        return msg;
+    }
+    dispatchRPCEvent(type, data) {
+        const event = (0, utils_1.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) {
+        var _a;
+        // connection already closed
+        if (this.isClosed) {
+            return;
+        }
+        try {
+            const witErr = err
+                ? utils_1.AttestorError.fromError(err)
+                : new utils_1.AttestorError('ERROR_NO_ERROR', '');
+            this.dispatchRPCEvent('connection-terminated', witErr);
+            if (this.isOpen) {
+                await this.sendMessage({
+                    connectionTerminationAlert: witErr.toProto()
+                });
+            }
+        }
+        catch (err) {
+            (_a = this.logger) === null || _a === void 0 ? void 0 : _a.error({ err }, 'error terminating connection');
+        }
+        finally {
+            this.socket.close();
+        }
+    }
+}
+exports.AttestorSocket = AttestorSocket;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic29ja2V0LWJhc2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvc29ja2V0LWJhc2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsc0VBQW1FO0FBQ25FLHVDQUFvRTtBQUVwRSxxQ0FBd0U7QUFFeEU7OztHQUdHO0FBQ0gsTUFBYSxjQUFjO0lBTTFCLFlBQ1csTUFBaUIsRUFDcEIsUUFBcUIsRUFDckIsTUFBYztRQUZYLFdBQU0sR0FBTixNQUFNLENBQVc7UUFDcEIsYUFBUSxHQUFSLFFBQVEsQ0FBYTtRQUNyQixXQUFNLEdBQU4sTUFBTSxDQUFRO1FBUGQsZ0JBQVcsR0FBRyxJQUFJLFdBQVcsRUFBRSxDQUFBO1FBRXZDLGtCQUFhLEdBQUcsS0FBSyxDQUFBO1FBT3BCLE1BQU0sQ0FBQyxnQkFBZ0IsQ0FBQyxPQUFPLEVBQUUsQ0FBQyxLQUFpQixFQUFFLEVBQUU7WUFDdEQsTUFBTSxNQUFNLEdBQUcscUJBQWEsQ0FBQyxTQUFTLENBQ3JDLEtBQUssQ0FBQyxLQUFLO21CQUNQLElBQUksS0FBSyxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FDNUIsQ0FBQTtZQUNELE1BQU0sQ0FBQyxJQUFJLEdBQUcscUJBQXFCLENBQUE7WUFFbkMsSUFBSSxDQUFDLGdCQUFnQixDQUFDLHVCQUF1QixFQUFFLE1BQU0sQ0FBQyxDQUFBO1FBQ3ZELENBQUMsQ0FBQyxDQUFBO1FBRUYsTUFBTSxDQUFDLGdCQUFnQixDQUFDLE9BQU8sRUFBRSxHQUFHLEVBQUUsQ0FBQyxDQUN0QyxJQUFJLENBQUMsZ0JBQWdCLENBQ3BCLHVCQUF1QixFQUN2QixJQUFJLHFCQUFhLENBQ2hCLGdCQUFnQixFQUNoQixtQkFBbUIsQ0FDbkIsQ0FDRCxDQUNELENBQUMsQ0FBQTtRQUVGLE1BQU0sQ0FBQyxnQkFBZ0IsQ0FBQyxTQUFTLEVBQUUsS0FBSyxFQUFDLEVBQUUsSUFBSSxFQUFFLEVBQUUsRUFBRTtZQUNwRCxJQUFJLENBQUM7Z0JBQ0osTUFBTSxrQ0FBZ0IsQ0FBQyxJQUFJLENBQUMsSUFBSSxFQUFFLElBQUksQ0FBQyxDQUFBO1lBQ3hDLENBQUM7WUFBQyxPQUFNLEdBQUcsRUFBRSxDQUFDO2dCQUNiLElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLEVBQUUsR0FBRyxFQUFFLEVBQUUsMEJBQTBCLENBQUMsQ0FBQTtZQUN2RCxDQUFDO1FBQ0YsQ0FBQyxDQUFDLENBQUE7SUFDSCxDQUFDO0lBRUQsSUFBSSxNQUFNO1FBQ1QsT0FBTyxJQUFJLENBQUMsTUFBTSxDQUFDLFVBQVUsS0FBSyxJQUFJLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQTtJQUNuRCxDQUFDO0lBRUQsSUFBSSxRQUFRO1FBQ1gsT0FBTyxJQUFJLENBQUMsTUFBTSxDQUFDLFVBQVUsS0FBSyxJQUFJLENBQUMsTUFBTSxDQUFDLE1BQU07ZUFDaEQsSUFBSSxDQUFDLE1BQU0sQ0FBQyxVQUFVLEtBQUssSUFBSSxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUE7SUFDbkQsQ0FBQztJQUVELEtBQUssQ0FBQyxXQUFXLENBQUMsR0FBRyxJQUEyQjtRQUMvQyxJQUFHLElBQUksQ0FBQyxRQUFRLEVBQUUsQ0FBQztZQUNsQixNQUFNLElBQUkscUJBQWEsQ0FDdEIscUJBQXFCLEVBQ3JCLHdDQUF3QyxDQUN4QyxDQUFBO1FBQ0YsQ0FBQztRQUVELElBQUcsQ0FBQyxJQUFJLENBQUMsTUFBTSxFQUFFLENBQUM7WUFDakIsTUFBTSxJQUFJLHFCQUFhLENBQ3RCLHFCQUFxQixFQUNyQixvREFBb0QsQ0FDcEQsQ0FBQTtRQUNGLENBQUM7UUFFRCxNQUFNLEdBQUcsR0FBRyxJQUFBLHVCQUFlLEVBQUMsR0FBRyxJQUFJLENBQUMsQ0FBQTtRQUNwQyxNQUFNLEtBQUssR0FBRyxpQkFBVyxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQyxNQUFNLEVBQUUsQ0FBQTtRQUU5QyxNQUFNLElBQUksQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFBO1FBRTdCLE9BQU8sR0FBRyxDQUFBO0lBQ1gsQ0FBQztJQUVELGdCQUFnQixDQUE4QixJQUFPLEVBQUUsSUFBb0I7UUFDMUUsTUFBTSxLQUFLLEdBQUcsSUFBQSxvQkFBWSxFQUFDLElBQUksRUFBRSxJQUFJLENBQUMsQ0FBQTtRQUN0QyxJQUFJLENBQUMsV0FBVyxDQUFDLGFBQWEsQ0FBQyxLQUFLLENBQUMsQ0FBQTtJQUN0QyxDQUFDO0lBRUQsZ0JBQWdCLENBQThCLElBQU8sRUFBRSxRQUFxQztRQUMzRixJQUFJLENBQUMsV0FBVyxDQUFDLGdCQUFnQixDQUFDLElBQUksRUFBRSxRQUFRLENBQUMsQ0FBQTtJQUNsRCxDQUFDO0lBRUQsbUJBQW1CLENBQThCLElBQU8sRUFBRSxRQUFxQztRQUM5RixJQUFJLENBQUMsV0FBVyxDQUFDLG1CQUFtQixDQUFDLElBQUksRUFBRSxRQUFRLENBQUMsQ0FBQTtJQUNyRCxDQUFDO0lBRUQsS0FBSyxDQUFDLG1CQUFtQixDQUFDLEdBQVc7O1FBQ3BDLDRCQUE0QjtRQUM1QixJQUFHLElBQUksQ0FBQyxRQUFRLEVBQUUsQ0FBQztZQUNsQixPQUFNO1FBQ1AsQ0FBQztRQUVELElBQUksQ0FBQztZQUNKLE1BQU0sTUFBTSxHQUFHLEdBQUc7Z0JBQ2pCLENBQUMsQ0FBQyxxQkFBYSxDQUFDLFNBQVMsQ0FBQyxHQUFHLENBQUM7Z0JBQzlCLENBQUMsQ0FBQyxJQUFJLHFCQUFhLENBQUMsZ0JBQWdCLEVBQUUsRUFBRSxDQUFDLENBQUE7WUFDMUMsSUFBSSxDQUFDLGdCQUFnQixDQUFDLHVCQUF1QixFQUFFLE1BQU0sQ0FBQyxDQUFBO1lBQ3RELElBQUcsSUFBSSxDQUFDLE1BQU0sRUFBRSxDQUFDO2dCQUNoQixNQUFNLElBQUksQ0FBQyxXQUFXLENBQUM7b0JBQ3RCLDBCQUEwQixFQUFFLE1BQU0sQ0FBQyxPQUFPLEVBQUU7aUJBQzVDLENBQUMsQ0FBQTtZQUNILENBQUM7UUFDRixDQUFDO1FBQUMsT0FBTSxHQUFHLEVBQUUsQ0FBQztZQUNiLE1BQUEsSUFBSSxDQUFDLE1BQU0sMENBQUUsS0FBSyxDQUFDLEVBQUUsR0FBRyxFQUFFLEVBQUUsOEJBQThCLENBQUMsQ0FBQTtRQUM1RCxDQUFDO2dCQUFTLENBQUM7WUFDVixJQUFJLENBQUMsTUFBTSxDQUFDLEtBQUssRUFBRSxDQUFBO1FBQ3BCLENBQUM7SUFDRixDQUFDO0NBQ0Q7QUEzR0Qsd0NBMkdDIn0=

package/lib/utils/tls.d.ts

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