@toruslabs/ethereum-controllers 5.5.3 → 5.5.4

package/src/Tokens/TokensController.ts

@@ -1,273 +0,0 @@
-import { BaseController, PreferencesState } from "@toruslabs/base-controllers";
-import { SafeEventEmitterProvider } from "@toruslabs/openlogin-jrpc";
-import { BrowserProvider, Contract, toQuantity } from "ethers";
-import log from "loglevel";
-
-import NetworkController from "../Network/NetworkController";
-import PreferencesController from "../Preferences/PreferencesController";
-import { singleBalanceCheckerAbi } from "../utils/abis";
-import { ETHERSCAN_SUPPORTED_CHAINS } from "../utils/constants";
-import { SINGLE_CALL_BALANCES_ADDRESSES } from "../utils/contractAddresses";
-import { idleTimeTracker, toChecksumAddressByChainId } from "../utils/helpers";
-import { CustomTokenInfo, EthereumNetworkState, ExtendedAddressPreferences } from "../utils/interfaces";
-import { TokensControllerConfig, TokensControllerState } from "./ITokensController";
-import { TokenHandler } from "./TokenHandler";
-
-export interface ITokensControllerOptions {
-  config?: Partial<TokensControllerConfig>;
-  state?: Partial<TokensControllerState>;
-  provider: SafeEventEmitterProvider;
-  getCustomTokens?: PreferencesController["getCustomTokens"];
-  getEtherScanTokens: PreferencesController["getEtherScanTokens"];
-  getProviderConfig: NetworkController["getProviderConfig"];
-  onPreferencesStateChange: (listener: (preferencesState: PreferencesState<ExtendedAddressPreferences>) => void) => void;
-  onNetworkStateChange: (listener: (networkState: EthereumNetworkState) => void) => void;
-}
-
-function getObjectFromArrayBasedonKey(oldArray: CustomTokenInfo[], key: string) {
-  return oldArray.reduce((acc: Record<string, CustomTokenInfo>, x) => {
-    const xkey = x[key as keyof CustomTokenInfo];
-    if (typeof xkey === "boolean") return acc;
-    acc[xkey] = x;
-    return acc;
-  }, {});
-}
-
-const mergeTokenArrays = (oldArray: CustomTokenInfo[], newArray: CustomTokenInfo[]): CustomTokenInfo[] => {
-  const oldMap = getObjectFromArrayBasedonKey(oldArray || [], "tokenAddress");
-  const newMap = getObjectFromArrayBasedonKey(newArray || [], "tokenAddress");
-  const finalArr = newArray;
-  Object.keys(oldMap).forEach((x) => {
-    if (!newMap[x] && oldMap[x].isEtherScan) finalArr.push(oldMap[x]);
-  });
-  return finalArr;
-};
-
-const DEFAULT_INTERVAL = 180 * 1000;
-
-export class TokensController extends BaseController<TokensControllerConfig, TokensControllerState> {
-  name = "TokensController";
-
-  private provider: SafeEventEmitterProvider;
-
-  private ethersProvider: BrowserProvider;
-
-  private _timer: number;
-
-  private getProviderConfig: NetworkController["getProviderConfig"];
-
-  private getCustomTokens: PreferencesController["getCustomTokens"];
-
-  private getEtherScanTokens: PreferencesController["getEtherScanTokens"];
-
-  constructor({
-    config,
-    state,
-    provider,
-    getCustomTokens,
-    getEtherScanTokens,
-    getProviderConfig,
-    onPreferencesStateChange,
-    onNetworkStateChange,
-  }: ITokensControllerOptions) {
-    super({ config, state });
-
-    this.provider = provider;
-    this.ethersProvider = new BrowserProvider(this.provider, "any");
-
-    this.getCustomTokens = getCustomTokens;
-    this.getEtherScanTokens = getEtherScanTokens;
-    this.getProviderConfig = getProviderConfig;
-
-    this.defaultConfig = {
-      interval: DEFAULT_INTERVAL,
-      selectedAddress: "",
-      chainId: "",
-    };
-
-    this.defaultState = {
-      tokens: {},
-    };
-    this.initialize();
-
-    onPreferencesStateChange((preferencesState) => {
-      if (preferencesState.selectedAddress !== this.config.selectedAddress) {
-        this.configure({ selectedAddress: preferencesState.selectedAddress });
-        this.restartTokenDetection();
-      }
-    });
-
-    onNetworkStateChange((networkState) => {
-      const { chainId } = networkState.providerConfig;
-      if (chainId !== this.config.chainId) {
-        this.configure({ chainId });
-        this.restartTokenDetection();
-      }
-    });
-  }
-
-  get userSelectedAddress(): string {
-    return this.config.selectedAddress;
-  }
-
-  get userTokens() {
-    if (!this.userSelectedAddress) return [];
-    return this.state.tokens[this.userSelectedAddress] ?? [];
-  }
-
-  get interval(): number {
-    return this.config.interval;
-  }
-
-  set interval(interval: number) {
-    if (this._timer) window.clearInterval(this._timer);
-    if (!interval) {
-      return;
-    }
-    this._timer = window.setInterval(() => {
-      if (!idleTimeTracker.checkIfIdle()) {
-        this.detectNewTokens();
-        this.refreshTokenBalances();
-      }
-    }, interval);
-  }
-
-  public startTokenDetection(selectedAddress: string) {
-    this.configure({ selectedAddress });
-    this.restartTokenDetection();
-  }
-
-  /**
-   * Restart token detection polling period and call detectNewTokens
-   * in case of address change or user session initialization.
-   *
-   */
-  public restartTokenDetection() {
-    if (!this.userSelectedAddress) {
-      return;
-    }
-    this.detectNewTokens();
-    this.refreshTokenBalances();
-    this.config.interval = DEFAULT_INTERVAL;
-  }
-
-  public detectNewTokens() {
-    const userAddress = this.userSelectedAddress;
-    if (!userAddress) return;
-    const currentChainId = this.config.chainId;
-    const tokens: CustomTokenInfo[] = []; // object[]
-    if (!currentChainId) {
-      this.update({ tokens: { [userAddress]: [...tokens] } });
-      return;
-    }
-
-    const networkConfig = this.getProviderConfig();
-
-    if (networkConfig?.isErc20 && networkConfig?.tokenAddress) {
-      tokens.push({
-        tokenAddress: networkConfig.tokenAddress,
-        name: networkConfig.tickerName,
-        logo: networkConfig.logo,
-        erc20: true,
-        symbol: networkConfig.ticker,
-        decimals: "18",
-        chainId: currentChainId,
-      });
-    }
-    if (this.getCustomTokens) {
-      const customTokens = this.getCustomTokens(userAddress);
-      tokens.push(
-        ...customTokens.reduce((acc, x) => {
-          if (x.network === currentChainId)
-            acc.push({
-              tokenAddress: x.token_address,
-              name: x.token_name,
-              logo: "eth.svg",
-              erc20: true,
-              symbol: x.token_symbol,
-              decimals: x.decimals,
-              balance: "",
-              customTokenId: x.id.toString(),
-              chainId: x.network,
-            });
-          return acc;
-        }, [] as CustomTokenInfo[])
-      );
-    }
-    this.update({ tokens: { [userAddress]: [...tokens] } });
-  }
-
-  async refreshTokenBalances() {
-    const userAddress = this.userSelectedAddress;
-    if (userAddress === "") return;
-    const oldTokens = [...this.userTokens];
-    const tokenAddresses = oldTokens.map((x) => x.tokenAddress);
-    const nonZeroTokens: CustomTokenInfo[] = [];
-    try {
-      const currentChainId = this.config.chainId;
-      if (ETHERSCAN_SUPPORTED_CHAINS.includes(currentChainId)) {
-        const etherscanBalances = await this.getEtherScanTokens(userAddress, currentChainId);
-        nonZeroTokens.push(...etherscanBalances);
-      }
-      if (tokenAddresses.length > 0) {
-        const currentSingleCallAddress = SINGLE_CALL_BALANCES_ADDRESSES[currentChainId];
-        if (currentSingleCallAddress) {
-          const ethContract = new Contract(currentSingleCallAddress, singleBalanceCheckerAbi, this.ethersProvider);
-          const result = await ethContract.balances([userAddress], tokenAddresses);
-          tokenAddresses.forEach((_, index) => {
-            const balance = toQuantity(result[index]);
-            if (balance && balance !== "0x0") {
-              nonZeroTokens.push({ ...oldTokens[index], balance, chainId: currentChainId });
-            }
-          });
-        } else {
-          this.getTokenBalancesUsingHandler(oldTokens);
-        }
-      }
-    } catch (error) {
-      log.error(error, "unable to fetch token balances using single call balance address");
-      this.getTokenBalancesUsingHandler(oldTokens);
-    } finally {
-      this.update({ tokens: { [userAddress]: nonZeroTokens } });
-    }
-  }
-
-  async getTokenBalancesUsingHandler(customTokens: CustomTokenInfo[]) {
-    if (!this.userSelectedAddress) return;
-    const currentNetworkTokens = customTokens;
-    const promiseSettledResult = await Promise.allSettled(
-      currentNetworkTokens.map(async (x) => {
-        try {
-          const tokenInstance = new TokenHandler({
-            address: x.tokenAddress,
-            decimals: Number.parseInt(x.decimals),
-            name: x.name,
-            symbol: x.symbol,
-            provider: this.ethersProvider,
-          });
-          const balance = await tokenInstance.getUserBalance(this.userSelectedAddress);
-          return {
-            decimals: tokenInstance.decimals.toString(),
-            erc20: true,
-            logo: x.logo || "eth.svg",
-            name: tokenInstance.name,
-            symbol: tokenInstance.symbol,
-            tokenAddress: toChecksumAddressByChainId(tokenInstance.address, x.chainId),
-            balance: `0x${balance}`,
-            customTokenId: x.customTokenId,
-            network: x.chainId,
-            chainId: x.chainId,
-          } as CustomTokenInfo;
-        } catch (error) {
-          log.warn("Invalid contract address while fetching", error);
-          return undefined;
-        }
-      })
-    );
-    const nonZeroTokens = promiseSettledResult
-      .filter((x) => x.status === "fulfilled")
-      .map((x) => (x as PromiseFulfilledResult<CustomTokenInfo>).value);
-
-    this.update({ tokens: { [this.userSelectedAddress]: mergeTokenArrays(this.userTokens, nonZeroTokens) } });
-  }
-}

