@sabaaa1/common 0.0.1

package/src/API/enclaveCalls.ts

@@ -0,0 +1,23 @@
+import { type EncryptedOutputWithSign } from '../types/commitments.types';
+import { type IUtxoConstructor } from '../data-structures/utxo/Utxo';
+import { ENCLAVE_EC2_URL } from '../functions/snarkjs/constant';
+import { httpClient } from '../data-structures/tor';
+
+type DecryptUtxoEnclaveCallResponse = {
+  utxos: IUtxoConstructor<string>[];
+  encryptedOutputs: EncryptedOutputWithSign[];
+  lastOutput: string;
+};
+
+export const decryptUtxoEnclaveCall = async (
+  chainId: number,
+  keyCiphertext: string,
+  inputCiphertext: string,
+): Promise<DecryptUtxoEnclaveCallResponse> => {
+  const enclaveResponse = await httpClient.post<DecryptUtxoEnclaveCallResponse>(`${ENCLAVE_EC2_URL}/decrypt-utxos`, {
+    chainId,
+    input: inputCiphertext,
+    key: keyCiphertext,
+  });
+  return enclaveResponse;
+};

package/src/API/fetchCommitmentsCache.ts

@@ -0,0 +1,63 @@
+import { API_CONFIG } from '../constants/server.constants';
+import { MerkleTreeJson } from '../data-structures/merkle-tree/MerkleTree';
+import { SenderAddressIndexMapJson } from '../data-structures/event-service/AbstractAccessTokenSnapshotService';
+import { ApprovedUtxo, EncryptedOutputWithSign } from '../types';
+import { getSnapshotServerURL } from './getServerURL';
+import { httpClient } from '../data-structures/tor';
+
+export interface ICommitmentsTreeSnapshot {
+  merkleTree: MerkleTreeJson;
+  latestBlockNumber: number;
+  encryptedOutputs: EncryptedOutputWithSign<string>[];
+  hinkalAddress: string;
+  chainId: number;
+}
+
+export interface IAccessTokenTreeSnapshot {
+  merkleTree: MerkleTreeJson;
+  senderAddresses: string[];
+  senderAddressIndexMap?: SenderAddressIndexMapJson;
+  latestBlockNumber: number;
+  accessTokenContractAddress: string;
+  chainId: number;
+}
+
+export interface IApprovalsSnapshot {
+  approvals: Record<string, ApprovedUtxo<string>[]>;
+  events: string[];
+  latestBlockNumber: number;
+  hinkalAddress: string;
+  chainId: number;
+}
+
+export interface INullifiersSnapshot {
+  nullifiers: string[];
+  latestBlockNumber: number;
+}
+
+export interface ISnapshotsResponse {
+  commitments: ICommitmentsTreeSnapshot;
+  accessTokens: IAccessTokenTreeSnapshot;
+  nullifiers: INullifiersSnapshot;
+  approvals: IApprovalsSnapshot;
+}
+
+export const fetchSnapshots = async (chainId: number): Promise<ISnapshotsResponse> => {
+  const { commitments, accessTokens, nullifiers, approvals } = await httpClient.get(
+    `${getSnapshotServerURL(chainId)}${API_CONFIG.ROUTES.getSnapshots}`,
+  );
+
+  const [commitmentsData, accessTokensData, nullifiersData, approvalsData] = await Promise.all([
+    httpClient.get(commitments.url).then((r) => ({ ...r, ...commitments })),
+    httpClient.get(accessTokens.url).then((r) => ({ ...r, ...accessTokens })),
+    httpClient.get(nullifiers.url).then((r) => ({ ...r, ...nullifiers })),
+    httpClient.get(approvals.url).then((r) => ({ ...r, ...approvals })),
+  ]);
+
+  return {
+    commitments: commitmentsData,
+    accessTokens: accessTokensData,
+    nullifiers: nullifiersData,
+    approvals: approvalsData,
+  };
+};

package/src/API/generate-trading-points.ts

