diff --git a/adamant-wallets b/adamant-wallets
index 2e4175ae3..af8f93b3a 160000
--- a/adamant-wallets
+++ b/adamant-wallets
@@ -1 +1 @@
-Subproject commit 2e4175ae32c380eb3006021b34830a3874f3e47b
+Subproject commit af8f93b3a140a2baf983f935d59bd4a8a1938130
diff --git a/src/components/SendFundsForm.vue b/src/components/SendFundsForm.vue
index d722e2363..236817ce0 100644
--- a/src/components/SendFundsForm.vue
+++ b/src/components/SendFundsForm.vue
@@ -186,7 +186,10 @@
 </template>
 
 <script>
+import { adm } from '@/lib/nodes'
 import lskIndexer from '@/lib/nodes/lsk-indexer'
+import { AllNodesOfflineError } from '@/lib/nodes/utils/errors'
+import { PendingTransactionError } from '@/lib/pending-transactions'
 import axios from 'axios'
 import { nextTick } from 'vue'
 
@@ -207,7 +210,8 @@ import {
   CryptosInfo,
   CryptosOrder,
   isTextDataAllowed,
-  MessageType
+  MessageType,
+  Fees
 } from '@/lib/constants'
 
 import { parseURIasAIP } from '@/lib/uri'
@@ -405,6 +409,14 @@ export default {
         : this.$store.state[this.currency.toLowerCase()].balance
     },
 
+    /**
+     * Return ADM balance
+     * @returns {number}
+     */
+    admBalance() {
+      return this.$store.state.balance
+    },
+
     ethBalance() {
       return this.$store.state.eth.balance
     },
@@ -489,6 +501,19 @@ export default {
         ],
         amount: [
           (v) => v > 0 || this.$t('transfer.error_incorrect_amount'),
+          () => {
+            const isAdmTransfer = this.currency === Cryptos.ADM
+            const isDirectTransfer = !this.address
+
+            if (isAdmTransfer || isDirectTransfer) {
+              return true // skips validation
+            }
+
+            return (
+              this.admBalance >= Fees.NOT_ADM_TRANSFER ||
+              this.$t('transfer.error_not_enough_adm_fee')
+            )
+          },
           () => this.amount <= this.maxToTransfer || this.$t('transfer.error_not_enough'),
           (v) => this.validateMinAmount(v, this.currency) || this.$t('transfer.error_dust_amount'),
           (v) => this.validateNaturalUnits(v, this.currency) || this.$t('transfer.error_precision'),
@@ -720,6 +745,14 @@ export default {
             message = this.$t('transfer.recipient_minimum_balance')
           } else if (/Invalid JSON RPC Response/i.test(message)) {
             message = this.$t('transfer.error_unknown')
+          } else if (error instanceof AllNodesOfflineError) {
+            message = this.$t('transfer.error_all_nodes_offline', {
+              crypto: error.nodeLabel.toUpperCase()
+            })
+          } else if (error instanceof PendingTransactionError) {
+            message = this.$t('transfer.error_pending_transaction', {
+              crypto: error.crypto
+            })
           }
           this.$emit('error', message)
         })
@@ -729,7 +762,7 @@ export default {
           this.dialog = false
         })
     },
