@sabaaa1/common 0.0.13 → 0.0.14

package/types/transactions.types.mjs

@@ -0,0 +1,39 @@
+import { BigNumber as d } from "ethers";
+const m = d.from(0), g = {
+  blockNumber: 0,
+  timeStamp: 0,
+  methodId: "",
+  input: "",
+  decodedInput: {
+    erc20TokenAddresses: [],
+    amountChanges: [],
+    flatFees: [0n, 0n].map((e) => d.from(e)),
+    externalActionId: m,
+    externalActionMetadata: "",
+    encryptedOutputs: [],
+    hookData: {
+      hookContract: "",
+      preHookContract: "",
+      preHookMetadata: "",
+      postHookMetadata: ""
+    },
+    stealthAddressStructure: {
+      extraRandomization: 0n,
+      stealthAddress: 0n,
+      H0: 0n,
+      H1: 0n
+    }
+  },
+  logs: [],
+  hash: "",
+  gas: 0,
+  gasPrice: 0,
+  isError: "",
+  status: ""
+};
+var l = /* @__PURE__ */ ((e) => (e[e.NotStarted = 0] = "NotStarted", e[e.Loading = 1] = "Loading", e[e.Confirmed = 2] = "Confirmed", e[e.Failed = 3] = "Failed", e))(l || {}), p = /* @__PURE__ */ ((e) => (e[e.None = 0] = "None", e[e.Deposit = 1] = "Deposit", e[e.Mint = 2] = "Mint", e[e.PoolAdd = 3] = "PoolAdd", e[e.PoolRemove = 4] = "PoolRemove", e[e.Redeem = 5] = "Redeem", e[e.Swap = 6] = "Swap", e[e.Bridge = 7] = "Bridge", e[e.Transfer = 8] = "Transfer", e[e.Withdraw = 9] = "Withdraw", e[e.Send = 10] = "Send", e[e.HinkalStake = 11] = "HinkalStake", e[e.HinkalUnstake = 12] = "HinkalUnstake", e[e.Fund = 13] = "Fund", e[e.Receive = 14] = "Receive", e))(p || {});
+export {
+  p as TransactionAction,
+  l as TransactionStatus,
+  g as emptyDecodedTx
+};

package/types/wc.types.d.ts

@@ -0,0 +1,78 @@
+import { BuildApprovedNamespacesParams } from '@walletconnect/utils';
+import { SessionMetadata } from './session.types';
+export interface VerifyContextOptions {
+    verified: {
+        origin: string;
+        validation: string;
+        verifyUrl: string;
+    };
+}
+export type WCSessionProposalOptions = {
+    id: number;
+    params: BuildApprovedNamespacesParams['proposal'];
+    verifyContext: VerifyContextOptions;
+};
+export type WCSessionRequestOptions = {
+    id: number;
+    topic: string;
+    params: {
+        chainId: string;
+        request: {
+            method: string;
+            params: unknown[];
+        };
+    };
+    verifyContext: VerifyContextOptions;
+};
+export interface TxParametersBase {
+    from: string;
+    to: string;
+    gas?: string;
+    gasPrice?: string;
+    value: string;
+    data?: string;
+}
+export interface WCTransactionParameters<T = number> extends TxParametersBase {
+    chainId: T;
+}
+type BaseNamespace = {
+    chains?: string[];
+    accounts: string[];
+    methods: string[];
+    events: string[];
+};
+export type Namespaces = Record<string, BaseNamespace>;
+export type WCSession = {
+    topic: string;
+    pairingTopic: string;
+    acknowledged: boolean;
+    controller: string;
+    self: {
+        publicKey: string;
+    };
+    peer: {
+        publicKey: string;
+        metadata: SessionMetadata;
+    };
+    namespaces: Namespaces;
+};
+export interface WCErrorResponse {
+    id: number;
+    error: {
+        code: number;
+        message: string;
+    };
+    jsonrpc: string;
+}
+export interface WCSuccessResponse {
+    id: number;
+    result: string | null | object;
+    jsonrpc: string;
+}
+export type WCResponse = WCErrorResponse | WCSuccessResponse;
+export type AppMetaData = {
+    url?: string;
+    icon: string;
+    name: string;
+};
+export {};

