@sabaaa1/common 0.0.8 → 0.0.9

package/src/API/proxyAccountsCalls.ts

@@ -0,0 +1,40 @@
+import { API_CONFIG } from '../constants/server.constants';
+import { getServerURL } from './getServerURL';
+import type { SubAccountLight } from '../types/proxy.types';
+import { UserKeys } from '../data-structures/crypto-keys';
+import { ethers } from 'ethers';
+import { hashEthereumAddress } from '../functions/utils/addresses';
+import { httpClient } from '../data-structures/tor';
+
+const generateSecureProxyKey = (ethereumAddress: string, userKeys: UserKeys): string => {
+  const shieldedPrivateKey = userKeys.getShieldedPrivateKey();
+
+  const combinedString = `HinkalProxyAccounts|${ethereumAddress.toLowerCase()}|${shieldedPrivateKey}`;
+
+  // Use keccak256 for consistent hashing
+  return ethers.utils.keccak256(ethers.utils.toUtf8Bytes(combinedString));
+};
+
+export const getProxyAccounts = async (chainId: number, ethereumAddress: string, userKeys: UserKeys) => {
+  const secureKey = generateSecureProxyKey(ethereumAddress, userKeys);
+  const response = await httpClient.get<SubAccountLight[]>(
+    `${getServerURL(chainId)}${API_CONFIG.ROUTES.getProxyAccounts(secureKey)}`,
+  );
+  return response;
+};
+
+export const updateProxyAccounts = async (
+  chainId: number,
+  ethereumAddress: string,
+  userKeys: UserKeys,
+  proxyAccounts: SubAccountLight[],
+) => {
+  const secureKey = generateSecureProxyKey(ethereumAddress, userKeys);
+  const hashedEthereumAddress = hashEthereumAddress(ethereumAddress);
+  const response = await httpClient.post(`${getServerURL(chainId)}${API_CONFIG.ROUTES.updateProxyAccounts}`, {
+    secureKey,
+    hashedEthereumAddress,
+    proxyAccounts,
+  });
+  return response;
+};

package/src/API/referralsCalls.ts

@@ -0,0 +1,52 @@
+import { DATA_SERVER_URL } from './getServerURL';
+import { DATA_SERVER_CONFIG } from '../constants/server.constants';
+import { Referral } from '../types';
+import { httpClient } from '../data-structures/tor';
+
+interface GetCurrentUserReferralProps {
+  ethereumAddress: string;
+}
+
+interface GetCurrentUserReferralRes {
+  referral: Referral | undefined;
+}
+
+export const getCurrentUserReferral = async ({
+  ethereumAddress,
+}: GetCurrentUserReferralProps): Promise<GetCurrentUserReferralRes> => {
+  return httpClient.get(`${DATA_SERVER_URL}${DATA_SERVER_CONFIG.getCurrentUserReferral}`, {
+    params: { ethereumAddress },
+  });
+};
+
+interface SubmitReferralCodeProps {
+  referralCode: string;
+  ethereumAddress: string;
+}
+
+export interface SubmitReferralCodeRes {
+  message: string;
+  success: boolean;
+}
+
+export const submitReferralCode = async ({
+  referralCode,
+  ethereumAddress,
+}: SubmitReferralCodeProps): Promise<SubmitReferralCodeRes> => {
+  return httpClient.post(`${DATA_SERVER_URL}${DATA_SERVER_CONFIG.submitReferralCode}`, {
+    referralCode,
+    ethereumAddress,
+  });
+};
+
+interface GetCurrentUserAppliedReferralCodeRes {
+  appliedReferralCode: string | undefined;
+}
+
+export const getCurrentUserAppliedReferralCode = async (
+  ethereumAddress: string,
+): Promise<GetCurrentUserAppliedReferralCodeRes> => {
+  return httpClient.get(`${DATA_SERVER_URL}${DATA_SERVER_CONFIG.getCurrentUserAppliedReferralCode}`, {
+    params: { ethereumAddress },
+  });
+};

package/src/API/relayCalls.ts

@@ -0,0 +1,14 @@
+import { getRelayerURL } from './getRelayerURL';
+import { RELAYER_CONFIG } from '../constants/server.constants';
+import { httpClient } from '../data-structures/tor';
+
+interface IGetIdleRelay {
+  relay: string | undefined;
+}
+
+export const getIdleRelay = async (chainId: number, markAsPending = false): Promise<IGetIdleRelay> => {
+  const response = await httpClient.get<IGetIdleRelay>(
+    `${getRelayerURL(chainId)}${RELAYER_CONFIG.getIdleRelay}?markAsPending=${markAsPending}`,
+  );
+  return response;
+};

