@reclaimprotocol/attestor-core 5.0.1-beta.9 → 5.0.2-beta.1

package/lib/browser/utils/b64-json.d.ts

@@ -1,2 +0,0 @@
-export declare const B64_JSON_REPLACER: (key: string, value: any) => any;
-export declare const B64_JSON_REVIVER: (key: string, value: any) => any;

package/lib/browser/utils/b64-json.js

@@ -1,17 +0,0 @@
-import { decodeBase64, encodeBase64 } from "ethers";
-const B64_JSON_REPLACER = (key, value) => {
-  if (value instanceof Uint8Array || typeof value === "object" && value && "buffer" in value && value.buffer instanceof ArrayBuffer) {
-    return { type: "uint8array", value: encodeBase64(value) };
-  }
-  return value;
-};
-const B64_JSON_REVIVER = (key, value) => {
-  if (value?.type === "uint8array") {
-    return decodeBase64(value.value);
-  }
-  return value;
-};
-export {
-  B64_JSON_REPLACER,
-  B64_JSON_REVIVER
-};

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

@@ -1,33 +0,0 @@
-import { ClaimTunnelResponse } from '#src/proto/api.ts';
-import type { ClaimID, ClaimInfo, CompleteClaimData, ProviderParams } from '#src/types/index.ts';
-/**
- * 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.ts").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/browser/utils/claims.js

@@ -1,89 +0,0 @@
-import canonicalize from "canonicalize";
-import { keccak256 } from "ethers";
-import { DEFAULT_METADATA } from "../config/index.js";
-import { ClaimTunnelResponse } from "../proto/api.js";
-import { SIGNATURES, strToUint8Array } from "../utils/index.js";
-function createSignDataForClaim(data) {
-  const lines = [
-    getIdentifierFromClaimInfo(data),
-    // 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");
-}
-async function assertValidClaimSignatures({
-  signatures,
-  ...res
-}, metadata = DEFAULT_METADATA) {
-  if (!signatures) {
-    throw new Error("No signatures provided");
-  }
-  const {
-    resultSignature,
-    claimSignature,
-    attestorAddress
-  } = signatures;
-  const { verify } = SIGNATURES[metadata.signatureType];
-  if (signatures?.resultSignature) {
-    const resBytes = ClaimTunnelResponse.encode(ClaimTunnelResponse.create(res)).finish();
-    const verified = await verify(resBytes, resultSignature, attestorAddress);
-    if (!verified) {
-      throw new Error("Invalid result signature");
-    }
-  }
-  if (!res.claim) {
-    return;
-  }
-  const signData = createSignDataForClaim(res.claim);
-  const verifiedClaim = await verify(
-    strToUint8Array(signData),
-    claimSignature,
-    attestorAddress
-  );
-  if (!verifiedClaim) {
-    throw new Error("Invalid claim signature");
-  }
-}
-function getIdentifierFromClaimInfo(info) {
-  if (info.context?.length > 0) {
-    try {
-      const ctx = JSON.parse(info.context);
-      info.context = canonicalStringify(ctx);
-    } catch {
-      throw new Error("unable to parse non-empty context. Must be JSON");
-    }
-  }
-  const str = `${info.provider}
-${info.parameters}
-${info.context || ""}`;
-  return keccak256(strToUint8Array(str)).toLowerCase();
-}
-function canonicalStringify(params) {
-  if (!params) {
-    return "";
-  }
-  return canonicalize(params) || "";
-}
-function hashProviderParams(params) {
-  const filteredParams = {
-    url: params.url,
-    method: params.method,
-    body: params.body,
-    responseMatches: params.responseMatches,
-    responseRedactions: params.responseRedactions
-  };
-  const serializedParams = canonicalStringify(filteredParams);
-  return keccak256(
-    strToUint8Array(serializedParams)
-  ).toLowerCase();
-}
-export {
-  assertValidClaimSignatures,
-  canonicalStringify,
-  createSignDataForClaim,
-  getIdentifierFromClaimInfo,
-  hashProviderParams
-};

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

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

package/lib/browser/utils/env.js

@@ -1,19 +0,0 @@
-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 void 0;
-  }
-  return process?.env[name];
-}
-export {
-  detectEnvironment,
-  getEnvVariable
-};

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

@@ -1,26 +0,0 @@
-import { ErrorCode, ErrorData } from '#src/proto/api.ts';
-/**
- * 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 {
-    readonly name = "AttestorError";
-    readonly code: keyof typeof ErrorCode;
-    readonly data: {
-        [_: string]: any;
-    } | undefined;
-    constructor(code: keyof typeof ErrorCode, message: string, data?: {
-        [_: string]: any;
-    });
-    /**
-     * Encodes the error as a ErrorData
-     * protobuf message
-     */
-    toProto(): ErrorData;
-    static fromProto(data?: ErrorData): AttestorError;
-    static fromError(err: Error, code?: keyof typeof ErrorCode): AttestorError;
-    static badRequest(message: string, data?: {
-        [_: string]: any;
-    }): AttestorError;
-}