package/types/with-id.types.d.ts

@@ -0,0 +1,3 @@
+export type WithId<T> = T & {
+    id: number;
+};

package/webworker/performTaskWithWorker.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const l=require("../constants/chains.constants.cjs"),h=require("../constants/vite.constants.cjs"),w=require("./workerFactory.cjs"),y=async t=>{const e=await w.WorkerFactory.getWebWorker(t.type);return new Promise((r,s)=>{let n={};if(typeof window<"u"&&window.location){const{origin:o,protocol:i,host:c,port:d,hostname:m,href:p}=window.location;n={origin:o,protocol:i,host:c,port:d,hostname:m,href:p}}e.onmessage=o=>{r(o.data),e.terminate()},e.onerror=o=>{s(o),e.terminate()};const a={payload:t.payload,metadata:{hostLocation:n,constants:{chains:{chainIds:l.chainIds},isDevelopment:h.isDevelopment}}};e.postMessage(a)})};exports.performTaskWithWorker=y;

package/webworker/performTaskWithWorker.d.ts

@@ -0,0 +1,5 @@
+import { WorkerVariant } from './worker.registry';
+export declare const performTaskWithWorker: <P, T>(workerData: {
+    type: WorkerVariant;
+    payload: P;
+}) => Promise<T>;

package/webworker/performTaskWithWorker.mjs

@@ -0,0 +1,41 @@
+import { chainIds as f } from "../constants/chains.constants.mjs";
+import { isDevelopment as w } from "../constants/vite.constants.mjs";
+import { WorkerFactory as h } from "./workerFactory.mjs";
+const W = async (e) => {
+  const o = await h.getWebWorker(e.type);
+  return new Promise((n, a) => {
+    let r = {};
+    if (typeof window < "u" && window.location) {
+      const { origin: t, protocol: i, host: m, port: c, hostname: p, href: d } = window.location;
+      r = {
+        origin: t,
+        protocol: i,
+        host: m,
+        port: c,
+        hostname: p,
+        href: d
+      };
+    }
+    o.onmessage = (t) => {
+      n(t.data), o.terminate();
+    }, o.onerror = (t) => {
+      a(t), o.terminate();
+    };
+    const s = {
+      payload: e.payload,
+      metadata: {
+        hostLocation: r,
+        constants: {
+          chains: {
+            chainIds: f
+          },
+          isDevelopment: w
+        }
+      }
+    };
+    o.postMessage(s);
+  });
+};
+export {
+  W as performTaskWithWorker
+};

package/webworker/snarkjsWorker/snarkjsWorker.types.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});var r=(e=>(e[e.FULL_PROVE=0]="FULL_PROVE",e))(r||{});exports.SnarkJSWorkerActionType=r;

package/webworker/snarkjsWorker/snarkjsWorker.types.d.ts

@@ -0,0 +1,14 @@
+import { WorkerParams, WorkerPayload } from '../worker.types';
+export declare enum SnarkJSWorkerActionType {
+    FULL_PROVE = 0
+}
+export interface SnarkJSWorkerFullProvePayload extends WorkerPayload<{
+    input: any;
+    chainId: number;
+    wasmFilePath: string;
+    zKeyFilePath: string;
+}> {
+    type: SnarkJSWorkerActionType.FULL_PROVE;
+}
+export type SnarkJSPayload = SnarkJSWorkerFullProvePayload;
+export type SnarkJSParams = WorkerParams<SnarkJSPayload>;

package/webworker/snarkjsWorker/snarkjsWorker.types.mjs

