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

package/lib/utils/logger.js

@@ -1,82 +0,0 @@
-import { pino, stdTimeFunctions } from "pino";
-import { getEnvVariable } from "../utils/env.js";
-const PII_PROPERTIES = ["ownerPrivateKey", "secretParams"];
-const redactedText = "[REDACTED]";
-const envLevel = getEnvVariable("LOG_LEVEL");
-let logger = pino();
-makeLogger(false, envLevel);
-function makeLogger(redactPii, level, onLog) {
-  const opts = {
-    // Log human readable time stamps instead of epoch time
-    timestamp: 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 = pino(opts);
-  pLogger.level = level || "info";
-  logger = pLogger;
-  return pLogger;
-  function writeLog(level2, log) {
-    log = redact(log);
-    const { msg, ...obj } = log;
-    if (console[level2]) {
-      console[level2](obj, msg);
-    } else {
-      console.log(obj, msg);
-    }
-    onLog?.(level2, log);
-  }
-}
-function isObjectProperty(property) {
-  return typeof property === "object" && !Array.isArray(property) && property !== null;
-}
-function getReplacer() {
-  const references = /* @__PURE__ */ 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;
-}
-export {
-  logger,
-  makeLogger,
-  redact
-};

package/lib/utils/prepare-packets.js

@@ -1,69 +0,0 @@
-import { concatenateUint8Arrays, crypto } from "../utils/tls-imports.js";
-import {
-  TranscriptMessageSenderType
-} from "../proto/api.js";
-import { makeZkProofGenerator } from "../utils/zk.js";
-async function preparePacketsForReveal(tlsTranscript, reveals, { onZkProgress, ...opts }) {
-  const transcript = [];
-  const proofGenerator = await makeZkProofGenerator(opts);
-  let zkPacketsDone = 0;
-  await Promise.all(tlsTranscript.map(async ({ message, sender }, i) => {
-    const msg = {
-      sender: sender === "client" ? TranscriptMessageSenderType.TRANSCRIPT_MESSAGE_SENDER_TYPE_CLIENT : TranscriptMessageSenderType.TRANSCRIPT_MESSAGE_SENDER_TYPE_SERVER,
-      message: message.data,
-      reveal: void 0
-    };
-    transcript.push(msg);
-    const reveal = reveals.get(message);
-    if (!reveal || message.type === "plaintext") {
-      return;
-    }
-    switch (reveal?.type) {
-      case "complete":
-        msg.reveal = {
-          directReveal: {
-            key: await crypto.exportKey(message.encKey),
-            iv: message.fixedIv,
-            recordNumber: message.recordNumber
-          }
-        };
-        break;
-      case "zk": {
-        reveal.redactedPlaintext = concatenateUint8Arrays([
-          reveal.redactedPlaintext,
-          message.plaintext.slice(reveal.redactedPlaintext.length)
-        ]);
-        const oprfRawMarkers = reveal.oprfRawMarkers?.map((m) => ({
-          dataLocation: m.dataLocation
-        })) || [];
-        const overshotOprfRawLength = reveal.overshotOprfRawFromPrevBlock?.length ?? 0;
-        await proofGenerator.addPacketToProve(
-          message,
-          reveal,
-          (proofs, toprfs) => msg.reveal = {
-            zkReveal: { proofs, toprfs, oprfRawMarkers, overshotOprfRawLength }
-          },
-          () => {
-            const next = tlsTranscript.slice(i + 1).find((t) => t.sender === sender);
-            return next?.message;
-          }
-        );
-        break;
-      }
-      default:
-        break;
-    }
-  }));
-  const zkPacketsTotal = proofGenerator.getTotalChunksToProve();
-  onZkProgress?.(zkPacketsDone, zkPacketsTotal);
-  await proofGenerator.generateProofs(
-    () => {
-      zkPacketsDone += 1;
-      onZkProgress?.(zkPacketsDone, zkPacketsTotal);
-    }
-  );
-  return transcript;
-}
-export {
-  preparePacketsForReveal
-};

package/lib/utils/redactions.js

@@ -1,135 +0,0 @@
-import { base64Encode } from "@bufbuild/protobuf/wire";
-import { concatenateUint8Arrays } from "../utils/tls-imports.js";
-const REDACTION_CHAR = "*";
-const REDACTION_CHAR_CODE = REDACTION_CHAR.charCodeAt(0);
-function isRedactionCongruent(redacted, original) {
-  for (let i = 0; i < redacted.length; i++) {
-    const element = redacted[i];
-    const areSame = element === original[i] || typeof element === "string" && element === REDACTION_CHAR || typeof element === "number" && element === REDACTION_CHAR_CODE;
-    if (!areSame) {
-      return false;
-    }
-  }
-  return true;
-}
-function isFullyRedacted(redacted) {
-  for (const element of redacted) {
-    if (element !== REDACTION_CHAR && element !== REDACTION_CHAR_CODE) {
-      return false;
-    }
-  }
-  return true;
-}
-async function getBlocksToReveal(blocks, redact, performOprf) {
-  const slicesWithReveal = blocks.map((block) => ({
-    block,
-    // copy the plaintext to avoid mutating the original
-    redactedPlaintext: new Uint8Array(block.plaintext)
-  }));
-  const total = 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) {
-    await redactBlocks(redaction);
-  }
-  return slicesWithReveal.filter((s) => !isFullyRedacted(s.redactedPlaintext));
-  async function redactBlocks(slice) {
-    while (cursor < slice.fromIndex) {
-      advance();
-    }
-    if (slice.hash === "oprf-raw") {
-      const startBlockIdx = blockIdx;
-      const startCursorInBlock = cursorInBlock;
-      const totalLength = slice.toIndex - slice.fromIndex;
-      const block = slicesWithReveal[blockIdx];
-      block.oprfRawMarkers ||= [];
-      block.oprfRawMarkers.push({
-        dataLocation: {
-          fromIndex: startCursorInBlock,
-          length: totalLength
-        }
-      });
-      let overshootLen = 0;
-      while (cursor < slice.toIndex) {
-        if (blockIdx !== startBlockIdx) {
-          overshootLen += 1;
-        }
-        advance();
-      }
-      if (overshootLen) {
-        slicesWithReveal[blockIdx].overshotOprfRawFromPrevBlock = { length: overshootLen };
-      }
-      return;
-    }
-    if (slice.hash) {
-      const plaintext = total.slice(slice.fromIndex, slice.toIndex);
-      const { nullifier, responses, mask } = await performOprf(plaintext);
-      const toprf = {
-        nullifier,
-        responses,
-        dataLocation: {
-          fromIndex: cursorInBlock,
-          length: slice.toIndex - slice.fromIndex
-        },
-        mask,
-        plaintext
-      };
-      const startBlockIdx = blockIdx;
-      const block = slicesWithReveal[blockIdx];
-      block.toprfs ||= [];
-      block.toprfs.push(toprf);
-      const nullifierStr = binaryHashToStr(nullifier, toprf.dataLocation.length);
-      let i = 0;
-      let overshootLen = 0;
-      while (cursor < slice.toIndex) {
-        if (blockIdx !== startBlockIdx) {
-          overshootLen += 1;
-        }
-        slicesWithReveal[blockIdx].redactedPlaintext[cursorInBlock] = nullifierStr.charCodeAt(i);
-        advance();
-        i += 1;
-      }
-      if (overshootLen) {
-        slicesWithReveal[blockIdx].overshotToprfFromPrevBlock = { length: overshootLen };
-      }
-    }
-    while (cursor < slice.toIndex) {
-      slicesWithReveal[blockIdx].redactedPlaintext[cursorInBlock] = REDACTION_CHAR_CODE;
-      advance();
-    }
-  }
-  function advance() {
-    cursor += 1;
-    cursorInBlock += 1;
-    if (cursorInBlock >= blocks[blockIdx].plaintext.length) {
-      blockIdx += 1;
-      cursorInBlock = 0;
-    }
-  }
-}
-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] = REDACTION_CHAR_CODE;
-    }
-  }
-  return redacted;
-}
-function binaryHashToStr(hash, expLength) {
-  return base64Encode(hash).padEnd(expLength, "0").slice(0, expLength);
-}
-export {
-  REDACTION_CHAR,
-  REDACTION_CHAR_CODE,
-  binaryHashToStr,
-  getBlocksToReveal,
-  isFullyRedacted,
-  isRedactionCongruent,
-  redactSlices
-};

