@reclaimprotocol/attestor-core 5.0.1-beta.7 → 5.0.1

package/lib/client/utils/client-socket.js

@@ -1,120 +0,0 @@
-import { encodeBase64 } from "ethers";
-import { DEFAULT_METADATA, DEFAULT_RPC_TIMEOUT_MS } from "../../config/index.js";
-import { RPCMessages } from "../../proto/api.js";
-import { AttestorError, generateRpcMessageId, getRpcRequestType, logger as LOGGER, packRpcMessages } from "../../utils/index.js";
-import { AttestorSocket } from "../../utils/socket-base.js";
-import { makeWebSocket as defaultMakeWebSocket } from "../../utils/ws.js";
-class AttestorClient extends AttestorSocket {
-  waitForInitPromise;
-  initResponse;
-  constructor({
-    url,
-    initMessages = [],
-    signatureType = DEFAULT_METADATA.signatureType,
-    logger = LOGGER,
-    authRequest,
-    makeWebSocket = defaultMakeWebSocket
-  }) {
-    const initRequest = {
-      ...DEFAULT_METADATA,
-      signatureType,
-      auth: authRequest
-    };
-    const msg = packRpcMessages({ initRequest }, ...initMessages);
-    const initRequestBytes = RPCMessages.encode(msg).finish();
-    const initRequestB64 = encodeBase64(initRequestBytes);
-    url = new URL(url.toString());
-    url.searchParams.set("messages", initRequestB64);
-    super(
-      makeWebSocket(url),
-      initRequest,
-      logger
-    );
-    const initReqId = msg.messages[0].id;
-    this.waitForInitPromise = this.waitForResponse(initReqId, DEFAULT_RPC_TIMEOUT_MS).then((res) => {
-      logger.info("client initialised");
-      this.isInitialised = true;
-      this.initResponse = res;
-    });
-    this.waitForInitPromise.catch(() => {
-    });
-    this.addEventListener("connection-terminated", (ev) => logger.info({ err: ev.data }, "connection terminated"));
-  }
-  async rpc(type, request, timeoutMs = DEFAULT_RPC_TIMEOUT_MS) {
-    const msgId = generateRpcMessageId();
-    this.logger.debug({ type, id: msgId }, "sending rpc request");
-    const now = Date.now();
-    try {
-      const rslt = this.waitForResponse(msgId, timeoutMs);
-      await this.sendMessage({ id: msgId, [getRpcRequestType(type)]: request });
-      return await rslt;
-    } finally {
-      const timeTakenMs = Date.now() - now;
-      this.logger.debug({ type, timeTakenMs }, "received rpc response");
-    }
-  }
-  waitForResponse(id, timeoutMs = DEFAULT_RPC_TIMEOUT_MS) {
-    if (this.isClosed) {
-      throw new AttestorError(
-        "ERROR_NETWORK_ERROR",
-        "Client connection already closed"
-      );
-    }
-    return new Promise((resolve, reject) => {
-      const handler = (event) => {
-        if (event.data.id !== id) {
-          return;
-        }
-        removeHandlers();
-        if ("error" in event.data) {
-          reject(event.data.error);
-          return;
-        }
-        resolve(event.data.data);
-      };
-      const terminateHandler = (event) => {
-        removeHandlers();
-        if (event.data.code === "ERROR_NO_ERROR") {
-          reject(
-            new AttestorError(
-              "ERROR_NETWORK_ERROR",
-              event.data.message,
-              event.data.data
-            )
-          );
-          return;
-        }
-        reject(event.data);
-      };
-      const timeout = setTimeout(() => {
-        removeHandlers();
-        reject(
-          new AttestorError(
-            "ERROR_TIMEOUT",
-            `RPC request timed out after ${timeoutMs}ms`,
-            { id }
-          )
-        );
-      }, timeoutMs);
-      const removeHandlers = () => {
-        clearTimeout(timeout);
-        this.removeEventListener("rpc-response", handler);
-        this.removeEventListener("connection-terminated", terminateHandler);
-      };
-      this.addEventListener("rpc-response", handler);
-      this.addEventListener("connection-terminated", terminateHandler);
-    });
-  }
-  waitForInit = () => {
-    if (this.isClosed) {
-      throw new AttestorError(
-        "ERROR_NETWORK_ERROR",
-        "Client connection already closed"
-      );
-    }
-    return this.waitForInitPromise;
-  };
-}
-export {
-  AttestorClient
-};