@@ -0,0 +1,4 @@
+var E = /* @__PURE__ */ ((L) => (L[L.FULL_PROVE = 0] = "FULL_PROVE", L))(E || {});
+export {
+  E as SnarkJSWorkerActionType
+};

package/webworker/snarkjsWorker/snarkjsWorkerLauncher.cjs

@@ -0,0 +1 @@
+"use strict";const e=""+(typeof document>"u"?require("url").pathToFileURL(__dirname+"/../../assets/snarkjsWorkerLauncher-C7k0eivz.js").href:new URL("../../assets/snarkjsWorkerLauncher-C7k0eivz.js",document.currentScript&&document.currentScript.src||document.baseURI).href);module.exports=e;

package/webworker/snarkjsWorker/snarkjsWorkerLauncher.d.ts

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

package/webworker/snarkjsWorker/snarkjsWorkerLauncher.mjs

@@ -0,0 +1,4 @@
+const r = "" + new URL("../../assets/snarkjsWorkerLauncher-C7k0eivz.js", import.meta.url).href;
+export {
+  r as default
+};

package/webworker/snarkjsWorker/snarkjsWorkerLogic.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const M=require("../workerProxy.cjs"),o=require("../../constants/vite.constants.cjs"),O=require("snarkjs");require("../../data-structures/tor/TorClient.cjs");require("@hazae41/binary");require("@hazae41/cascade");const q=require("../../data-structures/tor/HttpClient.cjs");function v(e){const r=Object.create(null,{[Symbol.toStringTag]:{value:"Module"}});if(e){for(const t in e)if(t!=="default"){const s=Object.getOwnPropertyDescriptor(e,t);Object.defineProperty(r,t,s.get?s:{enumerable:!0,get:()=>e[t]})}}return r.default=e,Object.freeze(r)}const y=v(O),n=new M.WorkerProxy,g=async e=>new Uint8Array(await q.httpClient.get(e,{responseType:"arraybuffer"})),b=async e=>{try{const{input:r,wasmFilePath:t,zKeyFilePath:s,chainId:w}=e.payload.data,{hostLocation:{origin:c},constants:{isDevelopment:k,chains:{chainIds:P}}}=e.metadata;let a=t,i=s,l,u;const f=a.startsWith("https://");if(o.isNode&&!f){o.isWebpack?(a=`libs/hardhat/test/circuits/${t}`,i=`libs/hardhat/test/circuits/${s}`):!o.isWebpack&&k&&(a=`test/circuits/${t}`,i=`test/circuits/${s}`);const d=require("path");a=d.resolve(a),i=d.resolve(i)}o.isNode&&f?(l=await g(a),u=await g(i)):w===P.localhost&&!o.isNode&&(a=`${c}/${t}`,i=`${c}/${s}`);const{proof:h,publicSignals:p}=await y.groth16.fullProve(r,l??a,u??i),m=await y.groth16.exportSolidityCallData(h,p),$=JSON.parse(`[${m}]`);n.postMessageToMainThread({zkCallData:$,proof:h,publicSignals:p})}catch(r){console.error(r),n.postErrorToMainThread(r)}};n.attachWorkerSideOnMessage(b);exports.default=n;exports.onWorkerMessage=b;

package/webworker/snarkjsWorker/snarkjsWorkerLogic.d.ts

@@ -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/snarkjsWorker/snarkjsWorkerLogic.mjs

