@cofhe/sdk 0.0.0-alpha-20260409113701

package/dist/web.d.cts

@@ -0,0 +1,42 @@
+import { I as IStorage, C as CofheInputConfig, a as CofheConfig, b as CofheClient, E as EncryptableItem } from './clientTypes-AVSCBet7.cjs';
+import 'viem';
+import './types-YiAC4gig.cjs';
+import 'zod';
+import './permit-jRirYqFt.cjs';
+import 'zustand/vanilla';
+
+declare function createSsrStorage(): IStorage;
+
+/**
+ * Terminate the worker
+ */
+declare function terminateWorker(): void;
+/**
+ * Check if workers are available
+ */
+declare function areWorkersAvailable(): boolean;
+
+declare const hasDOM: boolean;
+
+/**
+ * Creates a CoFHE configuration for web with IndexedDB storage as default
+ * @param config - The CoFHE input configuration (fheKeyStorage will default to IndexedDB if not provided)
+ * @returns The CoFHE configuration with web defaults applied
+ */
+declare function createCofheConfig(config: CofheInputConfig): CofheConfig;
+/**
+ * Creates a CoFHE client instance for web with TFHE automatically configured
+ * TFHE will be initialized automatically on first encryption - no manual setup required
+ * Workers are automatically enabled if available (can be disabled via config.useWorkers)
+ * @param config - The CoFHE configuration (use createCofheConfig to create with web defaults)
+ * @returns The CoFHE client instance
+ */
+declare function createCofheClient<TConfig extends CofheConfig>(config: TConfig): CofheClient<TConfig>;
+
+/**
+ * Test helper: Create a client with custom worker function (for testing fallback behavior)
+ * @internal - Only for testing purposes
+ */
+declare function createCofheClientWithCustomWorker(config: CofheConfig, customZkProveWorkerFn: (fheKeyHex: string, crsHex: string, items: EncryptableItem[], metadata: Uint8Array) => Promise<Uint8Array>): CofheClient;
+
+export { areWorkersAvailable, createCofheClient, createCofheClientWithCustomWorker, createCofheConfig, createSsrStorage, hasDOM, terminateWorker };

package/dist/web.d.ts

@@ -0,0 +1,42 @@
+import { I as IStorage, C as CofheInputConfig, a as CofheConfig, b as CofheClient, E as EncryptableItem } from './clientTypes-flH1ju82.js';
+import 'viem';
+import './types-YiAC4gig.js';
+import 'zod';
+import './permit-jRirYqFt.js';
+import 'zustand/vanilla';
+
+declare function createSsrStorage(): IStorage;
+
+/**
+ * Terminate the worker
+ */
+declare function terminateWorker(): void;
+/**
+ * Check if workers are available
+ */
+declare function areWorkersAvailable(): boolean;
+
+declare const hasDOM: boolean;
+
+/**
+ * Creates a CoFHE configuration for web with IndexedDB storage as default
+ * @param config - The CoFHE input configuration (fheKeyStorage will default to IndexedDB if not provided)
+ * @returns The CoFHE configuration with web defaults applied
+ */
+declare function createCofheConfig(config: CofheInputConfig): CofheConfig;
+/**
+ * Creates a CoFHE client instance for web with TFHE automatically configured
+ * TFHE will be initialized automatically on first encryption - no manual setup required
+ * Workers are automatically enabled if available (can be disabled via config.useWorkers)
+ * @param config - The CoFHE configuration (use createCofheConfig to create with web defaults)
+ * @returns The CoFHE client instance
+ */
+declare function createCofheClient<TConfig extends CofheConfig>(config: TConfig): CofheClient<TConfig>;
+
+/**
+ * Test helper: Create a client with custom worker function (for testing fallback behavior)
+ * @internal - Only for testing purposes
+ */
+declare function createCofheClientWithCustomWorker(config: CofheConfig, customZkProveWorkerFn: (fheKeyHex: string, crsHex: string, items: EncryptableItem[], metadata: Uint8Array) => Promise<Uint8Array>): CofheClient;
+
+export { areWorkersAvailable, createCofheClient, createCofheClientWithCustomWorker, createCofheConfig, createSsrStorage, hasDOM, terminateWorker };