package/lib/client/utils/message-handler.js

@@ -1,97 +0,0 @@
-import { RPCMessages } from "../../proto/api.js";
-import { AttestorError, extractArrayBufferFromWsData, getRpcRequest, getRpcRequestType, getRpcResponseType } from "../../utils/index.js";
-async function wsMessageHandler(data) {
-  const buff = await extractArrayBufferFromWsData(data);
-  const { messages } = RPCMessages.decode(buff);
-  for (const msg of messages) {
-    await handleMessage.call(this, msg);
-  }
-}
-function handleMessage(msg) {
-  this.logger?.trace({ msg }, "received message");
-  if (msg.connectionTerminationAlert) {
-    const err = AttestorError.fromProto(
-      msg.connectionTerminationAlert
-    );
-    this.logger?.warn(
-      {
-        err: err.code !== "ERROR_NO_ERROR" ? err : void 0
-      },
-      "received connection termination alert"
-    );
-    this.dispatchRPCEvent("connection-terminated", err);
-    return;
-  }
-  const rpcRequest = getRpcRequest(msg);
-  if (rpcRequest) {
-    if (rpcRequest.direction === "response" && rpcRequest.type === "error") {
-      this.dispatchRPCEvent("rpc-response", {
-        id: msg.id,
-        error: AttestorError.fromProto(msg.requestError)
-      });
-      return;
-    }
-    const resType = getRpcResponseType(rpcRequest.type);
-    if (rpcRequest.direction === "response") {
-      this.dispatchRPCEvent("rpc-response", {
-        id: msg.id,
-        type: rpcRequest.type,
-        data: msg[resType]
-      });
-      return;
-    }
-    if (!this.isInitialised && rpcRequest.type !== "init") {
-      this.logger.warn(
-        { type: rpcRequest.type },
-        "RPC request received before initialisation"
-      );
-      void this.sendMessage({
-        id: msg.id,
-        requestError: AttestorError.badRequest("Initialise connection first").toProto()
-      });
-      return;
-    }
-    return new Promise((resolve, reject) => {
-      this.dispatchRPCEvent("rpc-request", {
-        requestId: msg.id,
-        type: rpcRequest.type,
-        data: msg[getRpcRequestType(rpcRequest.type)],
-        respond: (res) => {
-          if (!this.isOpen) {
-            this.logger?.debug(
-              { type: rpcRequest.type, res },
-              "connection closed before responding"
-            );
-            reject(new Error("connection closed"));
-            return;
-          }
-          if ("code" in res) {
-            reject(res);
-            return this.sendMessage({
-              id: msg.id,
-              requestError: res.toProto()
-            });
-          }
-          resolve();
-          return this.sendMessage({ id: msg.id, [resType]: res });
-        }
-      });
-    });
-  }
-  if (msg.tunnelMessage) {
-    this.dispatchRPCEvent("tunnel-message", msg.tunnelMessage);
-    return;
-  }
-  if (msg.tunnelDisconnectEvent) {
-    this.dispatchRPCEvent(
-      "tunnel-disconnect-event",
-      msg.tunnelDisconnectEvent
-    );
-    return;
-  }
-  this.logger.warn({ msg }, "unhandled message");
-}
-export {
-  handleMessage,
-  wsMessageHandler
-};

package/lib/config/index.js