@@ -0,0 +1,39 @@
+import { WorkerProxy as b } from "../workerProxy.mjs";
+import { isNode as o, isWebpack as y } from "../../constants/vite.constants.mjs";
+import * as d from "snarkjs";
+import "../../data-structures/tor/TorClient.mjs";
+import "@hazae41/binary";
+import "@hazae41/cascade";
+import { httpClient as z } from "../../data-structures/tor/HttpClient.mjs";
+const l = new b(), w = async (e) => new Uint8Array(await z.get(e, { responseType: "arraybuffer" })), M = async (e) => {
+  try {
+    const { input: r, wasmFilePath: s, zKeyFilePath: i, chainId: $ } = e.payload.data, {
+      hostLocation: { origin: n },
+      constants: {
+        isDevelopment: g,
+        chains: { chainIds: k }
+      }
+    } = e.metadata;
+    let t = s, a = i, c, h;
+    const p = t.startsWith("https://");
+    if (o && !p) {
+      y ? (t = `libs/hardhat/test/circuits/${s}`, a = `libs/hardhat/test/circuits/${i}`) : !y && g && (t = `test/circuits/${s}`, a = `test/circuits/${i}`);
+      const u = require("path");
+      t = u.resolve(t), a = u.resolve(a);
+    }
+    o && p ? (c = await w(t), h = await w(a)) : $ === k.localhost && !o && (t = `${n}/${s}`, a = `${n}/${i}`);
+    const { proof: f, publicSignals: m } = await d.groth16.fullProve(
+      r,
+      c ?? t,
+      h ?? a
+    ), F = await d.groth16.exportSolidityCallData(f, m), P = JSON.parse(`[${F}]`);
+    l.postMessageToMainThread({ zkCallData: P, proof: f, publicSignals: m });
+  } catch (r) {
+    console.error(r), l.postErrorToMainThread(r);
+  }
+};
+l.attachWorkerSideOnMessage(M);
+export {
+  l as default,
+  M as onWorkerMessage
+};

package/webworker/utxoWorker/utxoWorker.types.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});var _=(I=>(I[I.BATCH_FILTER_UTXOS_WITH_NULLIFIER=0]="BATCH_FILTER_UTXOS_WITH_NULLIFIER",I[I.BUILD_UTXOS=1]="BUILD_UTXOS",I[I.DECIPHER_OUTPUTS=2]="DECIPHER_OUTPUTS",I))(_||{});exports.UtxoWorkerActionType=_;

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

@@ -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/utxoWorker.types.mjs

@@ -0,0 +1,4 @@
+var _ = /* @__PURE__ */ ((I) => (I[I.BATCH_FILTER_UTXOS_WITH_NULLIFIER = 0] = "BATCH_FILTER_UTXOS_WITH_NULLIFIER", I[I.BUILD_UTXOS = 1] = "BUILD_UTXOS", I[I.DECIPHER_OUTPUTS = 2] = "DECIPHER_OUTPUTS", I))(_ || {});
+export {
+  _ as UtxoWorkerActionType
+};

package/webworker/utxoWorker/utxoWorkerLauncher.cjs

@@ -0,0 +1 @@
+"use strict";const e=""+(typeof document>"u"?require("url").pathToFileURL(__dirname+"/../../assets/utxoWorkerLauncher-BUSzpnDL.js").href:new URL("../../assets/utxoWorkerLauncher-BUSzpnDL.js",document.currentScript&&document.currentScript.src||document.baseURI).href);module.exports=e;

package/webworker/utxoWorker/utxoWorkerLauncher.d.ts

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

package/webworker/utxoWorker/utxoWorkerLauncher.mjs

@@ -0,0 +1,4 @@
+const e = "" + new URL("../../assets/utxoWorkerLauncher-BUSzpnDL.js", import.meta.url).href;
+export {
+  e as default
+};

