@sabaaa1/common 0.0.13 → 0.0.15

package/src/data-structures/IndexedDB/activity-db.ts

@@ -1,204 +0,0 @@
-import { get, set } from 'idb-keyval';
-import { BigNumber } from 'ethers';
-import { Activity, ActivityAddRequest, ActivityStatus, SandboxResponse, StorageKeys } from '../../types';
-import { zeroAddress } from '../../constants';
-import { fixDecimalsAmount, getAmountInToken, getERC20Token } from '../../functions';
-import { getTokenPrice } from '../../API';
-import { Logger } from '../../error-handling';
-
-type TransactionRecord = Record<string, Activity>;
-
-class ActivityStorage {
-  private generateTxId(): string {
-    const timestamp = new Date().getTime();
-    const random = Math.random().toString(36).substring(2, 15);
-    return `tx_${timestamp}_${random}`;
-  }
-
-  private async getTransactionRecord(): Promise<TransactionRecord> {
-    const record = await get<TransactionRecord>(StorageKeys.TX_ACTIVITY);
-    return record || {};
-  }
-
-  private async saveTransactionRecord(record: TransactionRecord): Promise<void> {
-    await set(StorageKeys.TX_ACTIVITY, record);
-  }
-
-  public async saveTxRequest(txRequest: ActivityAddRequest) {
-    const {
-      from,
-      to,
-      gas,
-      gasPrice,
-      value,
-      chainId,
-      status,
-      txHash,
-      activityType,
-      tokensReceive,
-      tokensSpend,
-      tokensApprove,
-      ownerPublicAddress,
-      activityIcon,
-      dappUrl,
-      dappName,
-      integrationProvider,
-    } = txRequest;
-    const id = this.generateTxId();
-    const record = await this.getTransactionRecord();
-    const gasInDollar = await this.getGasInDollar(gas, gasPrice, chainId);
-
-    const transaction = {
-      id,
-      from,
-      to,
-      gas,
-      gasPrice,
-      gasInDollar: gasInDollar?.toString(),
-      value,
-      chainId,
-      txHash,
-      activityType,
-      status: status ?? ActivityStatus.PENDING,
-      timestamp: new Date(),
-      tokensReceive,
-      tokensSpend,
-      tokensApprove,
-      ownerPublicAddress,
-      activityIcon,
-      dappUrl,
-      dappName,
-      integrationProvider,
-    };
-
-    record[id] = transaction;
-
-    await this.saveTransactionRecord(record);
-    return id;
-  }
-
-  public async getTxRequest(id: string) {
-    const record = await this.getTransactionRecord();
-    return record[id] || null;
-  }
-
-  public async getAllTxRequests(chainId: number) {
-    const record = await this.getTransactionRecord();
-    return Object.values(record)
-      .filter((activity) => activity.chainId === chainId)
-      .sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
-  }
-
-  private async updateTxStatusAndHash(
-    id: string,
-    status: ActivityStatus,
-    txHash?: string,
-    value?: string,
-    from?: string,
-    to?: string,
-    gas?: BigNumber,
-    gasPrice?: BigNumber,
-  ): Promise<Activity> {
-    const transaction = await this.getTxRequest(id);
-    if (!transaction) {
-      throw new Error('Transaction not found');
-    }
-
-    const record = await this.getTransactionRecord();
-    const gasInDollar = await this.getGasInDollar(gas, gasPrice, transaction.chainId);
-    const updatedTx = {
-      ...transaction,
-      status,
-      txHash,
-      value: transaction.value ?? value,
-      from: transaction.from ?? from,
-      to: transaction.to ?? to,
-      gas,
-      gasPrice,
-      gasInDollar: gasInDollar?.toString(),
-      timestamp: new Date(),
-    };
-
-    record[id] = updatedTx;
-    await this.saveTransactionRecord(record);
-    return updatedTx;
-  }
-
-  private async updateActivity(
-    id: string,
-    status: ActivityStatus,
-    txHash?: string,
-    value?: string,
-    from?: string,
-    to?: string,
-    gas?: BigNumber,
-    gasPrice?: BigNumber,
-  ) {
-    try {
-      await this.updateTxStatusAndHash(id, status, txHash, value, from, to, gas, gasPrice);
-    } catch (err) {
-      console.log('error in updating tx request', err);
-    }
-  }
-
-  public async removePendingTransactions(pendingActivityId: string) {
-    try {
-      const record = await this.getTransactionRecord();
-      delete record[pendingActivityId];
-      await this.saveTransactionRecord(record);
-    } catch (err) {
-      console.log('error in deleting tx requests', err);
-    }
-  }
-
-  public async updatePendingTransactions(transactionResponse: SandboxResponse, pendingActivityId: string) {
-    try {
-      if (!transactionResponse.success) {
-        await this.updateActivity(
-          pendingActivityId,
-          ActivityStatus.FAILED,
-          'erroredTx' in transactionResponse ? transactionResponse.erroredTx?.transactionHash : undefined,
-        );
-        return;
-      }
-
-      if ('tx' in transactionResponse) {
-        const { tx } = transactionResponse;
-        await this.updateActivity(
-          pendingActivityId,
-          ActivityStatus.SUCCESSFUL,
-          tx.hash,
-          BigNumber.from(tx.value ?? 0n).toHexString(),
-          tx.from,
-          tx.to,
-          BigNumber.from(tx.gas ?? 0n),
-          BigNumber.from(tx.gasPrice ?? 0n),
-        );
-      }
-    } catch (err) {
-      console.log('error in updating pending transactions', err);
-    }
-  }
-
-  private getGasInDollar = async (gas: BigNumber | undefined, gasPrice: BigNumber | undefined, chainId: number) => {
-    if (!gas || !gasPrice) return undefined;
-
-    try {
-      const nativeToken = getERC20Token(zeroAddress, chainId);
-      if (!nativeToken) return undefined;
-
-      const tokenPriceDollar = (await getTokenPrice(chainId, nativeToken.erc20TokenAddress)).price;
-      if (!tokenPriceDollar) return undefined;
-
-      const gasPriceInDollar = tokenPriceDollar * Number(getAmountInToken(nativeToken, gasPrice.toBigInt()));
-      const totalGasInDollar = gasPriceInDollar * Number(gas.toBigInt());
-
-      return fixDecimalsAmount(totalGasInDollar);
-    } catch (error) {
-      Logger.error('Failed to calculate gas cost in dollars:', { chainId, error });
-      return undefined;
-    }
-  };
-}
-
-export const activityStorage = new ActivityStorage();