package/lib/utils/retries.js

@@ -1,26 +0,0 @@
-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");
-}
-export {
-  executeWithRetries
-};

package/lib/utils/signatures/eth.js

@@ -1,31 +0,0 @@
-import { computeAddress, getBytes, hexlify, SigningKey, verifyMessage, Wallet } from "ethers";
-const ETH_SIGNATURE_PROVIDER = {
-  getPublicKey(privateKey) {
-    const pub = SigningKey.computePublicKey(privateKey, true);
-    return getBytes(pub);
-  },
-  getAddress(publicKey) {
-    const pubKeyHex = typeof publicKey === "string" ? publicKey : hexlify(publicKey);
-    return computeAddress(pubKeyHex).toLowerCase();
-  },
-  async sign(data, privateKey) {
-    const wallet = getEthWallet(privateKey);
-    const signature = await wallet.signMessage(data);
-    return getBytes(signature);
-  },
-  async verify(data, signature, addressBytes) {
-    const address = typeof addressBytes === "string" ? addressBytes : hexlify(addressBytes);
-    const signatureHex = typeof signature === "string" ? signature : hexlify(signature);
-    const signerAddress = verifyMessage(data, signatureHex);
-    return signerAddress.toLowerCase() === address.toLowerCase();
-  }
-};
-function getEthWallet(privateKey) {
-  if (!privateKey) {
-    throw new Error("Private key missing");
-  }
-  return new Wallet(privateKey);
-}
-export {
-  ETH_SIGNATURE_PROVIDER
-};

