@sabaaa1/common 0.0.8 → 0.0.9

package/.env.example

@@ -0,0 +1,5 @@
+CLOUDFRONT_URL=https://d13x2m0ev3hbsi.cloudfront.net
+S3_BUCKET=s3://hinkal-workers
+AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
+AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
+AWS_DEFAULT_REGION=us-west-1

package/.eslintrc.json

@@ -0,0 +1,18 @@
+{
+  "extends": ["../../../.eslintrc.json"],
+  "ignorePatterns": ["!**/*"],
+  "overrides": [
+    {
+      "files": ["*.ts", "*.tsx", "*.js", "*.jsx"],
+      "rules": {}
+    },
+    {
+      "files": ["*.ts", "*.tsx"],
+      "rules": {}
+    },
+    {
+      "files": ["*.js", "*.jsx"],
+      "rules": {}
+    }
+  ]
+}

package/README.md

@@ -0,0 +1,164 @@
+# Hinkal SDK
+
+Hinkal is middleware and a set of smart contracts on EVM chains that use ZK-proofs and stealth addresses to enable compliant and private transactions on major dApps. Users can privately store assets and transact on platforms such as Uniswap, Pendle, Lido, Curve, and others.
+
+This SDK enables users to perform arbitrary smart contract interactions privately.
+
+## Installation
+
+Using npm:
+
+```sh
+npm install @hinkal/common
+```
+
+Or, yarn:
+
+```sh
+yarn add @hinkal/common
+```
+
+### Usage
+
+#### Initialization
+
+To get started with Hinkal, initialize it based on the Web3 connection library you’re using:
+
+**ethers.js:**
+
+```typescript
+import { prepareEthersHinkal } from '@hinkal/common/providers/prepareEthersHinkal';
+// signer: ethers.Signer
+const hinkal = await prepareEthersHinkal(signer);
+```
+
+**wagmi:**
+
+```typescript
+import { prepareWagmiHinkal } from '@hinkal/common/providers/prepareWagmiHinkal';
+// connector: wagmi.Connector
+// config: wagmi.Config
+const hinkal = await prepareWagmiHinkal(connector, config);
+```
+
+#### Shielded balance
+
+Once the Hinkal object is initialized, shielded balances become accessible and can be calculated as needed:
+
+```typescript
+const balances = await hinkal.getBalances();
+```
+
+#### Depositing funds to the shielded balance
+
+A user can deposit funds to their shielded address using:
+
+```typescript
+function deposit(erc20addresses: string[], amountChanges: bigint[]): Promise<TransactionObject>;
+```
+
+where erc20Addresses is an array of token addresses, and amountChanges represents the token amounts for the deposit.
+
+#### Interacting with smart contracts privately
+
+After a user’s shielded balance is updated, they can perform any smart contract interaction privately using:
+
+```typescript
+function actionPrivateWallet(
+  erc20Addresses: string[],
+  amountChanges: bigint[],
+  onChainCreation: boolean[],
+  ops: string[],
+): Promise<TransactionObject>;
+```
+
+where onChainCreation indicates the amounts of tokens that are uncertain before the transaction is executed on-chain. The ops array contains encoded user operations.
+
+##### User operations
+
+To generate user operations (`ops`) you will need the `emporiumOp` function.
+```typescript
+import {emporiumOp} from "@hinkal/common";
+```
+
+The function accepts the following arguments:
+  1. `endpoint` *(required)* - target address or contract instance (with address). The contract instance will be used to properly encode the call function, if any, in the custom operation.
+  2. `func` *(optional)* - the name of the function to be called on the target address.
+  3. `args` *(optional)* - arguments of the function to be called on the target address.
+  4. `invokeWallet` *(optional)* - bool flag that determines the type of transaction. There are two types: stateful and stateless interaction. The default is false (stateless).
+  5. `value` *(optional)* - the amount of native currency to transfer to the target address.
+
+The `emporiumOp` function will generate data for subsequent calls, supporting both stateful interaction (with state preservation) and stateless interaction (without state preservation). This is determined by the `invokeWallet` flag.
+
+To execute on a smart contract, the user operation will be received in the following format:
+```solidity
+(address endpoint, bool invokeWallet, uint256 value, bytes data)
+```
+
+This will make it possible to make that kind of call:
+```solidity
+(bool success, bytes memory err) = endpoint.call{value: value}(data);
+```
+
+##### Stateless and stateful
+
+The best way to demonstrate how this works is with an example.
+
+**Stateless interaction**
+
+Let's say we need to exchange USDC for ETH using DEX. 
+
+```typescript
+const operations = [
+  emporiumOp(usdcContractInstance, 'approve', [swapRouterAddress, amountIn]),
+  emporiumOp(swapRouterContractInstance, 'exactInputSingle', [swapSingleParams]),
+  emporiumOp(wethContractInstance, 'withdraw', [amountOut]),
+];
+```
+
+To perform a DEX swap, DEX does not need to know historical data about the calling party (e.g. when and what swaps have been performed from this account in the past). It only needs the current token balance for the exchange.
+
+In this case it will be **stateless interaction**, so there is no need to change the default value of the `invokeWallet` flag.
+
+**Stateful interaction**
+
+Another example is when the protocol with which an account interacts needs to know what actions this account has done before, for example, to gain rewards. In this case, some account state will be required.
+
+Let's imagine that you already have Curve LP tokens and need to make a stake.
+
+```solidity
+const operations = [
+  emporiumOp(lpTokenInstance, 'approve', [gaugeAddressInstance, amount]), // without flag, because is's stateless interaction
+  emporiumOp(gaugeAddressInstance, 'deposit', [amount, invokeWalletAddress], true), // with flag, because it's stateful interaction
+];
+```
+
+As you can see, in this case `approve` is a stateless interaction, but `deposit` is a stateful interaction, because under the hood Curve will record this address and timestamp in order to calculate the checkpoint correctly in the future.
+
+### Access Tokens
+
+Before interacting with Hinkal smart contracts, users need to mint an access token after passing compliance checks.
+
+To check whether a user already has an access token, use the checkAccessToken function:
+
+```typescript
+function checkAccessToken(): Promise<boolean>;
+```
+
+If the user does not have an access token, they must use one of the compliance providers to pass the check. To view the available providers:
+
+```typescript
+function getSupportedPassportLinks(): string[];
+```
+
+After passing the compliance check, the user can mint an access token using:
+
+```typescript
+const { signatureData } = await hinkal.getAPI().getAccessTokenSignature(chainId, ethereumAddress, accessKey);
+await mintAccessToken(this, signatureData);
+```
+
+### References
+
+Application: [Hinkal](https://app.hinkal.pro)
+Docs: [Hinkal Documentation](https://hinkal-team.gitbook.io/hinkal)

package/copyPackageJson.js

@@ -0,0 +1,81 @@
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+
+// Function to increment the version number
+const incrementVersion = (version) => {
+  const versionParts = version.split('.').map(Number); // Split version into [major, minor, patch]
+  if (versionParts.length === 3) {
+    versionParts[2] += 1; // Increment the patch version
+    return versionParts.join('.'); // Return the updated version as a string
+  } else {
+    throw new Error('Invalid version format in package.json');
+  }
+};
+
+const destPath = '../../../dist/libs/shared/common';
+
+const emptyWorkerAssets = () => {
+  const workersAssetsPath = path.join(path.join(__dirname, destPath), 'assets');
+  const files = fs.readdirSync(workersAssetsPath);
+  files.forEach((file) => {
+    const filePath = path.join(workersAssetsPath, file);
+    fs.unlinkSync(filePath);
+  });
+};
+
+const copyWorkers = () => {
+  const prebuildWorkerPath = '../../../dist/libs/shared/workers-prebuild';
+  const destWorkerPath = destPath + '/webworker';
+
+  const preBuildWorkersCjs = path.join(path.join(__dirname, prebuildWorkerPath), 'viteWorkerURL.constant.common.js');
+  const cjsWorkers = path.join(path.join(__dirname, destWorkerPath), 'viteWorkerURL.constant.cjs');
+  fs.copyFileSync(preBuildWorkersCjs, cjsWorkers);
+
+  const preBuildWorkersMjs = path.join(path.join(__dirname, prebuildWorkerPath), 'viteWorkerURL.constant.es.js');
+  const mjsWorkers = path.join(path.join(__dirname, destWorkerPath), 'viteWorkerURL.constant.mjs');
+  fs.copyFileSync(preBuildWorkersMjs, mjsWorkers);
+  emptyWorkerAssets();
+  console.log('Copy Prebuilded workers finished');
+};
+
+export const copyPackage = () => {
+  return;
+  const pkgSrc = path.resolve(__dirname, 'package.json');
+  const pkgDest = path.resolve(path.join(__dirname, destPath), 'package.json');
+  console.log({ pkgSrc, pkgDest });
+
+  // Read and parse the package.json file
+  const packageJson = JSON.parse(fs.readFileSync(pkgSrc, 'utf-8'));
+
+  // Increment the version in the source folder's package.json
+  packageJson.version = incrementVersion(packageJson.version);
+  console.log({ version: packageJson.version });
+
+  // Write the updated package.json back to the source folder
+  fs.writeFileSync(pkgSrc, JSON.stringify(packageJson, null, 2), 'utf-8');
+
+  // Modify the "type" field or any other field in package.json
+  // packageJson.type = 'module'; // Example: changing type field to 'module'
+
+  // Ensure the destination directory exists and write the modified package.json to the destination
+  fs.mkdirSync(path.dirname(pkgDest), { recursive: true });
+  fs.writeFileSync(pkgDest, JSON.stringify(packageJson, null, 2), 'utf-8');
+
+  // Copy Readme
+  fs.copyFileSync(path.resolve(__dirname, 'README.md'), path.join(__dirname, `${destPath}/README.md`));
+  console.log('Modified and copied package.json to build folder');
+
+  // Copying Workers
+  copyWorkers();
+
+  // Navigate to the destination directory
+  try {
+    console.log('Publishing package to npm...');
+    // Execute `npm publish` in the destination directory
+    execSync('npm publish --access=public', { cwd: path.join(__dirname, destPath), stdio: 'inherit' });
+    console.log('Package successfully published to npm.');
+  } catch (error) {
+    console.error('Failed to publish package:', error.message);
+  }
+};

package/handleCDNWorkers.js

@@ -0,0 +1,92 @@
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+import { config } from 'dotenv';
+config();
+
+// Function to increment the version number
+const incrementVersion = (version) => {
+  const versionParts = version.split('.').map(Number); // Split version into [major, minor, patch]
+  if (versionParts.length === 3) {
+    versionParts[2] += 1; // Increment the patch version
+    return versionParts.join('.'); // Return the updated version as a string
+  } else {
+    throw new Error('Invalid version format in package.json');
+  }
+};
+
+const requireEnv = (name) => {
+  if (!process.env[name]) throw new Error(`${name} environment variable missing`);
+  return process.env[name];
+};
+
+const CDN_URL = requireEnv('CLOUDFRONT_URL');
+const s3Bucket = requireEnv('S3_BUCKET');
+const AWS_ACCESS_KEY_ID = requireEnv('AWS_ACCESS_KEY_ID');
+const AWS_SECRET_ACCESS_KEY = requireEnv('AWS_SECRET_ACCESS_KEY');
+const AWS_DEFAULT_REGION = requireEnv('AWS_DEFAULT_REGION');
+const mjsFileToRewrite = 'viteWorkerURL.constant.es.js';
+const cjsFileToRewrite = 'viteWorkerURL.constant.common.js';
+
+if (!CDN_URL || !s3Bucket || !AWS_ACCESS_KEY_ID || !AWS_SECRET_ACCESS_KEY || !AWS_DEFAULT_REGION)
+  throw new Error('Necessary Environment variable missing');
+
+const fileWithCDNWorkersContent = `
+  const domain = '${CDN_URL}';
+
+  // Returns a blob:// URL which points
+  // to a javascript file which will call
+  // importScripts with the given URL
+  async function getWorkerURL(url) {
+    const contentRes = await fetch(url);
+    const content = await contentRes.text()
+
+    return URL.createObjectURL(new Blob([content], { type: "application/javascript" }));
+  }
+
+  var e = /* @__PURE__ */ ((r) => (r.ZKProof = "ZKProof", r.SnarkJS = "SnarkJS", r.UTXO = "UTXO", r))(e || {});
+
+  const n = async () => ({
+    [e.ZKProof]: await getWorkerURL(domain + '____folder____' + 'zkProofWorkerLauncher.js'),
+    [e.SnarkJS]: await getWorkerURL(domain + '____folder____' + 'snarkjsWorkerLauncher.js'),
+    [e.UTXO]: await getWorkerURL(domain + '____folder____' + 'utxoWorkerLauncher.js'),
+  });
+  export { n as getWorkerViteURL };
+`;
+
+export const proccessCDN = () => {
+  const pkgSrc = path.resolve(__dirname, 'package.json');
+  const destDir = path.resolve(__dirname, '../../../dist/libs/shared/workers-prebuild'); // Adjust if your build output directory is different
+  // Read and parse the package.json file
+  const packageJson = JSON.parse(fs.readFileSync(pkgSrc, 'utf-8'));
+
+  // Increment the version in the source folder's package.json
+  const version = incrementVersion(packageJson.version);
+
+  const assets = fs.readdirSync(path.resolve(destDir, './assets'));
+  console.log(version, assets);
+  const folder = `/workers/${version}/`;
+
+  fs.mkdirSync(path.join(destDir, `workers`));
+  fs.mkdirSync(path.join(path.resolve(destDir, './workers'), `${version}`));
+
+  // e.g. of filename utxoWorkerLauncher-BEutOJO3.js, so utxoWorkerLauncher-BEutOJO3.js -> utxoWorkerLauncher.js
+  const filesDestinations = assets.map((file) => `${folder}${file.split('.')[0].split('-')[0]}.js`);
+
+  assets.forEach((file, index) => {
+    fs.copyFileSync(path.resolve(destDir, `./assets/${file}`), path.resolve(destDir, `.${filesDestinations[index]}`));
+  });
+
+  execSync(
+    `AWS_ACCESS_KEY_ID=${AWS_ACCESS_KEY_ID} AWS_SECRET_ACCESS_KEY=${AWS_SECRET_ACCESS_KEY} AWS_DEFAULT_REGION=${AWS_DEFAULT_REGION} aws s3 cp ${path.resolve(destDir, `./workers`)} ${s3Bucket} --recursive --acl=public-read`,
+    { cwd: path.dirname(destDir), stdio: 'inherit' },
+  );
+
+  const mjsFileContent = fileWithCDNWorkersContent.replaceAll('____folder____', `/${version}/`);
+  const cjsFileContent = fileWithCDNWorkersContent
+    .replaceAll('____folder____', `/${version}/`)
+    .replace('export { n as getWorkerViteURL };', 'exports.getWorkerViteURL = n;');
+
+  fs.writeFileSync(path.resolve(destDir, mjsFileToRewrite), mjsFileContent);
+  fs.writeFileSync(path.resolve(destDir, cjsFileToRewrite), cjsFileContent);
+};

package/jest.config.ts

@@ -0,0 +1,10 @@
+/* eslint-disable */
+export default {
+  displayName: 'shared-common',
+  testEnvironment: 'node',
+  transform: {
+    '^.+\\.[tj]s$': ['ts-jest', { tsconfig: '<rootDir>/tsconfig.spec.json' }],
+  },
+  preset: '../../../jest.preset.js',
+  coverageDirectory: '.',
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sabaaa1/common",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "homepage": "hinkal.pro",
   "author": {
     "name": "Hinkal Protocol"

package/polyfillWorker.ts

@@ -0,0 +1,15 @@
+import virtual from 'vite-plugin-virtual';
+
+const workerPolyfillCode = `
+export class Worker {
+    postMessage() {
+      return;
+    }
+    terminate() {
+      return;
+    }
+    onmessage = null;
+  };
+  `;
+
+export const polyfillWorker = () => virtual({ workerPolyfillCode });

package/project.json

@@ -0,0 +1,32 @@
+{
+  "name": "shared-common",
+  "$schema": "../../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "libs/shared/common/src",
+  "projectType": "library",
+  "tags": [],
+  "targets": {
+    "prebuild:workers": {
+      "command": "vite build --config ./libs/shared/common/vite.config.workers.ts"
+    },
+    "build": {
+      "executor": "@nx/vite:build",
+      "outputs": ["{options.outputPath}"],
+      "defaultConfiguration": "production",
+      "options": {
+        "outputPath": "dist/libs/shared/common",
+        "skipTypeCheck": true
+      }
+    },
+    "lint": {
+      "executor": "@nx/eslint:lint",
+      "outputs": ["{options.outputFile}"]
+    },
+    "test": {
+      "executor": "@nx/jest:jest",
+      "outputs": ["{workspaceRoot}/coverage/{projectRoot}"],
+      "options": {
+        "jestConfig": "libs/shared/common/jest.config.ts"
+      }
+    }
+  }
+}

package/src/API/API.ts

@@ -0,0 +1,203 @@
+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 const API: IAPI = {
+  // KYC
+  getUserKycStatus,
+  setAiPriseVerificationUrl,
+  getAccessTokenSignature,
+  getReclaimVerificationRequest,
+  getZkMeAccessToken,
+  userHasKyc,
+  // Prices
+  getTokenPrice,
+  getTokenPriceEth,
+  getTokenPrices,
+  getOdosPriceForToken,
+  // relay
+  getIdleRelay,
+  // password
+  userHasPassword,
+  userRegisterPassword,
+  // points
+  generateTradingPoints,
+  generateAumPoints,
+  // brotherhood
+  getBrotherhoodUsers,
+  getCurrentUserBrotherhoodUsers,
+  getBrotherhood,
+  editBrotherhood,
+  createBrotherhood,
+  getCurrentUserBrotherhood,
+  getPublicBrotherhoods,
+  leaveBrotherhood,
+  joinBrotherhood,
+  // weekly analytics
+  getUserAnalytics,
+  getBrotherhoodAnalytics,
+  // rewards user
+  connectRewardsUser,
+  updateRewardsUser,
+  disconnectSocialNetwork,
+  // leaderboard
+  getUserCurrentLeaderboard,
+  getBrotherhoodsLeaderboard,
+  // referral
+  getCurrentUserReferral,
+  submitReferralCode,
+  getCurrentUserAppliedReferralCode,
+  // AI
+  getTokenApprovalAmountRequest,
+  getTokenSpendsFromOrderMessageRequest,
+  // tenderly
+  isTxStateless,
+  simulateBatchTx,
+  // token calls
+  tokensInfoCall,
+  getTokenData,
+  // enclave
+  decryptUtxoEnclaveCall,
+  // bridge protocols
+  getBridgeProtocols,
+  // lifi
+  getLifiStatus,
+  // callbacks
+  sendTelegramCallback,
+  // tasks
+  getTasksProgress,
+  // swap streak
+  getSwapStreak,
+  // proxy accounts
+  getProxyAccounts,
+  updateProxyAccounts,
+  // mystery boxes
+  openMysteryBox,
+  getMysteryBoxesHistory,
+  createOrUpdateMerchAddress,
+  claimMerchItem,
+  getMerchOrders,
+  getCurrentDayBoxPrizeCounts,
+  // nft multiplier
+  getNftMultiplier,
+  // auction
+  getCurrentAuctionsInfo,
+  // server utc
+  getServerUtc,
+  // hexagate
+  monitor,
+};

package/src/API/admin-calls.ts

@@ -0,0 +1,8 @@
+import { RELAYER_CONFIG } from '../constants/server.constants';
+import { getRelayerURL } from './getRelayerURL';
+import { httpClient } from '../data-structures/tor';
+import { AdminDataType } from '../types/admin.types';
+
+export const emitTxPublicData = (chainId: number, adminData: AdminDataType | undefined) => {
+  return httpClient.post(`${getRelayerURL(chainId)}${RELAYER_CONFIG.emitTxPublicData}`, { adminData });
+};