package/lib/browser/utils/error.js

@@ -1,54 +0,0 @@
-import { ErrorCode, ErrorData } from "../proto/api.js";
-const PROTO_ERROR = ErrorData.fromJSON({});
-class AttestorError extends Error {
-  name = "AttestorError";
-  code;
-  data;
-  constructor(code, message, data) {
-    super(message);
-    this.code = code;
-    this.data = data;
-  }
-  /**
-   * Encodes the error as a ErrorData
-   * protobuf message
-   */
-  toProto() {
-    return ErrorData.create({
-      code: ErrorCode[this.code],
-      message: this.message,
-      data: JSON.stringify(this.data)
-    });
-  }
-  static fromProto(data = PROTO_ERROR) {
-    return new AttestorError(
-      typeof data.code === "number" ? getKeyForValue(ErrorCode, data.code) || "UNRECOGNIZED" : data.code,
-      data.message,
-      data.data ? JSON.parse(data.data) : void 0
-    );
-  }
-  static fromError(err, code = "ERROR_INTERNAL") {
-    if (err instanceof AttestorError) {
-      return err;
-    }
-    return new AttestorError(code, err.message);
-  }
-  static badRequest(message, data) {
-    return new AttestorError(
-      "ERROR_BAD_REQUEST",
-      message,
-      data
-    );
-  }
-}
-function getKeyForValue(obj, value) {
-  for (const key in obj) {
-    if (obj[key] === value) {
-      return key;
-    }
-  }
-  return void 0;
-}
-export {
-  AttestorError
-};

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

@@ -1,119 +0,0 @@
-import type { CipherSuite, TLSProtocolVersion } from '@reclaimprotocol/tls';
-import { uint8ArrayToBinaryStr } from '#src/utils/tls-imports.ts';
-import { RPCMessage, RPCMessages } from '#src/proto/api.ts';
-import type { CompleteTLSPacket, IDecryptedTranscript, IDecryptedTranscriptMessage, ProviderField, RPCEvent, RPCEventMap, RPCEventType, RPCType, Transcript } from '#src/types/index.ts';
-export { uint8ArrayToBinaryStr };
-/**
- * Decodes a Uint8Array to a UTF-8 string.
- */
-export declare function uint8ArrayToStr(arr: Uint8Array): string;
-/**
- * Encodes a UTF-8 string to a Uint8Array.
- */
-export declare function strToUint8Array(str: string): Uint8Array;
-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;
-/**
- * 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<ArrayBufferLike>;
-/**
- * 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<ArrayBuffer>;
-export declare function getProviderValue<P, S, T>(params: P, fn: ProviderField<P, S, T>, secretParams?: S): 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<ArrayBufferLike>>;
-export type HandshakeTranscript<T> = {
-    sender: 'client' | 'server';
-    index: number;
-    message: T;
-}[];
-export declare function extractHandshakeFromTranscript({ transcript, tlsVersion }: {
-    transcript: IDecryptedTranscriptMessage[];
-    tlsVersion: TLSProtocolVersion;
-}): HandshakeTranscript<Uint8Array<ArrayBufferLike>>;
-export declare function decryptDirect(directReveal: any, cipherSuite: CipherSuite, recordHeader: Uint8Array, serverTlsVersion: TLSProtocolVersion, content: Uint8Array): Promise<{
-    plaintext: Uint8Array<ArrayBufferLike>;
-    iv: Uint8Array<ArrayBufferLike>;
-}>;
-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;
-export declare function isTls13Suite(suite: CipherSuite): suite is "TLS_CHACHA20_POLY1305_SHA256" | "TLS_AES_256_GCM_SHA384" | "TLS_AES_128_GCM_SHA256";
-/**
- * Validates a proxy session ID format.
- * Must be 8-14 lowercase alphanumeric characters.
- */
-export declare function isValidProxySessionId(sessionId: string): boolean;

package/lib/browser/utils/generics.js

