@sabaaa1/common 0.0.11 → 0.0.13

package/src/types/transactions.types.ts

@@ -0,0 +1,120 @@
+import { BigNumber } from 'ethers';
+import { HookDataType, StealthAddressStructure } from './circom-data.types';
+
+export interface RawTx {
+  blockNumber: number;
+  timeStamp: number;
+  isError: string;
+  methodId: string;
+  input: string;
+  logs: Log[];
+  hash: string;
+  gas: number;
+  gasPrice: number;
+  contract?: string;
+}
+
+type Log = {
+  topics: string[];
+  data: string;
+};
+
+export interface EventLog {
+  address: string;
+  topics: string[];
+  data: string;
+  blockNumber: string;
+  blockHash: string;
+  timeStamp: string;
+  gasPrice: string;
+  gasUsed: string;
+  logIndex: string;
+  transactionHash: string;
+  transactionIndex: string;
+}
+
+export interface DecodedTx<T = bigint, K = BigNumber> extends RawTx {
+  decodedInput: {
+    erc20TokenAddresses: string[];
+    amountChanges: K[];
+    flatFees: K[];
+    externalActionId: K;
+    externalActionMetadata: string;
+    encryptedOutputs: string[];
+    hookData: HookDataType;
+    stealthAddressStructure: StealthAddressStructure<T>;
+  };
+  status: string;
+}
+
+export interface DecodedTxWithUtxos<T = bigint, K = BigNumber> extends DecodedTx<T, K> {
+  utxosArray?: OnChainUtxo<T>[];
+}
+
+export type OnChainUtxo<AmountType = bigint> = {
+  amount: AmountType;
+  erc20TokenAddress: string;
+  timeStamp: string;
+  tokenId: number;
+};
+
+const zeroBigNumber = BigNumber.from(0);
+
+export const emptyDecodedTx: DecodedTx = {
+  blockNumber: 0,
+  timeStamp: 0,
+  methodId: '',
+  input: '',
+  decodedInput: {
+    erc20TokenAddresses: [],
+    amountChanges: [],
+    flatFees: [0n, 0n].map((item) => BigNumber.from(item)),
+    externalActionId: zeroBigNumber,
+    externalActionMetadata: '',
+    encryptedOutputs: [],
+    hookData: {
+      hookContract: '',
+      preHookContract: '',
+      preHookMetadata: '',
+      postHookMetadata: '',
+    },
+    stealthAddressStructure: {
+      extraRandomization: 0n,
+      stealthAddress: 0n,
+      H0: 0n,
+      H1: 0n,
+    },
+  },
+  logs: [],
+  hash: '',
+  gas: 0,
+  gasPrice: 0,
+  isError: '',
+  status: '',
+};
+
+// Added to prevent circular dependencies from hinkal react hooks
+export enum TransactionStatus {
+  NotStarted,
+  Loading,
+  Confirmed,
+  Failed,
+}
+
+export enum TransactionAction {
+  None,
+  Deposit,
+  Mint,
+  PoolAdd,
+  PoolRemove,
+  Redeem,
+  Swap,
+  Bridge,
+  Transfer,
+  Withdraw,
+  Send,
+  HinkalStake,
+  HinkalUnstake,
+  Fund,
+  Receive,
+}

package/src/types/wc.types.ts

@@ -0,0 +1,83 @@
+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; // "0x53a1eeb0c182144b27ca0a2010939da33ebc207d"
+  to: string; // "0x4200000000000000000000000000000000000042"
+  gas?: string; // "0xd5b8"
+  gasPrice?: string; // "0x16e666"
+  value: string; // "0x0"
+  data?: string; // "0x095ea7b3000000000000000000000000000000000022d473030f116ddee9f6b43ac78ba3ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
+}
+
+export interface WCTransactionParameters<T = number> extends TxParametersBase {
+  chainId: T; // "0xa"
+}
+
+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;
+};

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

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

package/src/webworker/performTaskWithWorker.ts

@@ -0,0 +1,50 @@
+import { chainIds } from '../constants/chains.constants';
+import { isDevelopment } from '../constants/vite.constants';
+import { WorkerVariant } from './worker.registry';
+import { WorkerParams } from './worker.types';
+import { WorkerFactory } from './workerFactory';
+
+// OPTIMIZE: allow for keeping worker alive and reusing
+export const performTaskWithWorker = async <P, T>(workerData: { type: WorkerVariant; payload: P }) => {
+  const worker = await WorkerFactory.getWebWorker(workerData.type);
+
+  return new Promise<T>((resolve, reject) => {
+    let hostLocation = {};
+    if (typeof window !== 'undefined' && window.location) {
+      const { origin, protocol, host, port, hostname, href } = window.location;
+      hostLocation = {
+        origin,
+        protocol,
+        host,
+        port,
+        hostname,
+        href,
+      };
+    }
+
+    worker.onmessage = (result: { data: T | PromiseLike<T> }) => {
+      resolve(result.data);
+      worker.terminate();
+    };
+
+    worker.onerror = (err: unknown) => {
+      reject(err);
+      worker.terminate();
+    };
+
+    const message: WorkerParams<unknown> = {
+      payload: workerData.payload,
+      metadata: {
+        hostLocation,
+        constants: {
+          chains: {
+            chainIds,
+          },
+          isDevelopment,
+        },
+      },
+    };
+
+    worker.postMessage(message);
+  });
+};