@@ -0,0 +1,77 @@
+import { DATA_SERVER_CONFIG } from '../constants/server.constants';
+import { DATA_SERVER_URL } from './getServerURL';
+import { AppMetaData, MinimalActivity, RewardsUser, TokenChanges, TradingType, UserWeeklyAnalytic } from '../types';
+import { httpClient } from '../data-structures/tor';
+import { getSignatureHeader } from '../functions/utils/get-signature-header';
+
+interface GenerateTradingPointsProps {
+  ethereumAddress: string;
+  type: TradingType;
+  signature: string;
+  proxyAddress: string;
+  tokenChanges?: TokenChanges<bigint>[];
+  appMetaData?: AppMetaData;
+  chainId?: number;
+}
+
+interface GenerateTradingPointsRes {
+  success: boolean;
+  weeklyAnalytic: UserWeeklyAnalytic;
+}
+
+export const generateTradingPoints = async ({
+  tokenChanges,
+  ethereumAddress,
+  type,
+  signature,
+  appMetaData,
+  chainId,
+  proxyAddress,
+}: GenerateTradingPointsProps): Promise<GenerateTradingPointsRes> => {
+  return httpClient.patch(
+    `${DATA_SERVER_URL}${DATA_SERVER_CONFIG.generateTradingPoints}`,
+    {
+      tokenChanges: tokenChanges?.map(({ amount, ...rest }) => ({
+        ...rest,
+        amount: amount.toString(),
+      })),
+      ethereumAddress,
+      type,
+      appMetaData,
+      chainId,
+      proxyAddress,
+    },
+    getSignatureHeader(signature),
+  );
+};
+
+interface GenerateAumPointsProps {
+  ethereumAddress: string;
+  activity: MinimalActivity[];
+  signature?: string;
+  proxyAddress?: string;
+}
+
+interface GenerateAumPointsRes {
+  message: string;
+  user: RewardsUser;
+}
+
+export const generateAumPoints = async ({
+  ethereumAddress,
+  activity,
+  signature,
+  proxyAddress,
+}: GenerateAumPointsProps): Promise<GenerateAumPointsRes> => {
+  const data = await httpClient.post(
+    `${DATA_SERVER_URL}${DATA_SERVER_CONFIG.generateAumPoints}`,
+    {
+      ethereumAddress,
+      activity,
+      proxyAddress,
+    },
+    getSignatureHeader(signature),
+  );
+
+  return data;
+};

package/src/API/get-token-data.ts

@@ -0,0 +1,12 @@
+import { API_CONFIG } from '../constants/server.constants';
+import { getServerURL } from './getServerURL';
+import { httpClient } from '../data-structures/tor';
+
+interface TokenDataResponse {
+  totalSupply: number;
+  marketCap: number;
+}
+
+export const getTokenData = async (chainId: number, tokenSymbol: string): Promise<TokenDataResponse> => {
+  return httpClient.get<TokenDataResponse>(`${getServerURL(chainId)}${API_CONFIG.ROUTES.getTokenData(tokenSymbol)}`);
+};

package/src/API/getBridgeProtocols.ts

@@ -0,0 +1,16 @@
+import { getServerURL } from './getServerURL';
+import { API_CONFIG } from '../constants/server.constants';
+import { BridgeProtocolQuery } from '../types/bridging.types';
+import { httpClient } from '../data-structures/tor';
+
+export type BridgeProtocolMatchResult = BridgeProtocolQuery & {
+  matched: boolean;
+};
+
+export const getBridgeProtocols = async (
+  chainId: number,
+  queries: BridgeProtocolQuery[],
+): Promise<{ results: BridgeProtocolMatchResult[] }> => {
+  const response = await httpClient.post(`${getServerURL(chainId)}${API_CONFIG.ROUTES.getBridgeProtocols}`, queries);
+  return response;
+};

package/src/API/getCoingeckoPrice.ts

