@reclaimprotocol/attestor-core 3.0.1

package/lib/utils/claims.d.ts

@@ -0,0 +1,33 @@
+import { ClaimTunnelResponse } from 'src/proto/api';
+import { ClaimID, ClaimInfo, CompleteClaimData, ProviderParams } from 'src/types';
+/**
+ * Creates the standard string to sign for a claim.
+ * This data is what the attestor will sign when it successfully
+ * verifies a claim.
+ */
+export declare function createSignDataForClaim(data: CompleteClaimData): string;
+/**
+ * Verify the claim tunnel response from a attestor.
+ *
+ * If you'd only like to verify the claim signature, you can
+ * optionally only pass "claim" & "signatures.claimSignature"
+ * to this function.
+ *
+ * The successful run of this function means that the claim
+ * is valid, and the attestor that signed the claim is valid.
+ */
+export declare function assertValidClaimSignatures({ signatures, ...res }: Partial<ClaimTunnelResponse>, metadata?: import("src/proto/api").InitRequest): Promise<void>;
+/**
+ * Generates a unique identifier for given claim info
+ * @param info
+ * @returns
+ */
+export declare function getIdentifierFromClaimInfo(info: ClaimInfo): ClaimID;
+/**
+ * Canonically stringifies an object, so that the same object will always
+ * produce the same string despite the order of keys
+ */
+export declare function canonicalStringify(params: {
+    [key: string]: any;
+} | undefined): string;
+export declare function hashProviderParams(params: ProviderParams<'http'>): string;

package/lib/utils/claims.js