package/src/API/restoreSnapshots.ts

@@ -0,0 +1,7 @@
+import { API_CONFIG } from '../constants/server.constants';
+import { getServerURL } from './getServerURL';
+import { httpClient } from '../data-structures/tor';
+
+export async function restoreSnapshots(chainId: number) {
+  return httpClient.post(`${getServerURL(chainId)}${API_CONFIG.ROUTES.restoreSnapshots}`);
+}

package/src/API/rewardsUserCalls.ts

@@ -0,0 +1,124 @@
+import { DATA_SERVER_URL } from './getServerURL';
+import { DATA_SERVER_CONFIG } from '../constants/server.constants';
+import { AchievementProgressItem, RewardsUser, SwapStreakClient, TaskProgress } from '../types';
+import { httpClient } from '../data-structures/tor';
+import { getSignatureHeader } from '../functions/utils/get-signature-header';
+
+interface ConnectRewardsUserRes {
+  message: string;
+  user: RewardsUser;
+  isFirstTimeUser: boolean;
+  signature: string;
+}
+
+export const connectRewardsUser = async (
+  ethereumAddress: string,
+  signature: string,
+  firstProxyAddress: string,
+): Promise<ConnectRewardsUserRes> => {
+  const data = await httpClient.post(
+    `${DATA_SERVER_URL}${DATA_SERVER_CONFIG.connectRewardsUser}`,
+    {
+      ethereumAddress,
+      proxyAddress: firstProxyAddress,
+    },
+    getSignatureHeader(signature),
+  );
+  return data;
+};
+
+interface InputDataTypes {
+  ethereumAddress: string;
+  signature: string;
+  username?: string;
+  profileImage?: string;
+  proxyAddress?: string;
+}
+
+interface UpdateRewardsUserRes {
+  message: string;
+  user: RewardsUser;
+}
+
+export const updateRewardsUser = async (inputData: InputDataTypes): Promise<UpdateRewardsUserRes> => {
+  const data = await httpClient.patch(
+    `${DATA_SERVER_URL}${DATA_SERVER_CONFIG.updateRewardsUser}`,
+    inputData,
+    getSignatureHeader(inputData.signature),
+  );
+
+  return data;
+};
+
+interface GetSwapStreakRes {
+  message: string;
+  swapStreak: SwapStreakClient;
+}
+
+export const getSwapStreak = async (ethereumAddress: string): Promise<GetSwapStreakRes> => {
+  const data = await httpClient.get<GetSwapStreakRes>(`${DATA_SERVER_URL}${DATA_SERVER_CONFIG.getSwapStreak}`, {
+    params: { ethereumAddress },
+  });
+
+  return data;
+};
+
+interface GetTasksProgressRes {
+  success: boolean;
+  userTasks: TaskProgress[];
+  userAchievements: AchievementProgressItem[];
+  brotherhoodTasks: TaskProgress[];
+  completedTasks: string[];
+  brotherhoodCompletedTasks: string[];
+  pointsToShowInCongratsPopup: number;
+}
+
+export const getTasksProgress = async (ethereumAddress: string): Promise<GetTasksProgressRes> => {
+  const data = await httpClient.get<GetTasksProgressRes>(
+    `${DATA_SERVER_URL}${DATA_SERVER_CONFIG.getTasksProgress(ethereumAddress)}`,
+  );
+
+  return data;
+};
+
+interface DisconnectSocialNetworkRes {
+  message: string;
+  user: RewardsUser;
+}
+
+interface DisconnectSocialNetworkProps {
+  ethereumAddress: string;
+  socialWebsiteId: string;
+  signature: string;
+  proxyAddress: string;
+}
+
+export const disconnectSocialNetwork = async ({
+  ethereumAddress,
+  socialWebsiteId,
+  signature,
+  proxyAddress,
+}: DisconnectSocialNetworkProps): Promise<DisconnectSocialNetworkRes> => {
+  const data = await httpClient.patch<DisconnectSocialNetworkRes>(
+    `${DATA_SERVER_URL}${DATA_SERVER_CONFIG.disconnectSocialNetwork}`,
+    {
+      ethereumAddress,
+      socialWebsiteId,
+      proxyAddress,
+    },
+    getSignatureHeader(signature),
+  );
+
+  return data;
+};
+
+interface GetNftMultiplierRes {
+  nftMultiplier: number;
+}
+
+export const getNftMultiplier = async (ethereumAddress: string): Promise<GetNftMultiplierRes> => {
+  const data = await httpClient.get<GetNftMultiplierRes>(
+    `${DATA_SERVER_URL}${DATA_SERVER_CONFIG.getNftMultiplier(ethereumAddress)}`,
+  );
+  return data;
+};

