@sabaaa1/common 0.0.1

package/src/webworker/workerFactory.ts

@@ -0,0 +1,47 @@
+import { isNode, isSandbox } from '../constants/vite.constants';
+import { WorkerVariant } from './worker.registry';
+
+export class WorkerFactory {
+  private constructor() {
+    // This class should be use as static class
+  }
+
+  private static resolveWorkerURL = async (workerVariant: WorkerVariant) => {
+    const { getWorkerViteURL }: any = await import('./viteWorkerURL.constant');
+
+    // Should be implemented as function for correct prebuild for CDN work
+    const workerViteURL = await getWorkerViteURL();
+
+    return workerViteURL[workerVariant];
+  };
+
+  private static createWorker = async (workerVariant: WorkerVariant) => {
+    if (isNode || isSandbox) {
+      let workerProxy: any; // TODO: do typing
+      // const workerProxy = await import(/* @vite-ignore */ workerNodeURL[workerVariant]); The vite-ignore flag need to be inside the import() call; Basically tell vite it does not have too bundle the import;
+      if (workerVariant === WorkerVariant.SnarkJS)
+        workerProxy = await import(/* @vite-ignore */ './snarkjsWorker/snarkjsWorkerLogic');
+      else if (workerVariant === WorkerVariant.ZKProof)
+        workerProxy = await import(/* @vite-ignore */ './zkProofWorker/zkProofWorkerLogic');
+      else if (workerVariant === WorkerVariant.UTXO)
+        workerProxy = await import(/* @vite-ignore */ './utxoWorker/utxoWorkerLogic');
+      return workerProxy.default;
+    }
+
+    const workerUrl = await WorkerFactory.resolveWorkerURL(workerVariant);
+    return new Worker(workerUrl, { type: 'module' });
+  };
+
+  public static getWebWorker(workerVariant: WorkerVariant) {
+    switch (workerVariant) {
+      case WorkerVariant.ZKProof:
+        return WorkerFactory.createWorker(workerVariant);
+      case WorkerVariant.SnarkJS:
+        return WorkerFactory.createWorker(workerVariant);
+      case WorkerVariant.UTXO:
+        return WorkerFactory.createWorker(workerVariant);
+      default:
+        throw Error(`Unknown worker type: ${workerVariant}`);
+    }
+  }
+}

package/src/webworker/workerProxy.ts

@@ -0,0 +1,88 @@
+/**
+ * This class mimic interface of real Web Worker so it can be passed to code that expect normal web
+ * worker on browser side and operate as if it is the same, while executing the actual code on main
+ * thread when Node environment is detected.
+ *
+ * The reason we need this is because hardhat, at the time of writting (Mar 12, 2024), do not support
+ * ES Module worker with typescript. Enabling experimental ESM support for `ts-node` does not work
+ * across all machines and environment, thus, we decided to run the worker's logic on main thread
+ * during hardhat step.
+ */
+export class WorkerProxy {
+  private isNode = false;
+
+  private isSandbox = false;
+
+  /**
+   * This allow browser or main thread to listen for worker response message
+   * using the normal `worker.onmessage = () => {}` syntax. Is should only be side on the
+   * main thread side, not on worker side.
+   */
+  public onmessage: ((e: { data: any }) => void) | null = null;
+
+  /**
+   * This allow browser or main thread to listen for worker response message
+   * using the normal `worker.onerror = () => {}` syntax. Is should only be side on the
+   * main thread side, not on worker side.
+   */
+  public onerror: ((e: { data: { error: unknown } }) => void) | null = null;
+
+  private _eventEmitter: any; // node EventEmitter
+
+  private get eventEmitter() {
+    if (this._eventEmitter) {
+      return this._eventEmitter;
+    }
+    if (this.isNode) {
+      // eslint-disable-next-line global-require, @typescript-eslint/no-var-requires
+      const EventEmitter = require('events');
+      this._eventEmitter = new EventEmitter();
+    } else {
+      this._eventEmitter = new EventTarget();
+    }
+    return this._eventEmitter;
+  }
+
+  public constructor() {
+    this.isNode = typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
+    this.isSandbox = typeof window !== 'undefined' && window.origin === 'null';
+  }
+
+  public terminate() {}
+
+  public postMessage(message: unknown) {
+    if (this.isNode) {
+      this.eventEmitter.emit('message', message);
+    } else if (this.isSandbox) {
+      this.eventEmitter?.dispatchEvent(new CustomEvent('worker-message', { detail: message }));
+    } else {
+      postMessage(message);
+    }
+  }
+
+  public postMessageToMainThread(message: unknown) {
+    const event = { data: message };
+    if (this.onmessage) {
+      this.onmessage(event);
+    } else postMessage(message);
+  }
+
+  public postErrorToMainThread(error: unknown) {
+    const event = { data: { error } };
+    if (this.onerror) {
+      this.onerror(event);
+    } else postMessage(error);
+  }
+
+  public attachWorkerSideOnMessage(fn: (e: any) => void | Promise<void>) {
+    if (this.isNode) {
+      this.eventEmitter.on('message', (message: any) => {
+        fn(message);
+      });
+    } else if (this.isSandbox) {
+      this.eventEmitter.addEventListener('worker-message', (message: any) => {
+        fn(message.detail);
+      });
+    }
+  }
+}