-    sendFunds() {
+    async sendFunds() {
       if (this.currency === Cryptos.ADM) {
         let promise
         // 1. if come from Chat then sendMessage
@@ -745,6 +778,7 @@ export default {
               })
             : this.comment
 
+          adm.assertAnyNodeOnline()
           promise = sendMessage({
             amount: this.amount,
             message: asset,
diff --git a/src/components/TransactionListItem.vue b/src/components/TransactionListItem.vue
index d0cd99ac1..0ab269721 100644
--- a/src/components/TransactionListItem.vue
+++ b/src/components/TransactionListItem.vue
@@ -23,7 +23,7 @@
         <span :class="`${className}__amount ${directionClass}`">{{
           currency(amount, crypto)
         }}</span>
-        <span :class="`${className}__rates`"> {{ historyRate }}</span>
+        <span :class="`${className}__rates`">{{ historyRate }}</span>
         <span v-if="comment" class="a-text-regular-enlarged-bold" style="font-style: italic">
           "</span
         >
@@ -39,7 +39,10 @@
       </v-list-item-title>
 
       <v-list-item-subtitle :class="`${className}__date`" class="a-text-explanation-small">
-        {{ formatDate(createdAt) }}
+        <span v-if="!isPendingTransaction">{{ formatDate(createdAt) }}</span>
+        <span v-else-if="status" :class="`${className}__status`">{{
+          $t(`transaction.statuses.${status}`)
+        }}</span>
       </v-list-item-subtitle>
 
       <template #append>
@@ -61,7 +64,7 @@
 
 <script>
 import formatDate from '@/filters/date'
-import { EPOCH, Cryptos } from '@/lib/constants'
+import { EPOCH, Cryptos, TransactionStatus } from '@/lib/constants'
 import partnerName from '@/mixins/partnerName'
 import { isStringEqualCI } from '@/lib/textHelpers'
 import currencyAmount from '@/filters/currencyAmount'
@@ -80,6 +83,10 @@ export default {
       type: String,
       required: true
     },
+    status: {
+      type: String,
+      required: true
+    },
     recipientId: {
       type: String,
       required: true
@@ -103,6 +110,9 @@ export default {
     }
   },
   emits: ['click:transaction', 'click:icon'],
+  data: () => ({
+    virtualTimestamp: Date.now()
+  }),
   computed: {
     // Own crypto address, like 1F9bMGsui6GbcFaGSNao5YcjnEk38eXXg7 or U3716604363012166999
     userId() {
@@ -176,15 +186,27 @@ export default {
       return (
         '~' +
         this.$store.getters['rate/historyRate'](
-          timestampInSec(this.crypto, this.timestamp),
+          timestampInSec(this.crypto, this.timestamp || this.virtualTimestamp),
           amount,
           this.crypto
         )
       )
+    },
+    isPendingTransaction() {
+      return (
+        this.status === TransactionStatus.PENDING || this.status === TransactionStatus.REGISTERED
+      )
     }
   },
   mounted() {
     this.getHistoryRates()
+
+    if (this.isPendingTransaction) {
+      this.$store.dispatch(`${this.crypto.toLowerCase()}/getTransaction`, {
+        hash: this.id,
+        force: true
+      })
+    }
   },
   methods: {
     isStringEqualCI(string1, string2) {
@@ -232,7 +254,7 @@ export default {
     },
     getHistoryRates() {
       this.$store.dispatch('rate/getHistoryRates', {
-        timestamp: timestampInSec(this.crypto, this.timestamp)
+        timestamp: timestampInSec(this.crypto, this.timestamp || this.virtualTimestamp)
       })
     },
     currency,
@@ -250,6 +272,7 @@ export default {
     color: hsla(0, 0%, 100%, 0.7);
     font-style: italic;
     @include a-text-regular();
+    margin-left: 4px;
   }
   &__amount {
     @include a-text-regular-enlarged-bold();
@@ -268,6 +291,9 @@ export default {
   &__action {
     min-width: 36px;
   }
+  &__status {
+    color: map-get($adm-colors, 'attention');
+  }
   // Do not break computed length of v-divider
   /*&__tile*/
   /*:deep(.v-list__tile)*/
diff --git a/src/lib/eth-index.js b/src/lib/eth-index.js
deleted file mode 100644
index ba4d474d2..000000000
--- a/src/lib/eth-index.js
+++ /dev/null
@@ -1,136 +0,0 @@
-import axios from 'axios'
-
-import config from '../config'
-import * as utils from './eth-utils'
-
-const cache = {}
-
-/**
- * @typedef {Object} EthTx
- * @property {number} time
- * @property {string} txfrom
- * @property {string} txto
- * @property {number} gas
- * @property {number} gasprice
- * @property {number} block
- * @property {string} input
- * @property {string} txhash
- * @property {number} value
- * @property {string} prefix
- * @property {string} contract_to
- * @property {string} contract_value
- */
-
-/**
- * @typedef {Object} Request
- * @property {string} address ETH address
- * @property {string} contract ERC20 contract (optional)
- * @property {number} from start from block number
- * @property {number} to up to block number
- * @property {number} limit defaults to 100
- * @property {number} offset defaults to 0
- */
-
-/**
- * Retrieves ETH transactions list according to the specified criteria.
- * @param {Request} options request options
- * @returns {Promise<{total: number, items: Array<EthTx>}>}
- */
-export function getTransactions(options) {
-  const { address, contract, from, to, limit, decimals } = options
-
-  const filters = []
-
-  if (contract) {
-    filters.push(
-      `txto.eq.${contract}`,
-      `or(txfrom.eq.${address},contract_to.eq.000000000000000000000000${address.replace('0x', '')})`
-    )
-  } else {
-    filters.push('contract_to.eq.', `or(txfrom.eq.${address},txto.eq.${address})`)
-  }
-
-  if (from) {
-    filters.push(`time.gte.${from}`)
-  }
-
-  if (to) {
-    filters.push(`time.lte.${to}`)
-  }
-
-  const filterString = filters.join(',')
-
-  if (!cache[filterString]) {
-    const params = {
-      and: `(${filters.join(',')})`,
-      order: 'time.desc'
-    }
-
-    if (limit) params.limit = limit
-
-    const config = {
-      url: getUrl(),
-      params
-    }
-
-    cache[filterString] = axios.request(config).then(
-      ({ data, headers }) => {
-        delete cache[filterString]
-
-        const range = headers['content-range']
-        const total = getTotalFromRange(range)
-
-        return {
-          total,
-          items: data.map((x) => parseTxFromIndex(x, decimals))
-        }
-      },
-      (error) => {
-        delete cache[filterString]
-        return Promise.reject(error)
-      }
-    )
-  }
-
-  return cache[filterString]
-}
-
-/**
- * Parses the content range to extract the total count of records
- * @param {string} range range to parse
- */
-function getTotalFromRange(range = '') {
-  const index = range.indexOf('/')
-  return index >= 0 ? Number(range.substr(index + 1)) : NaN
-}
-
-function getUrl() {
-  const nodes = config.eth.nodes.list.filter((x) => x.hasIndex).map((x) => x.url)
-  const index = Math.floor(Math.random() * nodes.length)
-  return nodes[index] + '/ethtxs'
-}
-
-/**
- * Parses ETH index entry.
- * @param {EthTx} tx entry
- */
-function parseTxFromIndex(tx, decimals) {
-  const hash = tx.txhash.replace(/^.*x/, '0x').toLowerCase()
-
-  const recipientId = tx.contract_to ? '0x' + tx.contract_to.substr(-40) : tx.txto.toLowerCase()
-
-  const value = tx.contract_value ? parseInt(tx.contract_value, 16) : tx.value
-
-  return {
-    id: hash,
-    hash,
-    senderId: tx.txfrom.toLowerCase(),
-    recipientId,
-    amount: utils.toFraction(value, decimals),
-    fee: utils.calculateFee(tx.gas, tx.gasprice || tx.effectivegasprice),
-    status: 'CONFIRMED',
-    timestamp: tx.time * 1000,
-    blockNumber: tx.block,
-    time: tx.time
-  }
-}
diff --git a/src/lib/nodes/abstract.client.ts b/src/lib/nodes/abstract.client.ts
index 63f55c6a5..62ff6f81c 100644
--- a/src/lib/nodes/abstract.client.ts
+++ b/src/lib/nodes/abstract.client.ts
@@ -1,4 +1,5 @@
 import type { HealthcheckInterval, NodeType } from '@/lib/nodes/types'
+import { AllNodesOfflineError } from './utils/errors'
 import { filterSyncedNodes } from './utils/filterSyncedNodes'
 import { Node } from './abstract.node'
 import { nodesStorage } from './storage'
@@ -122,6 +123,29 @@ export abstract class Client<N extends Node> {
     })
   }
 
+  protected getNode() {
+    const node = this.useFastest ? this.getFastestNode() : this.getRandomNode()
+    if (!node) {
+      // All nodes seem to be offline: let's refresh the statuses
+      this.checkHealth()
+      // But there's nothing we can do right now
+      throw new Error('No online nodes at the moment')
+    }
+
+    return node
+  }
+
+  /**
+   * Throws an error if all the nodes are offline.
+   */
+  assertAnyNodeOnline() {
+    const onlineNodes = this.nodes.filter((x) => x.online && x.active && !x.outOfSync)
+
+    if (onlineNodes.length === 0) {
+      throw new AllNodesOfflineError(this.type)
+    }
+  }
+
   /**
    * Updates `outOfSync` status of the nodes.
    *
diff --git a/src/lib/nodes/eth-indexer/EthIndexer.ts b/src/lib/nodes/eth-indexer/EthIndexer.ts
new file mode 100644
index 000000000..7bf6c6a92
--- /dev/null
+++ b/src/lib/nodes/eth-indexer/EthIndexer.ts
@@ -0,0 +1,65 @@
+import { Endpoints } from './types/api/endpoints'
+import axios, { AxiosInstance, AxiosRequestConfig } from 'axios'
+import { Node } from '@/lib/nodes/abstract.node'
+import { NODE_LABELS } from '@/lib/nodes/constants'
+
+/**
+ * ETH Indexer API
+ * https://github.com/Adamant-im/ETH-transactions-storage
+ */
+export class EthIndexer extends Node {
+  client: AxiosInstance
+
+  constructor(url: string) {
+    super(url, 'eth', 'service', NODE_LABELS.EthIndexer)
+
+    this.client = axios.create({ baseURL: url })
+
+    // Don't fetch node info if user disabled it
+    if (this.active) {
+      void this.fetchServiceInfo()
+    }
+    void this.startHealthcheck()
+  }
+
+  /**
+   * Performs a request to the ETH Indexer.
+   * The indexer uses PostgREST.
+   */
+  async request<E extends keyof Endpoints>(
+    endpoint: E,
+    params?: Endpoints[E]['params'],
+    requestConfig?: AxiosRequestConfig
+  ): Promise<Endpoints[E]['result']> {
+    const [method, path] = endpoint.split(' ')
+
+    return this.client
+      .request({
+        ...requestConfig,
+        url: path,
+        method,
+        params: method === 'GET' ? params : undefined,
+        data: method === 'POST' ? params : undefined
+      })
+      .then((res) => res.data)
+  }
+
+  private async fetchServiceInfo(): Promise<{ height: number }> {
+    const [{ max }] = await this.request('GET /max_block')
+    this.height = max
+
+    return {
+      height: this.height
+    }
+  }
+
+  protected async checkHealth() {
+    const time = Date.now()
+    const { height } = await this.fetchServiceInfo()
+
+    return {
+      height,
+      ping: Date.now() - time
+    }
+  }
+}
diff --git a/src/lib/nodes/eth-indexer/EthIndexerClient.ts b/src/lib/nodes/eth-indexer/EthIndexerClient.ts
new file mode 100644
index 000000000..0f6c37962
--- /dev/null
+++ b/src/lib/nodes/eth-indexer/EthIndexerClient.ts
@@ -0,0 +1,70 @@
+import { AxiosRequestConfig } from 'axios'
+import { GetTransactionsParams } from './types/client/get-transactions-params'
+import { GetTransactionsRequest } from './types/api/get-transactions/get-transactions.request'
+import { Endpoints } from './types/api/endpoints'
+import { EthIndexer } from './EthIndexer'
+import { normalizeTransaction } from './utils'
+import { Client } from '../abstract.client'
+
+export class EthIndexerClient extends Client<EthIndexer> {
+  constructor(endpoints: string[] = [], minNodeVersion = '0.0.0') {
+    super('eth')
+    this.nodes = endpoints.map((endpoint) => new EthIndexer(endpoint))
+    this.minNodeVersion = minNodeVersion
+
+    void this.watchNodeStatusChange()
+  }
+
+  private async request<E extends keyof Endpoints>(
+    endpoint: E,
+    params?: Endpoints[E]['params'],
+    axiosRequestConfig?: AxiosRequestConfig
+  ): Promise<Endpoints[E]['result']> {
+    const node = this.getNode()
+
+    return node.request(endpoint, params, axiosRequestConfig)
+  }
+
+  /**
+   * Query transactions history
+   */
+  async getTransactions(params: GetTransactionsParams) {
+    const { address, contract, from, to, limit, decimals } = params
+
+    const filters = []
+
+    if (contract) {
+      filters.push(
+        `txto.eq.${contract}`,
+        `or(txfrom.eq.${address},contract_to.eq.000000000000000000000000${address.replace(
+          '0x',
+          ''
+        )})`
+      )
+    } else {
+      filters.push('contract_to.eq.', `or(txfrom.eq.${address},txto.eq.${address})`)
+    }
+
+    if (from) {
+      filters.push(`time.gte.${from}`)
+    }
+
+    if (to) {
+      filters.push(`time.lte.${to}`)
+    }
+
+    const requestParams: GetTransactionsRequest = {
+      and: `(${filters.join(',')})`,
+      order: 'time.desc',
+      limit: limit ? limit : undefined
+    }
+
+    if (limit) requestParams.limit = limit
+
+    const transactions = await this.request('GET /ethtxs', {
+      ...requestParams
+    })
+
+    return transactions.map((transaction) => normalizeTransaction(transaction, address, decimals))
+  }
+}
diff --git a/src/lib/nodes/eth-indexer/index.ts b/src/lib/nodes/eth-indexer/index.ts
new file mode 100644
index 000000000..b67bc4f5b
--- /dev/null
+++ b/src/lib/nodes/eth-indexer/index.ts
@@ -0,0 +1,10 @@
+import config from '@/config'
+import { NodeInfo } from '@/types/wallets'
+import { EthIndexerClient } from './EthIndexerClient'
+
+const endpoints = (config.eth.nodes.list as NodeInfo[])
+  .filter((node) => node.hasIndex)
+  .map((endpoint) => endpoint.url)
+export const ethIndexer = new EthIndexerClient(endpoints)
+
+export default ethIndexer
diff --git a/src/lib/nodes/eth-indexer/types/api/endpoints.ts b/src/lib/nodes/eth-indexer/types/api/endpoints.ts
new file mode 100644
index 000000000..09aea9729
--- /dev/null
+++ b/src/lib/nodes/eth-indexer/types/api/endpoints.ts
@@ -0,0 +1,34 @@
+import { GetTransactionsRequest } from './get-transactions/get-transactions.request'
+import { Transaction } from './get-transactions/transaction'
+
+export type Endpoints = {
+  /**
+   * Get transactions
+   */
+  'GET /ethtxs': {
+    params: GetTransactionsRequest
+    result: Transaction[]
+  }
+  /**
+   * Get max block number
+   */
+  'GET /max_block': {
+    params: undefined
+    result: [
+      {
+        max: number
+      }
+    ]
+  }
+  /**
+   * Check availability
+   */
+  'GET /aval': {
+    params: undefined
+    result: [
+      {
+        status: number
+      }
+    ]
+  }
+}
diff --git a/src/lib/nodes/eth-indexer/types/api/get-transactions/get-transactions.request.ts b/src/lib/nodes/eth-indexer/types/api/get-transactions/get-transactions.request.ts
new file mode 100644
index 000000000..c7f76cf59
--- /dev/null
+++ b/src/lib/nodes/eth-indexer/types/api/get-transactions/get-transactions.request.ts
@@ -0,0 +1,19 @@
+import { Transaction } from './transaction'
+
+type OrderBy = keyof Transaction
+
+export type GetTransactionsRequest = {
+  /**
+   * Query params
+   * e.g. (contract_to.eq.,or(txfrom.eq.0x7e0Bd3F27EC0997A3B17045023097372b4c563B3,txto.eq.0x7e0Bd3F27EC0997A3B17045023097372b4c563B3))
+   */
+  and?: string
+  /**
+   * Order by
+   */
+  order?: `${OrderBy}.asc` | `${OrderBy}.desc`
+  /**
+   * Limit the number of transactions returned
+   */
+  limit?: number
+}
diff --git a/src/lib/nodes/eth-indexer/types/api/get-transactions/transaction.ts b/src/lib/nodes/eth-indexer/types/api/get-transactions/transaction.ts
new file mode 100644
index 000000000..537e34e20
--- /dev/null
+++ b/src/lib/nodes/eth-indexer/types/api/get-transactions/transaction.ts
@@ -0,0 +1,40 @@
+export type Transaction = {
+  /**
+   * Transaction timestamp (seconds)
+   */
+  time: number
+  /**
+   * Sender ID
+   * e.g. "0x3e3dec7969CbeeD2B488a3ECb943386C5BAbC781"
+   */
+  txfrom: string
+  /**
+   * Recipient ID
+   * e.g. 0x7e0Bd3F27EC0997A3B17045023097372b4c563B3
+   */
+  txto: string
+  gas: number
+  /**
+   * Gas price in wei
+   */
+  gasprice: number
+  block: number
+  /**
+   * e.g.: "0xca335cb7b871c58bf2d6e3a74e27f07d865daf1ed864bf9d06f6527c97d29a2b"
+   * or: "\\x46b4147aaf88ce8ce7a05b003446bc77e6732c0c100ee30b12c5d23ff7be91c3"
+   */
+  txhash: string
+  /**
+   * ETH value in wei
+   */
+  value: number
+  /**
+   * Empty for ETH transfers
+   */
+  contract_to: string
+  /**
+   * Empty for ETH transfers
+   */
+  contract_value: string
+  status: boolean | null
+}
diff --git a/src/lib/nodes/eth-indexer/types/client/get-transactions-params.ts b/src/lib/nodes/eth-indexer/types/client/get-transactions-params.ts
new file mode 100644
index 000000000..89e616beb
--- /dev/null
+++ b/src/lib/nodes/eth-indexer/types/client/get-transactions-params.ts
@@ -0,0 +1,30 @@
+export type GetTransactionsParams = {
+  /**
+   * ETH address
+   */
+  address: string
+  /**
+   * Number of decimals (for transfer amount formatting)
+   */
+  decimals: number
+  /**
+   * ERC20 contract address
+   */
+  contract?: string
+  /**
+   * Start block number
+   */
+  from?: number
+  /**
+   * Up to block number
+   */
+  to?: number
+  /**
+   * Limit the number of transactions returned. Default to `100`
+   */
+  limit?: number
+  /**
+   * Offset. Defaults to `0`
+   */
+  offset?: number
+}
diff --git a/src/lib/nodes/eth-indexer/utils.ts b/src/lib/nodes/eth-indexer/utils.ts
new file mode 100644
index 000000000..992630571
--- /dev/null
+++ b/src/lib/nodes/eth-indexer/utils.ts
@@ -0,0 +1,40 @@
+import { TransactionStatus } from '@/lib/constants'
+import * as utils from '@/lib/eth-utils'
+import { Transaction } from './types/api/get-transactions/transaction'
+import { EthTransaction } from '@/lib/nodes/types/transaction'
+
+/**
+ * @param transaction
+ * @param ownerAddress ETH address
+ * @param decimals Converts satoshi to specified decimals
+ */
+export function normalizeTransaction(
+  transaction: Transaction,
+  ownerAddress: string,
+  decimals: number
+): EthTransaction {
+  const hash = transaction.txhash.replace(/^.*x/, '0x').toLowerCase()
+  const senderId = transaction.txfrom.toLowerCase()
+  const recipientId = transaction.contract_to
+    ? '0x' + transaction.contract_to.substr(-40)
+    : transaction.txto.toLowerCase()
+
+  const direction = transaction.txfrom.toLowerCase() === ownerAddress.toLowerCase() ? 'from' : 'to'
+  const value = transaction.contract_value
+    ? parseInt(transaction.contract_value, 16)
+    : transaction.value
+
+  return {
+    id: hash,
+    hash: hash,
+    fee: Number(utils.calculateFee(transaction.gas, transaction.gasprice)),
+    status: TransactionStatus.CONFIRMED,
+    time: transaction.time, // block timestamp in seconds
+    timestamp: transaction.time * 1000, // block timestamp in ms
+    direction,
+    senderId,
+    recipientId,
+    amount: Number(utils.toFraction(value, decimals)),
+    blockNumber: transaction.block
+  }
+}
diff --git a/src/lib/nodes/eth/EthClient.ts b/src/lib/nodes/eth/EthClient.ts
index d4ad4f113..2c03d109e 100644
--- a/src/lib/nodes/eth/EthClient.ts
+++ b/src/lib/nodes/eth/EthClient.ts
@@ -1,5 +1,10 @@
+import { Web3Eth } from 'web3-eth'
+import { TransactionNotFound as Web3TransactionNotFound } from 'web3-errors'
+import { TransactionNotFound } from '@/lib/nodes/utils/errors'
 import { EthNode } from './EthNode'
 import { Client } from '../abstract.client'
+import { normalizeTransaction } from './utils'
+import { bytesToHex } from '@/lib/hex'
 
 /**
  * Provides methods for calling the ADAMANT API.
@@ -16,4 +21,57 @@ export class EthClient extends Client<EthNode> {
 
     void this.watchNodeStatusChange()
   }
+
+  async isTransactionFinalized(hash: string): Promise<boolean> {
+    const node = this.getNode()
+
+    try {
+      const transaction = await node.client.getTransaction(hash)
+      const isFinalized = !!transaction.blockNumber
+
+      return isFinalized
+    } catch (err) {
+      return false
+    }
+  }
+
+  async getTransaction(hash: string) {
+    const node = this.getNode()
+
+    try {
+      const transaction = await node.client.getTransaction(hash)
+      const isFinalized = transaction.blockNumber !== undefined
+
+      const blockTimestamp = isFinalized
+        ? await node.client.getBlock(transaction.blockNumber).then((block) => block.timestamp)
+        : undefined
+
+      return normalizeTransaction(transaction, blockTimestamp)
+    } catch (err) {
+      if (err instanceof Web3TransactionNotFound) {
+        throw new TransactionNotFound(hash, this.type)
+      }
+
+      throw err
+    }
+  }
+
+  sendSignedTransaction(...args: Parameters<Web3Eth['sendSignedTransaction']>): Promise<string> {
+    return new Promise((resolve, reject) => {
+      this.getNode()
+        .client.sendSignedTransaction(...args)
+        .on('transactionHash', (hash) => {
+          if (typeof hash === 'string') {
+            resolve(hash)
+          } else {
+            resolve(bytesToHex(hash))
+          }
+        })
+        .on('error', reject)
+    })
+  }
+
+  getNonce(address: string) {
+    return this.getNode().client.getTransactionCount(address)
+  }
 }
diff --git a/src/lib/nodes/eth/utils.ts b/src/lib/nodes/eth/utils.ts
new file mode 100644
index 000000000..d0c665f57
--- /dev/null
+++ b/src/lib/nodes/eth/utils.ts
@@ -0,0 +1,33 @@
+import { TransactionStatus } from '@/lib/constants'
+import { EthTransaction } from '@/lib/nodes/types/transaction'
+import * as utils from '@/lib/eth-utils'
+import Web3Eth from 'web3-eth'
+
+/**
+ * Normalize ETH transaction
+ * @param transaction
+ * @param blockTimestamp Block timestamp in seconds. Omitted if the transaction is not included in a block yet
+ */
+export function normalizeTransaction(
+  transaction: Awaited<ReturnType<Web3Eth['getTransaction']>>,
+  blockTimestamp?: number | bigint
+): EthTransaction {
+  const gasPrice = 'gasPrice' in transaction ? transaction.gasPrice : '0'
+  const fee = utils.calculateFee(transaction.gas, gasPrice.toString())
+  const amount = 'value' in transaction ? transaction.value : '0'
+
+  return {
+    id: transaction.hash,
+    hash: transaction.hash,
+    fee: Number(fee),
+    status: transaction.blockNumber ? TransactionStatus.CONFIRMED : TransactionStatus.PENDING,
+    time: blockTimestamp ? Number(blockTimestamp) : undefined,
+    timestamp: blockTimestamp ? Number(blockTimestamp) * 1000 : undefined,
+    blockNumber: transaction.blockNumber ? Number(transaction.blockNumber) : undefined,
+    direction: 'from',
+    senderId: transaction.from,
+    recipientId: transaction.to!,
+    amount: Number(utils.toEther(amount)),
+    confirmations: 0
+  }
+}
diff --git a/src/lib/nodes/lsk-indexer/LskIndexerClient.ts b/src/lib/nodes/lsk-indexer/LskIndexerClient.ts
index e1ab93e72..d4cc205b3 100644
--- a/src/lib/nodes/lsk-indexer/LskIndexerClient.ts
+++ b/src/lib/nodes/lsk-indexer/LskIndexerClient.ts
@@ -1,4 +1,5 @@
 import { LSK_TOKEN_ID } from '@/lib/lisk'
+import { TransactionNotFound } from '@/lib/nodes/utils/errors'
 import { AxiosRequestConfig } from 'axios'
 import { normalizeTransaction } from './utils'
 import { TransactionParams } from './types/api/transactions/transaction-params'
@@ -46,6 +47,23 @@ export class LskIndexerClient extends Client<LskIndexer> {
     return transactions.map((transaction) => normalizeTransaction(transaction, address))
   }
 
+  async isTransactionFinalized(transactionID: string): Promise<boolean> {
+    const { data: transactions } = await this.request('GET /transactions', {
+      transactionID
+    })
+
+    const transaction = transactions[0]
+
+    if (!transaction) {
+      return false
+    }
+
+    const isFinalized =
+      transaction.executionStatus === 'successful' || transaction.executionStatus === 'failed'
+
+    return isFinalized
+  }
+
   /**
    * Returns a single transaction by ID
    *
@@ -60,7 +78,7 @@ export class LskIndexerClient extends Client<LskIndexer> {
     const transaction = transactions[0]
 
     if (!transaction) {
-      throw new Error(`LskIndexer: Transaction ID:${transactionID} not found`)
+      throw new TransactionNotFound(transactionID, this.type)
     }
 
     return normalizeTransaction(transaction, address)
diff --git a/src/lib/nodes/lsk-indexer/types/api/transactions/normalized-transaction.ts b/src/lib/nodes/lsk-indexer/types/api/transactions/normalized-transaction.ts
deleted file mode 100644
index eba72917e..000000000
--- a/src/lib/nodes/lsk-indexer/types/api/transactions/normalized-transaction.ts
+++ /dev/null
@@ -1,16 +0,0 @@
-export type NormalizedTransaction = {
-  id: string
-  hash: string
-  fee: number
-  status: 'CONFIRMED' | 'REGISTERED'
-  data: string
-  timestamp: number // block timestamp
-  direction: 'from' | 'to'
-  senderId: string
-  recipientId: string
-  amount: number
-  height: number // block height
-  nonce: string
-  module: 'token'
-  command: 'transfer'
-}
diff --git a/src/lib/nodes/lsk-indexer/types/api/transactions/transaction.ts b/src/lib/nodes/lsk-indexer/types/api/transactions/transaction.ts
index 92f01e2e0..3a435d54f 100644
--- a/src/lib/nodes/lsk-indexer/types/api/transactions/transaction.ts
+++ b/src/lib/nodes/lsk-indexer/types/api/transactions/transaction.ts
@@ -1,16 +1,19 @@
-export type Transaction = {
+type Block = {
+  id: string
+  height: number
+  timestamp: number
+  isFinal: boolean
+}
+
+type TransactionStatus = 'successful' | 'pending' | 'failed'
+
+type BaseTransaction<Status extends TransactionStatus> = {
   id: string
   moduleCommand: string
   nonce: string
   fee: string
   minFee: string
   size: number
-  block: {
-    id: string
-    height: number
-    timestamp: number
-    isFinal: boolean
-  }
   sender: {
     address: string
     publicKey: string
@@ -22,13 +25,27 @@ export type Transaction = {
     tokenID: string
     data: string
   }
-  executionStatus: string
+  executionStatus: Status
   index: number
   meta: {
     recipient: {
       address: string
-      publicKey: string
-      name: string
+      publicKey: string | null
+      name: string | null
     }
   }
 }
+
+export type PendingTransaction = BaseTransaction<'pending'>
+
+export type SuccessfulTransaction = BaseTransaction<'successful'> & {
+  index: number
+  block: Block
+}
+
+export type FailedTransaction = BaseTransaction<'failed'> & {
+  index: number
+  block: Block
+}
+
+export type Transaction = PendingTransaction | SuccessfulTransaction | FailedTransaction
diff --git a/src/lib/nodes/lsk-indexer/utils.ts b/src/lib/nodes/lsk-indexer/utils.ts
index 5ba605e9a..f4fbc1444 100644
--- a/src/lib/nodes/lsk-indexer/utils.ts
+++ b/src/lib/nodes/lsk-indexer/utils.ts
@@ -1,7 +1,8 @@
 import { getMillisTimestamp } from '@/lib/lisk/lisk-utils'
 import { convertBeddowsToLSK } from '@liskhq/lisk-transactions'
+import { TransactionStatus, TransactionStatusType } from '@/lib/constants'
 import { Transaction } from './types/api/transactions/transaction'
-import { NormalizedTransaction } from './types/api/transactions/normalized-transaction'
+import { LskTransaction } from '@/lib/nodes/types/transaction'
 
 /**
  * @param transaction
@@ -10,23 +11,42 @@ import { NormalizedTransaction } from './types/api/transactions/normalized-trans
 export function normalizeTransaction(
   transaction: Transaction,
   ownerAddress: string
-): NormalizedTransaction {
+): LskTransaction {
   const direction = transaction.sender.address === ownerAddress ? 'from' : 'to'
+  const isFinalized =
+    transaction.executionStatus === 'successful' || transaction.executionStatus === 'failed'
 
   return {
     id: transaction.id,
     hash: transaction.id,
     fee: Number(convertBeddowsToLSK(transaction.fee)),
-    status: 'CONFIRMED',
+    status: mapStatus(transaction.executionStatus),
     data: transaction.params.data,
-    timestamp: getMillisTimestamp(transaction.block.timestamp), // block timestamp
+    timestamp: isFinalized ? getMillisTimestamp(transaction.block.timestamp) : undefined, // block timestamp
     direction,
     senderId: transaction.sender.address,
     recipientId: transaction.params.recipientAddress,
     amount: Number(convertBeddowsToLSK(transaction.params.amount)),
-    height: transaction.block.height,
+    height: isFinalized ? transaction.block.height : undefined,
     nonce: transaction.nonce,
     module: 'token',
     command: 'transfer'
   }
 }
+
+/**
+ * Map LSK transaction execution status to our internal status
+ * @param status
+ */
+function mapStatus(status: Transaction['executionStatus']): TransactionStatusType {
+  switch (status) {
+    case 'successful':
+      return TransactionStatus.CONFIRMED
+    case 'pending':
+      return TransactionStatus.PENDING
+    case 'failed':
+      return TransactionStatus.REJECTED
+    default:
+      throw new Error(`LskIndexer: Unknown status: ${status}`)
+  }
+}
diff --git a/src/lib/nodes/services.ts b/src/lib/nodes/services.ts
index f60c8f4e4..ee2688adf 100644
--- a/src/lib/nodes/services.ts
+++ b/src/lib/nodes/services.ts
@@ -1,5 +1,7 @@
 import { lskIndexer } from './lsk-indexer'
+import { ethIndexer } from './eth-indexer'
 
 export const services = {
-  lskIndexer
+  lskIndexer,
+  ethIndexer
 }
diff --git a/src/lib/nodes/storage.ts b/src/lib/nodes/storage.ts
index e3d2a89c6..3a742163d 100644
--- a/src/lib/nodes/storage.ts
+++ b/src/lib/nodes/storage.ts
@@ -1,3 +1,4 @@
+import { TypedStorage } from '@/lib/typed-storage'
 import type { NodeType } from './types'
 
 type URL = string
@@ -14,30 +15,7 @@ type Options = Record<
 const NODES_STATE_STORAGE_KEY = 'NODES_STATE_STORAGE' // for storing active/inactive state
 const NODES_OPTIONS_STORAGE_KEY = 'NODES_OPTIONS_STORAGE' // for storing common options
 
-function getItem<K extends string, S = unknown>(key: K, defaultValue: S): S {
-  const rawData = window.localStorage.getItem(key)
-  if (rawData === null) {
-    return defaultValue
-  }
-
-  try {
-    return JSON.parse(rawData) ?? defaultValue
-  } catch (err) {
-    window.localStorage.removeItem(key)
-
-    return defaultValue
-  }
-}
-
-function getState(): State {
-  return getItem(NODES_STATE_STORAGE_KEY, {})
-}
-
-function saveState(newState: State) {
-  const rawData = JSON.stringify(newState)
-
-  window.localStorage.setItem(NODES_STATE_STORAGE_KEY, rawData)
-}
+const stateStorage = new TypedStorage(NODES_STATE_STORAGE_KEY, {} as State, window.localStorage)
 
 const defaultOptions: Options = {
   adm: { useFastest: false },
@@ -48,37 +26,33 @@ const defaultOptions: Options = {
   lsk: { useFastest: false }
 }
 
-function getOptions() {
-  return getItem(NODES_OPTIONS_STORAGE_KEY, defaultOptions)
-}
-
-function saveOptions(newOptions: Options) {
-  const rawData = JSON.stringify(newOptions)
-
-  window.localStorage.setItem(NODES_OPTIONS_STORAGE_KEY, rawData)
-}
+const optionsStorage = new TypedStorage(
+  NODES_OPTIONS_STORAGE_KEY,
+  defaultOptions,
+  window.localStorage
+)
 
 export const nodesStorage = {
   isActive(url: string): boolean {
-    const state = getState()
+    const state = stateStorage.getItem()
 
     return state[url] ?? true
   },
   saveActive(url: string, enabled: boolean) {
-    const state = getState()
+    const state = stateStorage.getItem()
     state[url] = enabled
 
-    saveState(state)
+    stateStorage.setItem(state)
   },
   getUseFastest(node: NodeType) {
-    const options = getOptions()
+    const options = optionsStorage.getItem()
 
     return options[node].useFastest
   },
   setUseFastest(value: boolean, node: NodeType) {
-    const options = getOptions()
+    const options = optionsStorage.getItem()
     options[node].useFastest = value
 
-    saveOptions(options)
+    optionsStorage.setItem(options)
   }
 }
diff --git a/src/lib/nodes/types/transaction.ts b/src/lib/nodes/types/transaction.ts
new file mode 100644
index 000000000..67c1feb55
--- /dev/null
+++ b/src/lib/nodes/types/transaction.ts
@@ -0,0 +1,37 @@
+import { TransactionStatusType } from '@/lib/constants'
+
+export type CoinTransaction = {
+  id: string
+  hash: string
+  fee: number
+  status: TransactionStatusType
+  timestamp?: number
+  direction: 'from' | 'to'
+  /**
+   * Sender coin address
+   */
+  senderId: string
+  /**
+   * Recipient coin address
+   */
+  recipientId: string
+  /**
+   * Amount of coins
+   */
+  amount: number
+  confirmations?: number
+}
+
+export type LskTransaction = CoinTransaction & {
+  data: string
+  height?: number
+  nonce: string
+  module: 'token'
+  command: 'transfer'
+}
+
+export type EthTransaction = Omit<CoinTransaction, 'timestamp'> & {
+  blockNumber?: number
+  time?: number // timestamp in seconds
+  timestamp?: number // timestamp in milliseconds
+}
diff --git a/src/lib/nodes/utils/errors.ts b/src/lib/nodes/utils/errors.ts
index 0c4684e1a..52eebfb39 100644
--- a/src/lib/nodes/utils/errors.ts
+++ b/src/lib/nodes/utils/errors.ts
@@ -1,3 +1,5 @@
+import { NodeType } from '@/lib/nodes/types'
+
 /**
  * Custom error to indicate that the endpoint is not available
  */
@@ -16,3 +18,22 @@ export class NodeOfflineError extends Error {
 export function isNodeOfflineError(error: Error): error is NodeOfflineError {
   return (error as NodeOfflineError).code === 'NODE_OFFLINE'
 }
+
+/**
+ * Unified error class for all nodes. Must be used in `node.getTransaction()` method.
+ */
+export class TransactionNotFound extends Error {
+  constructor(hash: string, chain: string) {
+    super(`${chain}: Transaction ${hash} not found`)
+  }
+}
+
+export class AllNodesOfflineError extends Error {
+  nodeLabel: NodeType // to distinct eth-node from eth-indexer it may be better to use TNodeLabel
+
+  constructor(label: NodeType) {
+    super(`${label}: All nodes are offline`)
+
+    this.nodeLabel = label
+  }
+}
diff --git a/src/lib/nodes/utils/getHealthcheckConfig.ts b/src/lib/nodes/utils/getHealthcheckConfig.ts
index ed188da3c..c399ea180 100644
--- a/src/lib/nodes/utils/getHealthcheckConfig.ts
+++ b/src/lib/nodes/utils/getHealthcheckConfig.ts
@@ -7,6 +7,10 @@ export function getNodeHealthcheckConfig(nodeType: NodeType): NodeHealthcheck {
 }
 
 export function getServiceHealthcheckConfig(nodeType: NodeType): ServiceHealthcheck {
+  if (nodeType === 'eth') {
+    return config[nodeType].nodes.healthCheck // Workaround: there no configuration for ETH services
+  }
+
   return config[nodeType].services.healthCheck
 }
 
diff --git a/src/lib/pending-transactions/errors.ts b/src/lib/pending-transactions/errors.ts
new file mode 100644
index 000000000..fa2c4f2f4
--- /dev/null
+++ b/src/lib/pending-transactions/errors.ts
@@ -0,0 +1,15 @@
+import { PendingTransaction } from './types'
+
+export class PendingTransactionError extends Error {
+  pendingTransaction: PendingTransaction
+  crypto: string // e.g. 'ETH' | 'LSK'
+
+  constructor(pendingTransaction: PendingTransaction, crypto: string) {
+    super(
+      `There is a pending transaction ${pendingTransaction.hash}. Please wait until it is confirmed.`
+    )
+    this.name = 'PendingTransactionError'
+    this.pendingTransaction = pendingTransaction
+    this.crypto = crypto
+  }
+}
diff --git a/src/lib/pending-transactions/index.ts b/src/lib/pending-transactions/index.ts
new file mode 100644
index 000000000..cdb8db1d7
--- /dev/null
+++ b/src/lib/pending-transactions/index.ts
@@ -0,0 +1,5 @@
+export * from './storage'
+export * from './types'
+export * from './utils'
+export * from './errors'
+export * from './pending-transactions'
diff --git a/src/lib/pending-transactions/pending-transactions.ts b/src/lib/pending-transactions/pending-transactions.ts
new file mode 100644
index 000000000..c0de205e8
--- /dev/null
+++ b/src/lib/pending-transactions/pending-transactions.ts
@@ -0,0 +1,44 @@
+import { PendingTransactionError } from './errors'
+import { PendingTxStore } from './storage'
+
+type TxFinalizeChecker = (hash: string) => Promise<boolean>
+
+/**
+ * Asserts that there is no pending transaction for the given crypto
+ *
+ * @param crypto e.g. 'ETH' | 'LSK'
+ * @param nonce Current nonce
+ */
+export function assertNoPendingTransaction(crypto: string, nonce: string | number | bigint) {
+  const pendingTransaction = PendingTxStore.get(crypto)
+  if (!pendingTransaction) {
+    return
+  }
+
+  const nonceProvided = pendingTransaction.nonce != undefined && nonce != undefined
+  if (nonceProvided && Number(nonce) <= Number(pendingTransaction.nonce)) {
+    throw new PendingTransactionError(pendingTransaction, crypto)
+  }
+}
+
+/**
+ * Invalidates previous pending transaction.
+ * If transaction is finalized then it will be removed from the store.
+ *
+ * @param crypto  e.g. 'ETH' | 'LSK'
+ * @param checkTransactionFinalized Must return `true` if transaction was written to blockchain.
+ */
+export async function invalidatePendingTransaction(
+  crypto: string,
+  checkTransactionFinalized: TxFinalizeChecker
+) {
+  const pendingTransaction = PendingTxStore.get(crypto)
+  if (!pendingTransaction) {
+    return
+  }
+
+  const isFinalized = await checkTransactionFinalized(pendingTransaction.hash)
+  if (isFinalized) {
+    PendingTxStore.remove(crypto)
+  }
+}
diff --git a/src/lib/pending-transactions/storage.ts b/src/lib/pending-transactions/storage.ts
new file mode 100644
index 000000000..cff0d0822
--- /dev/null
+++ b/src/lib/pending-transactions/storage.ts
@@ -0,0 +1,38 @@
+import { PendingTransaction } from './types'
+import { TypedStorage } from '@/lib/typed-storage'
+
+type PendingTransactionsState = {
+  [coin: string]: PendingTransaction
+}
+
+const PENDING_TRANSACTION_STORAGE_KEY = 'PENDING_TRANSACTIONS'
+
+const storage = new TypedStorage(
+  PENDING_TRANSACTION_STORAGE_KEY,
+  {} as PendingTransactionsState,
+  window.sessionStorage
+)
+
+export const PendingTxStore = {
+  get(coin: string): PendingTransaction | null {
+    const state = storage.getItem()
+    const transaction = state[coin]
+
+    return transaction || null
+  },
+  save(coin: string, transaction: PendingTransaction) {
+    const state = storage.getItem()
+    state[coin] = transaction
+
+    storage.setItem(state)
+  },
+  remove(coin: string) {
+    const state = storage.getItem()
+    delete state[coin]
+
+    storage.setItem(state)
+  },
+  clear() {
+    storage.removeItem()
+  }
+}
diff --git a/src/lib/pending-transactions/types.ts b/src/lib/pending-transactions/types.ts
new file mode 100644
index 000000000..cc4cf57b4
--- /dev/null
+++ b/src/lib/pending-transactions/types.ts
@@ -0,0 +1,9 @@
+import { CoinTransaction } from '@/lib/nodes/types/transaction'
+
+export type PendingTransaction = Pick<
+  CoinTransaction,
+  'id' | 'hash' | 'senderId' | 'recipientId' | 'amount' | 'fee' | 'status' | 'direction'
+> & {
+  nonce?: number
+  timestamp: number
+}
diff --git a/src/lib/pending-transactions/utils.ts b/src/lib/pending-transactions/utils.ts
new file mode 100644
index 000000000..3f341093d
--- /dev/null
+++ b/src/lib/pending-transactions/utils.ts
@@ -0,0 +1,29 @@
+import { PendingTransaction } from './types'
+
+type CreatePendingTransactionParams = {
+  hash: string
+  senderId: string
+  recipientId: string
+  amount: number
+  fee: number | string
+  nonce?: number
+}
+
+export function createPendingTransaction(
+  params: CreatePendingTransactionParams
+): PendingTransaction {
+  const { hash, senderId, recipientId, amount, fee, nonce } = params
+
+  return {
+    id: hash,
+    hash,
+    senderId,
+    recipientId,
+    amount,
+    fee: Number(fee),
+    status: 'PENDING',
+    direction: 'from',
+    nonce,
+    timestamp: Date.now()
+  }
+}
diff --git a/src/lib/typed-storage/index.ts b/src/lib/typed-storage/index.ts
new file mode 100644
index 000000000..99bad5e34
--- /dev/null
+++ b/src/lib/typed-storage/index.ts
@@ -0,0 +1 @@
+export { TypedStorage } from './typed-storage'
diff --git a/src/lib/typed-storage/typed-storage.ts b/src/lib/typed-storage/typed-storage.ts
new file mode 100644
index 000000000..c9be8a3fd
--- /dev/null
+++ b/src/lib/typed-storage/typed-storage.ts
@@ -0,0 +1,32 @@
+export class TypedStorage<K extends string, S = unknown> {
+  constructor(
+    private storageKey: K,
+    private defaultValue: S,
+    private storage: Storage
+  ) {}
+
+  getItem(): S {
+    const rawData = this.storage.getItem(this.storageKey)
+    if (rawData === null) {
+      return this.defaultValue
+    }
+
+    try {
+      return JSON.parse(rawData) ?? this.defaultValue
+    } catch (err) {
+      this.storage.removeItem(this.storageKey)
+
+      return this.defaultValue
+    }
+  }
+
+  setItem(value: S) {
+    const rawData = JSON.stringify(value)
+
+    this.storage.setItem(this.storageKey, rawData)
+  }
+
+  removeItem() {
+    this.storage.removeItem(this.storageKey)
+  }
+}
diff --git a/src/locales/en.json b/src/locales/en.json
index 7ded3de6a..8a615e01b 100644
--- a/src/locales/en.json
+++ b/src/locales/en.json
@@ -312,6 +312,7 @@
     "error_chat_fee": "To send {crypto} via chat, you need 0.001 ADM",
     "error_dust_amount": "Dust amount—Send more tokens",
     "recipient_minimum_balance": "Recipient must have at least 0.05 LSK—Send more tokens",
+    "error_all_nodes_offline": "All {crypto} nodes are offline. Try again later",
     "error_precision": "Too high precision—Set less decimal places",
     "error_erc20_fee": "You need a {fee} to pay a transfer fee",
     "error_field_is_required": "Field is required",
@@ -320,7 +321,9 @@
     "error_no_address": "Enter recipient wallet address",
     "error_no_amount": "Enter amount to send",
     "error_not_enough": "Not enough tokens",
+    "error_not_enough_adm_fee": "Not enough ADM to pay the transaction fee",
     "error_not_enough_eth_fee": "Not enough ETH to pay a transfer fee",
+    "error_pending_transaction": "It seems you have a pending {crypto} tx. Wait while the blockchain confirms it, and try again.",
     "error_same_recipient": "Don't send tokens to yourself",
     "error_transfer_send": "Error while completing a transaction",
     "error_unknown": "Unknown error. Weak connection?",
diff --git a/src/locales/ru.json b/src/locales/ru.json
index 6283e870e..c53eff8bb 100644
--- a/src/locales/ru.json
+++ b/src/locales/ru.json
@@ -313,6 +313,7 @@
     "error_chat_fee": "Чтобы отправить {crypto} в чате, вам также нужно 0.001 ADM",
     "error_dust_amount": "Мелочь — Отправьте больше токенов",
     "recipient_minimum_balance": "На кошельке получателя должно быть больше 0.05 LSK — Отправьте больше токенов",
+    "error_all_nodes_offline": "Все {crypto} ноды недоступны. Попробуйте позже",
     "error_precision": "Уменьшите количество знаков после запятой",
     "error_erc20_fee": "Вам также нужно {fee}, чтобы оплатить комиссию",
     "error_field_is_required": "Поле не заполнено",
@@ -321,7 +322,9 @@
     "error_no_address": "Введите адрес кошелька получателя",
     "error_no_amount": "Введите сумму перевода",
     "error_not_enough": "Недостаточно токенов",
+    "error_not_enough_adm_fee": "Недостаточно ADM для оплаты комиссии",
     "error_not_enough_eth_fee": "Недостаточно ETH для оплаты комиссии",
+    "error_pending_transaction": "Похоже, что у вас есть незавершенная транзакция {crypto}. Подождите пока блокчейн ее обработает, и попробуйте снова.",
     "error_same_recipient": "Не отправляйте токены самому себе",
     "error_transfer_send": "Ошибка при отправке транзакции",
     "error_unknown": "Неизвестная ошибка. Плохое подключение?",
diff --git a/src/locales/zh.json b/src/locales/zh.json
index 962752bd2..835f42a2d 100644
--- a/src/locales/zh.json
+++ b/src/locales/zh.json
@@ -312,6 +312,7 @@
     "error_chat_fee": "要通过聊天发送 {crypto}，您需要 0.001 ADM",
     "error_dust_amount": "无存量--发送更多代币",
     "recipient_minimum_balance": "收件人必须至少有 0.05 LSK--发送更多令牌",
+    "error_all_nodes_offline": "All {crypto} nodes are offline. Try again later",
     "error_precision": "精度过高--设置小数位数较少",
     "error_erc20_fee": "您需要｛费｝来支付转会费",
     "error_field_is_required": "字段是必需的",
@@ -320,7 +321,9 @@
     "error_no_address": "输入收件人钱包地址",
     "error_no_amount": "输入要发送的金额",
     "error_not_enough": "令牌不足",
+    "error_not_enough_adm_fee": "Not enough ADM to pay the transaction fee",
     "error_not_enough_eth_fee": "没有足够的ETH支付转账费",
+    "error_pending_transaction": "It seems you have a pending {crypto} tx. Wait while the blockchain confirms it, and try again.",
     "error_same_recipient": "不要向自己发送令牌",
     "error_transfer_send": "完成事务时出错",
     "error_unknown": "未知错误。弱连接？",
diff --git a/src/store/index.js b/src/store/index.js
index 0edd934fc..fd8ddf81e 100644
--- a/src/store/index.js
+++ b/src/store/index.js
@@ -37,6 +37,7 @@ import notification from './modules/notification'
 import cache from '@/store/cache'
 import rate from './modules/rate'
 import { cryptoTransferAsset, replyWithCryptoTransferAsset } from '@/lib/adamant-api/asset'
+import { PendingTxStore } from '@/lib/pending-transactions'
 
 export let interval
 
@@ -135,6 +136,7 @@ const store = {
     logout({ dispatch }) {
       dispatch('reset')
       dispatch('draftMessage/resetState', null, { root: true })
+      PendingTxStore.clear()
     },
     unlock({ state, dispatch }) {
       // user updated an app, F5 or something
diff --git a/src/store/modules/adm/adm-actions.js b/src/store/modules/adm/adm-actions.js
index 1bf042e13..2be6ce9eb 100644
--- a/src/store/modules/adm/adm-actions.js
+++ b/src/store/modules/adm/adm-actions.js
@@ -1,4 +1,5 @@
 import * as admApi from '@/lib/adamant-api'
+import adm from '../../../lib/nodes/adm'
 
 export default {
   /** Starts background sync after login */
@@ -136,17 +137,20 @@ export default {
    * @param {{address: string, amount: number}} options send options
    * @returns {Promise<{nodeTimestamp: number, success: boolean, transactionId: string}>}
    */
-  sendTokens(context, options) {
-    return admApi.sendTokens(options.address, options.amount).then((result) => {
-      context.commit('transactions', [
-        {
-          id: result.transactionId,
-          recipientId: options.address,
-          senderId: context.state.address,
-          status: 'PENDING'
-        }
-      ])
-      return result
-    })
+  async sendTokens(context, options) {
+    await adm.assertAnyNodeOnline()
+
+    const result = await admApi.sendTokens(options.address, options.amount)
+
+    context.commit('transactions', [
+      {
+        id: result.transactionId,
+        recipientId: options.address,
+        senderId: context.state.address,
+        status: 'PENDING'
+      }
+    ])
+
+    return result
   }
 }
diff --git a/src/store/modules/adm/adm-getters.js b/src/store/modules/adm/adm-getters.js
index 15d40474f..a68359b9b 100644
--- a/src/store/modules/adm/adm-getters.js
+++ b/src/store/modules/adm/adm-getters.js
@@ -1,7 +1,6 @@
 import { Fees } from '@/lib/constants'
 import { isStringEqualCI } from '@/lib/textHelpers'
-
-const sortFunc = (a, b) => ((b && b.timestamp) || 0) - ((a && a.timestamp) || 0)
+import { sortTransactionsFn } from '@/store/utils/sortTransactionsFn'
 
 export default {
   areTransactionsLoading(state) {
@@ -20,7 +19,7 @@ export default {
    * @returns {Array}
    */
   sortedTransactions(state) {
-    return Object.values(state.transactions).sort(sortFunc)
+    return Object.values(state.transactions).sort(sortTransactionsFn)
   },
 
   /**
diff --git a/src/store/modules/btc-base/btc-base-actions.js b/src/store/modules/btc-base/btc-base-actions.js
index 43fbb780a..c2676559a 100644
--- a/src/store/modules/btc-base/btc-base-actions.js
+++ b/src/store/modules/btc-base/btc-base-actions.js
@@ -1,6 +1,8 @@
 import BigNumber from '@/lib/bignumber'
 import BtcBaseApi from '../../../lib/bitcoin/btc-base-api'
 import { FetchStatus } from '@/lib/constants'
+import { nodes } from '../../../lib/nodes'
+import { createPendingTransaction, PendingTxStore } from '../../../lib/pending-transactions'
 import { storeCryptoAddress } from '../../../lib/store-crypto-address'
 import * as tf from '../../../lib/transactionsFetching'
 
@@ -39,6 +41,16 @@ function createActions(options) {
         context.commit('address', api.address)
         context.dispatch('updateStatus')
         context.dispatch('storeAddress')
+
+        // restore pending transaction
+        const pendingTransaction = PendingTxStore.get(context.state.crypto)
+        if (pendingTransaction) {
+          context.commit('transactions', [pendingTransaction])
+          context.dispatch('getTransaction', {
+            hash: pendingTransaction.hash,
+            force: true
+          })
+        }
       }
     },
 
@@ -107,61 +119,80 @@ function createActions(options) {
         })
     },
 
-    sendTokens(context, { amount, admAddress, address, comments, fee, replyToId }) {
+    async sendTokens(context, { amount, admAddress, address, comments, fee, replyToId }) {
       if (!api) return
       address = address.trim()
 
       const crypto = context.state.crypto
+      const nodeName = crypto.toLowerCase()
 
-      return api
-        .createTransaction(address, amount, fee)
-        .then((tx) => {
-          if (!admAddress) return tx.hex
-
-          const msgPayload = {
-            address: admAddress,
-            amount: BigNumber(amount).toFixed(),
-            comments,
-            crypto,
-            hash: tx.txid,
-            replyToId
-          }
-
-          // Send a special message to indicate that we're performing a crypto transfer
-          return context
-            .dispatch('sendCryptoTransferMessage', msgPayload, { root: true })
-            .then((success) => (success ? tx.hex : Promise.reject(new Error('adm_message'))))
+      // 1. Check nodes availability
+      if (admAddress) {
+        await nodes.adm.assertAnyNodeOnline()
+      }
+      await nodes[nodeName].assertAnyNodeOnline()
+
+      // 2. Sign transaction offline
+      const signedTransaction = await api.createTransaction(address, amount, fee)
+
+      // 3. Ensure there is no pending transaction (skipped, no nonce in BTC like cryptos)
+
+      // 4. Send crypto transfer message to ADM blockchain (if ADM address provided)
+      if (admAddress) {
+        const msgPayload = {
+          address: admAddress,
+          amount: BigNumber(amount).toFixed(),
+          comments,
+          crypto,
+          hash: signedTransaction.txid,
+          replyToId
+        }
+        // Send a special message to indicate that we're performing a crypto transfer
+        const success = await context.dispatch('sendCryptoTransferMessage', msgPayload, {
+          root: true
         })
-        .then((rawTx) =>
-          api.sendTransaction(rawTx).then(
-            (hash) => ({ hash }),
-            (error) => ({ error })
-          )
+        if (!success) {
+          throw new Error('adm_message')
+        }
+      }
+
+      // 5. Save pending transaction
+      const pendingTransaction = createPendingTransaction({
+        hash: signedTransaction.txid,
+        senderId: context.state.address,
+        recipientId: address,
+        amount,
+        fee
+      })
+      await PendingTxStore.save(context.state.crypto, pendingTransaction)
+      context.commit('transactions', [pendingTransaction])
+
+      // 6. Send signed transaction to the blockchain
+      try {
+        const hash = await api.sendTransaction(signedTransaction.hex)
+        console.log(
+          `${crypto} transaction has been sent: localHash: ${signedTransaction.txid}, responseHash: ${hash}`
         )
-        .then(({ hash, error }) => {
-          if (error) {
-            context.commit('transactions', [{ hash, status: 'REJECTED' }])
-            throw error
-          } else {
-            console.log(`${crypto} transaction has been sent: ${hash}`)
-
-            context.commit('transactions', [
-              {
-                hash,
-                senderId: context.state.address,
-                recipientId: address,
-                amount,
-                fee,
-                status: 'PENDING',
-                timestamp: Date.now()
-              }
-            ])
-
-            context.dispatch('getTransaction', { hash, force: true })
-
-            return hash
+
+        context.commit('transactions', [
+          {
+            hash,
+            senderId: context.state.address,
+            recipientId: address,
+            amount,
+            fee,
+            status: 'PENDING'
           }
-        })
+        ])
+
+        context.dispatch('getTransaction', { hash, force: true })
+
+        return hash
+      } catch (error) {
+        context.commit('transactions', [{ hash: signedTransaction.txid, status: 'REJECTED' }])
+        PendingTxStore.remove(context.state.crypto)
+        throw error
+      }
     },
 
     /**
diff --git a/src/store/modules/btc-base/btc-base-getters.js b/src/store/modules/btc-base/btc-base-getters.js
index d65893a36..e485b754c 100644
--- a/src/store/modules/btc-base/btc-base-getters.js
+++ b/src/store/modules/btc-base/btc-base-getters.js
@@ -1,4 +1,4 @@
-const sortFunc = (a, b) => ((b && b.timestamp) || 0) - ((a && a.timestamp) || 0)
+import { sortTransactionsFn } from '@/store/utils/sortTransactionsFn'
 
 export default {
   transaction: (state) => (id) => state.transactions[id],
@@ -9,7 +9,7 @@ export default {
    * @returns {Array}
    */
   sortedTransactions(state) {
-    return Object.values(state.transactions).sort(sortFunc)
+    return Object.values(state.transactions).sort(sortTransactionsFn)
   },
 
   areTransactionsLoading(state) {
diff --git a/src/store/modules/erc20/erc20-actions.js b/src/store/modules/erc20/erc20-actions.js
index 61f010568..72c266ccb 100644
--- a/src/store/modules/erc20/erc20-actions.js
+++ b/src/store/modules/erc20/erc20-actions.js
@@ -13,10 +13,9 @@ const STATUS_INTERVAL = 25000
 // Setup decoder
 const abiDecoder = new AbiDecoder(Erc20)
 
-const initTransaction = async (api, context, ethAddress, amount, increaseFee) => {
+const initTransaction = async (api, context, ethAddress, amount, nonce, increaseFee) => {
   const contract = new EthContract(Erc20, context.state.contractAddress)
 
-  const nonce = await api.getClient().getTransactionCount(context.state.address)
   const gasPrice = await api.getClient().getGasPrice()
 
   const transaction = {
diff --git a/src/store/modules/eth-base/eth-base-actions.js b/src/store/modules/eth-base/eth-base-actions.js
index 9b3ee8330..2bdf722d8 100644
--- a/src/store/modules/eth-base/eth-base-actions.js
+++ b/src/store/modules/eth-base/eth-base-actions.js
@@ -1,14 +1,20 @@
 import BigNumber from 'bignumber.js'
+import { TransactionNotFound } from 'web3-errors'
 
 import * as utils from '../../../lib/eth-utils'
-import { getTransactions } from '../../../lib/eth-index'
+import adm from '../../../lib/nodes/adm'
+import ethIndexer from '../../../lib/nodes/eth-indexer'
+import {
+  assertNoPendingTransaction,
+  invalidatePendingTransaction,
+  createPendingTransaction,
+  PendingTxStore
+} from '../../../lib/pending-transactions'
 import * as tf from '../../../lib/transactionsFetching'
-import { isStringEqualCI } from '@/lib/textHelpers'
 import { signTransaction, TransactionFactory } from 'web3-eth-accounts'
 import api from '@/lib/nodes/eth'
 
 /** Interval between attempts to fetch the registered tx details */
-const RETRY_TIMEOUT = 20 * 1000
 const CHUNK_SIZE = 25
 
 export default function createActions(config) {
@@ -27,6 +33,16 @@ export default function createActions(config) {
         context.commit('account', account)
         context.dispatch('updateStatus')
 
+        // restore pending transaction
+        const pendingTransaction = PendingTxStore.get(context.state.crypto)
+        if (pendingTransaction) {
+          context.commit('transactions', [pendingTransaction])
+          context.dispatch('getTransaction', {
+            hash: pendingTransaction.hash,
+            force: true
+          })
+        }
+
         onInit(context)
       }
     },
@@ -56,107 +72,111 @@ export default function createActions(config) {
       }
     },
 
-    sendTokens(context, { amount, admAddress, address, comments, increaseFee, replyToId }) {
+    async sendTokens(context, { amount, admAddress, address, comments, increaseFee, replyToId }) {
       address = address.trim()
       const crypto = context.state.crypto
 
-      return initTransaction(api, context, address, amount, increaseFee)
-        .then((ethTx) => {
-          const tx = TransactionFactory.fromTxData(ethTx)
+      // 1. Check nodes availability
+      if (admAddress) {
+        await adm.assertAnyNodeOnline()
+      }
+      await api.assertAnyNodeOnline()
 
-          return signTransaction(tx, context.state.privateKey).then((signedTx) => {
-            const txInfo = {
-              signedTx,
-              ethTx
-            }
+      // 2. Invalidate previous pending transaction if finalized
+      await invalidatePendingTransaction(context.state.crypto, (hashLocal) =>
+        api.isTransactionFinalized(hashLocal)
+      )
 
-            if (!admAddress) {
-              return txInfo
-            }
-            const msgPayload = {
-              address: admAddress,
-              amount,
-              comments,
-              crypto,
-              hash: signedTx.transactionHash,
-              replyToId
-            }
-            // Send a rich ADM message to indicate that we're performing an ETH transfer
-            return context
-              .dispatch('sendCryptoTransferMessage', msgPayload, { root: true })
-              .then((success) => (success ? txInfo : Promise.reject(new Error('adm_message'))))
-          })
-        })
-        .then((txInfo) => {
-          return api
-            .getClient()
-            .sendSignedTransaction(txInfo.signedTx.rawTransaction)
-            .then(
-              (hash) => ({ txInfo, hash }),
-              (error) => {
-                // Known bug that after Tx sent successfully, this error occurred anyway https://github.com/ethereum/web3.js/issues/3145
-                if (!error.toString().includes('Failed to check for transaction receipt')) {
-                  return { txInfo, error }
-                } else {
-                  return { txInfo, hash: txInfo.signedTx.transactionHash }
-                }
-              }
-            )
+      // 3. Ensure there is no pending transaction
+      const nonce = await api.getNonce(context.state.address)
+      await assertNoPendingTransaction(context.state.crypto, nonce)
+
+      // 4. Sign transaction offline
+      const unsignedTransaction = await initTransaction(
+        api,
+        context,
+        address,
+        amount,
+        nonce,
+        increaseFee
+      )
+      const signedTransaction = await signTransaction(
+        TransactionFactory.fromTxData(unsignedTransaction),
+        context.state.privateKey
+      )
+
+      // 5. Send crypto transfer message to ADM blockchain (if ADM address provided)
+      if (admAddress) {
+        const msgPayload = {
+          address: admAddress,
+          amount,
+          comments,
+          crypto,
+          hash: signedTransaction.transactionHash,
+          replyToId
+        }
+        // Send a rich ADM message to indicate that we're performing an ETH transfer
+        const success = await context.dispatch('sendCryptoTransferMessage', msgPayload, {
+          root: true
         })
-        .then((sentTxInfo) => {
-          // Since London OpenEthereum (or web3?) update v3.3.0-rc.4, hash is an object, not a hex string
-          // Object is a Tx receipt with fields: blockHash, blockNumber, contractAddress, cumulativeGasUsed, effectiveGasPrice,
-          // ..from, gasUsed, logs, logsBloom, **status**: true or false, to, transactionHash, transactionIndex
-          // Though docs say "The callback will return the 32 bytes transaction hash"
-          // https://web3js.readthedocs.io/en/v3.0.0-rc.5/web3-eth.html?highlight=sendSignedTransaction#sendsignedtransaction
-          // We suppose result format may change in future, so expect both variants
-          if (typeof sentTxInfo.hash === 'object') {
-            // Before London hardfork, ethTx included gasPrice
-            // But after it, it include fields: from, gas (limit), to, value (hex),
-            // ..type: undefined, which interprets as 0 (Legacy)
-            // We should take gasPrice from Tx receipt object = effectiveGasPrice
-            sentTxInfo.txInfo.ethTx.gasPrice = sentTxInfo.hash.effectiveGasPrice
-            sentTxInfo.hash = sentTxInfo.hash.transactionHash
-          }
+        if (!success) {
+          throw new Error('adm_message')
+        }
+      }
 
-          if (sentTxInfo.error) {
-            console.error(`Failed to send ${crypto} transaction`, sentTxInfo.error)
-            context.commit('transactions', [
-              { hash: sentTxInfo.txInfo.signedTx.transactionHash, status: 'REJECTED' }
-            ])
-            throw sentTxInfo.error
-          } else {
-            if (!isStringEqualCI(sentTxInfo.hash, sentTxInfo.txInfo.signedTx.transactionHash)) {
-              console.warn(
-                `Something wrong with sent ETH tx, computed hash and sent tx differs: ${sentTxInfo.txInfo.signedTx.transactionHash} and ${sentTxInfo.hash}`
-              )
-            }
+      // 6. Save pending transaction
+      const pendingTransaction = createPendingTransaction({
+        hash: signedTransaction.transactionHash,
+        senderId: context.state.address,
+        recipientId: address,
+        amount,
+        fee: utils.calculateFee(unsignedTransaction.gasLimit, unsignedTransaction.gasPrice),
+        nonce: Number(unsignedTransaction.nonce) // convert BigInt to Number
+      })
+      await PendingTxStore.save(context.state.crypto, pendingTransaction)
+      context.commit('transactions', [pendingTransaction])
+
+      // 7. Send signed transaction to ETH blockchain
+      try {
+        /**
+         * @type {import('web3-types').TransactionReceipt}
+         */
+        const sentTransactionHash = await api.sendSignedTransaction(
+          signedTransaction.rawTransaction
+        )
+
+        if (sentTransactionHash !== signedTransaction.transactionHash) {
+          console.warn(
+            `Something wrong with sent ETH tx, computed hash and sent tx differs: ${signedTransaction.transactionHash} and ${sentTransactionHash}`
+          )
+        }
 
-            context.commit('transactions', [
-              {
-                hash: sentTxInfo.hash,
-                senderId: sentTxInfo.txInfo.ethTx.from,
-                recipientId: address,
-                amount,
-                fee: utils.calculateFee(
-                  sentTxInfo.txInfo.ethTx.gasLimit,
-                  sentTxInfo.txInfo.ethTx.gasPrice
-                ),
-                status: 'PENDING',
-                timestamp: Date.now(),
-                gasPrice: sentTxInfo.txInfo.ethTx.gasPrice
-              }
-            ])
-            context.dispatch('getTransaction', {
-              hash: sentTxInfo.hash,
-              isNew: true,
-              direction: 'from',
-              force: true
-            })
-
-            return sentTxInfo.hash
+        context.commit('transactions', [
+          {
+            hash: sentTransactionHash,
+            senderId: unsignedTransaction.from,
+            recipientId: address,
+            amount,
+            fee: undefined,
+            status: 'PENDING',
+            gasPrice: undefined
           }
+        ])
+        context.dispatch('getTransaction', {
+          hash: sentTransactionHash,
+          isNew: true,
+          direction: 'from',
+          force: true
         })
+
+        return sentTransactionHash
+      } catch (err) {
+        context.commit('transactions', [
+          { hash: signedTransaction.transactionHash, status: 'REJECTED' }
+        ])
+        PendingTxStore.remove(context.state.crypto)
+        throw err
+      }
     },
 
     /**
@@ -206,11 +226,24 @@ export default function createActions(config) {
         ])
       }
 
+      const attempt = payload.attempt || 0
+      const retryCount = tf.getPendingTxRetryCount(
+        payload.timestamp || existing?.timestamp,
+        context.state.crypto
+      )
+      const retry = attempt < retryCount
+      const retryTimeout = tf.getPendingTxRetryTimeout(
+        payload.timestamp || existing?.timestamp,
+        context.state.crypto
+      )
+
       void api
         .getClient()
         .getTransaction(payload.hash)
         .then((tx) => {
-          if (tx?.input) {
+          const isFinalized = tx.blockNumber !== undefined
+
+          if (tx?.input && isFinalized) {
             const transaction = parseTransaction(context, tx)
             const status = existing ? existing.status : 'REGISTERED'
             if (transaction) {
@@ -230,17 +263,6 @@ export default function createActions(config) {
             }
           }
 
-          const attempt = payload.attempt || 0
-          const retryCount = tf.getPendingTxRetryCount(
-            payload.timestamp || existing?.timestamp,
-            context.state.crypto
-          )
-          const retry = attempt < retryCount
-          const retryTimeout = tf.getPendingTxRetryTimeout(
-            payload.timestamp || existing?.timestamp,
-            context.state.crypto
-          )
-
           if (!retry) {
             // Give up, if transaction could not be found after so many attempts
             context.commit('transactions', [{ hash: payload.hash, status: 'REJECTED' }])
@@ -260,6 +282,23 @@ export default function createActions(config) {
             setTimeout(() => context.dispatch('getTransaction', newPayload), retryTimeout)
           }
         })
+        .catch((err) => {
+          if (retry && err instanceof TransactionNotFound) {
+            const newPayload = {
+              ...payload,
+              attempt: attempt + 1,
+              force: true,
+              updateOnly: false,
+              dropStatus: false
+            }
+
+            setTimeout(() => context.dispatch('getTransaction', newPayload), retryTimeout)
+
+            return
+          }
+
+          throw err
+        })
     },
 
     /**
@@ -273,6 +312,17 @@ export default function createActions(config) {
 
       const gasPrice = transaction.gasPrice
 
+      const attempt = payload.attempt || 0
+      const retryCount = tf.getPendingTxRetryCount(
+        transaction.timestamp || Date.now(),
+        context.state.crypto
+      )
+      const retry = attempt < retryCount
+      const retryTimeout = tf.getPendingTxRetryTimeout(
+        transaction.timestamp || Date.now(),
+        context.state.crypto
+      )
+
       void api
         .getClient()
         .getTransactionReceipt(payload.hash)
@@ -307,12 +357,22 @@ export default function createActions(config) {
             replay = !update.status
           }
 
-          if (replay) {
+          if (replay && retry) {
             // In case of an error or a pending transaction fetch its receipt once again later
             // Increment attempt counter, if no transaction was found so far
             const newPayload = { ...payload, attempt: 1 + (payload.attempt || 0) }
-            setTimeout(() => context.dispatch('getTransactionReceipt', newPayload), RETRY_TIMEOUT)
+            setTimeout(() => context.dispatch('getTransactionReceipt', newPayload), retryTimeout)
+          }
+        })
+        .catch((err) => {
+          if (retry && err instanceof TransactionNotFound) {
+            const newPayload = { ...payload, attempt: 1 + (payload.attempt || 0) }
+            setTimeout(() => context.dispatch('getTransactionReceipt', newPayload), retryTimeout)
+
+            return
           }
+
+          throw err
         })
     },
 
@@ -351,16 +411,16 @@ export default function createActions(config) {
 
       context.commit('areRecentLoading', true)
 
-      return getTransactions(options).then(
-        (result) => {
+      return ethIndexer
+        .getTransactions(options)
+        .then((transactions) => {
           context.commit('areRecentLoading', false)
-          context.commit('transactions', { transactions: result.items, updateTimestamps: true })
-        },
-        (error) => {
+          context.commit('transactions', { transactions, updateTimestamps: true })
+        })
+        .catch((err) => {
           context.commit('areRecentLoading', false)
-          return Promise.reject(error)
-        }
-      )
+          return Promise.reject(err)
+        })
     },
 
     getOldTransactions(context) {
@@ -381,20 +441,20 @@ export default function createActions(config) {
 
       context.commit('areOlderLoading', true)
 
-      return getTransactions(options).then(
-        (result) => {
+      return ethIndexer
+        .getTransactions(options)
+        .then((transactions) => {
           context.commit('areOlderLoading', false)
-          context.commit('transactions', { transactions: result.items, updateTimestamps: true })
+          context.commit('transactions', { transactions, updateTimestamps: true })
 
-          if (!result.items.length) {
+          if (transactions.length === 0) {
             context.commit('bottom', true)
           }
-        },
-        (error) => {
+        })
+        .catch((err) => {
           context.commit('areOlderLoading', false)
-          return Promise.reject(error)
-        }
-      )
+          return Promise.reject(err)
+        })
     }
   }
 }
diff --git a/src/store/modules/eth-base/eth-base-getters.js b/src/store/modules/eth-base/eth-base-getters.js
index d65893a36..e485b754c 100644
--- a/src/store/modules/eth-base/eth-base-getters.js
+++ b/src/store/modules/eth-base/eth-base-getters.js
@@ -1,4 +1,4 @@
-const sortFunc = (a, b) => ((b && b.timestamp) || 0) - ((a && a.timestamp) || 0)
+import { sortTransactionsFn } from '@/store/utils/sortTransactionsFn'
 
 export default {
   transaction: (state) => (id) => state.transactions[id],
@@ -9,7 +9,7 @@ export default {
    * @returns {Array}
    */
   sortedTransactions(state) {
-    return Object.values(state.transactions).sort(sortFunc)
+    return Object.values(state.transactions).sort(sortTransactionsFn)
   },
 
   areTransactionsLoading(state) {
diff --git a/src/store/modules/eth/actions.js b/src/store/modules/eth/actions.js
index 6bf4b6fb7..f259f32a3 100644
--- a/src/store/modules/eth/actions.js
+++ b/src/store/modules/eth/actions.js
@@ -17,8 +17,7 @@ function storeEthAddress(context) {
   storeCryptoAddress(context.state.crypto, context.state.address)
 }
 
-const initTransaction = async (api, context, ethAddress, amount, increaseFee) => {
-  const nonce = await api.getClient().getTransactionCount(context.state.address)
+const initTransaction = async (api, context, ethAddress, amount, nonce, increaseFee) => {
   const gasPrice = await api.getClient().getGasPrice()
 
   const transaction = {
diff --git a/src/store/modules/lsk-base/lsk-base-actions.js b/src/store/modules/lsk-base/lsk-base-actions.js
index d09a3d3a3..545310155 100644
--- a/src/store/modules/lsk-base/lsk-base-actions.js
+++ b/src/store/modules/lsk-base/lsk-base-actions.js
@@ -1,6 +1,13 @@
 import BigNumber from '@/lib/bignumber'
 import { LiskAccount, LSK_TXS_PER_PAGE } from '../../../lib/lisk'
 import { getLiskTimestamp } from '../../../lib/lisk/lisk-utils'
+import adm from '../../../lib/nodes/adm'
+import {
+  assertNoPendingTransaction,
+  createPendingTransaction,
+  invalidatePendingTransaction,
+  PendingTxStore
+} from '../../../lib/pending-transactions'
 import { storeCryptoAddress } from '../../../lib/store-crypto-address'
 import * as tf from '../../../lib/transactionsFetching'
 import { lsk } from '../../../lib/nodes/lsk'
@@ -35,6 +42,16 @@ function createActions(options) {
         context.commit('address', account.getLisk32Address())
         context.dispatch('updateStatus')
         context.dispatch('storeAddress')
+
+        // restore pending transaction
+        const pendingTransaction = PendingTxStore.get(context.state.crypto)
+        if (pendingTransaction) {
+          context.commit('transactions', [pendingTransaction])
+          context.dispatch('getTransaction', {
+            hash: pendingTransaction.hash,
+            force: true
+          })
+        }
       }
     },
 
@@ -66,7 +83,7 @@ function createActions(options) {
       storeCryptoAddress(state.crypto, state.address)
     },
 
-    sendTokens(
+    async sendTokens(
       context,
       { amount, admAddress, address, comments, fee, textData, replyToId, dryRun }
     ) {
@@ -75,56 +92,88 @@ function createActions(options) {
 
       const crypto = context.state.crypto
 
-      return account
-        .createTransaction(address, amount, fee, context.state.nonce, textData)
-        .then((tx) => {
-          if (!admAddress || dryRun) return tx.hex
-
-          const msgPayload = {
-            address: admAddress,
-            amount: BigNumber(amount).toFixed(),
-            comments,
-            crypto,
-            hash: tx.id,
-            replyToId
-          }
+      // 1. Check nodes availability
+      if (admAddress) {
+        await adm.assertAnyNodeOnline()
+      }
+      await lsk.assertAnyNodeOnline()
+
+      // 2. Invalidate previous pending transaction if finalized
+      await invalidatePendingTransaction(context.state.crypto, (hashLocal) =>
+        lskIndexer.isTransactionFinalized(hashLocal, context.state.address)
+      )
+
+      // 3. Ensure there is no pending transaction
+      await context.dispatch('updateStatus') // fetch the most recent nonce
+      const nonce = context.state.nonce
+      await assertNoPendingTransaction(context.state.crypto, nonce)
+
+      // 4. Sign transaction offline
+      const signedTransaction = await account.createTransaction(
+        address,
+        amount,
+        fee,
+        nonce,
+        textData
+      )
+
+      // 5. Send crypto transfer message to ADM blockchain (if ADM address provided)
+      if (admAddress && !dryRun) {
+        const msgPayload = {
+          address: admAddress,
+          amount: BigNumber(amount).toFixed(),
+          comments,
+          crypto,
+          hash: signedTransaction.id,
+          replyToId
+        }
 
-          // Send a special message to indicate that we're performing a crypto transfer
-          return context
-            .dispatch('sendCryptoTransferMessage', msgPayload, { root: true })
-            .then((success) => (success ? tx.hex : Promise.reject(new Error('adm_message'))))
-        })
-        .then((rawTx) =>
-          lsk.sendTransaction(rawTx, dryRun).then(
-            (hash) => ({ hash }),
-            (error) => ({ error })
-          )
-        )
-        .then(({ hash, error }) => {
-          if (error) {
-            context.commit('transactions', [{ hash, status: 'REJECTED' }])
-            throw error
-          } else {
-            console.log(`${crypto} transaction has been sent: ${hash}`)
-
-            context.commit('transactions', [
-              {
-                hash,
-                senderId: context.state.address,
-                recipientId: address,
-                amount,
-                fee,
-                status: 'PENDING',
-                timestamp: Date.now(),
-                data: textData
-              }
-            ])
-
-            context.dispatch('getTransaction', { hash, force: true })
-
-            return hash
+        // Send a special message to indicate that we're performing a crypto transfer
+        const success = context.dispatch('sendCryptoTransferMessage', msgPayload, { root: true })
+        if (!success) {
+          throw new Error('adm_message')
+        }
+      }
+
+      // 6. Save pending transaction
+      const pendingTransaction = createPendingTransaction({
+        hash: signedTransaction.id,
+        senderId: context.state.address,
+        recipientId: address,
+        amount,
+        fee,
+        nonce // convert BigInt to Number
+      })
+      await PendingTxStore.save(context.state.crypto, pendingTransaction)
+      context.commit('transactions', [pendingTransaction])
+
+      // 7. Send signed transaction to ETH blockchain
+      try {
+        const hash = await lsk.sendTransaction(signedTransaction.hex, dryRun)
+
+        console.log(`${crypto} transaction has been sent: ${hash}`)
+
+        context.commit('transactions', [
+          {
+            hash,
+            senderId: context.state.address,
+            recipientId: address,
+            amount,
+            fee,
+            status: 'PENDING',
+            timestamp: Date.now(),
+            data: textData
           }
-        })
+        ])
+
+        context.dispatch('getTransaction', { hash, force: true })
+
+        return hash
+      } catch (err) {
+        context.commit('transactions', [{ hash: signedTransaction.id, status: 'REJECTED' }])
+        PendingTxStore.remove(context.state.crypto)
+        throw err
+      }
     },
 
     /**
diff --git a/src/store/modules/lsk-base/lsk-base-getters.js b/src/store/modules/lsk-base/lsk-base-getters.js
index d65893a36..e485b754c 100644
--- a/src/store/modules/lsk-base/lsk-base-getters.js
+++ b/src/store/modules/lsk-base/lsk-base-getters.js
@@ -1,4 +1,4 @@
-const sortFunc = (a, b) => ((b && b.timestamp) || 0) - ((a && a.timestamp) || 0)
+import { sortTransactionsFn } from '@/store/utils/sortTransactionsFn'
 
 export default {
   transaction: (state) => (id) => state.transactions[id],
@@ -9,7 +9,7 @@ export default {
    * @returns {Array}
    */
   sortedTransactions(state) {
-    return Object.values(state.transactions).sort(sortFunc)
+    return Object.values(state.transactions).sort(sortTransactionsFn)
   },
 
   areTransactionsLoading(state) {
diff --git a/src/store/types/index.ts b/src/store/types/index.ts
new file mode 100644
index 000000000..b78a92e43
--- /dev/null
+++ b/src/store/types/index.ts
@@ -0,0 +1,2 @@
+export * from './root-state'
+export * from './transaction'
diff --git a/src/store/types.ts b/src/store/types/root-state.ts
similarity index 100%
rename from src/store/types.ts
rename to src/store/types/root-state.ts
diff --git a/src/store/types/transaction.ts b/src/store/types/transaction.ts
new file mode 100644
index 000000000..7a2ba6f75
--- /dev/null
+++ b/src/store/types/transaction.ts
@@ -0,0 +1,23 @@
+import { TransactionStatusType } from '@/lib/constants'
+
+export type StoreTransaction = {
+  id?: string
+  hash?: string
+  isNew?: true
+  direction?: 'from' | 'to'
+  force?: true
+  senderId?: string
+  recipientId?: string
+  amount?: number | string
+  fee?: number | string
+  status?: TransactionStatusType
+  timestamp?: number
+  /**
+   * ETH specific
+   */
+  gasPrice?: number | string
+  /**
+   * LSK specific
+   */
+  data?: string
+}
diff --git a/src/store/utils/sortTransactionsFn.spec.ts b/src/store/utils/sortTransactionsFn.spec.ts
new file mode 100644
index 000000000..c474aa533
--- /dev/null
+++ b/src/store/utils/sortTransactionsFn.spec.ts
@@ -0,0 +1,36 @@
+import { describe, it, expect } from 'vitest'
+
+import { sortTransactionsFn } from './sortTransactionsFn'
+import type { StoreTransaction } from '@/store/types/transaction'
+
+describe('sortTransactionsFn', () => {
+  it('should sort transactions by timestamp in descending order', () => {
+    const transactions: StoreTransaction[] = [{ timestamp: 3 }, { timestamp: 1 }, { timestamp: 2 }]
+
+    transactions.sort(sortTransactionsFn)
+
+    expect(transactions[0].timestamp).toBe(3)
+    expect(transactions[1].timestamp).toBe(2)
+    expect(transactions[2].timestamp).toBe(1)
+  })
+
+  it('should place transactions without a timestamp at the beginning', () => {
+    const transactions: StoreTransaction[] = [
+      { timestamp: 3 },
+      { timestamp: undefined },
+      { timestamp: 2 }
+    ]
+
+    transactions.sort(sortTransactionsFn)
+
+    expect(transactions[0].timestamp).toBeUndefined()
+    expect(transactions[1].timestamp).toBe(3)
+    expect(transactions[2].timestamp).toBe(2)
+  })
+
+  it('should return 0 when both transactions are not defined', () => {
+    const result = sortTransactionsFn(undefined, undefined)
+
+    expect(result).toBe(0)
+  })
+})
diff --git a/src/store/utils/sortTransactionsFn.ts b/src/store/utils/sortTransactionsFn.ts
new file mode 100644
index 000000000..a09b55c6e
--- /dev/null
+++ b/src/store/utils/sortTransactionsFn.ts
@@ -0,0 +1,22 @@
+import { StoreTransaction } from '@/store/types/transaction'
+
+/**
+ * Sort transactions by timestamp, from newest to oldest.
+ * Pending transactions are placed at the top.
+ *
+ * Marker of a pending transaction is a missing `timestamp`.
+ * @param left
+ * @param right
+ */
+export function sortTransactionsFn(left?: StoreTransaction, right?: StoreTransaction) {
+  if (!left || !right) {
+    return 0
+  }
+
+  if (!left.timestamp) {
+    return -1
+  }
+  if (!right.timestamp) return 1
+
+  return right.timestamp - left.timestamp
+}
diff --git a/src/views/Transactions.vue b/src/views/Transactions.vue
index 972a70c86..42b0c5898 100644
--- a/src/views/Transactions.vue
+++ b/src/views/Transactions.vue
@@ -19,6 +19,7 @@
               :timestamp="transaction.timestamp || NaN"
               :amount="transaction.amount"
               :crypto="crypto"
+              :status="transaction.status"
               :text-data="transaction.data"
               @click:transaction="goToTransaction"
               @click:icon="goToChat"