package/src/API/send-telegram-callback.ts

@@ -0,0 +1,17 @@
+import { DATA_SERVER_CONFIG } from '../constants/server.constants';
+import { DATA_SERVER_URL } from './getServerURL';
+import { TelegramUser } from '../types';
+import { httpClient } from '../data-structures/tor';
+
+interface TelegramCallbackProps {
+  ethereumAddress: string;
+  telegramUser: TelegramUser;
+}
+
+export const sendTelegramCallback = async ({ ethereumAddress, telegramUser }: TelegramCallbackProps) => {
+  const data = await httpClient.post(`${DATA_SERVER_URL}${DATA_SERVER_CONFIG.getTelegramCallback}`, {
+    ethereumAddress,
+    telegramUser,
+  });
+  return data;
+};

package/src/API/simulate-batch-tx.ts

@@ -0,0 +1,19 @@
+import { TransactionSimulatorMinimalResult } from '../types/TransactionSimulator.types';
+import { getServerURL } from './getServerURL';
+import { API_CONFIG } from '../constants/server.constants';
+import { WCTransactionParameters } from '../types';
+import { httpClient } from '../data-structures/tor';
+
+export const simulateBatchTx = async (
+  chainId: number,
+  batchCalls: WCTransactionParameters[],
+): Promise<TransactionSimulatorMinimalResult<string>> => {
+  const response = await httpClient.post<TransactionSimulatorMinimalResult<string>>(
+    `${getServerURL(chainId)}${API_CONFIG.ROUTES.simulateBatchTx}`,
+    {
+      batchCalls,
+    },
+  );
+
+  return response;
+};

package/src/API/tenderly.api.ts

@@ -0,0 +1,96 @@
+import type {
+  RpcSimulateResult,
+  RpcSimulateTransactionBody,
+  RpcSimulateTransactionResponse,
+  RpcTransactionParams,
+  SimulateTxBody,
+  SimulateTxResponse,
+} from '../types/tenderly.api.types';
+import { chainIds } from '../constants/chains.constants';
+import { httpClient } from '../data-structures/tor';
+
+const TENDERLY_API_KEY = '7o1iPUgCIjLI0rSxj2yuz9-Z3052uUc4';
+
+const accountSlug = 'hinkal-org';
+const projectSlug = 'project';
+
+const baseUrl = `https://api.tenderly.co/api/v1/account/${accountSlug}/project/${projectSlug}`;
+
+const HEADERS = { 'X-Access-Key': TENDERLY_API_KEY };
+
+// SIMULATE TRANSACTION ON ACTUAL NETWORK
+export const simulateTx = async (simulateTxBody: SimulateTxBody): Promise<SimulateTxResponse> => {
+  const response = await httpClient.post<SimulateTxResponse>(
+    `${baseUrl}/simulate`,
+    { ...simulateTxBody },
+    {
+      headers: HEADERS,
+    },
+  );
+  return response;
+};
+
+// TENDERLY RPC SIMULATE TRANSACTION
+export const tenderlyRpcLinks = {
+  [chainIds.optimism]: 'https://optimism.gateway.tenderly.co/2A3r4RCMoAZVmQOpNqRO29',
+  [chainIds.base]: 'https://base.gateway.tenderly.co/73UtIBn1YiCyhqRJuKTkWl',
+  [chainIds.ethMainnet]: 'https://mainnet.gateway.tenderly.co/SW3mROrzKEQYSq3RkStJ7',
+  [chainIds.avalanche]: 'https://avalanche.gateway.tenderly.co/2YdoJTNLCUHfzwvqIUVgwZ',
+  [chainIds.arbMainnet]: 'https://arbitrum.gateway.tenderly.co/4dUF2wEnsmvFw9fqLpoLga',
+  [chainIds.polygon]: 'https://polygon.gateway.tenderly.co/32hCaUScB41nXgyzCmeDVu',
+  // Arc Testnet is not supported by Tenderly
+};
+
+export const rpcSimulateTransaction = async (
+  chainId: number,
+  simulateTxBody: RpcSimulateTransactionBody,
+): Promise<RpcSimulateTransactionResponse> => {
+  const response = await httpClient.post<RpcSimulateTransactionResponse>(
+    tenderlyRpcLinks[chainId],
+    { jsonrpc: '2.0', id: 0, method: 'tenderly_simulateTransaction', params: simulateTxBody.params },
+    {
+      headers: HEADERS,
+    },
+  );
+  return response;
+};
+
+export const rpcSimulateBundle = async (
+  chainId: number,
+  simulateTxBody: RpcSimulateTransactionBody<RpcTransactionParams[]>,
+): Promise<RpcSimulateTransactionResponse<RpcSimulateResult[]>> => {
+  const response = await httpClient.post(
+    tenderlyRpcLinks[chainId],
+    { jsonrpc: '2.0', id: 0, method: 'tenderly_simulateBundle', params: simulateTxBody.params },
+    { headers: HEADERS },
+  );
+  return response;
+};
+
+export const rpcGetStorageChanges = async (chainId: number, address: string, offset: string) => {
+  const response = await httpClient.post<any>(
+    tenderlyRpcLinks[chainId],
+    {
+      jsonrpc: '2.0',
+      id: 0,
+      method: 'tenderly_getStorageChanges',
+      params: [
+        {
+          address,
+          offset,
+        },
+      ],
+    },
+    {
+      headers: HEADERS,
+    },
+  );
+  return response;
+};
+
+export const WALLET_API = {
+  rpcGetStorageChanges,
+  rpcSimulateTransaction,
+  rpcSimulateBundle,
+  simulateTx,
+};