@@ -1,62 +0,0 @@
-import { AttestorVersion, ServiceSignatureType } from "../proto/api.js";
-const DEFAULT_ZK_CONCURRENCY = 10;
-const RECLAIM_USER_AGENT = "reclaim/0.0.1";
-const DEFAULT_HTTPS_PORT = 443;
-const WS_PATHNAME = "/ws";
-const BROWSER_RPC_PATHNAME = "/browser-rpc";
-const ATTESTOR_ADDRESS_PATHNAME = "/address";
-const DEFAULT_REMOTE_FILE_FETCH_BASE_URL = `${BROWSER_RPC_PATHNAME}/resources`;
-const API_SERVER_PORT = 8001;
-const CONNECTION_TIMEOUT_MS = 1e4;
-const DNS_SERVERS = [
-  "8.8.8.8",
-  "8.8.4.4"
-];
-const MAX_CLAIM_TIMESTAMP_DIFF_S = 10 * 60;
-const CURRENT_ATTESTOR_VERSION = AttestorVersion.ATTESTOR_VERSION_3_0_0;
-const DEFAULT_METADATA = {
-  signatureType: ServiceSignatureType.SERVICE_SIGNATURE_TYPE_ETH,
-  clientVersion: CURRENT_ATTESTOR_VERSION,
-  auth: void 0
-};
-const PROVIDER_CTX = { version: CURRENT_ATTESTOR_VERSION };
-const PING_INTERVAL_MS = 1e4;
-const MAX_NO_DATA_INTERVAL_MS = 3e4;
-const MAX_PAYLOAD_SIZE = 512 * 1024 * 1024;
-const DEFAULT_AUTH_EXPIRY_S = 15 * 60;
-const DEFAULT_RPC_TIMEOUT_MS = 9e4;
-const TOPRF_DOMAIN_SEPARATOR = "reclaim-toprf";
-const MAX_CERT_SIZE_BYTES = 10 * 1024 * 1024 * 1024;
-const CERT_ALLOWED_MIMETYPES = [
-  "application/x-x509-ca-cert",
-  "application/x-x509-user-cert",
-  "application/pkix-cert",
-  "application/pkcs7-mime",
-  "application/octet-stream"
-];
-const BGP_WS_URL = "wss://ris-live.ripe.net/v1/ws/?client=reclaim-hijack-detector";
-export {
-  API_SERVER_PORT,
-  ATTESTOR_ADDRESS_PATHNAME,
-  BGP_WS_URL,
-  BROWSER_RPC_PATHNAME,
-  CERT_ALLOWED_MIMETYPES,
-  CONNECTION_TIMEOUT_MS,
-  CURRENT_ATTESTOR_VERSION,
-  DEFAULT_AUTH_EXPIRY_S,
-  DEFAULT_HTTPS_PORT,
-  DEFAULT_METADATA,
-  DEFAULT_REMOTE_FILE_FETCH_BASE_URL,
-  DEFAULT_RPC_TIMEOUT_MS,
-  DEFAULT_ZK_CONCURRENCY,
-  DNS_SERVERS,
-  MAX_CERT_SIZE_BYTES,
-  MAX_CLAIM_TIMESTAMP_DIFF_S,
-  MAX_NO_DATA_INTERVAL_MS,
-  MAX_PAYLOAD_SIZE,
-  PING_INTERVAL_MS,
-  PROVIDER_CTX,
-  RECLAIM_USER_AGENT,
-  TOPRF_DOMAIN_SEPARATOR,
-  WS_PATHNAME
-};

package/lib/external-rpc/benchmark.js

@@ -1,82 +0,0 @@
-import {
-  crypto,
-  encryptWrappedRecord,
-  SUPPORTED_CIPHER_SUITE_MAP
-} from "../utils/tls-imports.js";
-import { strToUint8Array } from "../utils/generics.js";
-import { logger } from "../utils/logger.js";
-import { makeZkProofGenerator } from "../utils/zk.js";
-const ZK_CIPHER_SUITES = [
-  "TLS_CHACHA20_POLY1305_SHA256",
-  "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384",
-  "TLS_AES_128_GCM_SHA256"
-];
-async function benchmark() {
-  let benchmarkRes = "";
-  for (const cipherSuite of ZK_CIPHER_SUITES) {
-    const now = Date.now();
-    const alg = cipherSuite.includes("CHACHA20") ? "CHACHA20-POLY1305" : cipherSuite.includes("AES_256_GCM") ? "AES-256-GCM" : "AES-128-GCM";
-    const keylength = alg === "AES-128-GCM" ? 16 : 32;
-    const key = Buffer.alloc(keylength, 0);
-    const {
-      ivLength: fixedIvLength
-    } = SUPPORTED_CIPHER_SUITE_MAP[cipherSuite];
-    const fixedIv = Buffer.alloc(fixedIvLength, 0);
-    const encKey = await crypto.importKey(alg, key);
-    const vectors = [
-      {
-        plaintext: `My cool API secret is "my name jeff". Please don't reveal it`
-      }
-    ];
-    const proofGenerator = await makeZkProofGenerator({
-      logger,
-      cipherSuite
-    });
-    for (const { plaintext } of vectors) {
-      const plaintextArr = strToUint8Array(plaintext);
-      const { ciphertext, iv } = await encryptWrappedRecord(
-        plaintextArr,
-        {
-          key: encKey,
-          iv: fixedIv,
-          recordNumber: 0,
-          recordHeaderOpts: {
-            type: "WRAPPED_RECORD"
-          },
-          cipherSuite,
-          version: cipherSuite.includes("ECDHE_") ? "TLS1_2" : "TLS1_3"
-        }
-      );
-      const packet = {
-        type: "ciphertext",
-        encKey,
-        iv,
-        recordNumber: 0,
-        plaintext: plaintextArr,
-        ciphertext,
-        fixedIv: new Uint8Array(0),
-        data: ciphertext
-      };
-      await proofGenerator.addPacketToProve(
-        packet,
-        {
-          type: "zk",
-          redactedPlaintext: plaintextArr
-        },
-        () => {
-        },
-        () => {
-          throw new Error("should not be called in benchmark");
-        }
-      );
-      await proofGenerator.generateProofs();
-    }
-    benchmarkRes = benchmarkRes + `Benchmark ${alg} ok. Took ${Date.now() - now} ms 
-`;
-  }
-  logger.info(benchmarkRes);
-  return benchmarkRes;
-}
-export {
-  benchmark
-};