package/src/data-structures/IndexedDB/balances-db.ts

@@ -1,97 +0,0 @@
-import { get, update } from 'idb-keyval';
-import { ERC20Token, TokenBalance } from '../../types';
-import { getStateKey } from '../../functions/utils';
-import { Logger } from '../../error-handling/logger';
-
-interface WalletBalances {
-  [key: string]: TokenBalance[];
-}
-
-class PublicBalancesStorage {
-  readonly balancesRecordLabel = 'walletsBalances';
-
-  async getBalances(): Promise<WalletBalances | undefined> {
-    const walletBalances = await get<WalletBalances>(this.balancesRecordLabel);
-    return walletBalances;
-  }
-
-  async getBalancesByWallet(address: string, chainId: number): Promise<TokenBalance[] | undefined> {
-    const walletBalances = await this.getBalances();
-    if (!walletBalances) return undefined;
-    const key = getStateKey(address, chainId);
-    return walletBalances[key];
-  }
-
-  async setBalances(
-    chainId: number,
-    ethereumAddress: string,
-    balances: TokenBalance[],
-    concreteTokensList: ERC20Token[] | undefined,
-  ): Promise<TokenBalance[]> {
-    let updatedBalances: TokenBalance[] = [];
-
-    if (!concreteTokensList) {
-      // If no concrete token list is provided, it means "balances" already contains all tokens the user holds in their wallet.
-      await update(this.balancesRecordLabel, (oldWalletBalances: WalletBalances = {}) => {
-        const key = getStateKey(ethereumAddress, chainId);
-        return {
-          ...oldWalletBalances,
-          [key]: balances,
-        };
-      });
-      return balances;
-    }
-
-    // If the concrete token list is empty, just return the balances stored in the database.
-    if (concreteTokensList.length === 0) {
-      return (await this.getBalancesByWallet(ethereumAddress, chainId)) ?? [];
-    }
-
-    try {
-      // If a concrete token list is provided, "balances" only includes the tokens from that list.
-      // The user may still hold other tokens, so we must update balances for tokens in the list
-      // while preserving any other existing balances.
-      await update(this.balancesRecordLabel, (oldWalletBalances: WalletBalances = {}) => {
-        const key = getStateKey(ethereumAddress, chainId);
-
-        const existingBalances = this.createBalanceLookup(oldWalletBalances[key]);
-        const newBalances = this.createBalanceLookup(balances);
-
-        // Update or remove balances only for tokens in the concrete token list.
-        concreteTokensList.forEach(({ erc20TokenAddress }) => {
-          const tokenAddress = erc20TokenAddress.toLowerCase();
-
-          if (tokenAddress in newBalances) {
-            existingBalances[tokenAddress] = newBalances[tokenAddress];
-          } else {
-            delete existingBalances[tokenAddress];
-          }
-        });
-
-        // Convert back to array format for storage
-        updatedBalances = Object.values(existingBalances);
-
-        return {
-          ...oldWalletBalances,
-          [key]: updatedBalances,
-        };
-      });
-    } catch (error) {
-      Logger.error('Failed to update wallet balances:', error);
-    }
-
-    return updatedBalances;
-  }
-
-  private createBalanceLookup(balances: TokenBalance[] = []): Record<string, TokenBalance> {
-    return balances.reduce(
-      (acc, balance) => ({
-        ...acc,
-        [balance.token.erc20TokenAddress.toLowerCase()]: balance,
-      }),
-      {},
-    );
-  }
-}
-
-export const publicBalancesStorage = new PublicBalancesStorage();