package/src/webworker/zkProofWorker/zkProofWorker.types.ts

@@ -0,0 +1,52 @@
+import { IUtxoConstructor } from '../../data-structures/utxo/Utxo';
+import { type MerkleTreeJson } from '../../data-structures/merkle-tree';
+import { WorkerParams, WorkerPayload } from '../worker.types';
+import { ProverVersion } from '../../types/hinkal.types';
+
+export enum ZKProofWorkerActionType {
+  CALC_COMMITMENTS_SIBLING_AND_SIDES,
+  CALC_ACCESS_TOKEN_SIBLING_AND_SIDES,
+  BUILD_IN_NULLIFIERS,
+}
+
+export interface ZKProofWorkerCalcCommitmentsPayload
+  extends WorkerPayload<{
+    inputUtxosSerialized: IUtxoConstructor[][];
+    merkleTreeSerialized: MerkleTreeJson;
+    userSignature: string;
+  }> {
+  type: ZKProofWorkerActionType.CALC_COMMITMENTS_SIBLING_AND_SIDES;
+}
+export interface ZKProofWorkerCalcCommitmentsReturn {
+  inCommitmentSiblings: string[][][];
+  inCommitmentSiblingSides: string[][][];
+}
+
+export interface ZKProofWorkerCalcAccessTokenPayload
+  extends WorkerPayload<{
+    merkleTreeAccessTokenSerialized: MerkleTreeJson;
+    userSignature: string;
+  }> {
+  type: ZKProofWorkerActionType.CALC_ACCESS_TOKEN_SIBLING_AND_SIDES;
+}
+export interface ZKProofWorkerCalcAccessTokenReturn {
+  accessTokenSiblings: string[];
+  accessTokenSiblingSides: string[];
+}
+
+export interface ZKProofWorkerBuildInNullifiersPayload
+  extends WorkerPayload<{
+    inputUtxosSerialized: IUtxoConstructor[][];
+    onChainCreation: boolean[];
+    proverVersion: ProverVersion;
+  }> {
+  type: ZKProofWorkerActionType.BUILD_IN_NULLIFIERS;
+}
+export type ZKProofWorkerBuildInNullifiersReturn = string[][];
+
+export type ZKProofWorkerPayload =
+  | ZKProofWorkerCalcCommitmentsPayload
+  | ZKProofWorkerCalcAccessTokenPayload
+  | ZKProofWorkerBuildInNullifiersPayload;
+
+export type ZKProofWorkerParams = WorkerParams<ZKProofWorkerPayload>;

package/src/webworker/zkProofWorker/zkProofWorkerLauncher.ts

@@ -0,0 +1,19 @@
+import { Buffer } from 'buffer';
+import process from 'process';
+import { addWorkerErrorHandler } from '../workerErrorHandler';
+import { ZKProofWorkerParams } from './zkProofWorker.types';
+
+globalThis.process = process;
+globalThis.Buffer = Buffer;
+
+// This set up is needed because imports in logic file need
+// globalThis.process and globalThis.Buffer to be declared first.
+const zkProofWorker = import('./zkProofWorkerLogic');
+
+// eslint-disable-next-line no-restricted-globals
+addEventListener('message', async (e: MessageEvent<unknown>) => {
+  const { onWorkerMessage } = await zkProofWorker;
+  onWorkerMessage(e.data as ZKProofWorkerParams);
+});
+
+addWorkerErrorHandler();

package/src/webworker/zkProofWorker/zkProofWorkerLogic.ts