package/src/API/token-calls.ts

@@ -0,0 +1,19 @@
+import { API_CONFIG } from '../constants/server.constants';
+import { getServerURL } from './getServerURL';
+import { ERC20Token } from '../types';
+import { httpClient } from '../data-structures/tor';
+
+export const tokensInfoCall = async (
+  chainId: number,
+  tokenAddresses: string[],
+  waitForOffsetUpdate = false,
+): Promise<(ERC20Token | undefined)[]> => {
+  const response = await httpClient.post<(ERC20Token | undefined)[]>(
+    `${getServerURL(chainId)}${API_CONFIG.ROUTES.getTokensInfo}`,
+    {
+      tokenAddresses,
+      waitForOffsetUpdate,
+    },
+  );
+  return response;
+};

package/src/API/weeklyAnalyticCalls.ts

@@ -0,0 +1,43 @@
+import { DATA_SERVER_URL } from './getServerURL';
+import { DATA_SERVER_CONFIG } from '../constants/server.constants';
+import { AllPoints, BrotherhoodWeeklyAnalytic, UserWeeklyAnalytic } from '../types';
+import { httpClient } from '../data-structures/tor';
+
+interface GetUserAnalyticsProps {
+  ethereumAddress: string;
+}
+
+interface GetUserAnalyticsRes {
+  success: boolean;
+  currentWeek: UserWeeklyAnalytic;
+  previousWeeks: UserWeeklyAnalytic[];
+  allTime: AllPoints;
+}
+
+export const getUserAnalytics = async ({ ethereumAddress }: GetUserAnalyticsProps): Promise<GetUserAnalyticsRes> => {
+  const data = await httpClient.get(`${DATA_SERVER_URL}${DATA_SERVER_CONFIG.getUserAnalytics}`, {
+    params: { ethereumAddress },
+  });
+  return data;
+};
+
+interface GetBrotherhoodAnalyticsRes {
+  success: boolean;
+  currentWeek: BrotherhoodWeeklyAnalytic | undefined;
+  allTime: AllPoints | undefined;
+}
+
+interface GetBrotherhoodAnalyticsProps {
+  brotherhoodId?: number;
+  ethereumAddress?: string | undefined | null;
+}
+
+export const getBrotherhoodAnalytics = async ({
+  brotherhoodId,
+  ethereumAddress,
+}: GetBrotherhoodAnalyticsProps): Promise<GetBrotherhoodAnalyticsRes> => {
+  const data = await httpClient.get(`${DATA_SERVER_URL}${DATA_SERVER_CONFIG.getBrotherhoodAnalytics}`, {
+    params: { brotherhoodId, ethereumAddress },
+  });
+  return data;
+};

package/src/constants/activity.constants.ts