package/webworker/utxoWorker/utxoWorkerLogic.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const f=require("../../crypto/preProcessing.cjs"),a=require("../../data-structures/crypto-keys/keys.cjs"),T=require("../../data-structures/utxo/Utxo.cjs"),h=require("../../data-structures/crypto-keys/encryptDecryptUtxo.cjs"),y=require("../../data-structures/crypto-keys/decodeUTXO.cjs"),k=require("../workerProxy.cjs"),d=require("./utxoWorker.types.cjs"),c=new k.WorkerProxy,p=async({data:e})=>{const{utxos:r,nullifiers:s}=e,o=r.filter(t=>{const u=new T.Utxo(t);return!s.has(u.getNullifier())});c.postMessageToMainThread({utxoConstructors:o,stealthPairCache:a.stealthPairCacheDevice.serialize(),stealthAddressCache:a.stealthAddressCacheDevice.serialize()})},U=async({data:e})=>{const r=new a.UserKeys(e.signature),s=r.getShieldedPrivateKey(),o=e.encryptedOutputs.map(t=>{try{return t.isPositive?h.decryptUtxoConstructorArgs(Buffer.from(t.value.slice(2),"hex"),r):y.decodeUtxoConstructorArgs(t.value,s)}catch{return}}).filter(t=>t!==void 0&&t.amount!==0n);c.postMessageToMainThread(o)},x=async({data:e})=>{const r=new a.UserKeys(e.signature),s=[],{encryptedOutputs:o}=e;let{lastOutput:t}=e;const u=r.getShieldedPrivateKey();for(let l=0;l<o.length;l+=1){const n=o[l];if(t=n.value,n.isPositive)try{const i=h.decryptUtxo(Buffer.from(t.slice(2),"hex"),r);if(!i.erc20TokenAddress||!i.amount||!i.stealthAddress)throw Error("bruh");s.push(n)}catch{}else try{y.checkUtxoSignature(t,u)&&s.push(n)}catch{}}c.postMessageToMainThread({additionalEncryptedOutputs:s,lastOutput:t})},g=async e=>{try{await f.preProcessing();const{type:r}=e.payload;switch(r){case d.UtxoWorkerActionType.BATCH_FILTER_UTXOS_WITH_NULLIFIER:await p(e.payload);return;case d.UtxoWorkerActionType.BUILD_UTXOS:await U(e.payload);return;case d.UtxoWorkerActionType.DECIPHER_OUTPUTS:await x(e.payload);return;default:throw Error(`Unknown worker message type ${r}`)}}catch(r){console.error(r),c.postErrorToMainThread(r)}};c.attachWorkerSideOnMessage(g);exports.default=c;exports.handleBuildUtxosMessage=U;exports.handleDecipherMessage=x;exports.handleFilterUtxosWithNullifier=p;exports.onWorkerMessage=g;

package/webworker/utxoWorker/utxoWorkerLogic.d.ts

@@ -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/utxoWorker/utxoWorkerLogic.mjs