@@ -0,0 +1,84 @@
+import { preProcessing } from '../../crypto/preProcessing';
+import { UserKeys } from '../../data-structures/crypto-keys/keys';
+import { IUtxoConstructor, Utxo } from '../../data-structures/utxo/Utxo';
+import {
+  calcAccessTokenSiblingsAndSides,
+  calcCommitmentsSiblingAndSides,
+} from '../../functions/snarkjs/common.snarkjs';
+import { WorkerProxy } from '../workerProxy';
+import {
+  ZKProofWorkerActionType,
+  ZKProofWorkerBuildInNullifiersPayload,
+  ZKProofWorkerCalcAccessTokenPayload,
+  ZKProofWorkerCalcCommitmentsPayload,
+  ZKProofWorkerParams,
+} from './zkProofWorker.types';
+import { contructMerkleTreeFromSerialized } from '../../functions/utils/merkleTree.utils';
+
+const workerProxy = new WorkerProxy();
+
+export const handleCalcCommitmentsSiblingAndSides = (payload: ZKProofWorkerCalcCommitmentsPayload) => {
+  const { inputUtxosSerialized, merkleTreeSerialized } = payload.data;
+
+  const merkleTree = contructMerkleTreeFromSerialized(merkleTreeSerialized);
+
+  const inputUtxos = inputUtxosSerialized.map((utxoList: IUtxoConstructor[]) =>
+    utxoList.map((serializedUtxo) => new Utxo(serializedUtxo)),
+  );
+
+  const { inCommitmentSiblings, inCommitmentSiblingSides } = calcCommitmentsSiblingAndSides(inputUtxos, merkleTree);
+  workerProxy.postMessageToMainThread({ inCommitmentSiblings, inCommitmentSiblingSides });
+};
+
+export const handleCalcAccessTokenSiblingAndSides = (payload: ZKProofWorkerCalcAccessTokenPayload) => {
+  const { userSignature, merkleTreeAccessTokenSerialized } = payload.data;
+  const userKeys = new UserKeys(userSignature);
+
+  const merkleTree = contructMerkleTreeFromSerialized(merkleTreeAccessTokenSerialized);
+
+  const { accessTokenSiblings, accessTokenSiblingSides } = calcAccessTokenSiblingsAndSides(userKeys, merkleTree);
+  workerProxy.postMessageToMainThread({ accessTokenSiblings, accessTokenSiblingSides });
+};
+
+export const handleBuildInNullifiers = (payload: ZKProofWorkerBuildInNullifiersPayload) => {
+  const { inputUtxosSerialized, onChainCreation, proverVersion } = payload.data;
+  const inputUtxos = inputUtxosSerialized.map((utxoList: IUtxoConstructor[]) =>
+    utxoList.map((serializedUtxo) => new Utxo(serializedUtxo)),
+  );
+  let result: string[][] = [];
+  if (proverVersion === 'v1x0') {
+    result = inputUtxos.map((token, index) =>
+      token.map((utxo) => (onChainCreation[index] ? '0' : utxo.getNullifier())),
+    );
+  } else {
+    result = inputUtxos.map((token) => token.map((utxo) => (utxo.amount === 0n ? '0' : utxo.getNullifier())));
+  }
+
+  workerProxy.postMessageToMainThread(result);
+};
+
+export const onWorkerMessage = async (data: ZKProofWorkerParams) => {
+  try {
+    await preProcessing();
+    const { type } = data.payload;
+    switch (type) {
+      case ZKProofWorkerActionType.CALC_COMMITMENTS_SIBLING_AND_SIDES:
+        handleCalcCommitmentsSiblingAndSides(data.payload);
+        return;
+      case ZKProofWorkerActionType.CALC_ACCESS_TOKEN_SIBLING_AND_SIDES:
+        handleCalcAccessTokenSiblingAndSides(data.payload);
+        return;
+      case ZKProofWorkerActionType.BUILD_IN_NULLIFIERS:
+        handleBuildInNullifiers(data.payload);
+        return;
+      default:
+        throw Error(`Unknown worker message type ${type}`);
+    }
+  } catch (err) {
+    console.error(err);
+    workerProxy.postErrorToMainThread(err);
+  }
+};
+
+workerProxy.attachWorkerSideOnMessage(onWorkerMessage);
+export default workerProxy;

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "compilerOptions": {
+    "declaration": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "noImplicitOverride": true,
+    "noPropertyAccessFromIndexSignature": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "allowSyntheticDefaultImports": true
+  },
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ]
+}

package/tsconfig.lib.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../../dist/libs/shared/common",
+    "declaration": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["jest.config.ts", "src/**/*.spec.ts", "src/**/*.test.ts"]
+}

package/tsconfig.spec.json

@@ -0,0 +1,15 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../../dist/out-tsc",
+    "module": "CommonJS",
+    "esModuleInterop": true,
+    "types": ["jest", "node"],
+    "baseUrl": ".",
+    "moduleResolution": "node",
+    "paths": {
+      "@hinkal/common": ["./src/index.ts"]
+    }
+  },
+  "include": ["jest.config.ts", "src/**/*.test.ts", "src/**/*.spec.ts", "src/**/*.d.ts"]
+}

package/vite.config.ts

