@sabaaa1/common 0.0.1 → 0.0.3

package/src/types/transactions.types.ts

@@ -1,120 +0,0 @@
-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

@@ -1,83 +0,0 @@
-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

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

package/src/webworker/performTaskWithWorker.ts

@@ -1,50 +0,0 @@
-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

@@ -1,2 +0,0 @@
-// 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

@@ -1,18 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,90 +0,0 @@
-/* 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

@@ -1,41 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,107 +0,0 @@
-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

@@ -1,25 +0,0 @@
-/**
- * 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

@@ -1,11 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,10 +0,0 @@
-/* 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);
-  });
-};