@@ -1,272 +0,0 @@
-import {
-  areUint8ArraysEqual,
-  CONTENT_TYPE_MAP,
-  crypto,
-  decryptWrappedRecord,
-  PACKET_TYPE,
-  SUPPORTED_CIPHER_SUITE_MAP,
-  uint8ArrayToBinaryStr,
-  uint8ArrayToDataView
-} from "../utils/tls-imports.js";
-import { REDACTION_CHAR_CODE } from "@reclaimprotocol/zk-symmetric-crypto";
-import { RPCMessage, RPCMessages } from "../proto/api.js";
-const DEFAULT_REDACTION_DATA = new Uint8Array(4).fill(REDACTION_CHAR_CODE);
-function uint8ArrayToStr(arr) {
-  return new TextDecoder().decode(arr);
-}
-function strToUint8Array(str) {
-  return new TextEncoder().encode(str);
-}
-function getTranscriptString(receipt) {
-  const applMsgs = extractApplicationDataFromTranscript(receipt);
-  const strList = [];
-  for (const { message, sender } of applMsgs) {
-    const content = uint8ArrayToStr(message);
-    if (strList[strList.length - 1]?.startsWith(sender)) {
-      strList[strList.length - 1] += content;
-    } else {
-      strList.push(`${sender}: ${content}`);
-    }
-  }
-  return strList.join("\n");
-}
-const unixTimestampSeconds = () => Math.floor(Date.now() / 1e3);
-function findIndexInUint8Array(haystack, needle) {
-  for (let i = 0; i < haystack.length; i++) {
-    if (areUint8ArraysEqual(haystack.slice(i, i + needle.length), needle)) {
-      return i;
-    }
-  }
-  return -1;
-}
-function getZkAlgorithmForCipherSuite(cipherSuite) {
-  if (cipherSuite.includes("CHACHA20")) {
-    return "chacha20";
-  }
-  if (cipherSuite.includes("AES_256_GCM")) {
-    return "aes-256-ctr";
-  }
-  if (cipherSuite.includes("AES_128_GCM")) {
-    return "aes-128-ctr";
-  }
-  throw new Error(`${cipherSuite} not supported for ZK ops`);
-}
-function getPureCiphertext(content, cipherSuite) {
-  getZkAlgorithmForCipherSuite(cipherSuite);
-  content = content.slice(0, -16);
-  const {
-    ivLength: fixedIvLength
-  } = SUPPORTED_CIPHER_SUITE_MAP[cipherSuite];
-  const recordIvLength = 12 - fixedIvLength;
-  content = content.slice(recordIvLength);
-  return content;
-}
-function getRecordIV(content, cipherSuite) {
-  getZkAlgorithmForCipherSuite(cipherSuite);
-  const {
-    ivLength: fixedIvLength
-  } = SUPPORTED_CIPHER_SUITE_MAP[cipherSuite];
-  const recordIvLength = 12 - fixedIvLength;
-  return content.slice(0, recordIvLength);
-}
-function getProviderValue(params, fn, secretParams) {
-  return typeof fn === "function" ? fn(params, secretParams) : fn;
-}
-function generateRpcMessageId() {
-  return uint8ArrayToDataView(crypto.randomBytes(4)).getUint32(0);
-}
-function generateSessionId() {
-  return generateRpcMessageId();
-}
-function generateTunnelId() {
-  return generateRpcMessageId();
-}
-function makeRpcEvent(type, data) {
-  const ev = new Event(type);
-  ev.data = data;
-  return ev;
-}
-function getRpcTypeFromKey(key) {
-  if (key.endsWith("Request")) {
-    return {
-      type: key.slice(0, -7),
-      direction: "request"
-    };
-  }
-  if (key.endsWith("Response")) {
-    return {
-      type: key.slice(0, -8),
-      direction: "response"
-    };
-  }
-}
-function getRpcResponseType(type) {
-  return `${type}Response`;
-}
-function getRpcRequestType(type) {
-  return `${type}Request`;
-}
-function isApplicationData(packet, tlsVersion) {
-  return packet.type === "ciphertext" && (packet.contentType === "APPLICATION_DATA" || packet.data[0] === PACKET_TYPE.WRAPPED_RECORD && tlsVersion === "TLS1_2");
-}
-async function extractArrayBufferFromWsData(data) {
-  if (data instanceof ArrayBuffer) {
-    return new Uint8Array(data);
-  }
-  if (data instanceof Uint8Array || typeof data === "object" && data && "buffer" in data) {
-    return data;
-  }
-  if (typeof data === "string") {
-    return strToUint8Array(data);
-  }
-  if (typeof Blob !== "undefined" && data instanceof Blob) {
-    return new Uint8Array(await data.arrayBuffer());
-  }
-  throw new Error("unsupported data: " + String(data));
-}
-function getRpcRequest(msg) {
-  if (msg.requestError) {
-    return {
-      direction: "response",
-      type: "error"
-    };
-  }
-  for (const key in msg) {
-    if (!msg[key]) {
-      continue;
-    }
-    const rpcType = getRpcTypeFromKey(key);
-    if (!rpcType) {
-      continue;
-    }
-    return rpcType;
-  }
-}
-function extractApplicationDataFromTranscript({ transcript, tlsVersion }) {
-  const msgs = [];
-  for (const m of transcript) {
-    let message;
-    if (m.redacted) {
-      if (!m.plaintextLength) {
-        message = DEFAULT_REDACTION_DATA;
-      } else {
-        const len = tlsVersion === "TLS1_3" ? m.plaintextLength - 1 : m.plaintextLength;
-        message = new Uint8Array(len).fill(REDACTION_CHAR_CODE);
-      }
-    } else if (tlsVersion === "TLS1_3") {
-      const contentType = m.message[m.message.length - 1];
-      if (contentType !== CONTENT_TYPE_MAP["APPLICATION_DATA"]) {
-        continue;
-      }
-      message = m.message.slice(0, -1);
-    } else if (m.recordHeader[0] === PACKET_TYPE.WRAPPED_RECORD) {
-      message = m.message;
-    } else {
-      continue;
-    }
-    msgs.push({ message, sender: m.sender });
-  }
-  return msgs;
-}
-function extractHandshakeFromTranscript({ transcript, tlsVersion }) {
-  const msgs = [];
-  for (const [i, m] of transcript.entries()) {
-    if (m.redacted) {
-      break;
-    }
-    let message;
-    if (m.recordHeader[0] === PACKET_TYPE.HELLO) {
-      message = m.message;
-    } else if (m.recordHeader[0] === PACKET_TYPE.WRAPPED_RECORD) {
-      if (tlsVersion === "TLS1_3") {
-        const contentType = m.message[m.message.length - 1];
-        if (contentType !== CONTENT_TYPE_MAP["HANDSHAKE"]) {
-          break;
-        }
-        message = m.message.slice(0, -1);
-      } else {
-        break;
-      }
-    } else {
-      continue;
-    }
-    if (!message.length) {
-      throw new Error("unsupported handshake message");
-    }
-    msgs.push({ message, sender: m.sender, index: i });
-  }
-  return msgs;
-}
-async function decryptDirect(directReveal, cipherSuite, recordHeader, serverTlsVersion, content) {
-  const { key, iv, recordNumber } = directReveal;
-  const { cipher } = SUPPORTED_CIPHER_SUITE_MAP[cipherSuite];
-  const importedKey = await crypto.importKey(cipher, key);
-  return await decryptWrappedRecord(
-    content,
-    {
-      iv,
-      key: importedKey,
-      recordHeader,
-      recordNumber,
-      version: serverTlsVersion,
-      cipherSuite
-    }
-  );
-}
-function packRpcMessages(...msgs) {
-  return RPCMessages.create({
-    messages: msgs.map((msg) => RPCMessage.create({
-      ...msg,
-      id: msg.id || generateRpcMessageId()
-    }))
-  });
-}
-function ethersStructToPlainObject(struct) {
-  if (!Array.isArray(struct)) {
-    return struct;
-  }
-  const namedKeys = Object.keys(struct).filter((key) => isNaN(Number(key)));
-  if (!namedKeys.length) {
-    return struct.map(ethersStructToPlainObject);
-  }
-  const obj = {};
-  for (const key of namedKeys) {
-    obj[key] = ethersStructToPlainObject(struct[key]);
-  }
-  return obj;
-}
-function isTls13Suite(suite) {
-  return suite === "TLS_AES_128_GCM_SHA256" || suite === "TLS_AES_256_GCM_SHA384" || suite === "TLS_CHACHA20_POLY1305_SHA256";
-}
-function isValidProxySessionId(sessionId) {
-  return typeof sessionId === "string" && sessionId.length >= 8 && sessionId.length < 15 && /^[a-z0-9]+$/.test(sessionId);
-}
-export {
-  decryptDirect,
-  ethersStructToPlainObject,
-  extractApplicationDataFromTranscript,
-  extractArrayBufferFromWsData,
-  extractHandshakeFromTranscript,
-  findIndexInUint8Array,
-  generateRpcMessageId,
-  generateSessionId,
-  generateTunnelId,
-  getProviderValue,
-  getPureCiphertext,
-  getRecordIV,
-  getRpcRequest,
-  getRpcRequestType,
-  getRpcResponseType,
-  getRpcTypeFromKey,
-  getTranscriptString,
-  getZkAlgorithmForCipherSuite,
-  isApplicationData,
-  isTls13Suite,
-  isValidProxySessionId,
-  makeRpcEvent,
-  packRpcMessages,
-  strToUint8Array,
-  uint8ArrayToBinaryStr,
-  uint8ArrayToStr,
-  unixTimestampSeconds
-};