package/src/data-structures/IndexedDB/contact-db.ts

@@ -1,81 +0,0 @@
-import { get, update } from 'idb-keyval';
-import { Contact } from '../../types/contacts.types';
-import { Logger } from '../../error-handling/logger';
-import { caseInsensitiveEqual } from '../../functions';
-
-type ContactStorageType = Record<string, Contact[]>;
-
-class ContactStorage {
-  private readonly STORAGE_KEY = 'contacts';
-
-  private checkForDuplicate(currentContacts: Contact[], newContact: Contact, oldContactAddress?: string) {
-    const contactWithSameNicknameOrAddress = currentContacts.find(
-      ({ ethereumAddress, nickname }) =>
-        (ethereumAddress === newContact.ethereumAddress || nickname === newContact.nickname) &&
-        ethereumAddress !== oldContactAddress,
-    );
-    if (contactWithSameNicknameOrAddress !== undefined) throw new Error('Duplicate Contact attribute');
-  }
-
-  async createContact(walletAddress: string, newContact: Contact) {
-    const walletAddressFormatted = walletAddress.toLowerCase();
-    await update<ContactStorageType>(this.STORAGE_KEY, (currentContacts) => {
-      const contacts = currentContacts ?? {};
-      const walletContacts = contacts[walletAddressFormatted] ?? [];
-      this.checkForDuplicate(walletContacts, newContact);
-
-      walletContacts.push(newContact);
-      contacts[walletAddressFormatted] = walletContacts;
-      return contacts;
-    });
-  }
-
-  async getContacts(walletAddress: string) {
-    try {
-      const walletAddressFormatted = walletAddress.toLowerCase();
-      const contacts = await get<ContactStorageType>(this.STORAGE_KEY);
-
-      if (!contacts || !contacts[walletAddressFormatted]) return [];
-      return contacts[walletAddressFormatted];
-    } catch (err) {
-      Logger.error('Error while getting contacts:', err);
-      return [];
-    }
-  }
-
-  async editContact(walletAddress: string, oldContactAddress: string, editedContact: Contact) {
-    const walletAddressFormatted = walletAddress.toLowerCase();
-    await update<ContactStorageType>(this.STORAGE_KEY, (currentContacts) => {
-      const contacts = currentContacts ?? {};
-      const walletContacts = contacts[walletAddressFormatted];
-      if (!contacts || !walletContacts) throw new Error('Contacts could not be fetched');
-      this.checkForDuplicate(walletContacts, editedContact, oldContactAddress);
-      const contactToEditIndex = walletContacts.findIndex(({ ethereumAddress }) =>
-        caseInsensitiveEqual(ethereumAddress, oldContactAddress),
-      );
-      if (contactToEditIndex === -1) throw new Error('Contact to be edited was not found');
-
-      walletContacts[contactToEditIndex] = editedContact;
-      contacts[walletAddressFormatted] = walletContacts;
-      return contacts;
-    });
-  }
-
-  async deleteContact(walletAddress: string, contactAddressToDelete: string) {
-    const walletAddressFormatted = walletAddress.toLowerCase();
-    await update<ContactStorageType>(this.STORAGE_KEY, (currentContacts) => {
-      const contacts = currentContacts ?? {};
-      const walletContacts = contacts[walletAddressFormatted];
-      if (!contacts || !walletContacts) throw new Error('Contacts could not be fetched');
-
-      const updatedContacts = walletContacts.filter(
-        ({ ethereumAddress }) => ethereumAddress !== contactAddressToDelete,
-      );
-
-      contacts[walletAddressFormatted] = updatedContacts;
-      return contacts;
-    });
-  }
-}
-
-export const contactStorage = new ContactStorage();