package/lib/external-rpc/event-bus.js

@@ -1,17 +0,0 @@
-class EventBus {
-  #listeners = [];
-  addListener(fn) {
-    this.#listeners.push(fn);
-    return () => {
-      this.#listeners = this.#listeners.filter((l) => l !== fn);
-    };
-  }
-  dispatch(data) {
-    for (const listener of this.#listeners) {
-      listener(data);
-    }
-  }
-}
-export {
-  EventBus
-};

package/lib/external-rpc/handle-incoming-msg.js

@@ -1,241 +0,0 @@
-import { hexlify } from "ethers";
-import { createClaimOnAvs } from "../avs/client/create-claim-on-avs.js";
-import { createClaimOnAttestor } from "../client/index.js";
-import { benchmark } from "../external-rpc/benchmark.js";
-import { generateRpcRequestId, getCurrentMemoryUsage, getWsApiUrlFromBaseUrl, RPC_MSG_BRIDGE, sendMessageToApp, waitForResponse } from "../external-rpc/utils.js";
-import { ALL_ENC_ALGORITHMS, makeExternalRpcOprfOperator, makeExternalRpcZkOperator } from "../external-rpc/zk.js";
-import { createClaimOnMechain } from "../mechain/client/create-claim-on-mechain.js";
-import { extractHTMLElement, extractJSONValueIndex, generateRequstAndResponseFromTranscript } from "../providers/http/utils.js";
-import { B64_JSON_REVIVER } from "../utils/b64-json.js";
-import { AttestorError, getIdentifierFromClaimInfo, logger, makeLogger, uint8ArrayToStr } from "../utils/index.js";
-async function handleIncomingMessage(data) {
-  let id = "";
-  try {
-    const req = typeof data === "string" ? JSON.parse(data, B64_JSON_REVIVER) : data;
-    id = req.id || "";
-    const rslt = await _handleIncomingMessage(req);
-    if (!rslt) {
-      return;
-    }
-    respond(rslt);
-  } catch (err) {
-    console.error("Error in RPC", { id, error: err });
-    respond({
-      type: "error",
-      data: {
-        message: err.message,
-        stack: err.stack
-      }
-    });
-  }
-  function respond(data2) {
-    const res = {
-      ...data2,
-      id,
-      isResponse: true
-    };
-    return sendMessageToApp(res);
-  }
-}
-async function _handleIncomingMessage(req) {
-  const { id: reqId, type: reqType } = req;
-  if (!reqId || !reqType) {
-    return;
-  }
-  RPC_MSG_BRIDGE.dispatch(req);
-  if ("isResponse" in req && req.isResponse) {
-    return;
-  }
-  if (!reqId) {
-    logger.warn({ req }, "Window RPC request missing ID");
-    return;
-  }
-  logger.info({ req }, "processing RPC request");
-  switch (req.type) {
-    case "createClaim":
-      const claimTunnelRes = await createClaimOnAttestor({
-        ...req.request,
-        context: req.request.context ? JSON.parse(req.request.context) : void 0,
-        zkOperators: getZkOperators(
-          req.request.zkOperatorMode,
-          req.request.zkEngine
-        ),
-        oprfOperators: getOprfOperators(
-          req.request.zkOperatorMode,
-          req.request.zkEngine
-        ),
-        client: {
-          url: getWsApiUrlFromBaseUrl(),
-          authRequest: req.request.authRequest
-        },
-        logger,
-        onStep(step) {
-          sendMessageToApp({
-            type: "createClaimStep",
-            step: { name: "attestor-progress", step },
-            id: req.id
-          });
-        },
-        updateProviderParams: req.request.updateProviderParams ? updateProviderParams : void 0
-      });
-      const response = mapToCreateClaimResponse(claimTunnelRes);
-      return { type: "createClaimDone", response };
-    case "createClaimOnAvs":
-      const avsRes = await createClaimOnAvs({
-        ...req.request,
-        payer: req.request.payer === "attestor" ? { attestor: getWsApiUrlFromBaseUrl() } : void 0,
-        context: req.request.context ? JSON.parse(req.request.context) : void 0,
-        zkOperators: getZkOperators(
-          req.request.zkOperatorMode,
-          req.request.zkEngine
-        ),
-        oprfOperators: getOprfOperators(
-          req.request.zkOperatorMode,
-          req.request.zkEngine
-        ),
-        logger,
-        onStep(step) {
-          sendMessageToApp({
-            type: "createClaimOnAvsStep",
-            step,
-            id: req.id
-          });
-        }
-      });
-      return {
-        type: "createClaimOnAvsDone",
-        response: avsRes
-      };
-    case "createClaimOnMechain":
-      const mechainRes = await createClaimOnMechain({
-        ...req.request,
-        context: req.request.context ? JSON.parse(req.request.context) : void 0,
-        zkOperators: getZkOperators(
-          req.request.zkOperatorMode,
-          req.request.zkEngine
-        ),
-        oprfOperators: getOprfOperators(
-          req.request.zkOperatorMode,
-          req.request.zkEngine
-        ),
-        client: { url: getWsApiUrlFromBaseUrl() },
-        logger,
-        onStep(step) {
-          sendMessageToApp({
-            type: "createClaimOnMechainStep",
-            step,
-            id: req.id
-          });
-        }
-      });
-      const claimResponses = [];
-      for (let i = 0; i < mechainRes.responses.length; i++) {
-        claimResponses[i] = mapToCreateClaimResponse(mechainRes.responses[i]);
-      }
-      return {
-        type: "createClaimOnMechainDone",
-        response: { taskId: mechainRes.taskId, data: claimResponses }
-      };
-    case "extractHtmlElement":
-      return {
-        type: "extractHtmlElementDone",
-        response: extractHTMLElement(
-          req.request.html,
-          req.request.xpathExpression,
-          req.request.contentsOnly
-        )
-      };
-    case "extractJSONValueIndex":
-      return {
-        type: "extractJSONValueIndexDone",
-        response: extractJSONValueIndex(
-          req.request.json,
-          req.request.jsonPath
-        )
-      };
-    case "getCurrentMemoryUsage":
-      return {
-        type: "getCurrentMemoryUsageDone",
-        response: await getCurrentMemoryUsage()
-      };
-    case "setLogLevel":
-      makeLogger(
-        true,
-        req.request.logLevel,
-        req.request.sendLogsToApp ? (level, message) => sendMessageToApp({
-          type: "log",
-          level,
-          message,
-          id: req.id
-        }) : void 0
-      );
-      return { type: "setLogLevelDone", response: void 0 };
-    case "benchmarkZK":
-      return { type: "benchmarkZKDone", response: await benchmark() };
-    case "ping":
-      return { type: "pingDone", response: { pong: (/* @__PURE__ */ new Date()).toJSON() } };
-    default:
-      break;
-  }
-}
-function getZkOperators(mode = "default", zkEngine = "snarkjs") {
-  if (mode === "default") {
-    return;
-  }
-  const operators = {};
-  for (const alg of ALL_ENC_ALGORITHMS) {
-    operators[alg] = makeExternalRpcZkOperator(alg, zkEngine);
-  }
-  return operators;
-}
-function getOprfOperators(mode = "default", zkEngine = "snarkjs") {
-  if (mode === "default") {
-    return;
-  }
-  const operators = {};
-  for (const alg of ALL_ENC_ALGORITHMS) {
-    operators[alg] = makeExternalRpcOprfOperator(alg, zkEngine);
-  }
-  return operators;
-}
-async function updateProviderParams(transcript, tlsVersion) {
-  const { req, res } = generateRequstAndResponseFromTranscript(
-    transcript,
-    tlsVersion
-  );
-  const id = generateRpcRequestId();
-  const waitForRes = waitForResponse("updateProviderParams", id);
-  sendMessageToApp({
-    type: "updateProviderParams",
-    id,
-    request: {
-      request: {
-        ...req,
-        body: req.body ? uint8ArrayToStr(req.body) : void 0
-      },
-      response: { ...res, body: uint8ArrayToStr(res.body) }
-    }
-  });
-  return waitForRes;
-}
-function mapToCreateClaimResponse(res) {
-  if (!res.claim) {
-    throw AttestorError.fromProto(res.error);
-  }
-  return {
-    identifier: getIdentifierFromClaimInfo(res.claim),
-    claimData: res.claim,
-    witnesses: [
-      {
-        id: res.signatures.attestorAddress,
-        url: getWsApiUrlFromBaseUrl()
-      }
-    ],
-    signatures: [
-      hexlify(res.signatures.claimSignature).toLowerCase()
-    ]
-  };
-}
-export {
-  handleIncomingMessage
-};