@@ -0,0 +1,59 @@
+import axios from 'axios';
+import {
+  COINGECKO_API_KEY,
+  coingeckoPriceUrl,
+  coingeckoPriceUrl2,
+  coingeckoTokenListUrl,
+  proHeader,
+} from '../constants/coingecko.constants';
+import { CoingeckoToken } from '../types/coingecko.types';
+
+export interface CoingeckoPriceResponse {
+  usd: number;
+  eth: number;
+}
+
+export async function getCoingeckoPrice(tokenId: string): Promise<CoingeckoPriceResponse> {
+  return (
+    await axios.get(coingeckoPriceUrl(tokenId), {
+      headers: { [proHeader]: COINGECKO_API_KEY || '' },
+    })
+  ).data[tokenId];
+}
+
+/**
+ * Fetches the price of a token from Coingecko API based on token address and platform.
+ * Also Coingecko API works for lowercased addresses, so that is why we lowercase inside the function.
+ * @param tokenAddress The address of the token contract.
+ * @param platform The platform identifier for the token.
+ * @returns Promise resolving to CoingeckoPriceResponse object.
+ */
+export async function getCoingeckoPrice2(tokenAddress: string, platform: string): Promise<CoingeckoPriceResponse> {
+  const lowercasedTokenAddress = tokenAddress.toLowerCase();
+
+  return (
+    await axios.get(coingeckoPriceUrl2(lowercasedTokenAddress, platform), {
+      headers: { [proHeader]: COINGECKO_API_KEY || '' },
+    })
+  ).data[tokenAddress];
+}
+
+export interface CoingeckoPricesResponse {
+  [coingeckoId: string]: {
+    usd?: number;
+    eth?: number;
+  };
+}
+
+export async function getCoingeckoPrices(tokenIds: string): Promise<CoingeckoPricesResponse> {
+  return (
+    await axios.get(coingeckoPriceUrl(tokenIds), {
+      headers: { [proHeader]: COINGECKO_API_KEY || '' },
+    })
+  ).data;
+}
+
+export async function getCoingeckoTokenList(): Promise<CoingeckoToken[]> {
+  const coinList: CoingeckoToken[] = await axios.get(coingeckoTokenListUrl);
+  return coinList;
+}

package/src/API/getGasEstimates.ts

@@ -0,0 +1,30 @@
+import { RELAYER_CONFIG } from '../constants/server.constants';
+import { getRelayerURL } from './getRelayerURL';
+import { ExternalActionId } from '../types/external-action.types';
+import { CallInfo } from '../types/API.types';
+import { httpClient } from '../data-structures/tor';
+
+interface GetGasEstimateResponse {
+  status: 'success' | 'failed';
+  priceOfTransactionInUSD?: number;
+  priceOfTransactionInToken?: number;
+}
+
+export const getGasEstimates = async (
+  chainId: number,
+  tokenAddress: string,
+  externalActionId: ExternalActionId,
+  erc20TokenAddressLength: number,
+  calls: CallInfo<string>[],
+  gasAmount?: number,
+): Promise<GetGasEstimateResponse> => {
+  return httpClient.post(
+    `${getRelayerURL(chainId)}${RELAYER_CONFIG.getGasEstimate(
+      tokenAddress,
+      externalActionId,
+      erc20TokenAddressLength,
+      gasAmount,
+    )}`,
+    { calls },
+  );
+};

package/src/API/getLifiStatus.ts

@@ -0,0 +1,35 @@
+import { getServerURL } from './getServerURL';
+import { API_CONFIG } from '../constants/server.constants';
+import { httpClient } from '../data-structures/tor';
+
+interface LifiTxStatus {
+  txHash: string;
+  amount: string;
+  token: {
+    address: string;
+    chainId: string;
+  };
+}
+
+export enum LifiStatus {
+  PENDING = 'PENDING',
+  DONE = 'DONE',
+  NOT_FOUND = 'NOT_FOUND',
+  FAILED = 'FAILED',
+}
+
+// note; only stuff that that is relevant to us
+// more info here: https://docs.li.fi/api-reference/check-the-status-of-a-cross-chain-transfer
+export interface LifiStatusResponse {
+  status: LifiStatus;
+  tool: string;
+  sending: LifiTxStatus;
+  receiving?: LifiTxStatus;
+}
+
+export const getLifiStatus = async (chainId: number, txHash: string) => {
+  const urlSearchParams = new URLSearchParams([['txHash', txHash]]);
+  return httpClient.get<{ lifiResponse: LifiStatusResponse }>(
+    `${getServerURL(chainId)}${API_CONFIG.ROUTES.lifiStatus}?${urlSearchParams}`,
+  );
+};

package/src/API/getRelayerURL.ts

