@sabaaa1/common 0.0.8 → 0.0.9

package/src/webworker/workerFactory.ts

@@ -0,0 +1,47 @@
+import { isNode, isSandbox } from '../constants/vite.constants';
+import { WorkerVariant } from './worker.registry';
+
+export class WorkerFactory {
+  private constructor() {
+    // This class should be use as static class
+  }
+
+  private static resolveWorkerURL = async (workerVariant: WorkerVariant) => {
+    const { getWorkerViteURL }: any = await import('./viteWorkerURL.constant');
+
+    // Should be implemented as function for correct prebuild for CDN work
+    const workerViteURL = await getWorkerViteURL();
+
+    return workerViteURL[workerVariant];
+  };
+
+  private static createWorker = async (workerVariant: WorkerVariant) => {
+    if (isNode || isSandbox) {
+      let workerProxy: any; // TODO: do typing
+      // const workerProxy = await import(/* @vite-ignore */ workerNodeURL[workerVariant]); The vite-ignore flag need to be inside the import() call; Basically tell vite it does not have too bundle the import;
+      if (workerVariant === WorkerVariant.SnarkJS)
+        workerProxy = await import(/* @vite-ignore */ './snarkjsWorker/snarkjsWorkerLogic');
+      else if (workerVariant === WorkerVariant.ZKProof)
+        workerProxy = await import(/* @vite-ignore */ './zkProofWorker/zkProofWorkerLogic');
+      else if (workerVariant === WorkerVariant.UTXO)
+        workerProxy = await import(/* @vite-ignore */ './utxoWorker/utxoWorkerLogic');
+      return workerProxy.default;
+    }
+
+    const workerUrl = await WorkerFactory.resolveWorkerURL(workerVariant);
+    return new Worker(workerUrl, { type: 'module' });
+  };
+
+  public static getWebWorker(workerVariant: WorkerVariant) {
+    switch (workerVariant) {
+      case WorkerVariant.ZKProof:
+        return WorkerFactory.createWorker(workerVariant);
+      case WorkerVariant.SnarkJS:
+        return WorkerFactory.createWorker(workerVariant);
+      case WorkerVariant.UTXO:
+        return WorkerFactory.createWorker(workerVariant);
+      default:
+        throw Error(`Unknown worker type: ${workerVariant}`);
+    }
+  }
+}

package/src/webworker/workerProxy.ts

@@ -0,0 +1,88 @@
+/**
+ * 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 class WorkerProxy {
+  private isNode = false;
+
+  private isSandbox = false;
+
+  /**
+   * 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.
+   */
+  public onmessage: ((e: { data: any }) => void) | null = 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.
+   */
+  public onerror: ((e: { data: { error: unknown } }) => void) | null = null;
+
+  private _eventEmitter: any; // node EventEmitter
+
+  private get eventEmitter() {
+    if (this._eventEmitter) {
+      return this._eventEmitter;
+    }
+    if (this.isNode) {
+      // eslint-disable-next-line global-require, @typescript-eslint/no-var-requires
+      const EventEmitter = require('events');
+      this._eventEmitter = new EventEmitter();
+    } else {
+      this._eventEmitter = new EventTarget();
+    }
+    return this._eventEmitter;
+  }
+
+  public constructor() {
+    this.isNode = typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
+    this.isSandbox = typeof window !== 'undefined' && window.origin === 'null';
+  }
+
+  public terminate() {}
+
+  public postMessage(message: unknown) {
+    if (this.isNode) {
+      this.eventEmitter.emit('message', message);
+    } else if (this.isSandbox) {
+      this.eventEmitter?.dispatchEvent(new CustomEvent('worker-message', { detail: message }));
+    } else {
+      postMessage(message);
+    }
+  }
+
+  public postMessageToMainThread(message: unknown) {
+    const event = { data: message };
+    if (this.onmessage) {
+      this.onmessage(event);
+    } else postMessage(message);
+  }
+
+  public postErrorToMainThread(error: unknown) {
+    const event = { data: { error } };
+    if (this.onerror) {
+      this.onerror(event);
+    } else postMessage(error);
+  }
+
+  public attachWorkerSideOnMessage(fn: (e: any) => void | Promise<void>) {
+    if (this.isNode) {
+      this.eventEmitter.on('message', (message: any) => {
+        fn(message);
+      });
+    } else if (this.isSandbox) {
+      this.eventEmitter.addEventListener('worker-message', (message: any) => {
+        fn(message.detail);
+      });
+    }
+  }
+}

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

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