package/lib/external-rpc/jsc-polyfills/1.js

@@ -1,80 +0,0 @@
-import { TextDecoder, TextEncoder } from "@kayahr/text-encoding";
-import { crypto, uint8ArrayToBinaryStr } from "../../utils/tls-imports.js";
-import { fromByteArray, toByteArray } from "base64-js";
-import { EventTarget } from "event-target-shim";
-if (typeof global === "undefined") {
-  globalThis.global = globalThis;
-}
-if (typeof console === "undefined") {
-  globalThis.console = {
-    log: print,
-    error: print,
-    warn: print,
-    info: print,
-    debug: print
-  };
-}
-if (typeof globalThis.crypto === "undefined") {
-  globalThis.crypto = {
-    // @ts-expect-error
-    getRandomValues(arr) {
-      const randVals = crypto.randomBytes(arr.length);
-      for (let i = 0; i < arr.length; i++) {
-        arr[i] = randVals[i];
-      }
-      return arr;
-    },
-    randomBytes(length) {
-      return crypto.randomBytes(length);
-    }
-  };
-}
-if (typeof globalThis.TextEncoder === "undefined") {
-  globalThis.TextEncoder = TextEncoder;
-}
-if (typeof globalThis.TextDecoder === "undefined") {
-  globalThis.TextDecoder = TextDecoder;
-}
-if (typeof globalThis.EventTarget === "undefined") {
-  globalThis.EventTarget = EventTarget;
-}
-if (typeof globalThis.atob === "undefined") {
-  globalThis.atob = (a) => uint8ArrayToBinaryStr(toByteArray(a));
-}
-if (typeof globalThis.btoa === "undefined") {
-  let binaryStringToUint8Array = function(binaryString) {
-    const uint8Array = new Uint8Array(binaryString.length);
-    for (let i = 0; i < binaryString.length; i++) {
-      uint8Array[i] = binaryString.charCodeAt(i);
-    }
-    return uint8Array;
-  };
-  globalThis.btoa = (b) => fromByteArray(binaryStringToUint8Array(b));
-}
-if (typeof globalThis.clearTimeout === "undefined") {
-  const ogSettimeout = globalThis.setTimeout;
-  if (!ogSettimeout) {
-    throw new Error("setTimeout is not defined, no polyfill yet");
-  }
-  globalThis.setTimeout = (fn, delayMs, ...args) => {
-    let aborted = false;
-    const abortableFn = (...args2) => {
-      if (aborted) {
-        return;
-      }
-      return fn(...args2);
-    };
-    const val = ogSettimeout(abortableFn, delayMs, ...args);
-    return {
-      original: val,
-      abort() {
-        aborted = true;
-      }
-    };
-  };
-  globalThis.clearTimeout = (id) => {
-    if (typeof id === "object" && !!id && "abort" in id) {
-      id.abort();
-    }
-  };
-}