Added transaction manager

src/constants/transactions.constants.ts

@@ -4,3 +4,4 @@ export const CROSS_SHARD_ROUNDS = 5;
 export const TRANSACTIONS_STATUS_POLLING_INTERVAL_MS = 90 * 1000; // 90sec
 export const TRANSACTIONS_STATUS_DROP_INTERVAL_MS = 10 * 60 * 1000; // 10min
 export const CANCEL_TRANSACTION_TOAST_DEFAULT_DURATION = 20000;
+export const BATCH_TRANSACTIONS_ID_SEPARATOR = '-';

src/core/managers/TransactionManager.ts

@@ -0,0 +1,149 @@
+import { Transaction } from '@multiversx/sdk-core/out';
+import axios, { AxiosError } from 'axios';
+import { BATCH_TRANSACTIONS_ID_SEPARATOR } from 'constants/transactions.constants';
+import { getAccount } from 'core/methods/account/getAccount';
+import { networkSelector } from 'store/selectors';
+import { getState } from 'store/store';
+import { GuardianActionsEnum } from 'types';
+import { BatchTransactionsResponseType } from 'types/serverTransactions.types';
+import { SignedTransactionType } from 'types/transactions.types';
+
+export class TransactionManager {
+  private static instance: TransactionManager | null = null;
+
+  private constructor() {}
+
+  public static getInstance(): TransactionManager {
+    if (!TransactionManager.instance) {
+      TransactionManager.instance = new TransactionManager();
+    }
+    return TransactionManager.instance;
+  }
+
+  public send = async (
+    signedTransactions: Transaction[] | Transaction[][]
+  ): Promise<string[] | null> => {
+    if (signedTransactions.length === 0) {
+      return null;
+    }
+
+    try {
+      if (this.isBatchTransaction(signedTransactions)) {
+        const sentTransactions =
+          await this.sendSignedBatchTransactions(signedTransactions);
+
+        if (!sentTransactions.data || sentTransactions.data.error) {
+          throw new Error(
+            sentTransactions.data?.error || 'Failed to send transactions'
+          );
+        }
+
+        const flatSentTransactions = this.sequentialToFlatArray(
+          sentTransactions.data.transactions
+        );
+
+        return flatSentTransactions.map((transaction) => transaction.hash);
+      }
+
+      return await this.sendSignedTransactions(signedTransactions);
+    } catch (error) {
+      const responseData = <{ message: string }>(
+        (error as AxiosError).response?.data
+      );
+      throw responseData?.message ?? (error as any).message;
+    }
+  };
+
+  private sendSignedTransactions = async (
+    signedTransactions: Transaction[]
+  ): Promise<string[]> => {
+    const { apiAddress, apiTimeout } = networkSelector(getState());
+
+    const promises = signedTransactions.map((transaction) =>
+      axios.post(`${apiAddress}/transactions`, transaction.toPlainObject(), {
+        timeout: Number(apiTimeout)
+      })
+    );
+
+    const response = await Promise.all(promises);
+
+    return response.map(({ data }) => data.txHash);
+  };
+
+  private sendSignedBatchTransactions = async (
+    signedTransactions: Transaction[][]
+  ) => {
+    const { address } = getAccount();
+    const { apiAddress, apiTimeout } = networkSelector(getState());
+
+    if (!address) {
+      return {
+        error:
+          'Invalid address provided. You need to be logged in to send transactions'
+      };
+    }
+
+    const batchId = this.buildBatchId(address);
+    const parsedTransactions = signedTransactions.map((transactions) =>
+      transactions.map((transaction) =>
+        this.parseSignedTransaction(transaction)
+      )
+    );
+
+    const payload = {
+      transactions: parsedTransactions,
+      id: batchId
+    };
+
+    const response = await axios.post<BatchTransactionsResponseType>(
+      `${apiAddress}/batch`,
+      payload,
+      {
+        timeout: Number(apiTimeout)
+      }
+    );
+
+    return { data: response.data };
+  };
+
+  private buildBatchId = (address: string) => {
+    const sessionId = Date.now().toString();
+    return `${sessionId}${BATCH_TRANSACTIONS_ID_SEPARATOR}${address}`;
+  };
+
+  private sequentialToFlatArray = (
+    transactions: SignedTransactionType[] | SignedTransactionType[][] = []
+  ) =>
+    this.getIsSequential(transactions)
+      ? transactions.flat()
+      : (transactions as SignedTransactionType[]);
+
+  private getIsSequential = (
+    transactions?: SignedTransactionType[] | SignedTransactionType[][]
+  ) => transactions?.some((transaction) => Array.isArray(transaction));
+
+  private isBatchTransaction = (
+    transactions: Transaction[] | Transaction[][]
+  ): transactions is Transaction[][] => {
+    return Array.isArray(transactions[0]);
+  };
+
+  private parseSignedTransaction = (signedTransaction: Transaction) => {
+    const parsedTransaction = {
+      ...signedTransaction.toPlainObject(),
+      hash: signedTransaction.getHash().hex()
+    };
+
+    // TODO: Remove when the protocol supports usernames for guardian transactions
+    if (this.isGuardianTx(parsedTransaction.data)) {
+      delete parsedTransaction.senderUsername;
+      delete parsedTransaction.receiverUsername;
+    }
+
+    return parsedTransaction;
+  };
+
+  private isGuardianTx = (transactionData?: string) =>
+    transactionData &&
+    transactionData.startsWith(GuardianActionsEnum.SetGuardian);
+}

src/types/enums.types.ts

@@ -42,3 +42,9 @@ export enum ESDTTransferTypesEnum {
   ESDTWipe = 'ESDTWipe',
   ESDTFreeze = 'ESDTFreeze'
 }
+
+export enum GuardianActionsEnum {
+  SetGuardian = 'SetGuardian',
+  GuardAccount = 'GuardAccount',
+  UnGuardAccount = 'UnGuardAccount'
+}