package/dist/web.js

@@ -0,0 +1,256 @@
+import { createCofheConfigBase, createCofheClientBase, fheTypeToString } from './chunk-36FBWLUS.js';
+import './chunk-TBLR7NNE.js';
+import './chunk-7HLGHV67.js';
+import { constructClient } from 'iframe-shared-storage';
+import init, { init_panic_hook, TfheCompactPublicKey, CompactPkeCrs, ProvenCompactCiphertextList } from 'tfhe';
+
+// web/const.ts
+var hasDOM = typeof globalThis?.document !== "undefined" && typeof globalThis?.window !== "undefined";
+
+// web/storage.ts
+var createWebStorage = (opts = { enableLog: false }) => {
+  if (!hasDOM)
+    throw new Error("createWebStorage can only be used in a browser environment");
+  const client = constructClient({
+    iframe: {
+      src: "https://iframe-shared-storage.vercel.app/hub.html",
+      messagingOptions: {
+        enableLog: opts.enableLog ? "both" : void 0
+      },
+      iframeReadyTimeoutMs: 3e4,
+      // if the iframe is not initied during this interval AND a reuqest is made, such request will throw an error
+      methodCallTimeoutMs: 1e4,
+      // if a method call is not answered during this interval, the call will throw an error
+      methodCallRetries: 3
+      // number of retries for a method call if it times out
+    }
+  });
+  const indexedDBKeyval = client.indexedDBKeyval;
+  return {
+    getItem: async (name) => {
+      return await indexedDBKeyval.get(name) ?? null;
+    },
+    setItem: async (name, value) => {
+      await indexedDBKeyval.set(name, value);
+    },
+    removeItem: async (name) => {
+      await indexedDBKeyval.del(name);
+    }
+  };
+};
+function createSsrStorage() {
+  console.warn("using no-op server-side SSR storage");
+  return {
+    getItem: async () => null,
+    setItem: async () => {
+    },
+    removeItem: async () => {
+    }
+  };
+}
+
+// web/workerManager.ts
+var ZkProveWorkerManager = class {
+  worker = null;
+  pendingRequests = /* @__PURE__ */ new Map();
+  requestCounter = 0;
+  workerReady = false;
+  initializationPromise = null;
+  /**
+   * Initialize the worker
+   */
+  async initializeWorker() {
+    if (this.worker && this.workerReady) {
+      return;
+    }
+    if (this.initializationPromise) {
+      return this.initializationPromise;
+    }
+    this.initializationPromise = new Promise((resolve, reject) => {
+      try {
+        if (typeof Worker === "undefined") {
+          reject(new Error("Web Workers not supported"));
+          return;
+        }
+        try {
+          this.worker = new Worker(new URL("./zkProve.worker.js", import.meta.url), { type: "module" });
+        } catch (error) {
+          reject(new Error(`Failed to create worker: ${error}`));
+          return;
+        }
+        this.worker.onmessage = (event) => {
+          const { id, type, result, error } = event.data;
+          if (type === "ready") {
+            this.workerReady = true;
+            resolve();
+            return;
+          }
+          const pending = this.pendingRequests.get(id);
+          if (!pending) {
+            console.warn("[Worker Manager] Received response for unknown request:", id);
+            return;
+          }
+          clearTimeout(pending.timeoutId);
+          this.pendingRequests.delete(id);
+          if (type === "success" && result) {
+            pending.resolve(new Uint8Array(result));
+          } else if (type === "error") {
+            pending.reject(new Error(error || "Worker error"));
+          } else {
+            pending.reject(new Error("Invalid response from worker"));
+          }
+        };
+        this.worker.onerror = (error) => {
+          console.error("[Worker Manager] Worker error event:", error);
+          console.error("[Worker Manager] Error message:", error.message);
+          console.error("[Worker Manager] Error filename:", error.filename);
+          console.error("[Worker Manager] Error lineno:", error.lineno);
+          if (!this.workerReady) {
+            reject(new Error(`Worker failed to initialize: ${error.message || "Unknown error"}`));
+          }
+          this.pendingRequests.forEach(({ reject: reject2, timeoutId }) => {
+            clearTimeout(timeoutId);
+            reject2(new Error("Worker encountered an error"));
+          });
+          this.pendingRequests.clear();
+        };
+        setTimeout(() => {
+          if (!this.workerReady) {
+            reject(new Error("Worker initialization timeout"));
+          }
+        }, 5e3);
+      } catch (error) {
+        reject(error);
+      }
+    });
+    return this.initializationPromise;
+  }
+  /**
+   * Submit a proof generation request to the worker
+   */
+  async submitProof(fheKeyHex, crsHex, items, metadata) {
+    await this.initializeWorker();
+    const id = `zkprove-${Date.now()}-${this.requestCounter++}`;
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        this.pendingRequests.delete(id);
+        reject(new Error("Worker request timeout (30s)"));
+      }, 3e4);
+      this.pendingRequests.set(id, { resolve, reject, timeoutId });
+      const message = {
+        id,
+        type: "zkProve",
+        fheKeyHex,
+        crsHex,
+        items,
+        metadata: Array.from(metadata)
+      };
+      this.worker.postMessage(message);
+    });
+  }
+  /**
+   * Terminate the worker and clean up
+   */
+  terminate() {
+    if (this.worker) {
+      this.worker.terminate();
+      this.worker = null;
+      this.workerReady = false;
+      this.initializationPromise = null;
+    }
+    this.pendingRequests.forEach(({ reject, timeoutId }) => {
+      clearTimeout(timeoutId);
+      reject(new Error("Worker terminated"));
+    });
+    this.pendingRequests.clear();
+  }
+  /**
+   * Check if worker is available
+   */
+  isAvailable() {
+    return typeof Worker !== "undefined";
+  }
+};
+var workerManager = null;
+function getWorkerManager() {
+  if (!workerManager) {
+    workerManager = new ZkProveWorkerManager();
+  }
+  return workerManager;
+}
+function terminateWorker() {
+  if (workerManager) {
+    workerManager.terminate();
+    workerManager = null;
+  }
+}
+function areWorkersAvailable() {
+  return typeof Worker !== "undefined";
+}
+var tfheInitialized = false;
+async function initTfhe() {
+  if (tfheInitialized)
+    return false;
+  await init();
+  await init_panic_hook();
+  tfheInitialized = true;
+  return true;
+}
+var fromHexString = (hexString) => {
+  const cleanString = hexString.length % 2 === 1 ? `0${hexString}` : hexString;
+  const arr = cleanString.replace(/^0x/, "").match(/.{1,2}/g);
+  if (!arr)
+    return new Uint8Array();
+  return new Uint8Array(arr.map((byte) => parseInt(byte, 16)));
+};
+var tfhePublicKeyDeserializer = (buff) => {
+  TfheCompactPublicKey.deserialize(fromHexString(buff));
+};
+var compactPkeCrsDeserializer = (buff) => {
+  CompactPkeCrs.deserialize(fromHexString(buff));
+};
+var zkBuilderAndCrsGenerator = (fhe, crs) => {
+  const fhePublicKey = TfheCompactPublicKey.deserialize(fromHexString(fhe));
+  const zkBuilder = ProvenCompactCiphertextList.builder(fhePublicKey);
+  const zkCrs = CompactPkeCrs.deserialize(fromHexString(crs));
+  return { zkBuilder, zkCrs };
+};
+async function zkProveWithWorker(fheKeyHex, crsHex, items, metadata) {
+  const serializedItems = items.map((item) => ({
+    utype: fheTypeToString(item.utype),
+    data: typeof item.data === "bigint" ? item.data.toString() : item.data
+  }));
+  const workerManager2 = getWorkerManager();
+  return await workerManager2.submitProof(fheKeyHex, crsHex, serializedItems, metadata);
+}
+function createCofheConfig(config) {
+  return createCofheConfigBase({
+    environment: "web",
+    ...config,
+    fheKeyStorage: config.fheKeyStorage === null ? null : config.fheKeyStorage ?? (hasDOM ? createWebStorage() : createSsrStorage())
+  });
+}
+function createCofheClient(config) {
+  return createCofheClientBase({
+    config,
+    zkBuilderAndCrsGenerator,
+    tfhePublicKeyDeserializer,
+    compactPkeCrsDeserializer,
+    initTfhe,
+    // Always provide the worker function if available - config.useWorkers controls usage
+    // areWorkersAvailable will return true if the Worker API is available and false in Node.js
+    zkProveWorkerFn: areWorkersAvailable() ? zkProveWithWorker : void 0
+  });
+}
+function createCofheClientWithCustomWorker(config, customZkProveWorkerFn) {
+  return createCofheClientBase({
+    config,
+    zkBuilderAndCrsGenerator,
+    tfhePublicKeyDeserializer,
+    compactPkeCrsDeserializer,
+    initTfhe,
+    zkProveWorkerFn: customZkProveWorkerFn
+  });
+}
+
+export { areWorkersAvailable, createCofheClient, createCofheClientWithCustomWorker, createCofheConfig, createSsrStorage, hasDOM, terminateWorker };