package/src/data-structures/IndexedDB/prices-db.ts

@@ -1,89 +0,0 @@
-import { get, update } from 'idb-keyval';
-import { API } from '../../API/API';
-import { getStateKey } from '../../functions/utils/string.utils';
-
-class PricesStorage {
-  readonly tokenPricesRecordLabel = 'tokenPrices';
-
-  async getPrices() {
-    const prices = await get<Record<string, number>>(this.tokenPricesRecordLabel);
-    return prices;
-  }
-
-  async updatePrices(chainId: number, erc20Addresses: string[]) {
-    if (!erc20Addresses.length) return [];
-
-    const { prices: newPrices } = await API.getTokenPrices(chainId, erc20Addresses);
-
-    await update(this.tokenPricesRecordLabel, (prevPrices: Record<string, number> = {}) => {
-      const clonedPrices = { ...prevPrices };
-      newPrices.forEach((price, index) => {
-        clonedPrices[getStateKey(erc20Addresses[index], chainId)] = price;
-      });
-      return clonedPrices;
-    });
-    return newPrices;
-  }
-
-  // Fetches token prices and updates missing prices as needed.
-  async getAndUpdatePrices(currentChainId: number, erc20Addresses: string[]) {
-    const cachedTokenPrices = await this.getPrices();
-    let prices: number[] = new Array(erc20Addresses.length).fill(0);
-
-    if (!cachedTokenPrices) {
-      prices = await this.updatePrices(currentChainId, erc20Addresses);
-    } else {
-      const dontHavePrices: string[] = [];
-      const dontHavePricesIndexes: number[] = [];
-
-      erc20Addresses.forEach((tokenAddress, index) => {
-        const tokenStateKey = getStateKey(tokenAddress, currentChainId);
-        if (cachedTokenPrices[tokenStateKey]) {
-          prices[index] = cachedTokenPrices[tokenStateKey];
-        } else {
-          dontHavePrices.push(tokenAddress);
-          dontHavePricesIndexes.push(index);
-        }
-      });
-
-      const restPrices = await this.updatePrices(currentChainId, dontHavePrices);
-      dontHavePricesIndexes.forEach((index, i) => {
-        prices[index] = restPrices[i];
-      });
-    }
-
-    return prices;
-  }
-
-  async updateCachedPricesByChain(chainId: number) {
-    const cachedPrices = await this.getPrices();
-
-    if (!cachedPrices || Object.keys(cachedPrices).length === 0) {
-      return;
-    }
-
-    const chainTokens = Object.entries(cachedPrices)
-      .filter(([key]) => {
-        const [, chainIdStr] = key.split('-');
-        return parseInt(chainIdStr, 10) === chainId;
-      })
-      .map(([key]) => key.split('-')[0]);
-
-    if (chainTokens.length === 0) {
-      return;
-    }
-
-    const { prices: updatedPrices } = await API.getTokenPrices(chainId, chainTokens);
-
-    await update(this.tokenPricesRecordLabel, (prevPrices: Record<string, number> = {}) => {
-      const clonedPrices = { ...prevPrices };
-      updatedPrices.forEach((price, index) => {
-        const stateKey = getStateKey(chainTokens[index], chainId);
-        clonedPrices[stateKey] = price;
-      });
-      return clonedPrices;
-    });
-  }
-}
-
-export const pricesStorage = new PricesStorage();

