@sabaaa1/common 0.0.12 → 0.0.13

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

@@ -0,0 +1,204 @@
+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

@@ -0,0 +1,97 @@
+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

@@ -0,0 +1,81 @@
+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

@@ -0,0 +1,89 @@
+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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,62 @@
+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();