package/src/webworker/zkProofWorker/zkProofWorkerLauncher.ts

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

package/src/webworker/zkProofWorker/zkProofWorkerLogic.ts

@@ -0,0 +1,84 @@
+import { preProcessing } from '../../crypto/preProcessing';
+import { UserKeys } from '../../data-structures/crypto-keys/keys';
+import { IUtxoConstructor, Utxo } from '../../data-structures/utxo/Utxo';
+import {
+  calcAccessTokenSiblingsAndSides,
+  calcCommitmentsSiblingAndSides,
+} from '../../functions/snarkjs/common.snarkjs';
+import { WorkerProxy } from '../workerProxy';
+import {
+  ZKProofWorkerActionType,
+  ZKProofWorkerBuildInNullifiersPayload,
+  ZKProofWorkerCalcAccessTokenPayload,
+  ZKProofWorkerCalcCommitmentsPayload,
+  ZKProofWorkerParams,
+} from './zkProofWorker.types';
+import { contructMerkleTreeFromSerialized } from '../../functions/utils/merkleTree.utils';
+
+const workerProxy = new WorkerProxy();
+
+export const handleCalcCommitmentsSiblingAndSides = (payload: ZKProofWorkerCalcCommitmentsPayload) => {
+  const { inputUtxosSerialized, merkleTreeSerialized } = payload.data;
+
+  const merkleTree = contructMerkleTreeFromSerialized(merkleTreeSerialized);
+
+  const inputUtxos = inputUtxosSerialized.map((utxoList: IUtxoConstructor[]) =>
+    utxoList.map((serializedUtxo) => new Utxo(serializedUtxo)),
+  );
+
+  const { inCommitmentSiblings, inCommitmentSiblingSides } = calcCommitmentsSiblingAndSides(inputUtxos, merkleTree);
+  workerProxy.postMessageToMainThread({ inCommitmentSiblings, inCommitmentSiblingSides });
+};
+
+export const handleCalcAccessTokenSiblingAndSides = (payload: ZKProofWorkerCalcAccessTokenPayload) => {
+  const { userSignature, merkleTreeAccessTokenSerialized } = payload.data;
+  const userKeys = new UserKeys(userSignature);
+
+  const merkleTree = contructMerkleTreeFromSerialized(merkleTreeAccessTokenSerialized);
+
+  const { accessTokenSiblings, accessTokenSiblingSides } = calcAccessTokenSiblingsAndSides(userKeys, merkleTree);
+  workerProxy.postMessageToMainThread({ accessTokenSiblings, accessTokenSiblingSides });
+};
+
+export const handleBuildInNullifiers = (payload: ZKProofWorkerBuildInNullifiersPayload) => {
+  const { inputUtxosSerialized, onChainCreation, proverVersion } = payload.data;
+  const inputUtxos = inputUtxosSerialized.map((utxoList: IUtxoConstructor[]) =>
+    utxoList.map((serializedUtxo) => new Utxo(serializedUtxo)),
+  );
+  let result: string[][] = [];
+  if (proverVersion === 'v1x0') {
+    result = inputUtxos.map((token, index) =>
+      token.map((utxo) => (onChainCreation[index] ? '0' : utxo.getNullifier())),
+    );
+  } else {
+    result = inputUtxos.map((token) => token.map((utxo) => (utxo.amount === 0n ? '0' : utxo.getNullifier())));
+  }
+
+  workerProxy.postMessageToMainThread(result);
+};
+
+export const onWorkerMessage = async (data: ZKProofWorkerParams) => {
+  try {
+    await preProcessing();
+    const { type } = data.payload;
+    switch (type) {
+      case ZKProofWorkerActionType.CALC_COMMITMENTS_SIBLING_AND_SIDES:
+        handleCalcCommitmentsSiblingAndSides(data.payload);
+        return;
+      case ZKProofWorkerActionType.CALC_ACCESS_TOKEN_SIBLING_AND_SIDES:
+        handleCalcAccessTokenSiblingAndSides(data.payload);
+        return;
+      case ZKProofWorkerActionType.BUILD_IN_NULLIFIERS:
+        handleBuildInNullifiers(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/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "compilerOptions": {
+    "declaration": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "noImplicitOverride": true,
+    "noPropertyAccessFromIndexSignature": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "allowSyntheticDefaultImports": true
+  },
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ]
+}

package/tsconfig.lib.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../../dist/libs/shared/common",
+    "declaration": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["jest.config.ts", "src/**/*.spec.ts", "src/**/*.test.ts"]
+}

package/tsconfig.spec.json

@@ -0,0 +1,15 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../../dist/out-tsc",
+    "module": "CommonJS",
+    "esModuleInterop": true,
+    "types": ["jest", "node"],
+    "baseUrl": ".",
+    "moduleResolution": "node",
+    "paths": {
+      "@hinkal/common": ["./src/index.ts"]
+    }
+  },
+  "include": ["jest.config.ts", "src/**/*.test.ts", "src/**/*.spec.ts", "src/**/*.d.ts"]
+}