package/src/data-structures/IndexedDB/private-balances-db.ts

@@ -1,31 +0,0 @@
-import { get, update } from 'idb-keyval';
-import { TokenBalance } from '../../types/token.types';
-import { getStateKey } from '../../functions/utils/string.utils';
-
-class PrivateBalancesStorage {
-  readonly balancesRecordLabel = 'privateWalletsBalances';
-
-  async getBalances() {
-    const walletBalances = await get<Record<string, TokenBalance[]>>(this.balancesRecordLabel);
-    return walletBalances;
-  }
-
-  async getBalancesByWallet(address: string, chainId: number) {
-    const walletBalances = await this.getBalances();
-    if (!walletBalances) return undefined;
-    const key = getStateKey(address, chainId, true);
-    return walletBalances[key];
-  }
-
-  async setBalances(address: string, chainId: number, newBalances: TokenBalance[]) {
-    await update(this.balancesRecordLabel, (walletBalances: Record<string, TokenBalance[]> = {}) => {
-      const key = getStateKey(address, chainId, true);
-      return {
-        ...walletBalances,
-        [key]: newBalances,
-      };
-    });
-  }
-}
-
-export const privateBalancesStorage = new PrivateBalancesStorage();

package/src/data-structures/IndexedDB/signatures-db.ts

@@ -1,62 +0,0 @@
-import { get, set } from 'idb-keyval';
-import { Logger } from '../../error-handling';
-import { ConfirmationRequestType } from '../../types/confirmation-request.types';
-import { AppMetaData } from '../../types/wc.types';
-import { SignedMessage, StorageKeys } from '../../types';
-
-type SignedMessageRecord = Record<string, SignedMessage>;
-
-class SignedMessagesStorage {
-  private generateMessageId(): string {
-    const timestamp = new Date().getTime();
-    const random = Math.random().toString(36).substring(2, 15);
-    return `msg_${timestamp}_${random}`;
-  }
-
-  public async saveSignedMessage(
-    chainId: number,
-    messageText: string,
-    messageType: ConfirmationRequestType.PERSONAL_SIGN | ConfirmationRequestType.SIGN_TYPE_V4,
-    subAccountAddress: string,
-    signature: string,
-    appMetaData: AppMetaData,
-  ): Promise<void> {
-    try {
-      const id = this.generateMessageId();
-      const record = (await get<SignedMessageRecord>(StorageKeys.SIGNED_MESSAGES)) || {};
-
-      const messageData = {
-        chainId,
-        messageText,
-        messageType,
-        subAccountAddress,
-        signature,
-        appMetaData,
-      };
-
-      record[id] = {
-        timestamp: new Date().toISOString(),
-        ...messageData,
-      };
-
-      await set(StorageKeys.SIGNED_MESSAGES, record);
-    } catch (error) {
-      Logger.error('Failed to save signed message:', error, {
-        chainId,
-        messageType,
-      });
-    }
-  }
-
-  public async getAllSignedMessages(): Promise<SignedMessage[]> {
-    try {
-      const record = (await get<SignedMessageRecord>(StorageKeys.SIGNED_MESSAGES)) || {};
-      return Object.values(record).sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
-    } catch (error) {
-      Logger.error('Failed to retrieve signed messages:', error);
-      return [];
-    }
-  }
-}
-
-export const signedMessagesStorage = new SignedMessagesStorage();