@@ -0,0 +1,76 @@
+import { preProcessing as u } from "../../crypto/preProcessing.mjs";
+import { stealthPairCacheDevice as p, stealthAddressCacheDevice as y, UserKeys as h } from "../../data-structures/crypto-keys/keys.mjs";
+import { Utxo as f } from "../../data-structures/utxo/Utxo.mjs";
+import { decryptUtxoConstructorArgs as m, decryptUtxo as g } from "../../data-structures/crypto-keys/encryptDecryptUtxo.mjs";
+import { decodeUtxoConstructorArgs as x, checkUtxoSignature as U } from "../../data-structures/crypto-keys/decodeUTXO.mjs";
+import { WorkerProxy as T } from "../workerProxy.mjs";
+import { UtxoWorkerActionType as d } from "./utxoWorker.types.mjs";
+const i = new T(), w = async ({ data: e }) => {
+  const { utxos: r, nullifiers: s } = e, o = r.filter((t) => {
+    const n = new f(t);
+    return !s.has(n.getNullifier());
+  });
+  i.postMessageToMainThread({
+    utxoConstructors: o,
+    stealthPairCache: p.serialize(),
+    stealthAddressCache: y.serialize()
+  });
+}, P = async ({ data: e }) => {
+  const r = new h(e.signature), s = r.getShieldedPrivateKey(), o = e.encryptedOutputs.map((t) => {
+    try {
+      return t.isPositive ? m(Buffer.from(t.value.slice(2), "hex"), r) : x(t.value, s);
+    } catch {
+      return;
+    }
+  }).filter((t) => t !== void 0 && t.amount !== 0n);
+  i.postMessageToMainThread(o);
+}, v = async ({ data: e }) => {
+  const r = new h(e.signature), s = [], { encryptedOutputs: o } = e;
+  let { lastOutput: t } = e;
+  const n = r.getShieldedPrivateKey();
+  for (let l = 0; l < o.length; l += 1) {
+    const c = o[l];
+    if (t = c.value, c.isPositive)
+      try {
+        const a = g(Buffer.from(t.slice(2), "hex"), r);
+        if (!a.erc20TokenAddress || !a.amount || !a.stealthAddress)
+          throw Error("bruh");
+        s.push(c);
+      } catch {
+      }
+    else
+      try {
+        U(t, n) && s.push(c);
+      } catch {
+      }
+  }
+  i.postMessageToMainThread({ additionalEncryptedOutputs: s, lastOutput: t });
+}, k = async (e) => {
+  try {
+    await u();
+    const { type: r } = e.payload;
+    switch (r) {
+      case d.BATCH_FILTER_UTXOS_WITH_NULLIFIER:
+        await w(e.payload);
+        return;
+      case d.BUILD_UTXOS:
+        await P(e.payload);
+        return;
+      case d.DECIPHER_OUTPUTS:
+        await v(e.payload);
+        return;
+      default:
+        throw Error(`Unknown worker message type ${r}`);
+    }
+  } catch (r) {
+    console.error(r), i.postErrorToMainThread(r);
+  }
+};
+i.attachWorkerSideOnMessage(k);
+export {
+  i as default,
+  P as handleBuildUtxosMessage,
+  v as handleDecipherMessage,
+  w as handleFilterUtxosWithNullifier,
+  k as onWorkerMessage
+};

package/webworker/viteWorkerURL.constant.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./zkProofWorker/zkProofWorkerLauncher.cjs"),o=require("./snarkjsWorker/snarkjsWorkerLauncher.cjs"),t=require("./utxoWorker/utxoWorkerLauncher.cjs"),r=require("./worker.registry.cjs"),n=async()=>({[r.WorkerVariant.ZKProof]:e,[r.WorkerVariant.SnarkJS]:o,[r.WorkerVariant.UTXO]:t});exports.getWorkerViteURL=n;

package/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/webworker/viteWorkerURL.constant.mjs

@@ -0,0 +1,12 @@
+import o from "./zkProofWorker/zkProofWorkerLauncher.mjs";
+import t from "./snarkjsWorker/snarkjsWorkerLauncher.mjs";
+import e from "./utxoWorker/utxoWorkerLauncher.mjs";
+import { WorkerVariant as r } from "./worker.registry.mjs";
+const a = async () => ({
+  [r.ZKProof]: o,
+  [r.SnarkJS]: t,
+  [r.UTXO]: e
+});
+export {
+  a as getWorkerViteURL
+};

package/webworker/worker.registry.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});var e=(r=>(r.ZKProof="ZKProof",r.SnarkJS="SnarkJS",r.UTXO="UTXO",r))(e||{});exports.WorkerVariant=e;

package/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/webworker/worker.registry.mjs

@@ -0,0 +1,4 @@
+var o = /* @__PURE__ */ ((S) => (S.ZKProof = "ZKProof", S.SnarkJS = "SnarkJS", S.UTXO = "UTXO", S))(o || {});
+export {
+  o as WorkerVariant
+};

package/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/webworker/workerErrorHandler.d.ts

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