@@ -0,0 +1,112 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSignDataForClaim = createSignDataForClaim;
+exports.assertValidClaimSignatures = assertValidClaimSignatures;
+exports.getIdentifierFromClaimInfo = getIdentifierFromClaimInfo;
+exports.canonicalStringify = canonicalStringify;
+exports.hashProviderParams = hashProviderParams;
+const tls_1 = require("@reclaimprotocol/tls");
+const canonicalize_1 = __importDefault(require("canonicalize"));
+const ethers_1 = require("ethers");
+const config_1 = require("src/config");
+const api_1 = require("src/proto/api");
+const signatures_1 = require("src/utils/signatures");
+/**
+ * Creates the standard string to sign for a claim.
+ * This data is what the attestor will sign when it successfully
+ * verifies a claim.
+ */
+function createSignDataForClaim(data) {
+    const identifier = 'identifier' in data
+        ? data.identifier
+        : getIdentifierFromClaimInfo(data);
+    const lines = [
+        identifier,
+        // we lowercase the owner to ensure that the
+        // ETH addresses always serialize the same way
+        data.owner.toLowerCase(),
+        data.timestampS.toString(),
+        data.epoch.toString(),
+    ];
+    return lines.join('\n');
+}
+/**
+ * Verify the claim tunnel response from a attestor.
+ *
+ * If you'd only like to verify the claim signature, you can
+ * optionally only pass "claim" & "signatures.claimSignature"
+ * to this function.
+ *
+ * The successful run of this function means that the claim
+ * is valid, and the attestor that signed the claim is valid.
+ */
+async function assertValidClaimSignatures({ signatures, ...res }, metadata = config_1.DEFAULT_METADATA) {
+    if (!signatures) {
+        throw new Error('No signatures provided');
+    }
+    const { resultSignature, claimSignature, attestorAddress } = signatures;
+    const { verify } = signatures_1.SIGNATURES[metadata.signatureType];
+    if (signatures === null || signatures === void 0 ? void 0 : signatures.resultSignature) {
+        const resBytes = api_1.ClaimTunnelResponse.encode(api_1.ClaimTunnelResponse.create(res)).finish();
+        const verified = await verify(resBytes, resultSignature, attestorAddress);
+        if (!verified) {
+            throw new Error('Invalid result signature');
+        }
+    }
+    // claim wasn't generated -- i.e. the transcript
+    // did not contain the necessary data
+    if (!res.claim) {
+        return;
+    }
+    const signData = createSignDataForClaim(res.claim);
+    const verifiedClaim = await verify((0, tls_1.strToUint8Array)(signData), claimSignature, attestorAddress);
+    if (!verifiedClaim) {
+        throw new Error('Invalid claim signature');
+    }
+}
+/**
+ * Generates a unique identifier for given claim info
+ * @param info
+ * @returns
+ */
+function getIdentifierFromClaimInfo(info) {
+    var _a;
+    //re-canonicalize context if it's not empty
+    if (((_a = info.context) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+        try {
+            const ctx = JSON.parse(info.context);
+            info.context = canonicalStringify(ctx);
+        }
+        catch (e) {
+            throw new Error('unable to parse non-empty context. Must be JSON');
+        }
+    }
+    const str = `${info.provider}\n${info.parameters}\n${info.context || ''}`;
+    //console.log('Identifier: ' + btoa(str))
+    return ethers_1.utils.keccak256((0, tls_1.strToUint8Array)(str)).toLowerCase();
+}
+/**
+ * Canonically stringifies an object, so that the same object will always
+ * produce the same string despite the order of keys
+ */
+function canonicalStringify(params) {
+    if (!params) {
+        return '';
+    }
+    return (0, canonicalize_1.default)(params) || '';
+}
+function hashProviderParams(params) {
+    const filteredParams = {
+        url: params.url,
+        method: params.method,
+        responseMatches: params.responseMatches,
+        responseRedactions: params.responseRedactions,
+        geoLocation: params.geoLocation
+    };
+    const serializedParams = canonicalStringify(filteredParams);
+    return ethers_1.utils.keccak256((0, tls_1.strToUint8Array)(serializedParams)).toLowerCase();
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/utils/env.d.ts

@@ -0,0 +1,3 @@
+export type TransportType = 'node' | 'react-native' | 'browser';
+export declare function detectEnvironment(): TransportType;
+export declare function getEnvVariable(name: string): string | undefined;

package/lib/utils/env.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectEnvironment = detectEnvironment;
+exports.getEnvVariable = getEnvVariable;
+function detectEnvironment() {
+    if (typeof navigator !== 'undefined' && navigator.product === 'ReactNative') {
+        return 'react-native';
+    }
+    if (typeof window !== 'undefined') {
+        return 'browser';
+    }
+    return 'node';
+}
+function getEnvVariable(name) {
+    if (typeof process === 'undefined') {
+        return undefined;
+    }
+    return process === null || process === void 0 ? void 0 : process.env[name];
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW52LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3V0aWxzL2Vudi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUVBLDhDQVVDO0FBRUQsd0NBTUM7QUFsQkQsU0FBZ0IsaUJBQWlCO0lBQ2hDLElBQUcsT0FBTyxTQUFTLEtBQUssV0FBVyxJQUFJLFNBQVMsQ0FBQyxPQUFPLEtBQUssYUFBYSxFQUFFLENBQUM7UUFDNUUsT0FBTyxjQUFjLENBQUE7SUFDdEIsQ0FBQztJQUVELElBQUcsT0FBTyxNQUFNLEtBQUssV0FBVyxFQUFFLENBQUM7UUFDbEMsT0FBTyxTQUFTLENBQUE7SUFDakIsQ0FBQztJQUVELE9BQU8sTUFBTSxDQUFBO0FBQ2QsQ0FBQztBQUVELFNBQWdCLGNBQWMsQ0FBQyxJQUFZO0lBQzFDLElBQUcsT0FBTyxPQUFPLEtBQUssV0FBVyxFQUFFLENBQUM7UUFDbkMsT0FBTyxTQUFTLENBQUE7SUFDakIsQ0FBQztJQUVELE9BQU8sT0FBTyxhQUFQLE9BQU8sdUJBQVAsT0FBTyxDQUFFLEdBQUcsQ0FBQyxJQUFJLENBQUMsQ0FBQTtBQUMxQixDQUFDIn0=

package/lib/utils/error.d.ts

@@ -0,0 +1,27 @@
+import { ErrorCode, ErrorData } from 'src/proto/api';
+/**
+ * Represents an error that can be thrown by the Attestor Core
+ * or server. Provides a code, and optional data
+ * to pass along with the error.
+ */
+export declare class AttestorError extends Error {
+    code: keyof typeof ErrorCode;
+    message: string;
+    data?: {
+        [_: string]: any;
+    } | undefined;
+    readonly name = "AttestorError";
+    constructor(code: keyof typeof ErrorCode, message: string, data?: {
+        [_: string]: any;
+    } | undefined);
+    /**
+     * Encodes the error as a ErrorData
+     * protobuf message
+     */
+    toProto(): ErrorData;
+    static fromProto(data?: ErrorData): AttestorError;
+    static fromError(err: Error): AttestorError;
+    static badRequest(message: string, data?: {
+        [_: string]: any;
+    }): AttestorError;
+}

package/lib/utils/error.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AttestorError = void 0;
+const api_1 = require("src/proto/api");
+/**
+ * Represents an error that can be thrown by the Attestor Core
+ * or server. Provides a code, and optional data
+ * to pass along with the error.
+ */
+class AttestorError extends Error {
+    constructor(code, message, data) {
+        super(message);
+        this.code = code;
+        this.message = message;
+        this.data = data;
+        this.name = 'AttestorError';
+    }
+    /**
+     * Encodes the error as a ErrorData
+     * protobuf message
+     */
+    toProto() {
+        return api_1.ErrorData.create({
+            code: api_1.ErrorCode[this.code],
+            message: this.message,
+            data: JSON.stringify(this.data)
+        });
+    }
+    static fromProto(data = api_1.ErrorData.fromJSON({})) {
+        return new AttestorError(api_1.ErrorCode[data.code], data.message, data.data ? JSON.parse(data.data) : undefined);
+    }
+    static fromError(err) {
+        if (err instanceof AttestorError) {
+            return err;
+        }
+        return new AttestorError('ERROR_INTERNAL', err.message);
+    }
+    static badRequest(message, data) {
+        return new AttestorError('ERROR_BAD_REQUEST', message, data);
+    }
+}
+exports.AttestorError = AttestorError;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvZXJyb3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsdUNBQW9EO0FBRXBEOzs7O0dBSUc7QUFDSCxNQUFhLGFBQWMsU0FBUSxLQUFLO0lBSXZDLFlBQ1EsSUFBNEIsRUFDNUIsT0FBZSxFQUNmLElBQTJCO1FBRWxDLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQTtRQUpQLFNBQUksR0FBSixJQUFJLENBQXdCO1FBQzVCLFlBQU8sR0FBUCxPQUFPLENBQVE7UUFDZixTQUFJLEdBQUosSUFBSSxDQUF1QjtRQUwxQixTQUFJLEdBQUcsZUFBZSxDQUFBO0lBUS9CLENBQUM7SUFFRDs7O09BR0c7SUFDSCxPQUFPO1FBQ04sT0FBTyxlQUFTLENBQUMsTUFBTSxDQUFDO1lBQ3ZCLElBQUksRUFBRSxlQUFTLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQztZQUMxQixPQUFPLEVBQUUsSUFBSSxDQUFDLE9BQU87WUFDckIsSUFBSSxFQUFFLElBQUksQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQztTQUMvQixDQUFDLENBQUE7SUFDSCxDQUFDO0lBRUQsTUFBTSxDQUFDLFNBQVMsQ0FBQyxJQUFJLEdBQUcsZUFBUyxDQUFDLFFBQVEsQ0FBQyxFQUFFLENBQUM7UUFDN0MsT0FBTyxJQUFJLGFBQWEsQ0FDdkIsZUFBUyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQTJCLEVBQzlDLElBQUksQ0FBQyxPQUFPLEVBQ1osSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDLFNBQVMsQ0FDN0MsQ0FBQTtJQUNGLENBQUM7SUFFRCxNQUFNLENBQUMsU0FBUyxDQUFDLEdBQVU7UUFDMUIsSUFBRyxHQUFHLFlBQVksYUFBYSxFQUFFLENBQUM7WUFDakMsT0FBTyxHQUFHLENBQUE7UUFDWCxDQUFDO1FBRUQsT0FBTyxJQUFJLGFBQWEsQ0FDdkIsZ0JBQWdCLEVBQ2hCLEdBQUcsQ0FBQyxPQUFPLENBQ1gsQ0FBQTtJQUNGLENBQUM7SUFFRCxNQUFNLENBQUMsVUFBVSxDQUFDLE9BQWUsRUFBRSxJQUEyQjtRQUM3RCxPQUFPLElBQUksYUFBYSxDQUN2QixtQkFBbUIsRUFDbkIsT0FBTyxFQUNQLElBQUksQ0FDSixDQUFBO0lBQ0YsQ0FBQztDQUNEO0FBbERELHNDQWtEQyJ9

package/lib/utils/generics.d.ts

@@ -0,0 +1,112 @@
+import { CipherSuite, TLSProtocolVersion } from '@reclaimprotocol/tls';
+import { RPCMessage, RPCMessages } from 'src/proto/api';
+import { CompleteTLSPacket, IDecryptedTranscript, IDecryptedTranscriptMessage, ProviderField, RPCEvent, RPCEventMap, RPCEventType, RPCType, Transcript } from 'src/types';
+export declare function uint8ArrayToStr(arr: Uint8Array): string;
+export declare function getTranscriptString(receipt: IDecryptedTranscript): string;
+export declare const unixTimestampSeconds: () => number;
+/**
+ * Find index of needle in haystack
+ */
+export declare function findIndexInUint8Array(haystack: Uint8Array, needle: Uint8Array): number;
+/**
+ * convert a Uint8Array to a binary encoded str
+ * from: https://github.com/feross/buffer/blob/795bbb5bda1b39f1370ebd784bea6107b087e3a7/index.js#L1063
+ * @param buf
+ * @returns
+ */
+export declare function uint8ArrayToBinaryStr(buf: Uint8Array): string;
+export declare function gunzipSync(buf: Uint8Array): Uint8Array;
+/**
+ * Fetch the ZK algorithm for the specified cipher suite
+ */
+export declare function getZkAlgorithmForCipherSuite(cipherSuite: CipherSuite): "aes-256-ctr" | "aes-128-ctr" | "chacha20";
+/**
+ * Get the pure ciphertext without any MAC,
+ * or authentication tag,
+ * @param content content w/o header
+ * @param cipherSuite
+ */
+export declare function getPureCiphertext(content: Uint8Array, cipherSuite: CipherSuite): Uint8Array;
+/**
+ * Get the 8 byte IV part that's stored in the record for some cipher suites
+ * @param content content w/o header
+ * @param cipherSuite
+ */
+export declare function getRecordIV(content: Uint8Array, cipherSuite: CipherSuite): Uint8Array;
+export declare function getProviderValue<P, T>(params: P, fn: ProviderField<P, T>): T;
+export declare function generateRpcMessageId(): number;
+/**
+ * Random session ID for a WebSocket client.
+ */
+export declare function generateSessionId(): number;
+/**
+ * Random ID for a tunnel.
+ */
+export declare function generateTunnelId(): number;
+export declare function makeRpcEvent<T extends RPCEventType>(type: T, data: RPCEventMap[T]): RPCEvent<T>;
+/**
+ * Get the RPC type from the key.
+ * For eg. "claimTunnelRequest" ->
+ *    { type: 'claimTunnel', direction: 'request' }
+ */
+export declare function getRpcTypeFromKey(key: string): {
+    type: RPCType;
+    direction: "request";
+} | {
+    type: RPCType;
+    direction: "response";
+} | undefined;
+/**
+ * Get the RPC response type from the RPC type.
+ * For eg. "claimTunnel" -> "claimTunnelResponse"
+ */
+export declare function getRpcResponseType<T extends RPCType>(type: T): `${T}Response`;
+/**
+ * Get the RPC request type from the RPC type.
+ * For eg. "claimTunnel" -> "claimTunnelRequest"
+ */
+export declare function getRpcRequestType<T extends RPCType>(type: T): `${T}Request`;
+export declare function isApplicationData(packet: CompleteTLSPacket, tlsVersion: string | undefined): boolean;
+/**
+ * Convert the received data from a WS to a Uint8Array
+ */
+export declare function extractArrayBufferFromWsData(data: unknown): Promise<Uint8Array>;
+/**
+ * Check if the RPC message is a request or a response.
+ */
+export declare function getRpcRequest(msg: RPCMessage): {
+    type: RPCType;
+    direction: "request";
+} | {
+    type: RPCType;
+    direction: "response";
+} | {
+    direction: "response";
+    type: "error";
+} | undefined;
+/**
+ * Finds all application data messages in a transcript
+ * and returns them. Removes the "contentType" suffix from the message.
+ * in TLS 1.3
+ */
+export declare function extractApplicationDataFromTranscript({ transcript, tlsVersion }: IDecryptedTranscript): Transcript<Uint8Array>;
+export type HandshakeTranscript<T> = {
+    sender: 'client' | 'server';
+    index: number;
+    message: T;
+}[];
+export declare function extractHandshakeFromTranscript({ transcript, tlsVersion }: {
+    transcript: IDecryptedTranscriptMessage[];
+    tlsVersion: TLSProtocolVersion;
+}): HandshakeTranscript<Uint8Array>;
+export declare function decryptDirect(directReveal: any, cipherSuite: CipherSuite, recordHeader: Uint8Array, serverTlsVersion: TLSProtocolVersion, content: Uint8Array): Promise<{
+    plaintext: Uint8Array;
+    iv: Uint8Array;
+}>;
+export declare function packRpcMessages(...msgs: Partial<RPCMessage>[]): RPCMessages;
+/**
+ * Converts an Ethers struct (an array w named keys) to
+ * a plain object. Recursively converts all structs inside.
+ * Required to correctly JSON.stringify the struct.
+ */
+export declare function ethersStructToPlainObject<T>(struct: T): T;