package/src/webworker/snarkjsWorker/snarkjs.d.ts

@@ -0,0 +1,2 @@
+// The min snarkjs version that has type is 0.7; we are using 0.6.x so we need to manually declare module here.
+declare module 'snarkjs';

package/src/webworker/snarkjsWorker/snarkjsWorker.types.ts

@@ -0,0 +1,18 @@
+import { WorkerParams, WorkerPayload } from '../worker.types';
+
+export enum SnarkJSWorkerActionType {
+  FULL_PROVE,
+}
+
+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/src/webworker/snarkjsWorker/snarkjsWorkerLauncher.ts

@@ -0,0 +1,19 @@
+import { Buffer } from 'buffer';
+import process from 'process';
+import { addWorkerErrorHandler } from '../workerErrorHandler';
+import { SnarkJSParams } from './snarkjsWorker.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 snarkjsWorker = import('./snarkjsWorkerLogic');
+
+// eslint-disable-next-line no-restricted-globals
+addEventListener('message', async (e: MessageEvent<unknown>) => {
+  const { onWorkerMessage } = await snarkjsWorker;
+  onWorkerMessage(e.data as SnarkJSParams);
+});
+
+addWorkerErrorHandler();

package/src/webworker/snarkjsWorker/snarkjsWorkerLogic.ts