package/webworker/workerFactory.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const i=require("../constants/vite.constants.cjs"),r=require("./worker.registry.cjs");class t{constructor(){}static resolveWorkerURL=async e=>{const{getWorkerViteURL:s}=await Promise.resolve().then(()=>require("./viteWorkerURL.constant.cjs"));return(await s())[e]};static createWorker=async e=>{if(i.isNode||i.isSandbox){let o;return e===r.WorkerVariant.SnarkJS?o=await Promise.resolve().then(()=>require("./snarkjsWorker/snarkjsWorkerLogic.cjs")):e===r.WorkerVariant.ZKProof?o=await Promise.resolve().then(()=>require("./zkProofWorker/zkProofWorkerLogic.cjs")):e===r.WorkerVariant.UTXO&&(o=await Promise.resolve().then(()=>require("./utxoWorker/utxoWorkerLogic.cjs"))),o.default}const s=await t.resolveWorkerURL(e);return new Worker(s,{type:"module"})};static getWebWorker(e){switch(e){case r.WorkerVariant.ZKProof:return t.createWorker(e);case r.WorkerVariant.SnarkJS:return t.createWorker(e);case r.WorkerVariant.UTXO:return t.createWorker(e);default:throw Error(`Unknown worker type: ${e}`)}}}exports.WorkerFactory=t;

package/webworker/workerFactory.d.ts

@@ -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/workerFactory.mjs

@@ -0,0 +1,42 @@
+import { isNode as i, isSandbox as c } from "../constants/vite.constants.mjs";
+import { WorkerVariant as r } from "./worker.registry.mjs";
+class o {
+  constructor() {
+  }
+  static resolveWorkerURL = async (e) => {
+    const { getWorkerViteURL: s } = await import("./viteWorkerURL.constant.mjs");
+    return (await s())[e];
+  };
+  static createWorker = async (e) => {
+    if (i || c) {
+      let t;
+      return e === r.SnarkJS ? t = await import(
+        /* @vite-ignore */
+        "./snarkjsWorker/snarkjsWorkerLogic.mjs"
+      ) : e === r.ZKProof ? t = await import(
+        /* @vite-ignore */
+        "./zkProofWorker/zkProofWorkerLogic.mjs"
+      ) : e === r.UTXO && (t = await import(
+        /* @vite-ignore */
+        "./utxoWorker/utxoWorkerLogic.mjs"
+      )), t.default;
+    }
+    const s = await o.resolveWorkerURL(e);
+    return new Worker(s, { type: "module" });
+  };
+  static getWebWorker(e) {
+    switch (e) {
+      case r.ZKProof:
+        return o.createWorker(e);
+      case r.SnarkJS:
+        return o.createWorker(e);
+      case r.UTXO:
+        return o.createWorker(e);
+      default:
+        throw Error(`Unknown worker type: ${e}`);
+    }
+  }
+}
+export {
+  o as WorkerFactory
+};

package/webworker/workerProxy.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});class s{isNode=!1;isSandbox=!1;onmessage=null;onerror=null;_eventEmitter;get eventEmitter(){if(this._eventEmitter)return this._eventEmitter;if(this.isNode){const e=require("events");this._eventEmitter=new e}else this._eventEmitter=new EventTarget;return this._eventEmitter}constructor(){this.isNode=typeof process<"u"&&process.versions!=null&&process.versions.node!=null,this.isSandbox=typeof window<"u"&&window.origin==="null"}terminate(){}postMessage(e){this.isNode?this.eventEmitter.emit("message",e):this.isSandbox?this.eventEmitter?.dispatchEvent(new CustomEvent("worker-message",{detail:e})):postMessage(e)}postMessageToMainThread(e){const t={data:e};this.onmessage?this.onmessage(t):postMessage(e)}postErrorToMainThread(e){const t={data:{error:e}};this.onerror?this.onerror(t):postMessage(e)}attachWorkerSideOnMessage(e){this.isNode?this.eventEmitter.on("message",t=>{e(t)}):this.isSandbox&&this.eventEmitter.addEventListener("worker-message",t=>{e(t.detail)})}}exports.WorkerProxy=s;

package/webworker/workerProxy.d.ts

@@ -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;
+    private isSandbox;
+    /**
+     * 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;
+    attachWorkerSideOnMessage(fn: (e: any) => void | Promise<void>): void;
+}