package/src/Transaction/NonceTracker.ts

@@ -1,152 +0,0 @@
-// import assert from 'assert'
-import { SafeEventEmitterProvider } from "@toruslabs/openlogin-jrpc";
-import { Mutex, MutexInterface } from "async-mutex";
-
-import PollingBlockTracker from "../Block/PollingBlockTracker";
-import { METHOD_TYPES } from "../utils/constants";
-import { EthereumTransactionMeta, Nonce, NonceDetails, NonceLockRes } from "../utils/interfaces";
-import TransactionStateManager from "./TransactionStateManager";
-
-interface INonceTrackerOptions {
-  provider: SafeEventEmitterProvider;
-  blockTracker: PollingBlockTracker;
-  getPendingTransactions: TransactionStateManager["getPendingTransactions"];
-  getConfirmedTransactions: TransactionStateManager["getConfirmedTransactions"];
-}
-
-class NonceTracker {
-  private provider: SafeEventEmitterProvider;
-
-  private blockTracker: PollingBlockTracker;
-
-  private getPendingTransactions: TransactionStateManager["getPendingTransactions"];
-
-  private getConfirmedTransactions: TransactionStateManager["getConfirmedTransactions"];
-
-  private lockMap: Record<string, Mutex>;
-
-  constructor({ provider, blockTracker, getPendingTransactions, getConfirmedTransactions }: INonceTrackerOptions) {
-    this.provider = provider;
-    this.blockTracker = blockTracker;
-    this.getPendingTransactions = getPendingTransactions;
-    this.getConfirmedTransactions = getConfirmedTransactions;
-    this.lockMap = {};
-  }
-
-  public async getGlobalLock(): Promise<{ releaseLock: MutexInterface.Releaser }> {
-    const globalMutex = this._lookupMutex("global");
-    // await global mutex free
-    const releaseLock = await globalMutex.acquire();
-    return { releaseLock };
-  }
-
-  /**
-    this will return an object with the `nextNonce` 
-    `nonceDetails`, and the releaseLock.
-    Note: releaseLock must be called after adding a signed tx 
-    to pending transactions (or discarding).
-  */
-  public async getNonceLock(address: string): Promise<NonceLockRes> {
-    // await global mutex free
-    await this._globalMutexFree();
-    // await lock free, then take lock
-    const releaseLock = await this._takeMutex(address);
-    try {
-      // evaluate multiple nextNonce strategies
-      const nonceDetails = {} as NonceDetails;
-      const networkNonceResult = await this._getNetworkNextNonce(address);
-
-      const highestLocallyConfirmed = this._getHighestLocallyConfirmed(address);
-      const nextNetworkNonce = networkNonceResult.nonce;
-      const highestSuggested = Math.max(nextNetworkNonce, highestLocallyConfirmed);
-
-      const pendingTxs = this.getPendingTransactions(address);
-      const localNonceResult = this._getHighestContinuousFrom(pendingTxs, highestSuggested);
-
-      nonceDetails.params = {
-        highestLocallyConfirmed,
-        highestSuggested,
-        nextNetworkNonce,
-      };
-      nonceDetails.local = localNonceResult;
-      nonceDetails.network = networkNonceResult;
-
-      const nextNonce = Math.max(networkNonceResult.nonce, localNonceResult.nonce);
-
-      // return nonce and release cb
-      return { nextNonce, nonceDetails, releaseLock };
-    } catch (error) {
-      // release lock if we encounter an error
-      releaseLock();
-      throw error;
-    }
-  }
-
-  private async _globalMutexFree() {
-    const globalMutex = this._lookupMutex("global");
-    const releaseLock = await globalMutex.acquire();
-    releaseLock();
-  }
-
-  private async _takeMutex(lockId: string) {
-    const mutex = this._lookupMutex(lockId);
-    const releaseLock = await mutex.acquire();
-    return releaseLock;
-  }
-
-  private _lookupMutex(lockId: string): Mutex {
-    let mutex = this.lockMap[lockId];
-    if (!mutex) {
-      mutex = new Mutex();
-      this.lockMap[lockId] = mutex;
-    }
-    return mutex;
-  }
-
-  private async _getNetworkNextNonce(address: string) {
-    // calculate next nonce
-    // we need to make sure our base count
-    // and pending count are from the same block
-    const block = await this.blockTracker.getLatestBlock();
-    const baseCountStr = await this.provider.request<[string, string], string>({
-      method: METHOD_TYPES.ETH_GET_TRANSACTION_COUNT,
-      params: [address, block.idempotencyKey],
-    });
-    const baseCount = Number.parseInt(baseCountStr, 16);
-    const nonceDetails = { block, baseCount };
-    return { name: "network", nonce: baseCount, details: nonceDetails };
-  }
-
-  private _getHighestLocallyConfirmed(address: string): number {
-    const confirmedTransactions = this.getConfirmedTransactions(address);
-    const highest = this._getHighestNonce(confirmedTransactions);
-    return Number.isInteger(highest) ? highest + 1 : 0;
-  }
-
-  private _getHighestNonce(txList: EthereumTransactionMeta[]): number {
-    const nonces = txList.map((txMeta) => {
-      const { nonce } = txMeta.transaction;
-      return Number.parseInt(nonce, 16);
-    });
-    const highestNonce = Math.max.apply(null, nonces);
-    return highestNonce;
-  }
-
-  private _getHighestContinuousFrom(txList: EthereumTransactionMeta[], startPoint: number): Nonce {
-    const nonces = new Set(
-      txList.map((txMeta) => {
-        const { nonce } = txMeta.transaction;
-        return Number.parseInt(nonce, 16);
-      })
-    );
-
-    let highest = startPoint;
-    while (nonces.has(highest)) {
-      highest += 1;
-    }
-
-    return { name: "local", nonce: highest, details: { startPoint, highest } };
-  }
-}
-
-export default NonceTracker;