@@ -0,0 +1,27 @@
+import { PLAYGROUND_RELAYER_URLS, PRODUCTION_RELAYER_URLS, STAGING_RELAYER_URLS } from '../constants/server.constants';
+import { chainIds } from '../constants/chains.constants';
+import { DEPLOYMENT_MODE, deploymentMode } from '../constants/vite.constants';
+
+export const getRelayerURL = (chainId: number) => {
+  let URLS;
+  if (deploymentMode === DEPLOYMENT_MODE.DEVELOPMENT) {
+    URLS = STAGING_RELAYER_URLS;
+  } else if (deploymentMode === DEPLOYMENT_MODE.PLAYGROUND) {
+    URLS = PLAYGROUND_RELAYER_URLS;
+  } else if (deploymentMode === DEPLOYMENT_MODE.STAGING) {
+    URLS = STAGING_RELAYER_URLS;
+  } else if (deploymentMode === DEPLOYMENT_MODE.PRODUCTION) {
+    URLS = PRODUCTION_RELAYER_URLS;
+  } else {
+    URLS = PRODUCTION_RELAYER_URLS;
+  }
+  if (chainId === chainIds.polygon) return URLS.polygon;
+  if (chainId === chainIds.arbMainnet) return URLS.arbMainnet;
+  if (chainId === chainIds.ethMainnet) return URLS.ethMainnet;
+  if (chainId === chainIds.bnbMainnet) return URLS.bnbMainnet;
+  if (chainId === chainIds.avalanche) return URLS.avalanche;
+  if (chainId === chainIds.optimism) return URLS.optimism;
+  if (chainId === chainIds.base) return URLS.base;
+  if (chainId === chainIds.arcTestnet) return URLS.arcTestnet;
+  return URLS.ethMainnet;
+};

package/src/API/getServerURL.ts

@@ -0,0 +1,116 @@
+import { chainIds } from '../constants/chains.constants';
+import {
+  DATA_SERVER_URL_ENDPOINT,
+  PLAYGROUND_SERVER_URLS,
+  PLAYGROUND_SNAPSHOT_SERVER_URLS,
+  PLAYGROUND_URL,
+  PRODUCTION_SERVER_URLS,
+  PRODUCTION_SNAPSHOT_SERVER_URLS,
+  PRODUCTION_URL,
+  STAGING_SERVER_URLS,
+  STAGING_SNAPSHOT_SERVER_URLS,
+  STAGING_URL,
+} from '../constants/server.constants';
+import { DEPLOYMENT_MODE, deploymentMode } from '../constants/vite.constants';
+
+// SERVER URLS
+export const getServerURL = (chainId: number) => {
+  let URLS;
+  if (deploymentMode === DEPLOYMENT_MODE.DEVELOPMENT) {
+    URLS = STAGING_SERVER_URLS;
+  } else if (deploymentMode === DEPLOYMENT_MODE.PLAYGROUND) {
+    URLS = PLAYGROUND_SERVER_URLS;
+  } else if (deploymentMode === DEPLOYMENT_MODE.STAGING) {
+    URLS = STAGING_SERVER_URLS;
+  } else if (deploymentMode === DEPLOYMENT_MODE.PRODUCTION) {
+    URLS = PRODUCTION_SERVER_URLS;
+  } else {
+    URLS = PRODUCTION_SERVER_URLS;
+  }
+
+  switch (chainId) {
+    case chainIds.polygon:
+      return URLS.polygon;
+    case chainIds.arbMainnet:
+      return URLS.arbMainnet;
+    case chainIds.ethMainnet:
+      return URLS.ethMainnet;
+    case chainIds.avalanche:
+      return URLS.avalanche;
+    case chainIds.bnbMainnet:
+      return URLS.bnbMainnet;
+    case chainIds.optimism:
+      return URLS.optimism;
+    case chainIds.base:
+      return URLS.base;
+    case chainIds.arcTestnet:
+      return URLS.arcTestnet;
+    case chainIds.localhost:
+      return URLS.localhost;
+    default:
+      return URLS.ethMainnet;
+  }
+};
+
+// SNAPSHOT SERVER URLS
+export const getSnapshotServerURL = (chainId: number) => {
+  let URLS;
+
+  if (deploymentMode === DEPLOYMENT_MODE.DEVELOPMENT) {
+    URLS = STAGING_SNAPSHOT_SERVER_URLS;
+  } else if (deploymentMode === DEPLOYMENT_MODE.PLAYGROUND) {
+    URLS = PLAYGROUND_SNAPSHOT_SERVER_URLS;
+  } else if (deploymentMode === DEPLOYMENT_MODE.STAGING) {
+    URLS = STAGING_SNAPSHOT_SERVER_URLS;
+  } else if (deploymentMode === DEPLOYMENT_MODE.PRODUCTION) {
+    URLS = PRODUCTION_SNAPSHOT_SERVER_URLS;
+  } else {
+    URLS = PRODUCTION_SNAPSHOT_SERVER_URLS;
+  }
+
+  switch (chainId) {
+    case chainIds.polygon:
+      return URLS.polygon;
+    case chainIds.arbMainnet:
+      return URLS.arbMainnet;
+    case chainIds.ethMainnet:
+      return URLS.ethMainnet;
+    case chainIds.avalanche:
+      return URLS.avalanche;
+    case chainIds.bnbMainnet:
+      return URLS.bnbMainnet;
+    case chainIds.optimism:
+      return URLS.optimism;
+    case chainIds.base:
+      return URLS.base;
+    case chainIds.arcTestnet:
+      return URLS.arcTestnet;
+    case chainIds.localhost:
+      return URLS.localhost;
+    default:
+      return URLS.ethMainnet;
+  }
+};
+
+// DATA SERVER URLS
+export const getDataServerURL = () => {
+  // Uncomment this to use local data server
+  // return DATA_SERVER_URL_LOCAL;
+
+  switch (deploymentMode) {
+    case DEPLOYMENT_MODE.DEVELOPMENT:
+      return `${STAGING_URL}${DATA_SERVER_URL_ENDPOINT}`;
+
+    case DEPLOYMENT_MODE.PLAYGROUND:
+      return `${PLAYGROUND_URL}${DATA_SERVER_URL_ENDPOINT}`;
+
+    case DEPLOYMENT_MODE.STAGING:
+      return `${STAGING_URL}${DATA_SERVER_URL_ENDPOINT}`;
+
+    case DEPLOYMENT_MODE.PRODUCTION:
+    default:
+      return `${PRODUCTION_URL}${DATA_SERVER_URL_ENDPOINT}`;
+  }
+};
+
+export const DATA_SERVER_URL = getDataServerURL();