@@ -0,0 +1,97 @@
+/* eslint-disable import/no-extraneous-dependencies */
+import { defineConfig, UserConfig } from 'vite';
+import type { InlineConfig } from 'vitest';
+import { nxViteTsPaths } from '@nx/vite/plugins/nx-tsconfig-paths.plugin';
+import dts from 'vite-plugin-dts';
+import path from 'path';
+import { polyfillConstants } from '../../../vite.common';
+import { copyPackage } from './copyPackageJson';
+import { dependencies, devDependencies, peerDependencies } from './package.json';
+type ViteConfig = UserConfig & { test: InlineConfig };
+
+const config: ViteConfig = {
+  root: __dirname,
+  base: './',
+
+  plugins: [
+    polyfillConstants(),
+    // TODO: needs to be decided if it is needed
+    // polyfillWorker(),
+    dts({
+      entryRoot: 'src',
+      tsconfigPath: path.join(__dirname, 'tsconfig.lib.json'),
+    }),
+    nxViteTsPaths(),
+    {
+      name: 'copy-package-json',
+      apply: 'build',
+      closeBundle: copyPackage,
+    },
+  ],
+
+  worker: {
+    format: 'es',
+    plugins: () => [polyfillConstants(), nxViteTsPaths()],
+  },
+
+  // Configuration for building your library.
+  // See: https://vitejs.dev/guide/build.html#library-mode
+  build: {
+    target: 'esnext', // Ensures the output targets the latest ESM features
+    outDir: '../../../dist/libs/shared/common',
+    reportCompressedSize: true,
+    commonjsOptions: { transformMixedEsModules: true },
+    emptyOutDir: true,
+    lib: {
+      // Could also be a dictionary or array of multiple entry points.
+      entry: [
+        'src/index.ts',
+        'src/providers/WagmiProviderAdapter.ts',
+        'src/providers/EthersProviderAdapter.ts',
+        'src/providers/prepareWagmiHinkal.ts',
+        'src/providers/prepareEthersHinkal.ts',
+      ],
+      name: 'shared-common',
+      fileName: (format, entryName) => `${entryName}.${format === 'cjs' ? 'cjs' : 'mjs'}`,
+      // Change this to the formats you want to support.
+      // Don't forgot to update your package.json as well.
+      formats: ['es', 'cjs'],
+    },
+    rollupOptions: {
+      output: {
+        preserveModules: true,
+        preserveModulesRoot: path.resolve(__dirname, './src'),
+      },
+      external: [
+        /^ethers/,
+        /^@wagmi/,
+        /^@walletconnect/,
+        /^@ethersproject/,
+        /^@hazae41/,
+        /^@brumewallet/,
+        /^@zkmelabs/,
+        /^@openzeppelin/,
+        ...Object.keys(dependencies),
+        ...Object.keys(devDependencies),
+        ...Object.keys(peerDependencies),
+        'vite',
+        'nx',
+        'vite-plugin-dts',
+        'vite-tsconfig-paths',
+        'path',
+        'fs',
+        'crypto',
+      ],
+    },
+  },
+
+  test: {
+    globals: true,
+    environment: 'jsdom',
+    // setupFiles: './setupTests.ts',
+    include: ['src/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
+    hookTimeout: 1000000,
+  },
+};
+
+export default defineConfig(config);

package/vite.config.workers.ts

@@ -0,0 +1,51 @@
+/* eslint-disable import/no-extraneous-dependencies */
+import { defineConfig } from 'vite';
+import { nxViteTsPaths } from '@nx/vite/plugins/nx-tsconfig-paths.plugin';
+import { polyfillConstants } from '../../../vite.common';
+import { proccessCDN } from './handleCDNWorkers';
+
+const config = {
+  root: __dirname,
+  base: './',
+
+  plugins: [
+    polyfillConstants(),
+    nxViteTsPaths(),
+    {
+      name: 'procces-cdn',
+      apply: 'build',
+      closeBundle: proccessCDN,
+    },
+  ],
+
+  worker: {
+    format: 'es',
+    plugins: () => [polyfillConstants(), nxViteTsPaths()],
+    rollupOptions: {
+      output: { inlineDynamicImports: true }, // this essentially merges WorkerLogic with WorkerLauncher
+    },
+  },
+
+  // Configuration for building your library.
+  // See: https://vitejs.dev/guide/build.html#library-mode
+  build: {
+    target: 'esnext', // Ensures the output targets the latest ESM features
+    outDir: '../../../dist/libs/shared/workers-prebuild',
+    reportCompressedSize: true,
+    commonjsOptions: { transformMixedEsModules: true },
+    emptyOutDir: true,
+    lib: {
+      // Could also be a dictionary or array of multiple entry points.
+      entry: ['src/webworker/viteWorkerURL.constant.ts'],
+      name: 'workers-prebuild',
+      formats: ['es'],
+      fileName: (format, entryName) => `${entryName}.js`,
+    },
+    rollupOptions: {
+      // output: { inlineDynamicImports: true }, // this does not affect anything - there is no dynamic import
+      exclude: [], // why we need this?
+    },
+  },
+};
+
+export default defineConfig(config);