@@ -0,0 +1,10 @@
+import { ActivityTypes } from '../types';
+
+export const TVL_CHANGER_ACTIVITY_TYPES = [
+  ActivityTypes.SHIELD,
+  ActivityTypes.RECIEVE,
+  ActivityTypes.ONBOARDING_DEPOSIT,
+  ActivityTypes.SEND,
+  ActivityTypes.UNSHIELD,
+  ActivityTypes.DAPP_INTERACTION,
+];

package/src/constants/addresses.constants.ts

@@ -0,0 +1,74 @@
+import { ExternalActionId } from '../types';
+import { chainIds } from './chains.constants';
+
+export const HETH_ERC20_TOKEN_ADDRESS = '0x270B7748CdF8243bFe68FaCE7230ef0fCE695389';
+export const WETH_ERC20_TOKEN_ADDRESS = '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2';
+
+export const SWAP_ROUTER_ADDRESSES = {
+  [ExternalActionId.Uniswap]: {
+    [chainIds.ethMainnet]: '0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45',
+    [chainIds.polygon]: '0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45',
+    [chainIds.optimism]: '0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45',
+    [chainIds.arbMainnet]: '0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45',
+    [chainIds.bnbMainnet]: '0xB971eF87ede563556b2ED4b1C0b0019111Dd85d2',
+    [chainIds.avalanche]: '0xbb00FF08d01D300023C629E8fFfFcb65A5a578cE', // not this:0x5615CDAb10dc425a742d643d949a7F474C01abc4 ?
+    [chainIds.base]: '0x2626664c2603336E57B271c5C0b26F421741e481',
+  },
+  [ExternalActionId.Odos]: {
+    [chainIds.ethMainnet]: '0xCf5540fFFCdC3d510B18bFcA6d2b9987b0772559', // ToDo: routers need to be updated to version 3
+    [chainIds.polygon]: '0x4E3288c9ca110bCC82bf38F09A7b425c095d92Bf',
+    [chainIds.optimism]: '0xCa423977156BB05b13A2BA3b76Bc5419E2fE9680',
+    [chainIds.arbMainnet]: '0xa669e7A0d4b3e4Fa48af2dE86BD4CD7126Be4e13',
+    [chainIds.bnbMainnet]: '0x89b8AA89FDd0507a99d334CBe3C808fAFC7d850E',
+    [chainIds.avalanche]: '0x88de50B233052e4Fb783d4F6db78Cc34fEa3e9FC', // not this:0x88de50B233052e4Fb783d4F6db78Cc34fEa3e9FC ?
+    [chainIds.base]: '0x19cEeAd7105607Cd444F5ad10dd51356436095a1',
+  },
+  [ExternalActionId.OneInch]: {
+    [chainIds.ethMainnet]: '0x1111111254EEB25477B68fb85Ed929f73A960582',
+    [chainIds.polygon]: '0x1111111254EEB25477B68fb85Ed929f73A960582',
+    [chainIds.optimism]: '0x1111111254EEB25477B68fb85Ed929f73A960582',
+    [chainIds.arbMainnet]: '0x1111111254EEB25477B68fb85Ed929f73A960582',
+    [chainIds.bnbMainnet]: '0x1111111254EEB25477B68fb85Ed929f73A960582',
+    [chainIds.avalanche]: '0x1111111254EEB25477B68fb85Ed929f73A960582',
+    [chainIds.base]: '0x1111111254EEB25477B68fb85Ed929f73A960582',
+  },
+  [ExternalActionId.Lifi]: {
+    [chainIds.ethMainnet]: '0x1231DEB6f5749EF6cE6943a275A1D3E7486F4EaE',
+    [chainIds.polygon]: '0x1231DEB6f5749EF6cE6943a275A1D3E7486F4EaE',
+    [chainIds.optimism]: '0x1231DEB6f5749EF6cE6943a275A1D3E7486F4EaE',
+    [chainIds.arbMainnet]: '0x1231DEB6f5749EF6cE6943a275A1D3E7486F4EaE',
+    [chainIds.bnbMainnet]: '0x1231DEB6f5749EF6cE6943a275A1D3E7486F4EaE',
+    [chainIds.avalanche]: '0x1231DEB6f5749EF6cE6943a275A1D3E7486F4EaE',
+    [chainIds.base]: '0x1231DEB6f5749EF6cE6943a275A1D3E7486F4EaE',
+  },
+};
+
+export const NATIVE_TOKEN_WRAPPER_ADDRESSES = {
+  [chainIds.ethMainnet]: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
+  [chainIds.polygon]: '0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270',
+  [chainIds.optimism]: '0x4200000000000000000000000000000000000006',
+  [chainIds.arbMainnet]: '0x82aF49447D8a07e3bd95BD0d56f35241523fBab1',
+  [chainIds.bnbMainnet]: '0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c',
+  [chainIds.avalanche]: '0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7',
+  [chainIds.base]: '0x4200000000000000000000000000000000000006',
+};
+
+export const WRAPPER_TOKEN_EXCHANGE_ADDRESSES = {
+  [chainIds.ethMainnet]: '0xdaC7Fb8AC2e47F412e8556Fd13256D90FBae08CD',
+  [chainIds.polygon]: '0x9759Baf5eEfa817E3FdF4C488ED51a334e948C05',
+  [chainIds.optimism]: '0xDe6A7d13c7E01582F5989b14cdf64d4bc6608364',
+  [chainIds.arbMainnet]: '0xF43D84490c6A155f2DDDF501db378D77151590f4',
+  [chainIds.bnbMainnet]: '0x5fa6773A7dC2CA3fB411f9Ef157F30e91aa1e53d',
+  [chainIds.avalanche]: '0xD201f9ae495b23805C12ed74a816AE4ef0c00b05',
+  [chainIds.base]: '0x86B9e7F2698C0776b988085b5Ca8d7D6A1Dff74b',
+};
+
+export const SWAP_FEE_TAKER_ADDRESSES = {
+  [chainIds.ethMainnet]: '0x1D69943ea7D9874b43f9FbcC2B6a4f0f433F602d',
+  [chainIds.polygon]: '0x5181606B45302Bb7b83e03DC7c5390ec9e4d973f',
+  [chainIds.optimism]: '0x0720a259A8CaBb9ef0F6a6334fEB4da5f45a8579',
+  [chainIds.arbMainnet]: '0x7ae4AD3f4D2df012807C3CC50fc0d4bB19Cc9800',
+  [chainIds.bnbMainnet]: '0x4200000000000000000000000000000000000000', // add after deployment
+  [chainIds.avalanche]: '0x4200000000000000000000000000000000000000', // add after deployment
+  [chainIds.base]: '0xB69B207994506697196E5C1Ce40233c06040BB79',
+};