package/src/API/getTokenPrice.ts

@@ -0,0 +1,39 @@
+import { RELAYER_CONFIG } from '../constants/server.constants';
+import { getRelayerURL } from './getRelayerURL';
+import { httpClient } from '../data-structures/tor';
+
+interface GetTokenPriceInterface {
+  price: number;
+  status: 'success' | 'failed';
+}
+// to send verification code on email through server
+export async function getTokenPrice(
+  chainId: number,
+  erc20Address?: string,
+  id?: string,
+): Promise<GetTokenPriceInterface> {
+  return httpClient.post(`${getRelayerURL(chainId)}${RELAYER_CONFIG.getTokenPrice}`, {
+    erc20Address,
+    id,
+  });
+}
+
+interface GetTokenPriceEthInterface {
+  usd: number;
+  eth: number;
+  status: 'success' | 'failed';
+}
+
+export async function getTokenPriceEth(chainId: number, id: string): Promise<GetTokenPriceEthInterface> {
+  return httpClient.get(`${getRelayerURL(chainId)}${RELAYER_CONFIG.getTokenPriceEth(id)}`);
+}
+
+interface IGetPrices {
+  prices: number[];
+}
+export const getTokenPrices = async (chainId: number, erc20Addresses: string[]): Promise<IGetPrices> => {
+  const prices = await httpClient.post<IGetPrices>(`${getRelayerURL(chainId)}${RELAYER_CONFIG.getTokenPrices}`, {
+    erc20Addresses,
+  });
+  return prices;
+};

package/src/API/getWebsiteURL.ts