package/lib/utils/signatures/index.js

@@ -1,12 +0,0 @@
-import { ServiceSignatureType } from "../../proto/api.js";
-import { ETH_SIGNATURE_PROVIDER } from "../../utils/signatures/eth.js";
-const SIGNATURES = {
-  [ServiceSignatureType.SERVICE_SIGNATURE_TYPE_ETH]: ETH_SIGNATURE_PROVIDER
-};
-const SelectedServiceSignatureType = ServiceSignatureType.SERVICE_SIGNATURE_TYPE_ETH;
-const SelectedServiceSignature = SIGNATURES[SelectedServiceSignatureType];
-export {
-  SIGNATURES,
-  SelectedServiceSignature,
-  SelectedServiceSignatureType
-};

package/lib/utils/socket-base.js

@@ -1,96 +0,0 @@
-import { wsMessageHandler } from "../client/utils/message-handler.js";
-import { RPCMessages } from "../proto/api.js";
-import { AttestorError, makeRpcEvent, packRpcMessages } from "../utils/index.js";
-class AttestorSocket {
-  eventTarget = new EventTarget();
-  socket;
-  logger;
-  metadata;
-  isInitialised = false;
-  constructor(socket, metadata, logger) {
-    this.socket = socket;
-    this.metadata = metadata;
-    this.logger = logger;
-    socket.addEventListener("error", (event) => {
-      const witErr = AttestorError.fromError(
-        event.error || new Error(event.message),
-        "ERROR_NETWORK_ERROR"
-      );
-      this.dispatchRPCEvent("connection-terminated", witErr);
-    });
-    socket.addEventListener("close", () => this.dispatchRPCEvent(
-      "connection-terminated",
-      new AttestorError(
-        "ERROR_NO_ERROR",
-        "connection closed"
-      )
-    ));
-    socket.addEventListener("message", async (event) => {
-      try {
-        await wsMessageHandler.call(this, event.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 AttestorError(
-        "ERROR_NETWORK_ERROR",
-        "Connection closed, cannot send message"
-      );
-    }
-    if (!this.isOpen) {
-      throw new AttestorError(
-        "ERROR_NETWORK_ERROR",
-        "Wait for connection to open before sending message"
-      );
-    }
-    const msg = packRpcMessages(...msgs);
-    const bytes = RPCMessages.encode(msg).finish();
-    this.logger.trace({ msg }, "sending messages");
-    if ("sendPromise" in this.socket && this.socket.sendPromise) {
-      await this.socket.sendPromise(bytes);
-    } else {
-      this.socket.send(bytes);
-    }
-    return msg;
-  }
-  dispatchRPCEvent(type, data) {
-    const event = 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) {
-    if (this.isClosed) {
-      return;
-    }
-    try {
-      const witErr = err ? AttestorError.fromError(err) : new AttestorError("ERROR_NO_ERROR", "");
-      this.dispatchRPCEvent("connection-terminated", witErr);
-      if (this.isOpen) {
-        await this.sendMessage({
-          connectionTerminationAlert: witErr.toProto()
-        });
-      }
-    } catch (err2) {
-      this.logger?.error({ err: err2 }, "error terminating connection");
-    } finally {
-      this.socket.close();
-    }
-  }
-}
-export {
-  AttestorSocket
-};

package/lib/utils/tls-imports.d.ts

@@ -1,21 +0,0 @@
-/**
- * Convert ASCII string to Uint8Array
- */
-export declare function asciiToUint8Array(str: string): Uint8Array;
-/**
- * Concatenate multiple Uint8Arrays into one
- */
-export declare function concatenateUint8Arrays(arrays: Uint8Array[]): Uint8Array;
-/**
- * Check if two Uint8Arrays are equal
- */
-export declare function areUint8ArraysEqual(a: Uint8Array, b: Uint8Array): boolean;
-/**
- * Convert Uint8Array to binary string
- */
-export declare function uint8ArrayToBinaryStr(arr: Uint8Array): string;
-/**
- * Convert Uint8Array to DataView
- */
-export declare function uint8ArrayToDataView(arr: Uint8Array): DataView;
-export { crypto, decryptWrappedRecord, encryptWrappedRecord, generateIV, makeTLSClient, setCryptoImplementation, CONTENT_TYPE_MAP, PACKET_TYPE, SUPPORTED_CIPHER_SUITE_MAP, SUPPORTED_NAMED_CURVES, } from '@reclaimprotocol/tls';

package/lib/utils/tls-imports.js

@@ -1,71 +0,0 @@
-function asciiToUint8Array(str) {
-  const bytes = new Uint8Array(str.length);
-  for (let i = 0; i < str.length; i++) {
-    const charCode = str.charCodeAt(i);
-    if (charCode < 0 || charCode > 255) {
-      throw new Error(`Invalid ASCII character at index ${i}: ${str[i]}`);
-    }
-    bytes[i] = charCode;
-  }
-  return bytes;
-}
-function concatenateUint8Arrays(arrays) {
-  const totalLength = arrays.reduce((acc, curr) => acc + curr.length, 0);
-  const result = new Uint8Array(totalLength);
-  let offset = 0;
-  for (const arr of arrays) {
-    result.set(arr, offset);
-    offset += arr.length;
-  }
-  return result;
-}
-function areUint8ArraysEqual(a, b) {
-  if (a.length !== b.length) {
-    return false;
-  }
-  for (let i = 0; i < a.length; i++) {
-    if (a[i] !== b[i]) {
-      return false;
-    }
-  }
-  return true;
-}
-function uint8ArrayToBinaryStr(arr) {
-  let str = "";
-  for (const byte of arr) {
-    str += String.fromCharCode(byte);
-  }
-  return str;
-}
-function uint8ArrayToDataView(arr) {
-  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
-}
-import {
-  crypto,
-  decryptWrappedRecord,
-  encryptWrappedRecord,
-  generateIV,
-  makeTLSClient,
-  setCryptoImplementation,
-  CONTENT_TYPE_MAP,
-  PACKET_TYPE,
-  SUPPORTED_CIPHER_SUITE_MAP,
-  SUPPORTED_NAMED_CURVES
-} from "@reclaimprotocol/tls";
-export {
-  CONTENT_TYPE_MAP,
-  PACKET_TYPE,
-  SUPPORTED_CIPHER_SUITE_MAP,
-  SUPPORTED_NAMED_CURVES,
-  areUint8ArraysEqual,
-  asciiToUint8Array,
-  concatenateUint8Arrays,
-  crypto,
-  decryptWrappedRecord,
-  encryptWrappedRecord,
-  generateIV,
-  makeTLSClient,
-  setCryptoImplementation,
-  uint8ArrayToBinaryStr,
-  uint8ArrayToDataView
-};

package/lib/utils/tls.js

@@ -1,58 +0,0 @@
-import { SUPPORTED_NAMED_CURVES } from "../utils/tls-imports.js";
-import { detectEnvironment } from "../utils/env.js";
-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",
-  "TLS_RSA_WITH_AES_128_GCM_SHA256"
-];
-const NAMED_CURVE_LIST = detectEnvironment() === "node" ? SUPPORTED_NAMED_CURVES : SUPPORTED_NAMED_CURVES.filter((c) => c !== "X25519");
-TLS_ADDITIONAL_ROOT_CA_LIST.push(
-  `-----BEGIN CERTIFICATE-----
-MIIEszCCA5ugAwIBAgIQCyWUIs7ZgSoVoE6ZUooO+jANBgkqhkiG9w0BAQsFADBh
-MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3
-d3cuZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBH
-MjAeFw0xNzExMDIxMjI0MzNaFw0yNzExMDIxMjI0MzNaMGAxCzAJBgNVBAYTAlVT
-MRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5j
-b20xHzAdBgNVBAMTFlJhcGlkU1NMIFRMUyBSU0EgQ0EgRzEwggEiMA0GCSqGSIb3
-DQEBAQUAA4IBDwAwggEKAoIBAQC/uVklRBI1FuJdUEkFCuDL/I3aJQiaZ6aibRHj
-ap/ap9zy1aYNrphe7YcaNwMoPsZvXDR+hNJOo9gbgOYVTPq8gXc84I75YKOHiVA4
-NrJJQZ6p2sJQyqx60HkEIjzIN+1LQLfXTlpuznToOa1hyTD0yyitFyOYwURM+/CI
-8FNFMpBhw22hpeAQkOOLmsqT5QZJYeik7qlvn8gfD+XdDnk3kkuuu0eG+vuyrSGr
-5uX5LRhFWlv1zFQDch/EKmd163m6z/ycx/qLa9zyvILc7cQpb+k7TLra9WE17YPS
-n9ANjG+ECo9PDW3N9lwhKQCNvw1gGoguyCQu7HE7BnW8eSSFAgMBAAGjggFmMIIB
-YjAdBgNVHQ4EFgQUDNtsgkkPSmcKuBTuesRIUojrVjgwHwYDVR0jBBgwFoAUTiJU
-IBiV5uNu5g/6+rkS7QYXjzkwDgYDVR0PAQH/BAQDAgGGMB0GA1UdJQQWMBQGCCsG
-AQUFBwMBBggrBgEFBQcDAjASBgNVHRMBAf8ECDAGAQH/AgEAMDQGCCsGAQUFBwEB
-BCgwJjAkBggrBgEFBQcwAYYYaHR0cDovL29jc3AuZGlnaWNlcnQuY29tMEIGA1Ud
-HwQ7MDkwN6A1oDOGMWh0dHA6Ly9jcmwzLmRpZ2ljZXJ0LmNvbS9EaWdpQ2VydEds
-b2JhbFJvb3RHMi5jcmwwYwYDVR0gBFwwWjA3BglghkgBhv1sAQEwKjAoBggrBgEF
-BQcCARYcaHR0cHM6Ly93d3cuZGlnaWNlcnQuY29tL0NQUzALBglghkgBhv1sAQIw
-CAYGZ4EMAQIBMAgGBmeBDAECAjANBgkqhkiG9w0BAQsFAAOCAQEAGUSlOb4K3Wtm
-SlbmE50UYBHXM0SKXPqHMzk6XQUpCheF/4qU8aOhajsyRQFDV1ih/uPIg7YHRtFi
-CTq4G+zb43X1T77nJgSOI9pq/TqCwtukZ7u9VLL3JAq3Wdy2moKLvvC8tVmRzkAe
-0xQCkRKIjbBG80MSyDX/R4uYgj6ZiNT/Zg6GI6RofgqgpDdssLc0XIRQEotxIZcK
-zP3pGJ9FCbMHmMLLyuBd+uCWvVcF2ogYAawufChS/PT61D9rqzPRS5I2uqa3tmIT
-44JhJgWhBnFMb7AGQkvNq9KNS9dd3GWc17H/dXa1enoxzWjE0hBdFjxPhUb0W3wi
-8o34/m8Fxw==
------END CERTIFICATE-----`
-  //RapidSSL TLS RSA CA G1
-);
-function getDefaultTlsOptions() {
-  return {
-    cipherSuites: ZK_CIPHER_SUITES,
-    namedCurves: NAMED_CURVE_LIST
-  };
-}
-export {
-  getDefaultTlsOptions
-};

package/lib/utils/ws.js

@@ -1,22 +0,0 @@
-function makeWebSocket(url) {
-  return new WebSocket(url);
-}
-function promisifySend(ws) {
-  if (ws.sendPromise) {
-    return ws;
-  }
-  ws.sendPromise = (data) => new Promise((resolve, reject) => {
-    ws.send(data, (err) => {
-      if (err) {
-        reject(err);
-        return;
-      }
-      resolve();
-    });
-  });
-  return ws;
-}
-export {
-  makeWebSocket,
-  promisifySend
-};