package/src/constants/assets.constants.ts

@@ -0,0 +1,15 @@
+const S3_BASE_URL = 'https://d1nvbznp963lfd.cloudfront.net/assets/';
+
+export const IMAGE_PATHS = {
+  CHEVRON: `${S3_BASE_URL}Chevron.svg`,
+  MOON: `${S3_BASE_URL}Moon.svg`,
+  SUN: `${S3_BASE_URL}Sun.svg`,
+  ARROW_LEFT: `${S3_BASE_URL}ArrowLeft.svg`,
+  AUTHENTO_LIGHT: `${S3_BASE_URL}AuthentoLogoLight.png`,
+  AUTHENTO_DARK: `${S3_BASE_URL}AuthentoLogoDark.png`,
+  KING: `${S3_BASE_URL}King.svg`,
+  CIRCLE_STRIKETHROUGH: `${S3_BASE_URL}CircleStrikethrough.svg`,
+  RIGHT_SQUARE: `${S3_BASE_URL}RightSquare.svg`,
+  COINBASE_DARK: `${S3_BASE_URL}CoinbaseDark.png`,
+  COINBASE_LIGHT: `${S3_BASE_URL}CoinbaseLight.png`,
+};

package/src/constants/backend.constants.ts

@@ -0,0 +1,16 @@
+export const NETWORKS = {
+  polygon: 'polygon',
+  bnbMainnet: 'bnbMainnet',
+  arbMainnet: 'arbMainnet',
+  ethMainnet: 'ethMainnet',
+  avalanche: 'avalanche',
+  optimism: 'optimism',
+  base: 'base',
+  arcTestnet: 'arcTestnet',
+  localhost: 'localhost',
+};
+
+export const getGasStationUrl = (network: string) => {
+  if (network === NETWORKS.polygon) return 'https://gasstation.polygon.technology/v1';
+  return undefined;
+};

package/src/constants/balance.constants.ts

@@ -0,0 +1 @@
+export const MAX_DISPLAY_DECIMALS = 6;

package/src/constants/bridging.constants.ts

@@ -0,0 +1,5 @@
+export const BRIDGING_URLS = {
+  DEFILLAMA: 'https://api.llama.fi/protocols',
+  CHAINLIST: 'https://chainid.network/chains.json',
+  JUMPER_EXCHANGE: 'https://li.quest/v1/tools',
+};