@@ -0,0 +1,58 @@
+import { DEPLOYMENT_MODE, deploymentMode } from '../constants';
+
+const localhostHinkalLanding = 'http://localhost:4230';
+const playgroundHinkalLanding = 'https://hinkal-playground-landing.netlify.app';
+const stagingHinkalLanding = 'https://staging-hinkal-landing.netlify.app';
+const hinkalLanding = 'https://hinkal.pro';
+
+const localhostWalletOnboarding = 'http://localhost:4118';
+const playgroundWalletOnboarding = 'https://hinkal-playground-onboarding.netlify.app';
+const stagingWalletOnboarding = 'https://staging-hinkal-onboarding.netlify.app';
+const productionWalletOnboarding = 'https://onboarding.hinkal.pro';
+
+const localhostRewardsOrigin = 'http://localhost:4117';
+const playgroundRewardsOrigin = 'https://hinkal-playground.netlify.app';
+const stagingRewardsOrigin = 'https://staging-hinkal-rewards.netlify.app';
+const rewardsOrigin = 'https://rewards.hinkal.pro';
+
+export const getHinkalLandingURL = () => {
+  switch (deploymentMode) {
+    case DEPLOYMENT_MODE.DEVELOPMENT:
+      return localhostHinkalLanding;
+    case DEPLOYMENT_MODE.PLAYGROUND:
+      return playgroundHinkalLanding;
+    case DEPLOYMENT_MODE.STAGING:
+      return stagingHinkalLanding;
+    case DEPLOYMENT_MODE.PRODUCTION:
+    default:
+      return hinkalLanding;
+  }
+};
+
+export const getWalletOnboardingURL = () => {
+  switch (deploymentMode) {
+    case DEPLOYMENT_MODE.DEVELOPMENT:
+      return localhostWalletOnboarding;
+    case DEPLOYMENT_MODE.PLAYGROUND:
+      return playgroundWalletOnboarding;
+    case DEPLOYMENT_MODE.STAGING:
+      return stagingWalletOnboarding;
+    case DEPLOYMENT_MODE.PRODUCTION:
+    default:
+      return productionWalletOnboarding;
+  }
+};
+
+export const getRewardsURL = () => {
+  switch (deploymentMode) {
+    case DEPLOYMENT_MODE.DEVELOPMENT:
+      return localhostRewardsOrigin;
+    case DEPLOYMENT_MODE.PLAYGROUND:
+      return playgroundRewardsOrigin;
+    case DEPLOYMENT_MODE.STAGING:
+      return stagingRewardsOrigin;
+    case DEPLOYMENT_MODE.PRODUCTION:
+    default:
+      return rewardsOrigin;
+  }
+};

package/src/API/index.ts

@@ -0,0 +1,19 @@
+export * from './getServerURL';
+export * from './getCoingeckoPrice';
+export * from './callOneInchAPI';
+export * from './callRelayer';
+export * from './getGasEstimates';
+export * from './getTokenPrice';
+export * from './checkRisk';
+export * from './relayCalls';
+export * from './API';
+export * from './getRelayerURL';
+export * from './duneAPI';
+export * from './tenderly.api';
+export * from './token-calls';
+export * from './callLifiAPI';
+export * from './getLifiStatus';
+export * from './generate-trading-points';
+export * from './brotherhoodCalls';
+export * from './getWebsiteURL';
+export * from './mysteryBoxesCalls';

package/src/API/is-tx-stateless.ts

@@ -0,0 +1,32 @@
+import { TxParametersBase } from '../types/wc.types';
+import { getServerURL } from './getServerURL';
+import { API_CONFIG } from '../constants/server.constants';
+import { TransactionSimulatorResult, VolatileTokenTransferResult } from '../types/TransactionSimulator.types';
+import { httpClient } from '../data-structures/tor';
+import { VolatileTokenChange } from '../types';
+
+export const isTxStateless = async (
+  chainId: number,
+  txParameters: TxParametersBase,
+  simulateRandomUserTx: boolean,
+): Promise<TransactionSimulatorResult<string>> => {
+  return httpClient.post<TransactionSimulatorResult<string>>(
+    `${getServerURL(chainId)}${API_CONFIG.ROUTES.isTxStateless}`,
+    {
+      txParameters,
+      simulateRandomUserTx,
+    },
+  );
+};
+
+export const simulateVolatileTokenTransfer = async (
+  chainId: number,
+  tokenTransfers: VolatileTokenChange[],
+): Promise<VolatileTokenTransferResult[]> => {
+  return httpClient.post<VolatileTokenTransferResult[]>(
+    `${getServerURL(chainId)}${API_CONFIG.ROUTES.simulateVolatileTokenTransfer}`,
+    {
+      tokenTransfers,
+    },
+  );
+};