package/dist/zkProve.worker.cjs

@@ -0,0 +1,93 @@
+'use strict';
+
+// web/zkProve.worker.ts
+var tfheModule = null;
+var initialized = false;
+async function initTfhe() {
+  if (initialized)
+    return;
+  try {
+    tfheModule = await import('tfhe');
+    await tfheModule.default();
+    await tfheModule.init_panic_hook();
+    initialized = true;
+    console.log("[Worker] TFHE initialized");
+  } catch (error) {
+    console.error("[Worker] Failed to initialize TFHE:", error);
+    throw error;
+  }
+}
+function fromHexString(hexString) {
+  const cleanString = hexString.length % 2 === 1 ? `0${hexString}` : hexString;
+  const arr = cleanString.replace(/^0x/, "").match(/.{1,2}/g);
+  if (!arr)
+    return new Uint8Array();
+  return new Uint8Array(arr.map((byte) => parseInt(byte, 16)));
+}
+self.onmessage = async (event) => {
+  const { id, type, fheKeyHex, crsHex, items, metadata } = event.data;
+  if (type !== "zkProve") {
+    self.postMessage({
+      id,
+      type: "error",
+      error: "Invalid message type"
+    });
+    return;
+  }
+  try {
+    await initTfhe();
+    if (!tfheModule) {
+      throw new Error("TFHE module not initialized");
+    }
+    const fheKeyBytes = fromHexString(fheKeyHex);
+    const crsBytes = fromHexString(crsHex);
+    const fheKey = tfheModule.TfheCompactPublicKey.deserialize(fheKeyBytes);
+    const crs = tfheModule.CompactPkeCrs.deserialize(crsBytes);
+    const builder = tfheModule.ProvenCompactCiphertextList.builder(fheKey);
+    for (const item of items) {
+      switch (item.utype) {
+        case "bool":
+          builder.push_boolean(Boolean(item.data));
+          break;
+        case "uint8":
+          builder.push_u8(Number(item.data));
+          break;
+        case "uint16":
+          builder.push_u16(Number(item.data));
+          break;
+        case "uint32":
+          builder.push_u32(Number(item.data));
+          break;
+        case "uint64":
+          builder.push_u64(BigInt(item.data));
+          break;
+        case "uint128":
+          builder.push_u128(BigInt(item.data));
+          break;
+        case "uint160":
+          builder.push_u160(BigInt(item.data));
+          break;
+        default:
+          throw new Error(`Unsupported type: ${item.utype}`);
+      }
+    }
+    const metadataBytes = new Uint8Array(metadata);
+    const compactList = builder.build_with_proof_packed(crs, metadataBytes, 1);
+    const result = compactList.serialize();
+    self.postMessage({
+      id,
+      type: "success",
+      result: Array.from(result)
+    });
+  } catch (error) {
+    self.postMessage({
+      id,
+      type: "error",
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+};
+self.postMessage({
+  id: "init",
+  type: "ready"
+});

package/dist/zkProve.worker.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/zkProve.worker.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/zkProve.worker.js

@@ -0,0 +1,91 @@
+// web/zkProve.worker.ts
+var tfheModule = null;
+var initialized = false;
+async function initTfhe() {
+  if (initialized)
+    return;
+  try {
+    tfheModule = await import('tfhe');
+    await tfheModule.default();
+    await tfheModule.init_panic_hook();
+    initialized = true;
+    console.log("[Worker] TFHE initialized");
+  } catch (error) {
+    console.error("[Worker] Failed to initialize TFHE:", error);
+    throw error;
+  }
+}
+function fromHexString(hexString) {
+  const cleanString = hexString.length % 2 === 1 ? `0${hexString}` : hexString;
+  const arr = cleanString.replace(/^0x/, "").match(/.{1,2}/g);
+  if (!arr)
+    return new Uint8Array();
+  return new Uint8Array(arr.map((byte) => parseInt(byte, 16)));
+}
+self.onmessage = async (event) => {
+  const { id, type, fheKeyHex, crsHex, items, metadata } = event.data;
+  if (type !== "zkProve") {
+    self.postMessage({
+      id,
+      type: "error",
+      error: "Invalid message type"
+    });
+    return;
+  }
+  try {
+    await initTfhe();
+    if (!tfheModule) {
+      throw new Error("TFHE module not initialized");
+    }
+    const fheKeyBytes = fromHexString(fheKeyHex);
+    const crsBytes = fromHexString(crsHex);
+    const fheKey = tfheModule.TfheCompactPublicKey.deserialize(fheKeyBytes);
+    const crs = tfheModule.CompactPkeCrs.deserialize(crsBytes);
+    const builder = tfheModule.ProvenCompactCiphertextList.builder(fheKey);
+    for (const item of items) {
+      switch (item.utype) {
+        case "bool":
+          builder.push_boolean(Boolean(item.data));
+          break;
+        case "uint8":
+          builder.push_u8(Number(item.data));
+          break;
+        case "uint16":
+          builder.push_u16(Number(item.data));
+          break;
+        case "uint32":
+          builder.push_u32(Number(item.data));
+          break;
+        case "uint64":
+          builder.push_u64(BigInt(item.data));
+          break;
+        case "uint128":
+          builder.push_u128(BigInt(item.data));
+          break;
+        case "uint160":
+          builder.push_u160(BigInt(item.data));
+          break;
+        default:
+          throw new Error(`Unsupported type: ${item.utype}`);
+      }
+    }
+    const metadataBytes = new Uint8Array(metadata);
+    const compactList = builder.build_with_proof_packed(crs, metadataBytes, 1);
+    const result = compactList.serialize();
+    self.postMessage({
+      id,
+      type: "success",
+      result: Array.from(result)
+    });
+  } catch (error) {
+    self.postMessage({
+      id,
+      type: "error",
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+};
+self.postMessage({
+  id: "init",
+  type: "ready"
+});

package/node/client.test.ts

@@ -0,0 +1,159 @@
+import { type CofheClient, CofheError, CofheErrorCode } from '@/core';
+import { arbSepolia as cofheArbSepolia } from '@/chains';
+
+import { describe, it, expect, beforeAll, beforeEach, vi } from 'vitest';
+import type { PublicClient, WalletClient } from 'viem';
+import { createPublicClient, createWalletClient, http } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import { arbitrumSepolia as viemArbitrumSepolia } from 'viem/chains';
+import { createCofheClient, createCofheConfig } from './index.js';
+
+// Real test setup - no mocks
+const TEST_PRIVATE_KEY = '0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80';
+const TEST_ACCOUNT = privateKeyToAccount(TEST_PRIVATE_KEY).address;
+
+describe('@cofhe/node - Client Integration Tests', () => {
+  let cofheClient: CofheClient;
+  let publicClient: PublicClient;
+  let walletClient: WalletClient;
+
+  beforeAll(() => {
+    // Create real viem clients
+    publicClient = createPublicClient({
+      chain: viemArbitrumSepolia,
+      transport: http(),
+    });
+
+    const account = privateKeyToAccount(TEST_PRIVATE_KEY);
+    walletClient = createWalletClient({
+      chain: viemArbitrumSepolia,
+      transport: http(),
+      account,
+    });
+  });
+
+  beforeEach(() => {
+    const config = createCofheConfig({
+      supportedChains: [cofheArbSepolia],
+    });
+    cofheClient = createCofheClient(config);
+  });
+
+  describe('Real Client Initialization', () => {
+    it('should create a client with real node-tfhe', () => {
+      expect(cofheClient).toBeDefined();
+      expect(cofheClient.config).toBeDefined();
+      expect(cofheClient.connected).toBe(false);
+    });
+
+    it('should automatically use filesystem storage as default', () => {
+      expect(cofheClient.config.fheKeyStorage).toBeDefined();
+      expect(cofheClient.config.fheKeyStorage).not.toBeNull();
+    });
+
+    it('should have all expected methods', () => {
+      expect(typeof cofheClient.connect).toBe('function');
+      expect(typeof cofheClient.encryptInputs).toBe('function');
+      expect(typeof cofheClient.decryptForView).toBe('function');
+      expect(typeof cofheClient.getSnapshot).toBe('function');
+      expect(typeof cofheClient.subscribe).toBe('function');
+    });
+  });
+
+  describe('Environment', () => {
+    it('should have the correct environment', () => {
+      expect(cofheClient.config.environment).toBe('node');
+    });
+  });
+
+  describe('Real Connection', () => {
+    it('should connect to real chain', async () => {
+      await cofheClient.connect(publicClient, walletClient);
+
+      expect(cofheClient.connected).toBe(true);
+
+      const snapshot = cofheClient.getSnapshot();
+      expect(snapshot.connected).toBe(true);
+      expect(snapshot.chainId).toBe(cofheArbSepolia.id);
+      expect(snapshot.account).toBe(TEST_ACCOUNT);
+    }, 30000);
+
+    it('should handle real network errors', async () => {
+      try {
+        await cofheClient.connect(
+          {
+            getChainId: vi.fn().mockRejectedValue(new Error('Network error')),
+          } as unknown as PublicClient,
+          walletClient
+        );
+      } catch (error) {
+        expect(error).toBeInstanceOf(CofheError);
+        expect((error as CofheError).code).toBe(CofheErrorCode.PublicWalletGetChainIdFailed);
+      }
+    }, 30000);
+  });
+
+  describe('State Management', () => {
+    it('should track connection state changes', async () => {
+      const states: any[] = [];
+      const unsubscribe = cofheClient.subscribe((snapshot) => {
+        states.push({ ...snapshot });
+      });
+
+      await cofheClient.connect(publicClient, walletClient);
+
+      unsubscribe();
+
+      expect(states.length).toBeGreaterThan(0);
+
+      // First state should be connecting
+      const firstState = states.find((s) => s.connecting);
+      expect(firstState).toBeDefined();
+      expect(firstState?.connecting).toBe(true);
+      expect(firstState?.connected).toBe(false);
+
+      // Last state should be connected
+      const lastState = states[states.length - 1];
+      expect(lastState.connected).toBe(true);
+      expect(lastState.connecting).toBe(false);
+      expect(lastState.chainId).toBe(cofheArbSepolia.id);
+    }, 30000);
+  });
+
+  describe('Builder Creation', () => {
+    it('should create encrypt builder after connection', async () => {
+      await cofheClient.connect(publicClient, walletClient);
+
+      const builder = cofheClient.encryptInputs([{ data: 100n, utype: 2, securityZone: 0 }]);
+
+      expect(builder).toBeDefined();
+      expect(typeof builder.setChainId).toBe('function');
+      expect(typeof builder.setAccount).toBe('function');
+      expect(typeof builder.setSecurityZone).toBe('function');
+      expect(typeof builder.execute).toBe('function');
+    }, 30000);
+
+    it('should create decrypt builder after connection', async () => {
+      await cofheClient.connect(publicClient, walletClient);
+
+      const builder = cofheClient.decryptForView('0x123', 2);
+
+      expect(builder).toBeDefined();
+      expect(typeof builder.setChainId).toBe('function');
+      expect(typeof builder.setAccount).toBe('function');
+      expect(typeof builder.onPoll).toBe('function');
+      expect(typeof builder.execute).toBe('function');
+    }, 30000);
+
+    it('should create decryptForTx builder after connection', async () => {
+      await cofheClient.connect(publicClient, walletClient);
+
+      const builder = cofheClient.decryptForTx('0x123');
+
+      expect(builder).toBeDefined();
+      expect(typeof builder.setChainId).toBe('function');
+      expect(typeof builder.setAccount).toBe('function');
+      expect(typeof builder.onPoll).toBe('function');
+    }, 30000);
+  });
+});