package/vite.config.ts

@@ -0,0 +1,76 @@
+/* eslint-disable import/no-extraneous-dependencies */
+import { defineConfig, UserConfig } from 'vite';
+import type { InlineConfig } from 'vitest';
+import { nxViteTsPaths } from '@nx/vite/plugins/nx-tsconfig-paths.plugin';
+import dts from 'vite-plugin-dts';
+import path from 'path';
+import { polyfillConstants } from '../../../vite.common';
+import { copyPackage } from './copyPackageJson';
+import { dependencies, devDependencies, peerDependencies } from './package.json';
+
+type ViteConfig = UserConfig & { test: InlineConfig };
+
+const config: ViteConfig = {
+  root: __dirname,
+  base: './',
+  plugins: [
+    polyfillConstants(),
+    dts({
+      entryRoot: 'src',
+      tsconfigPath: path.join(__dirname, 'tsconfig.lib.json'),
+    }),
+    nxViteTsPaths(),
+    {
+      name: 'copy-package-json',
+      apply: 'build',
+      closeBundle: copyPackage,
+    },
+  ],
+  worker: {
+    format: 'es',
+    plugins: () => [polyfillConstants(), nxViteTsPaths()],
+  },
+  build: {
+    target: 'esnext',
+    outDir: '../../../dist/libs/shared/common',
+    reportCompressedSize: true,
+    commonjsOptions: { transformMixedEsModules: true },
+    emptyOutDir: true,
+    lib: {
+      entry: [
+        'src/index.ts',
+        'src/providers/WagmiProviderAdapter.ts',
+        'src/providers/EthersProviderAdapter.ts',
+        'src/providers/prepareWagmiHinkal.ts',
+        'src/providers/prepareEthersHinkal.ts',
+      ],
+      name: 'shared-common',
+      fileName: (format, entryName) => `${entryName}.${format === 'cjs' ? 'cjs' : 'mjs'}`,
+      formats: ['es', 'cjs'],
+    },
+    rollupOptions: {
+      output: {
+        preserveModules: true,
+        preserveModulesRoot: path.resolve(__dirname, './src'),
+      },
+      external: (id) => {
+        const allDeps = [
+          ...Object.keys(dependencies),
+          ...Object.keys(devDependencies),
+          ...Object.keys(peerDependencies),
+        ];
+
+        // Match exact package or any subpath (e.g., '@wagmi/core' or '@wagmi/core/actions')
+        return allDeps.some((dep) => id === dep || id.startsWith(`${dep}/`));
+      },
+    },
+  },
+  test: {
+    globals: true,
+    environment: 'jsdom',
+    include: ['src/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
+    hookTimeout: 1000000,
+  },
+};
+
+export default defineConfig(config);

package/vite.config.workers.ts

@@ -0,0 +1,51 @@
+/* eslint-disable import/no-extraneous-dependencies */
+import { defineConfig } from 'vite';
+import { nxViteTsPaths } from '@nx/vite/plugins/nx-tsconfig-paths.plugin';
+import { polyfillConstants } from '../../../vite.common';
+import { proccessCDN } from './handleCDNWorkers';
+
+const config = {
+  root: __dirname,
+  base: './',
+
+  plugins: [
+    polyfillConstants(),
+    nxViteTsPaths(),
+    {
+      name: 'procces-cdn',
+      apply: 'build',
+      closeBundle: proccessCDN,
+    },
+  ],
+
+  worker: {
+    format: 'es',
+    plugins: () => [polyfillConstants(), nxViteTsPaths()],
+    rollupOptions: {
+      output: { inlineDynamicImports: true }, // this essentially merges WorkerLogic with WorkerLauncher
+    },
+  },
+
+  // Configuration for building your library.
+  // See: https://vitejs.dev/guide/build.html#library-mode
+  build: {
+    target: 'esnext', // Ensures the output targets the latest ESM features
+    outDir: '../../../dist/libs/shared/workers-prebuild',
+    reportCompressedSize: true,
+    commonjsOptions: { transformMixedEsModules: true },
+    emptyOutDir: true,
+    lib: {
+      // Could also be a dictionary or array of multiple entry points.
+      entry: ['src/webworker/viteWorkerURL.constant.ts'],
+      name: 'workers-prebuild',
+      formats: ['es'],
+      fileName: (format, entryName) => `${entryName}.js`,
+    },
+    rollupOptions: {
+      // output: { inlineDynamicImports: true }, // this does not affect anything - there is no dynamic import
+      exclude: [], // why we need this?
+    },
+  },
+};
+
+export default defineConfig(config);

package/API/API.cjs

@@ -1 +0,0 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const u=require("./relayCalls.cjs"),n=require("./passwordCalls.cjs"),s=require("./getTokenPrice.cjs"),t=require("./kycCalls.cjs"),h=require("./callOdosAPI.cjs"),i=require("./ai-calls.cjs"),C=require("./is-tx-stateless.cjs"),y=require("./simulate-batch-tx.cjs"),P=require("./token-calls.cjs"),k=require("./get-token-data.cjs"),B=require("./enclaveCalls.cjs"),T=require("./getBridgeProtocols.cjs"),A=require("./getLifiStatus.cjs"),c=require("./generate-trading-points.cjs"),e=require("./brotherhoodCalls.cjs"),l=require("./leaderboardCalls.cjs"),a=require("./referralsCalls.cjs"),o=require("./rewardsUserCalls.cjs"),g=require("./weeklyAnalyticCalls.cjs"),U=require("./send-telegram-callback.cjs"),d=require("./proxyAccountsCalls.cjs"),r=require("./mysteryBoxesCalls.cjs"),q=require("./callMonitor.cjs"),p={getUserKycStatus:t.getUserKycStatus,setAiPriseVerificationUrl:t.setAiPriseVerificationUrl,getAccessTokenSignature:t.getAccessTokenSignature,getReclaimVerificationRequest:t.getReclaimVerificationRequest,getZkMeAccessToken:t.getZkMeAccessToken,userHasKyc:t.userHasKyc,getTokenPrice:s.getTokenPrice,getTokenPriceEth:s.getTokenPriceEth,getTokenPrices:s.getTokenPrices,getOdosPriceForToken:h.getOdosPriceForToken,getIdleRelay:u.getIdleRelay,userHasPassword:n.userHasPassword,userRegisterPassword:n.userRegisterPassword,generateTradingPoints:c.generateTradingPoints,generateAumPoints:c.generateAumPoints,getBrotherhoodUsers:e.getBrotherhoodUsers,getCurrentUserBrotherhoodUsers:e.getCurrentUserBrotherhoodUsers,getBrotherhood:e.getBrotherhood,editBrotherhood:e.editBrotherhood,createBrotherhood:e.createBrotherhood,getCurrentUserBrotherhood:e.getCurrentUserBrotherhood,getPublicBrotherhoods:e.getPublicBrotherhoods,leaveBrotherhood:e.leaveBrotherhood,joinBrotherhood:e.joinBrotherhood,getUserAnalytics:g.getUserAnalytics,getBrotherhoodAnalytics:g.getBrotherhoodAnalytics,connectRewardsUser:o.connectRewardsUser,updateRewardsUser:o.updateRewardsUser,disconnectSocialNetwork:o.disconnectSocialNetwork,getUserCurrentLeaderboard:l.getUserCurrentLeaderboard,getBrotherhoodsLeaderboard:l.getBrotherhoodsLeaderboard,getCurrentUserReferral:a.getCurrentUserReferral,submitReferralCode:a.submitReferralCode,getCurrentUserAppliedReferralCode:a.getCurrentUserAppliedReferralCode,getTokenApprovalAmountRequest:i.getTokenApprovalAmountRequest,getTokenSpendsFromOrderMessageRequest:i.getTokenSpendsFromOrderMessageRequest,isTxStateless:C.isTxStateless,simulateBatchTx:y.simulateBatchTx,tokensInfoCall:P.tokensInfoCall,getTokenData:k.getTokenData,decryptUtxoEnclaveCall:B.decryptUtxoEnclaveCall,getBridgeProtocols:T.getBridgeProtocols,getLifiStatus:A.getLifiStatus,sendTelegramCallback:U.sendTelegramCallback,getTasksProgress:o.getTasksProgress,getSwapStreak:o.getSwapStreak,getProxyAccounts:d.getProxyAccounts,updateProxyAccounts:d.updateProxyAccounts,openMysteryBox:r.openMysteryBox,getMysteryBoxesHistory:r.getMysteryBoxesHistory,createOrUpdateMerchAddress:r.createOrUpdateMerchAddress,claimMerchItem:r.claimMerchItem,getMerchOrders:r.getMerchOrders,getCurrentDayBoxPrizeCounts:r.getCurrentDayBoxPrizeCounts,getNftMultiplier:o.getNftMultiplier,getCurrentAuctionsInfo:r.getCurrentAuctionsInfo,getServerUtc:r.getServerUtc,monitor:q.monitor};exports.API=p;

package/API/API.d.ts

@@ -1,84 +0,0 @@
-import { getIdleRelay } from './relayCalls';
-import { userHasPassword, userRegisterPassword } from './passwordCalls';
-import { getTokenPrice, getTokenPriceEth, getTokenPrices } from './getTokenPrice';
-import { getAccessTokenSignature, getReclaimVerificationRequest, getUserKycStatus, getZkMeAccessToken, setAiPriseVerificationUrl, userHasKyc } from './kycCalls';
-import { getOdosPriceForToken } from './callOdosAPI';
-import { getTokenApprovalAmountRequest, getTokenSpendsFromOrderMessageRequest } from './ai-calls';
-import { isTxStateless } from './is-tx-stateless';
-import { simulateBatchTx } from './simulate-batch-tx';
-import { tokensInfoCall } from './token-calls';
-import { getTokenData } from './get-token-data';
-import { decryptUtxoEnclaveCall } from './enclaveCalls';
-import { getBridgeProtocols } from './getBridgeProtocols';
-import { getLifiStatus } from './getLifiStatus';
-import { generateAumPoints, generateTradingPoints } from './generate-trading-points';
-import { createBrotherhood, editBrotherhood, getBrotherhood, getBrotherhoodUsers, getCurrentUserBrotherhood, getCurrentUserBrotherhoodUsers, getPublicBrotherhoods, joinBrotherhood, leaveBrotherhood } from './brotherhoodCalls';
-import { getBrotherhoodsLeaderboard, getUserCurrentLeaderboard } from './leaderboardCalls';
-import { getCurrentUserAppliedReferralCode, getCurrentUserReferral, submitReferralCode } from './referralsCalls';
-import { connectRewardsUser, disconnectSocialNetwork, getNftMultiplier, getSwapStreak, getTasksProgress, updateRewardsUser } from './rewardsUserCalls';
-import { getBrotherhoodAnalytics, getUserAnalytics } from './weeklyAnalyticCalls';
-import { sendTelegramCallback } from './send-telegram-callback';
-import { getProxyAccounts, updateProxyAccounts } from './proxyAccountsCalls';
-import { claimMerchItem, createOrUpdateMerchAddress, getCurrentAuctionsInfo, getCurrentDayBoxPrizeCounts, getMerchOrders, getMysteryBoxesHistory, getServerUtc, openMysteryBox } from './mysteryBoxesCalls';
-import { monitor } from './callMonitor';
-export type IAPI = {
-    getUserKycStatus: typeof getUserKycStatus;
-    setAiPriseVerificationUrl: typeof setAiPriseVerificationUrl;
-    getAccessTokenSignature: typeof getAccessTokenSignature;
-    getReclaimVerificationRequest: typeof getReclaimVerificationRequest;
-    getZkMeAccessToken: typeof getZkMeAccessToken;
-    getTokenPrice: typeof getTokenPrice;
-    getTokenPriceEth: typeof getTokenPriceEth;
-    getTokenPrices: typeof getTokenPrices;
-    getOdosPriceForToken: typeof getOdosPriceForToken;
-    getIdleRelay: typeof getIdleRelay;
-    userHasPassword: typeof userHasPassword;
-    userRegisterPassword: typeof userRegisterPassword;
-    getTokenApprovalAmountRequest: typeof getTokenApprovalAmountRequest;
-    getTokenSpendsFromOrderMessageRequest: typeof getTokenSpendsFromOrderMessageRequest;
-    isTxStateless: typeof isTxStateless;
-    simulateBatchTx: typeof simulateBatchTx;
-    tokensInfoCall: typeof tokensInfoCall;
-    getTokenData: typeof getTokenData;
-    decryptUtxoEnclaveCall: typeof decryptUtxoEnclaveCall;
-    getBridgeProtocols: typeof getBridgeProtocols;
-    getLifiStatus: typeof getLifiStatus;
-    userHasKyc: typeof userHasKyc;
-    generateTradingPoints: typeof generateTradingPoints;
-    getBrotherhoodUsers: typeof getBrotherhoodUsers;
-    getCurrentUserBrotherhoodUsers: typeof getCurrentUserBrotherhoodUsers;
-    editBrotherhood: typeof editBrotherhood;
-    createBrotherhood: typeof createBrotherhood;
-    getCurrentUserBrotherhood: typeof getCurrentUserBrotherhood;
-    getPublicBrotherhoods: typeof getPublicBrotherhoods;
-    leaveBrotherhood: typeof leaveBrotherhood;
-    joinBrotherhood: typeof joinBrotherhood;
-    getUserAnalytics: typeof getUserAnalytics;
-    connectRewardsUser: typeof connectRewardsUser;
-    getBrotherhood: typeof getBrotherhood;
-    updateRewardsUser: typeof updateRewardsUser;
-    getUserCurrentLeaderboard: typeof getUserCurrentLeaderboard;
-    getBrotherhoodsLeaderboard: typeof getBrotherhoodsLeaderboard;
-    getCurrentUserReferral: typeof getCurrentUserReferral;
-    submitReferralCode: typeof submitReferralCode;
-    getCurrentUserAppliedReferralCode: typeof getCurrentUserAppliedReferralCode;
-    sendTelegramCallback: typeof sendTelegramCallback;
-    generateAumPoints: typeof generateAumPoints;
-    getSwapStreak: typeof getSwapStreak;
-    getBrotherhoodAnalytics: typeof getBrotherhoodAnalytics;
-    getTasksProgress: typeof getTasksProgress;
-    disconnectSocialNetwork: typeof disconnectSocialNetwork;
-    getProxyAccounts: typeof getProxyAccounts;
-    updateProxyAccounts: typeof updateProxyAccounts;
-    openMysteryBox: typeof openMysteryBox;
-    getMysteryBoxesHistory: typeof getMysteryBoxesHistory;
-    createOrUpdateMerchAddress: typeof createOrUpdateMerchAddress;
-    claimMerchItem: typeof claimMerchItem;
-    getMerchOrders: typeof getMerchOrders;
-    getNftMultiplier: typeof getNftMultiplier;
-    getCurrentDayBoxPrizeCounts: typeof getCurrentDayBoxPrizeCounts;
-    getCurrentAuctionsInfo: typeof getCurrentAuctionsInfo;
-    getServerUtc: typeof getServerUtc;
-    monitor: typeof monitor;
-};
-export declare const API: IAPI;