package/src/Transaction/PendingTransactionTracker.ts

@@ -1,235 +0,0 @@
-import {
-  BASE_TX_EVENT_TYPE,
-  ITransactionController,
-  TransactionStatus,
-  TX_CONFIRMED_EVENT_TYPE,
-  TX_DROPPED_EVENT_TYPE,
-  TX_EVENTS,
-  TX_FAILED_EVENT_TYPE,
-  TX_WARNING_EVENT_TYPE,
-} from "@toruslabs/base-controllers";
-import { SafeEventEmitter, SafeEventEmitterProvider } from "@toruslabs/openlogin-jrpc";
-import log from "loglevel";
-
-import { METHOD_TYPES } from "../utils/constants";
-import { EthereumBlock, EthereumTransactionMeta, TransactionParams, TransactionReceipt } from "../utils/interfaces";
-import NonceTracker from "./NonceTracker";
-import TransactionStateManager from "./TransactionStateManager";
-
-export default class PendingTransactionTracker extends SafeEventEmitter {
-  DROPPED_BUFFER_COUNT = 3;
-
-  private nonceTracker: NonceTracker;
-
-  private provider: SafeEventEmitterProvider;
-
-  private approveTransaction: ITransactionController<EthereumTransactionMeta>["approveTransaction"];
-
-  private droppedBlocksBufferByHash: Map<string, number>;
-
-  private getConfirmedTransactions: TransactionStateManager["getConfirmedTransactions"];
-
-  private getPendingTransactions: TransactionStateManager["getPendingTransactions"];
-
-  private publishTransaction: (rawTx: string) => Promise<string>;
-
-  constructor({
-    provider,
-    nonceTracker,
-    approveTransaction,
-    publishTransaction,
-    getPendingTransactions,
-    getConfirmedTransactions,
-  }: {
-    provider: SafeEventEmitterProvider;
-    nonceTracker: NonceTracker;
-    approveTransaction: ITransactionController<EthereumTransactionMeta>["approveTransaction"];
-    publishTransaction: (rawTx: string) => Promise<string>;
-    getPendingTransactions: TransactionStateManager["getPendingTransactions"];
-    getConfirmedTransactions: TransactionStateManager["getConfirmedTransactions"];
-  }) {
-    super();
-    this.provider = provider;
-    this.nonceTracker = nonceTracker;
-    this.approveTransaction = approveTransaction;
-    this.publishTransaction = publishTransaction;
-    this.getPendingTransactions = getPendingTransactions;
-    this.getConfirmedTransactions = getConfirmedTransactions;
-    this.droppedBlocksBufferByHash = new Map();
-  }
-
-  /**
-    checks the network for signed txs and releases the nonce global lock if it is
-  */
-  public async updatePendingTxs(): Promise<void> {
-    // in order to keep the nonceTracker accurate we block it while updating pending transactions
-    const nonceGlobalLock = await this.nonceTracker.getGlobalLock();
-    try {
-      const pendingTxs = this.getPendingTransactions();
-      await Promise.all(pendingTxs.map((txMeta) => this._checkPendingTx(txMeta)));
-    } catch (error) {
-      log.error("PendingTransactionTracker - Error updating pending transactions");
-      log.error(error);
-    }
-    nonceGlobalLock.releaseLock();
-  }
-
-  public async resubmitPendingTxs(block: EthereumBlock) {
-    const pending = this.getPendingTransactions();
-    // only try resubmitting if their are transactions to resubmit
-    if (pending.length === 0) return;
-    // Keep this as a for loop because we want to wait for each item to be submitted
-    for (const txMeta of pending) {
-      try {
-        await this._resubmitTx(txMeta, block.idempotencyKey);
-      } catch (error: unknown) {
-        /*
-      Dont marked as failed if the error is a "known" transaction warning
-      "there is already a transaction with the same sender-nonce
-      but higher/same gas price"
-
-      Also don't mark as failed if it has ever been broadcast successfully.
-      A successful broadcast means it may still be mined.
-      */
-        const errorMessage = (error as { value: Error }).value?.message?.toLowerCase() || (error as Error).message.toLowerCase();
-        const isKnownTx =
-          // geth
-          errorMessage.includes("replacement transaction underpriced") ||
-          errorMessage.includes("known transaction") ||
-          // parity
-          errorMessage.includes("gas price too low to replace") ||
-          errorMessage.includes("transaction with the same hash was already imported") ||
-          // other
-          errorMessage.includes("gateway timeout") ||
-          errorMessage.includes("nonce too low");
-        // ignore resubmit warnings, return early
-        if (isKnownTx) return;
-        // encountered real error - transition to error state
-        txMeta.warning = {
-          error: errorMessage,
-          message: "There was an error when resubmitting this transaction.",
-        };
-        this.emit(TX_EVENTS.TX_WARNING, { txMeta, error, txId: txMeta.id } as TX_WARNING_EVENT_TYPE<TransactionParams, EthereumTransactionMeta>);
-      }
-    }
-  }
-
-  async _resubmitTx(txMeta: EthereumTransactionMeta, latestBlockNumber?: string) {
-    if (!txMeta.firstRetryBlockNumber) {
-      this.emit(TX_EVENTS.TX_BLOCK_UPDATE, { txMeta, latestBlockNumber, txId: txMeta.id } as BASE_TX_EVENT_TYPE);
-    }
-
-    const firstRetryBlockNumber = txMeta.firstRetryBlockNumber || latestBlockNumber;
-    const txBlockDistance = Number.parseInt(latestBlockNumber, 16) - Number.parseInt(firstRetryBlockNumber, 16);
-
-    const retryCount = txMeta.retryCount || 0;
-
-    // Exponential backoff to limit retries at publishing (capped at last 15 mins)
-    if (txBlockDistance <= Math.min(50, 2 ** retryCount)) return undefined;
-
-    // Only auto-submit already-signed txs:
-    if (!("rawTx" in txMeta)) return this.approveTransaction(txMeta.id);
-
-    const { rawTx } = txMeta;
-    const txHash = await this.publishTransaction(rawTx as string);
-
-    // Increment successful tries:
-    this.emit(TX_EVENTS.TX_RETRY, { txMeta, txId: txMeta.id } as BASE_TX_EVENT_TYPE);
-    return txHash;
-  }
-
-  async _checkPendingTx(foundTx: EthereumTransactionMeta): Promise<void> {
-    const txMeta = foundTx;
-    const txHash = txMeta.transactionHash;
-    const txId = txMeta.id;
-
-    // Only check submitted txs
-    if (txMeta.status !== TransactionStatus.submitted) return;
-
-    // extra check in case there was an uncaught error during the
-    // signature and submission process
-    if (!txHash) {
-      const noTxHashError = new Error("We had an error while submitting this transaction, please try again.");
-      noTxHashError.name = "NoTxHashError";
-      this.emit(TX_EVENTS.TX_FAILED, { txId, error: noTxHashError } as TX_FAILED_EVENT_TYPE);
-      return;
-    }
-
-    // If another tx with the same nonce is mined, set as failed.
-    if (this._checkIfNonceIsTaken(txMeta)) {
-      this.emit(TX_EVENTS.TX_DROPPED, { txId } as TX_DROPPED_EVENT_TYPE);
-      return;
-    }
-
-    try {
-      const transactionReceipt = await this.provider.request<[string], TransactionReceipt>({
-        method: METHOD_TYPES.ETH_GET_TRANSACTION_RECEIPT,
-        params: [txHash],
-      });
-      if (transactionReceipt?.blockNumber) {
-        const { baseFeePerGas, timestamp } = await this.provider.request<[string, boolean], EthereumBlock>({
-          method: METHOD_TYPES.ETH_GET_BLOCK_BY_HASH,
-          params: [transactionReceipt.blockHash, false],
-        });
-        this.emit(TX_EVENTS.TX_CONFIRMED, {
-          txId,
-          txReceipt: transactionReceipt,
-          baseFeePerGas,
-          blockTimestamp: timestamp,
-        } as TX_CONFIRMED_EVENT_TYPE);
-        return;
-      }
-    } catch (error) {
-      log.error("error while loading tx", error);
-      txMeta.warning = {
-        error: (error as Error).message,
-        message: "There was a problem loading this transaction.",
-      };
-      this.emit(TX_EVENTS.TX_WARNING, { txMeta } as TX_WARNING_EVENT_TYPE<TransactionParams, EthereumTransactionMeta>);
-    }
-
-    if (await this._checkIfTxWasDropped(txMeta)) {
-      this.emit(TX_EVENTS.TX_DROPPED, { txId } as TX_DROPPED_EVENT_TYPE);
-    }
-  }
-
-  async _checkIfTxWasDropped(txMeta: EthereumTransactionMeta): Promise<boolean> {
-    const {
-      transactionHash: txHash,
-      transaction: { nonce, from },
-    } = txMeta;
-    const networkNextNonce = await this.provider.request<[string, string], string>({
-      method: METHOD_TYPES.ETH_GET_TRANSACTION_COUNT,
-      params: [from, "latest"],
-    });
-
-    if (Number.parseInt(nonce, 16) >= Number.parseInt(networkNextNonce, 16)) {
-      return false;
-    }
-
-    if (!this.droppedBlocksBufferByHash.has(txHash)) {
-      this.droppedBlocksBufferByHash.set(txHash, 0);
-    }
-
-    const currentBlockBuffer = this.droppedBlocksBufferByHash.get(txHash);
-
-    if (currentBlockBuffer < this.DROPPED_BUFFER_COUNT) {
-      this.droppedBlocksBufferByHash.set(txHash, currentBlockBuffer + 1);
-      return false;
-    }
-
-    this.droppedBlocksBufferByHash.delete(txHash);
-    return true;
-  }
-
-  _checkIfNonceIsTaken(txMeta: EthereumTransactionMeta) {
-    const address = txMeta.transaction.from;
-    const completed = this.getConfirmedTransactions(address);
-    return completed.some((otherMeta) => {
-      if (otherMeta.id === txMeta.id) {
-        return false;
-      }
-      return otherMeta.transaction.nonce === txMeta.transaction.nonce;
-    });
-  }
-}