@hinkal/common 0.2.10 → 0.2.11

package/webworker/snarkjsWorker/snarkjsWorkerLogic.d.mts

@@ -0,0 +1,10 @@
+/**
+ * This Web Worker only handle snarkjs operation.
+ * If possible, avoid importing modules form main project and instead pass data along with message
+ * to ensure this worker stay lean.
+ */
+import { WorkerProxy } from '../workerProxy';
+import { SnarkJSParams } from './snarkjsWorker.types';
+declare const workerProxy: WorkerProxy;
+export declare const onWorkerMessage: (data: SnarkJSParams) => Promise<void>;
+export default workerProxy;

package/webworker/utxoWorker/utxoWorker.types.d.mts

@@ -0,0 +1,29 @@
+import { EncryptedOutputWithSign } from '../../types/commitments.types';
+import { WorkerParams, WorkerPayload } from '../worker.types';
+import { IUtxoConstructor } from '../../data-structures/utxo/Utxo';
+export declare enum UtxoWorkerActionType {
+    BATCH_FILTER_UTXOS_WITH_NULLIFIER = 0,
+    BUILD_UTXOS = 1,
+    DECIPHER_OUTPUTS = 2
+}
+export interface BatchFilterUtxosWithNullifierPayload extends WorkerPayload<{
+    utxos: IUtxoConstructor[];
+    nullifiers: Set<string>;
+}> {
+    type: UtxoWorkerActionType.BATCH_FILTER_UTXOS_WITH_NULLIFIER;
+}
+export interface BuildBatchProcessPayload extends WorkerPayload<{
+    signature: string;
+    encryptedOutputs: EncryptedOutputWithSign[];
+}> {
+    type: UtxoWorkerActionType.BUILD_UTXOS;
+}
+export interface DecipherProcessPayload extends WorkerPayload<{
+    encryptedOutputs: EncryptedOutputWithSign[];
+    lastOutput: string;
+    signature: string;
+}> {
+    type: UtxoWorkerActionType.DECIPHER_OUTPUTS;
+}
+export type UtxoWorkerPayload = BuildBatchProcessPayload | BatchFilterUtxosWithNullifierPayload | DecipherProcessPayload;
+export type UtxoWorkerParams = WorkerParams<UtxoWorkerPayload>;

package/webworker/utxoWorker/utxoWorkerLauncher.d.mts

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

package/webworker/utxoWorker/utxoWorkerLogic.d.mts

@@ -0,0 +1,8 @@
+import { WorkerProxy } from '../workerProxy';
+import { BatchFilterUtxosWithNullifierPayload, BuildBatchProcessPayload, DecipherProcessPayload, UtxoWorkerParams } from './utxoWorker.types';
+declare const workerProxy: WorkerProxy;
+export declare const handleFilterUtxosWithNullifier: ({ data }: BatchFilterUtxosWithNullifierPayload) => Promise<void>;
+export declare const handleBuildUtxosMessage: ({ data }: BuildBatchProcessPayload) => Promise<void>;
+export declare const handleDecipherMessage: ({ data }: DecipherProcessPayload) => Promise<void>;
+export declare const onWorkerMessage: (data: UtxoWorkerParams) => Promise<void>;
+export default workerProxy;

package/webworker/viteWorkerURL.constant.d.mts

@@ -0,0 +1,9 @@
+/**
+ * These imports tell vite to generate and bundle worker file.
+ * These are import conditionally because we do not have vite when running on node.
+ */
+export declare const getWorkerViteURL: () => Promise<{
+    ZKProof: any;
+    SnarkJS: any;
+    UTXO: any;
+}>;

package/webworker/worker.registry.d.mts

@@ -0,0 +1,10 @@
+export declare enum WorkerVariant {
+    ZKProof = "ZKProof",
+    SnarkJS = "SnarkJS",
+    UTXO = "UTXO"
+}
+export declare const workerNodeURL: {
+    ZKProof: string;
+    SnarkJS: string;
+    UTXO: string;
+};

package/webworker/worker.types.d.mts