@@ -0,0 +1,90 @@
+/* eslint-disable @typescript-eslint/dot-notation */
+/**
+ * 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';
+import { isNode, isWebpack } from '../../constants/vite.constants';
+
+// DO NOT install @types for this, else hardhat will pick up the wrong file and fail (our version is older than oldest @types)
+// eslint-disable-next-line
+// @ts-ignore
+import * as snarkjs from 'snarkjs';
+import { httpClient } from '../../data-structures/tor';
+
+const workerProxy = new WorkerProxy();
+
+const fetchUint8Array = async (fileUrl: string) => {
+  return new Uint8Array(await httpClient.get<ArrayBuffer>(fileUrl, { responseType: 'arraybuffer' }));
+};
+
+export const onWorkerMessage = async (data: SnarkJSParams) => {
+  try {
+    const { input, wasmFilePath, zKeyFilePath, chainId } = data.payload.data;
+    const {
+      hostLocation: { origin },
+      constants: {
+        isDevelopment,
+        chains: { chainIds },
+      },
+    } = data.metadata;
+
+    // DEFAULT CASE: browser and production, so we access verifiers with remote links
+    let wasmFullFilePath = wasmFilePath;
+    let zKeyFullFilePath = zKeyFilePath;
+
+    let wasmFileBuffer: Uint8Array | undefined;
+    let zKeyFileBuffer: Uint8Array | undefined;
+
+    const isOnline = wasmFullFilePath.startsWith('https://');
+
+    // CASE 1: nodejs accessign files localy
+    if (isNode && !isOnline) {
+      // subcase 1: when nodejs code is bundled
+      if (isWebpack) {
+        wasmFullFilePath = `libs/hardhat/test/circuits/${wasmFilePath}`;
+        zKeyFullFilePath = `libs/hardhat/test/circuits/${zKeyFilePath}`;
+      }
+      // subcase 2: when nodejs code is not bundled
+      else if (!isWebpack && isDevelopment) {
+        wasmFullFilePath = `test/circuits/${wasmFilePath}`;
+        zKeyFullFilePath = `test/circuits/${zKeyFilePath}`;
+      }
+      // else if case: !isWebpack && !isDevelopment
+      // eslint-disable-next-line global-require, @typescript-eslint/no-var-requires
+      const path = require('path');
+      wasmFullFilePath = path.resolve(wasmFullFilePath);
+      zKeyFullFilePath = path.resolve(zKeyFullFilePath);
+      // CASE 2: nodejs accessing files remotely
+    }
+    if (isNode && isOnline) {
+      // In case, we have node enviroment that uses @hinkal/common as a library, snarkjs tries to read "https://..." from local, that's why we put here download operation. Otherwise, file is not found
+      // snarkjs uses fastfile to manage verifiers. We want to download file and provide it to snarkjs and do it in one line.
+      // @ts-ignore Here:https://github.com/iden3/fastfile/blob/master/src/fastfile.js Line 59, they use this variable to indicate to download file first and then to process. We need it even if we run in node enviroment.
+      wasmFileBuffer = await fetchUint8Array(wasmFullFilePath);
+      zKeyFileBuffer = await fetchUint8Array(zKeyFullFilePath);
+    }
+    // CASE 3: local developement and we access files localy
+    else if (chainId === chainIds['localhost'] && !isNode) {
+      wasmFullFilePath = `${origin}/${wasmFilePath}`;
+      zKeyFullFilePath = `${origin}/${zKeyFilePath}`;
+    }
+    const { proof, publicSignals } = await snarkjs.groth16.fullProve(
+      input,
+      wasmFileBuffer ?? wasmFullFilePath,
+      zKeyFileBuffer ?? zKeyFullFilePath,
+    );
+    const zkCallDataRaw = await snarkjs.groth16.exportSolidityCallData(proof, publicSignals);
+    const zkCallData = JSON.parse(`[${zkCallDataRaw}]`);
+
+    workerProxy.postMessageToMainThread({ zkCallData, proof, publicSignals });
+  } catch (err) {
+    console.error(err);
+    workerProxy.postErrorToMainThread(err);
+  }
+};
+
+workerProxy.attachWorkerSideOnMessage(onWorkerMessage);
+export default workerProxy;

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

@@ -0,0 +1,41 @@
+import { EncryptedOutputWithSign } from '../../types/commitments.types';
+import { WorkerParams, WorkerPayload } from '../worker.types';
+import { IUtxoConstructor } from '../../data-structures/utxo/Utxo';
+
+export enum UtxoWorkerActionType {
+  BATCH_FILTER_UTXOS_WITH_NULLIFIER,
+  BUILD_UTXOS,
+  DECIPHER_OUTPUTS,
+}
+
+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/src/webworker/utxoWorker/utxoWorkerLauncher.ts

@@ -0,0 +1,19 @@
+import { Buffer } from 'buffer';
+import process from 'process';
+import { addWorkerErrorHandler } from '../workerErrorHandler';
+import { UtxoWorkerParams } from './utxoWorker.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 utxoWorker = import('./utxoWorkerLogic');
+
+// eslint-disable-next-line no-restricted-globals
+addEventListener('message', async (e: MessageEvent<unknown>) => {
+  const { onWorkerMessage } = await utxoWorker;
+  onWorkerMessage(e.data as UtxoWorkerParams);
+});
+
+addWorkerErrorHandler();

package/src/webworker/utxoWorker/utxoWorkerLogic.ts

@@ -0,0 +1,107 @@
+import { preProcessing } from '../../crypto/preProcessing';
+import { stealthAddressCacheDevice, stealthPairCacheDevice, UserKeys } from '../../data-structures/crypto-keys/keys';
+import { Utxo } from '../../data-structures/utxo/Utxo';
+import { decryptUtxo, decryptUtxoConstructorArgs } from '../../data-structures/crypto-keys/encryptDecryptUtxo';
+import { checkUtxoSignature, decodeUtxoConstructorArgs } from '../../data-structures/crypto-keys/decodeUTXO';
+import { WorkerProxy } from '../workerProxy';
+import {
+  BatchFilterUtxosWithNullifierPayload,
+  BuildBatchProcessPayload,
+  DecipherProcessPayload,
+  UtxoWorkerActionType,
+  UtxoWorkerParams,
+} from './utxoWorker.types';
+
+const workerProxy = new WorkerProxy();
+
+export const handleFilterUtxosWithNullifier = async ({ data }: BatchFilterUtxosWithNullifierPayload) => {
+  const { utxos, nullifiers } = data;
+
+  const filteredUtxos = utxos.filter((serializedUtxo) => {
+    const utxo = new Utxo(serializedUtxo);
+    return !nullifiers.has(utxo.getNullifier());
+  });
+
+  workerProxy.postMessageToMainThread({
+    utxoConstructors: filteredUtxos,
+    stealthPairCache: stealthPairCacheDevice.serialize(),
+    stealthAddressCache: stealthAddressCacheDevice.serialize(),
+  });
+};
+
+export const handleBuildUtxosMessage = async ({ data }: BuildBatchProcessPayload) => {
+  const userKeys = new UserKeys(data.signature);
+  const shieldedPrivateKey = userKeys.getShieldedPrivateKey();
+  const decrypted = data.encryptedOutputs
+    .map((encryptedOutput) => {
+      try {
+        if (encryptedOutput.isPositive)
+          return decryptUtxoConstructorArgs(Buffer.from(encryptedOutput.value.slice(2), 'hex'), userKeys);
+        return decodeUtxoConstructorArgs(encryptedOutput.value, shieldedPrivateKey);
+      } catch {
+        return undefined;
+      }
+    })
+    .filter((val) => val !== undefined && val.amount !== 0n);
+  workerProxy.postMessageToMainThread(decrypted);
+};
+
+export const handleDecipherMessage = async ({ data }: DecipherProcessPayload) => {
+  const userKeys = new UserKeys(data.signature);
+  const additionalEncryptedOutputs = [];
+  const { encryptedOutputs } = data;
+  let { lastOutput } = data;
+  const shieldedPrivateKey = userKeys.getShieldedPrivateKey();
+  for (let i = 0; i < encryptedOutputs.length; i += 1) {
+    const output = encryptedOutputs[i];
+    lastOutput = output.value;
+    if (output.isPositive) {
+      try {
+        const decryptedUtxo = decryptUtxo(Buffer.from(lastOutput.slice(2), 'hex'), userKeys);
+
+        if (!decryptedUtxo.erc20TokenAddress || !decryptedUtxo.amount || !decryptedUtxo.stealthAddress)
+          throw Error('bruh');
+
+        additionalEncryptedOutputs.push(output);
+      } catch (error: unknown) {
+        // logError('Utxo not decrypted');
+      }
+    } else {
+      try {
+        const checked = checkUtxoSignature(lastOutput, shieldedPrivateKey);
+        if (checked) {
+          additionalEncryptedOutputs.push(output);
+        }
+      } catch (error: unknown) {
+        // logError('Utxo not decoded');
+      }
+    }
+  }
+  workerProxy.postMessageToMainThread({ additionalEncryptedOutputs, lastOutput });
+};
+
+export const onWorkerMessage = async (data: UtxoWorkerParams) => {
+  try {
+    await preProcessing();
+    const { type } = data.payload;
+    switch (type) {
+      case UtxoWorkerActionType.BATCH_FILTER_UTXOS_WITH_NULLIFIER:
+        await handleFilterUtxosWithNullifier(data.payload);
+        return;
+      case UtxoWorkerActionType.BUILD_UTXOS:
+        await handleBuildUtxosMessage(data.payload);
+        return;
+      case UtxoWorkerActionType.DECIPHER_OUTPUTS:
+        await handleDecipherMessage(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/src/webworker/viteWorkerURL.constant.ts

@@ -0,0 +1,25 @@
+/**
+ * These imports tell vite to generate and bundle worker file.
+ * These are import conditionally because we do not have vite when running on node.
+ */
+
+// eslint-disable-next-line
+// @ts-ignore
+import zkProofWorkerURL from './zkProofWorker/zkProofWorkerLauncher?worker&url';
+
+// eslint-disable-next-line
+// @ts-ignore
+import snarkjsWorkerURL from './snarkjsWorker/snarkjsWorkerLauncher?worker&url';
+
+// eslint-disable-next-line
+// @ts-ignore
+import utxoWorkerURL from './utxoWorker/utxoWorkerLauncher?worker&url';
+
+import { WorkerVariant } from './worker.registry';
+
+// Should be implemented as function for correct prebuild for CDN work
+export const getWorkerViteURL = async () => ({
+  [WorkerVariant.ZKProof]: zkProofWorkerURL,
+  [WorkerVariant.SnarkJS]: snarkjsWorkerURL,
+  [WorkerVariant.UTXO]: utxoWorkerURL,
+});

package/src/webworker/worker.registry.ts

@@ -0,0 +1,11 @@
+export enum WorkerVariant {
+  ZKProof = 'ZKProof',
+  SnarkJS = 'SnarkJS',
+  UTXO = 'UTXO',
+}
+
+export const workerNodeURL = {
+  [WorkerVariant.ZKProof]: './zkProofWorker/zkProofWorkerLogic.ts',
+  [WorkerVariant.SnarkJS]: './snarkjsWorker/snarkjsWorkerLogic.ts',
+  [WorkerVariant.UTXO]: './utxoWorker/utxoWorkerLogic.ts',
+};

package/src/webworker/worker.types.ts

@@ -0,0 +1,35 @@
+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/src/webworker/workerErrorHandler.ts

@@ -0,0 +1,10 @@
+/* eslint-disable no-restricted-globals */
+// this function adds an event listener for unhandledrejection error
+// unhandledrejection error happens when there was a promise error that wasn't handled
+// this is done because unhandled rejections aren't reported back
+// to the parent webworker instance's onerror callback function
+export const addWorkerErrorHandler = () => {
+  self.addEventListener('unhandledrejection', (event) => {
+    throw new Error(event.reason);
+  });
+};