@gurge/sdk 0.3.4 → 0.3.7

package/common/src/webworker/utxoWorker/utxoWorker.types.d.ts

@@ -0,0 +1,31 @@
+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[];
+    chainId: number;
+}> {
+    type: UtxoWorkerActionType.BUILD_UTXOS;
+}
+export interface DecipherProcessPayload extends WorkerPayload<{
+    encryptedOutputs: EncryptedOutputWithSign[];
+    lastOutput: string;
+    signature: string;
+    chainId: number;
+}> {
+    type: UtxoWorkerActionType.DECIPHER_OUTPUTS;
+}
+export type UtxoWorkerPayload = BuildBatchProcessPayload | BatchFilterUtxosWithNullifierPayload | DecipherProcessPayload;
+export type UtxoWorkerParams = WorkerParams<UtxoWorkerPayload>;

package/common/src/webworker/utxoWorker/utxoWorkerLauncher.d.ts

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

package/common/src/webworker/utxoWorker/utxoWorkerLogic.d.ts

@@ -0,0 +1,5 @@
+import { BatchFilterUtxosWithNullifierPayload, BuildBatchProcessPayload, DecipherProcessPayload, UtxoWorkerParams } from './utxoWorker.types';
+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>;

package/common/src/webworker/utxoWorker/utxoWorkerNode.d.ts

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

package/common/src/webworker/viteWorkerURL.constant.cjs

@@ -14,8 +14,8 @@
   var e = /* @__PURE__ */ ((r) => (r.ZKProof = "ZKProof", r.SnarkJS = "SnarkJS", r.UTXO = "UTXO", r))(e || {});
 
   const n = async () => ({
-    [e.ZKProof]: await getWorkerURL(domain + '/0.3.4/' + 'zkProofWorkerLauncher.js'),
-    [e.SnarkJS]: await getWorkerURL(domain + '/0.3.4/' + 'snarkjsWorkerLauncher.js'),
-    [e.UTXO]: await getWorkerURL(domain + '/0.3.4/' + 'utxoWorkerLauncher.js'),
+    [e.ZKProof]: await getWorkerURL(domain + '/0.3.5/' + 'zkProofWorkerLauncher.js'),
+    [e.SnarkJS]: await getWorkerURL(domain + '/0.3.5/' + 'snarkjsWorkerLauncher.js'),
+    [e.UTXO]: await getWorkerURL(domain + '/0.3.5/' + 'utxoWorkerLauncher.js'),
   });
   exports.getWorkerViteURL = n;

package/common/src/webworker/viteWorkerURL.constant.d.ts

@@ -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/common/src/webworker/viteWorkerURL.constant.mjs

@@ -14,8 +14,8 @@
   var e = /* @__PURE__ */ ((r) => (r.ZKProof = "ZKProof", r.SnarkJS = "SnarkJS", r.UTXO = "UTXO", r))(e || {});
 
   const n = async () => ({
-    [e.ZKProof]: await getWorkerURL(domain + '/0.3.4/' + 'zkProofWorkerLauncher.js'),
-    [e.SnarkJS]: await getWorkerURL(domain + '/0.3.4/' + 'snarkjsWorkerLauncher.js'),
-    [e.UTXO]: await getWorkerURL(domain + '/0.3.4/' + 'utxoWorkerLauncher.js'),
+    [e.ZKProof]: await getWorkerURL(domain + '/0.3.5/' + 'zkProofWorkerLauncher.js'),
+    [e.SnarkJS]: await getWorkerURL(domain + '/0.3.5/' + 'snarkjsWorkerLauncher.js'),
+    [e.UTXO]: await getWorkerURL(domain + '/0.3.5/' + 'utxoWorkerLauncher.js'),
   });
   export { n as getWorkerViteURL };

package/common/src/webworker/worker.registry.d.ts

@@ -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/common/src/webworker/worker.types.d.ts

@@ -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/common/src/webworker/workerErrorHandler.d.ts

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

package/common/src/webworker/workerFactory.d.ts

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

package/common/src/webworker/workerProxy.d.ts

@@ -0,0 +1,39 @@
+/**
+ * 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;
+    /**
+     * 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.
+     */
+    onerror: ((e: {
+        data: {
+            error: unknown;
+        };
+    }) => void) | null;
+    private _eventEmitter;
+    private get eventEmitter();
+    constructor();
+    terminate(): void;
+    postMessage(message: unknown): void;
+    postMessageToMainThread(message: unknown): void;
+    postErrorToMainThread(error: unknown): void;
+    private get parentPort();
+}

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

@@ -0,0 +1,26 @@
+import { IUtxoConstructor } from '../../data-structures/utxo/Utxo';
+import { MerkleTreeJson } from '../../data-structures/merkle-tree';
+import { WorkerParams, WorkerPayload } from '../worker.types';
+export declare enum ZKProofWorkerActionType {
+    CALC_COMMITMENTS_SIBLING_AND_SIDES = 0,
+    BUILD_IN_NULLIFIERS = 1
+}
+export interface ZKProofWorkerCalcCommitmentsPayload extends WorkerPayload<{
+    inputUtxosSerialized: IUtxoConstructor[][];
+    merkleTreeSerialized: MerkleTreeJson;
+}> {
+    type: ZKProofWorkerActionType.CALC_COMMITMENTS_SIBLING_AND_SIDES;
+}
+export interface ZKProofWorkerCalcCommitmentsReturn {
+    inCommitmentSiblings: string[][][];
+    inCommitmentSiblingSides: string[][][];
+}
+export interface ZKProofWorkerBuildInNullifiersPayload extends WorkerPayload<{
+    inputUtxosSerialized: IUtxoConstructor[][];
+}> {
+    type: ZKProofWorkerActionType.BUILD_IN_NULLIFIERS;
+}
+export type ZKProofWorkerBuildInNullifiersReturn = string[][];
+export type ZKProofWorkerPayload = ZKProofWorkerCalcCommitmentsPayload | ZKProofWorkerBuildInNullifiersPayload;
+export type ZKProofWorkerParams = WorkerParams<ZKProofWorkerPayload>;
+export type ZKProofWorkerReturn = ZKProofWorkerCalcCommitmentsReturn | ZKProofWorkerBuildInNullifiersReturn;

package/common/src/webworker/zkProofWorker/zkProofWorkerLauncher.d.ts

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

package/common/src/webworker/zkProofWorker/zkProofWorkerLogic.d.ts

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

package/common/src/webworker/zkProofWorker/zkProofWorkerNode.d.ts

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

package/functions/utils/getERC20Token.d.ts

@@ -1,2 +1,2 @@
-import { ERC20Token } from '../../common/src/types';
+import { ERC20Token } from '../../types';
 export declare const getERC20Token: (chainId: number, address: string) => Promise<ERC20Token | undefined>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gurge/sdk",
-  "version": "0.3.4",
+  "version": "0.3.7",
   "homepage": "hinkal.io",
   "author": {
     "name": "Hinkal Protocol"