@@ -0,0 +1,33 @@
+export interface WorkerPayload<T> {
+    data: T;
+}
+export interface WorkerMetadata {
+    hostLocation: {
+        origin?: string;
+        protocol?: string;
+        host?: string;
+        port?: string;
+        hostname?: string;
+        href?: string;
+    };
+    /**
+     * Importing these in worker script will executed the whole constant script in worker env,
+     * which could resolve into different values, as well as, result in many unnecessary imports
+     */
+    constants: {
+        chains: {
+            chainIds: {
+                [key: string]: number;
+            };
+        };
+        /**
+         * Worker do not have access to window.location -> so this will always be false if import
+         * directly from vite constant file.
+         */
+        isDevelopment: boolean;
+    };
+}
+export interface WorkerParams<T = WorkerPayload<unknown>> {
+    payload: T;
+    metadata: WorkerMetadata;
+}

package/webworker/workerErrorHandler.d.mts

@@ -0,0 +1 @@
+export declare const addWorkerErrorHandler: () => void;

package/webworker/workerFactory.d.mts

@@ -0,0 +1,7 @@
+import { WorkerVariant } from './worker.registry';
+export declare class WorkerFactory {
+    private constructor();
+    private static resolveWorkerURL;
+    private static createWorker;
+    static getWebWorker(workerVariant: WorkerVariant): Promise<any>;
+}

package/webworker/workerProxy.d.mts

@@ -0,0 +1,40 @@
+/**
+ * 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 declare class WorkerProxy {
+    private isNode;
+    /**
+     * 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.
+     */
+    onmessage: ((e: {
+        data: any;
+    }) => void) | null;
+    private _eventEmitter;
+    /**
+     * Lazy load event emitter so it is only initialize if require/if in node environment
+     */
+    private get eventEmitter();
+    constructor();
+    terminate(): void;
+    /**
+     * This postMessage() should only be called when intending to send message from main thread to
+     * worker; In a typical browser environment, this will just act as a normal postMessage() function.
+     */
+    postMessage(message: unknown): void;
+    /**
+     * A separate postMessage() is needed because both main thread and worker thread communicate with
+     * each other using postMessage(), but we cannot (and do not) differentiate between the two
+     * while running on main thread on hardhat
+     */
+    postMessageToMainThread(message: unknown): void;
+    attachWorkerSideOnMessage(fn: (e: any) => void | Promise<void>): void;
+}

package/webworker/zkProofWorker/zkProofWorker.types.d.mts

@@ -0,0 +1,38 @@
+import { IUtxoConstructor } from '../../data-structures/utxo/Utxo';
+import { type MerkleTreeJson } from '../../data-structures/merkle-tree';
+import { WorkerParams, WorkerPayload } from '../worker.types';
+export declare enum ZKProofWorkerActionType {
+    CALC_COMMITMENTS_SIBLING_AND_SIDES = 0,
+    CALC_ACCESS_TOKEN_SIBLING_AND_SIDES = 1,
+    BUILD_IN_NULLIFIERS = 2
+}
+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[];
+}> {
+    type: ZKProofWorkerActionType.BUILD_IN_NULLIFIERS;
+}
+export type ZKProofWorkerBuildInNullifiersReturn = string[][];
+export type ZKProofWorkerPayload = ZKProofWorkerCalcCommitmentsPayload | ZKProofWorkerCalcAccessTokenPayload | ZKProofWorkerBuildInNullifiersPayload;
+export type ZKProofWorkerParams = WorkerParams<ZKProofWorkerPayload>;

package/webworker/zkProofWorker/zkProofWorkerLauncher.d.mts

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

package/webworker/zkProofWorker/zkProofWorkerLogic.d.mts

@@ -0,0 +1,8 @@
+import { WorkerProxy } from '../workerProxy';
+import { ZKProofWorkerBuildInNullifiersPayload, ZKProofWorkerCalcAccessTokenPayload, ZKProofWorkerCalcCommitmentsPayload, ZKProofWorkerParams } from './zkProofWorker.types';
+declare const workerProxy: WorkerProxy;
+export declare const handleCalcCommitmentsSiblingAndSides: (payload: ZKProofWorkerCalcCommitmentsPayload) => void;
+export declare const handleCalcAccessTokenSiblingAndSides: (payload: ZKProofWorkerCalcAccessTokenPayload) => void;
+export declare const handleBuildInNullifiers: (payload: ZKProofWorkerBuildInNullifiersPayload) => void;
+export declare const onWorkerMessage: (data: ZKProofWorkerParams) => Promise<void>;
+export default workerProxy;