@subwallet/extension-base 0.8.4-0 → 1.0.2-1

package/services/transaction-service/index.js

@@ -0,0 +1,728 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { EvmProviderError } from '@subwallet/extension-base/background/errors/EvmProviderError';
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { BasicTxErrorType, BasicTxWarningCode, ChainType, EvmProviderErrorType, ExtrinsicStatus, ExtrinsicType, NotificationType, TransactionDirection } from '@subwallet/extension-base/background/KoniTypes';
+import { TransactionWarning } from '@subwallet/extension-base/background/warnings/TransactionWarning';
+import { ALL_ACCOUNT_KEY } from '@subwallet/extension-base/constants';
+import { _getChainNativeTokenBasicInfo, _getEvmChainId } from '@subwallet/extension-base/services/chain-service/utils';
+import { EXTENSION_REQUEST_URL } from '@subwallet/extension-base/services/request-service/constants';
+import { parseTransferEventLogs, parseXcmEventLogs } from '@subwallet/extension-base/services/transaction-service/event-parser';
+import { getTransactionId, isSubstrateTransaction } from '@subwallet/extension-base/services/transaction-service/helpers';
+import { getTransactionLink, parseTransactionData } from '@subwallet/extension-base/services/transaction-service/utils';
+import { anyNumberToBN } from '@subwallet/extension-base/utils/eth';
+import { parseTxAndSignature } from '@subwallet/extension-base/utils/eth/mergeTransactionAndSignature';
+import { isContractAddress, parseContractInput } from '@subwallet/extension-base/utils/eth/parseTransaction';
+import keyring from '@subwallet/ui-keyring';
+import EventEmitter from 'eventemitter3';
+import RLP from 'rlp';
+import { BehaviorSubject } from 'rxjs';
+import { u8aToHex } from '@polkadot/util';
+export default class TransactionService {
+  transactionSubject = new BehaviorSubject({});
+  get transactions() {
+    return this.transactionSubject.getValue();
+  }
+  constructor(chainService, eventService, requestService, balanceService, historyService, notificationService, databaseService) {
+    this.chainService = chainService;
+    this.eventService = eventService;
+    this.requestService = requestService;
+    this.balanceService = balanceService;
+    this.historyService = historyService;
+    this.notificationService = notificationService;
+    this.databaseService = databaseService;
+  }
+  get allTransactions() {
+    return Object.values(this.transactions);
+  }
+  get processingTransactions() {
+    return this.allTransactions.filter(t => t.status === ExtrinsicStatus.PENDING || t.status === ExtrinsicStatus.PROCESSING);
+  }
+  getTransaction(id) {
+    return this.transactions[id];
+  }
+  checkDuplicate(transaction) {
+    // Check duplicated transaction
+    const existed = this.processingTransactions.filter(item => item.address === transaction.address && item.chain === transaction.chain);
+    if (existed.length > 0) {
+      return [new TransactionError(BasicTxErrorType.DUPLICATE_TRANSACTION)];
+    }
+    return [];
+  }
+  async generalValidate(validationInput) {
+    const validation = {
+      ...validationInput,
+      errors: validationInput.errors || [],
+      warnings: validationInput.warnings || []
+    };
+    const {
+      additionalValidator,
+      address,
+      chain,
+      edAsWarning,
+      isTransferAll,
+      transaction
+    } = validation;
+
+    // Check duplicate transaction
+    validation.errors.push(...this.checkDuplicate(validationInput));
+
+    // Return unsupported error if not found transaction
+    if (!transaction) {
+      validation.errors.push(new TransactionError(BasicTxErrorType.UNSUPPORTED));
+    }
+    const validationResponse = {
+      status: undefined,
+      ...validation
+    };
+
+    // Estimate fee
+    const estimateFee = {
+      symbol: '',
+      decimals: 0,
+      value: ''
+    };
+    const chainInfo = this.chainService.getChainInfoByKey(chain);
+    if (!chainInfo) {
+      validationResponse.errors.push(new TransactionError(BasicTxErrorType.INTERNAL_ERROR, "Can't find network"));
+    } else {
+      const {
+        decimals,
+        symbol
+      } = _getChainNativeTokenBasicInfo(chainInfo);
+      estimateFee.decimals = decimals;
+      estimateFee.symbol = symbol;
+      if (transaction) {
+        try {
+          if (isSubstrateTransaction(transaction)) {
+            estimateFee.value = (await transaction.paymentInfo(address)).partialFee.toString();
+          } else {
+            const web3 = this.chainService.getEvmApi(chain);
+            if (!web3) {
+              validationResponse.errors.push(new TransactionError(BasicTxErrorType.CHAIN_DISCONNECTED));
+            } else {
+              const gasPrice = await web3.api.eth.getGasPrice();
+              const gasLimit = await web3.api.eth.estimateGas(transaction);
+              estimateFee.value = (gasLimit * parseInt(gasPrice)).toString();
+            }
+          }
+        } catch (e) {
+          estimateFee.value = '0';
+        }
+      }
+    }
+    validationResponse.estimateFee = estimateFee;
+
+    // Read-only account
+    const pair = keyring.getPair(address);
+    if (!pair) {
+      validationResponse.errors.push(new TransactionError(BasicTxErrorType.INTERNAL_ERROR, 'Can\'t find account'));
+    } else {
+      var _pair$meta;
+      if ((_pair$meta = pair.meta) !== null && _pair$meta !== void 0 && _pair$meta.isReadOnly) {
+        validationResponse.errors.push(new TransactionError(BasicTxErrorType.INTERNAL_ERROR, 'This is read-only account'));
+      }
+    }
+
+    // Balance
+    const transferNative = validationResponse.transferNativeAmount || '0';
+    const nativeTokenInfo = this.chainService.getNativeTokenInfo(chain);
+    const balance = await this.balanceService.getTokenFreeBalance(address, chain, nativeTokenInfo.slug);
+    const existentialDeposit = nativeTokenInfo.minAmount || '0';
+    const feeNum = parseInt(estimateFee.value);
+    const balanceNum = parseInt(balance.value);
+    const edNum = parseInt(existentialDeposit);
+    const transferNativeNum = parseInt(transferNative);
+    if (!isTransferAll) {
+      if (transferNativeNum + feeNum > balanceNum) {
+        validationResponse.errors.push(new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE));
+      } else {
+        if (balanceNum - (transferNativeNum + feeNum) <= edNum) {
+          if (edAsWarning) {
+            validationResponse.warnings.push(new TransactionWarning(BasicTxWarningCode.NOT_ENOUGH_EXISTENTIAL_DEPOSIT, ''));
+          } else {
+            validationResponse.errors.push(new TransactionError(BasicTxErrorType.NOT_ENOUGH_EXISTENTIAL_DEPOSIT, ''));
+          }
+        }
+      }
+    }
+
+    // Validate transaction with additionalValidator method
+    additionalValidator && (await additionalValidator(validationResponse));
+    return validationResponse;
+  }
+  getTransactionSubject() {
+    return this.transactionSubject;
+  }
+  fillTransactionDefaultInfo(transaction) {
+    const isInternal = !transaction.url;
+    return {
+      ...transaction,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+      errors: transaction.errors || [],
+      warnings: transaction.warnings || [],
+      url: transaction.url || EXTENSION_REQUEST_URL,
+      status: ExtrinsicStatus.PENDING,
+      isInternal,
+      id: getTransactionId(transaction.chainType, transaction.chain, isInternal),
+      extrinsicHash: ''
+    };
+  }
+  async addTransaction(inputTransaction) {
+    const transactions = this.transactions;
+    // Fill transaction default info
+    const transaction = this.fillTransactionDefaultInfo(inputTransaction);
+
+    // Add Transaction
+    transactions[transaction.id] = transaction;
+    this.transactionSubject.next({
+      ...transactions
+    });
+    console.log(transaction);
+
+    // Send transaction
+    return await this.sendTransaction(transaction);
+  }
+  generateBeforeHandleResponseErrors(errors) {
+    return {
+      errors,
+      additionalValidator: undefined,
+      address: '',
+      chain: '',
+      chainType: ChainType.SUBSTRATE,
+      data: undefined,
+      extrinsicType: ExtrinsicType.UNKNOWN,
+      transferNativeAmount: undefined,
+      url: undefined,
+      warnings: []
+    };
+  }
+  async handleTransaction(transaction) {
+    const validatedTransaction = await this.generalValidate(transaction);
+    const stopByErrors = validatedTransaction.errors.length > 0;
+    const stopByWarnings = validatedTransaction.warnings.length > 0 && !validatedTransaction.ignoreWarnings;
+    if (stopByErrors || stopByWarnings) {
+      return validatedTransaction;
+    }
+    validatedTransaction.warnings = [];
+    const emitter = await this.addTransaction(validatedTransaction);
+    await new Promise(resolve => {
+      emitter.on('extrinsicHash', data => {
+        validatedTransaction.extrinsicHash = data.extrinsicHash;
+        resolve();
+      });
+      emitter.on('error', data => {
+        if (data.errors.length > 0) {
+          validatedTransaction.errors.push(...data.errors);
+          resolve();
+        }
+      });
+    });
+    return validatedTransaction;
+  }
+  async sendTransaction(transaction) {
+    // Send Transaction
+    const emitter = transaction.chainType === 'substrate' ? this.signAndSendSubstrateTransaction(transaction) : await this.signAndSendEvmTransaction(transaction);
+    emitter.on('extrinsicHash', data => {
+      this.onHasTransactionHash(data);
+    });
+    emitter.on('success', data => {
+      this.handlePostProcessing(data.id);
+      this.onSuccess(data);
+    });
+    emitter.on('error', data => {
+      // this.handlePostProcessing(data.id); // might enable this later
+      this.onFailed({
+        ...data,
+        errors: [...data.errors, new TransactionError(BasicTxErrorType.INTERNAL_ERROR)]
+      });
+    });
+
+    // Todo: handle any event with transaction.eventsHandler
+
+    return emitter;
+  }
+  removeTransaction(id) {
+    if (this.transactions[id]) {
+      delete this.transactions[id];
+      this.transactionSubject.next({
+        ...this.transactions
+      });
+    }
+  }
+  updateTransaction(id, data) {
+    const transaction = this.transactions[id];
+    if (transaction) {
+      this.transactions[id] = {
+        ...transaction,
+        ...data
+      };
+    }
+  }
+  getTransactionLink(id) {
+    const transaction = this.getTransaction(id);
+    const chainInfo = this.chainService.getChainInfoByKey(transaction.chain);
+    return getTransactionLink(chainInfo, transaction.extrinsicHash);
+  }
+  transactionToHistories(id, eventLogs) {
+    const transaction = this.getTransaction(id);
+    const historyItem = {
+      origin: 'app',
+      chain: transaction.chain,
+      direction: TransactionDirection.SEND,
+      type: transaction.extrinsicType,
+      from: transaction.address,
+      to: '',
+      chainType: transaction.chainType,
+      address: transaction.address,
+      status: ExtrinsicStatus.PROCESSING,
+      extrinsicHash: transaction.extrinsicHash,
+      time: transaction.createdAt.getTime(),
+      fee: transaction.estimateFee,
+      blockNumber: 0,
+      // Will be added in next step
+      blockHash: '' // Will be added in next step
+    };
+
+    const chainInfo = this.chainService.getChainInfoByKey(transaction.chain);
+    const nativeAsset = _getChainNativeTokenBasicInfo(chainInfo);
+    const baseNativeAmount = {
+      value: '0',
+      decimals: nativeAsset.decimals,
+      symbol: nativeAsset.symbol
+    };
+
+    // Fill data by extrinsicType
+    switch (transaction.extrinsicType) {
+      case ExtrinsicType.TRANSFER_BALANCE:
+        {
+          const inputData = parseTransactionData(transaction.data);
+          historyItem.to = inputData.to;
+          const sendingTokenInfo = this.chainService.getAssetBySlug(inputData.tokenSlug);
+          historyItem.amount = {
+            value: inputData.value || '0',
+            decimals: sendingTokenInfo.decimals || 0,
+            symbol: sendingTokenInfo.symbol
+          };
+          eventLogs && parseTransferEventLogs(historyItem, eventLogs, transaction.chain, sendingTokenInfo, chainInfo);
+        }
+        break;
+      case ExtrinsicType.TRANSFER_TOKEN:
+        {
+          const inputData = parseTransactionData(transaction.data);
+          historyItem.to = inputData.to;
+          const sendingTokenInfo = this.chainService.getAssetBySlug(inputData.tokenSlug);
+          historyItem.amount = {
+            value: inputData.value || '0',
+            decimals: sendingTokenInfo.decimals || 0,
+            symbol: sendingTokenInfo.symbol
+          };
+          eventLogs && parseTransferEventLogs(historyItem, eventLogs, transaction.chain, sendingTokenInfo, chainInfo);
+        }
+        break;
+      case ExtrinsicType.TRANSFER_XCM:
+        {
+          const inputData = parseTransactionData(transaction.data);
+          historyItem.to = inputData.to;
+          const sendingTokenInfo = this.chainService.getAssetBySlug(inputData.tokenSlug);
+          historyItem.amount = {
+            value: inputData.value || '0',
+            decimals: sendingTokenInfo.decimals || 0,
+            symbol: sendingTokenInfo.symbol
+          };
+
+          // @ts-ignore
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+          historyItem.additionalInfo = {
+            destinationChain: (inputData === null || inputData === void 0 ? void 0 : inputData.destinationNetworkKey) || ''
+          };
+          eventLogs && parseXcmEventLogs(historyItem, eventLogs, transaction.chain, sendingTokenInfo, chainInfo);
+        }
+        break;
+      case ExtrinsicType.SEND_NFT:
+        {
+          const inputData = parseTransactionData(transaction.data);
+          historyItem.to = inputData.recipientAddress;
+          historyItem.amount = {
+            decimals: 0,
+            symbol: 'NFT',
+            value: '1'
+          };
+        }
+        break;
+      case ExtrinsicType.STAKING_BOND:
+        {
+          const data = parseTransactionData(transaction.data);
+          historyItem.amount = {
+            ...baseNativeAmount,
+            value: data.amount || '0'
+          };
+        }
+        break;
+      case ExtrinsicType.STAKING_JOIN_POOL:
+        {
+          const data = parseTransactionData(transaction.data);
+          historyItem.amount = {
+            ...baseNativeAmount,
+            value: data.amount || '0'
+          };
+          historyItem.to = data.selectedPool.name || data.selectedPool.id.toString();
+        }
+        break;
+      case ExtrinsicType.STAKING_UNBOND:
+        {
+          const data = parseTransactionData(transaction.data);
+          historyItem.to = data.validatorAddress || '';
+          historyItem.amount = {
+            ...baseNativeAmount,
+            value: data.amount || '0'
+          };
+        }
+        break;
+      case ExtrinsicType.STAKING_LEAVE_POOL:
+        {
+          const data = parseTransactionData(transaction.data);
+          historyItem.to = data.nominatorMetadata.address || '';
+          historyItem.amount = {
+            ...baseNativeAmount,
+            value: data.amount || '0'
+          };
+        }
+        break;
+      case ExtrinsicType.STAKING_CLAIM_REWARD:
+        {
+          const data = parseTransactionData(transaction.data);
+          historyItem.amount = {
+            ...baseNativeAmount,
+            value: data.unclaimedReward || '0'
+          };
+        }
+        break;
+      case ExtrinsicType.STAKING_WITHDRAW:
+        {
+          const data = parseTransactionData(transaction.data);
+          historyItem.to = data.validatorAddress || '';
+          historyItem.amount = {
+            ...baseNativeAmount,
+            value: data.unstakingInfo.claimable || '0'
+          };
+          break;
+        }
+      case ExtrinsicType.STAKING_CANCEL_UNSTAKE:
+        {
+          const data = parseTransactionData(transaction.data);
+          historyItem.amount = {
+            ...baseNativeAmount,
+            value: data.selectedUnstaking.claimable || '0'
+          };
+          break;
+        }
+      case ExtrinsicType.EVM_EXECUTE:
+        // Todo: Update historyItem.to
+        break;
+      case ExtrinsicType.UNKNOWN:
+        break;
+    }
+    try {
+      // Return one more history record if transaction send to account in the wallets
+      const toAccount = (historyItem === null || historyItem === void 0 ? void 0 : historyItem.to) && keyring.getAccount(historyItem.to);
+      if (toAccount) {
+        return [historyItem, {
+          ...historyItem,
+          address: historyItem.to,
+          direction: TransactionDirection.RECEIVED
+        }];
+      }
+    } catch (e) {
+      console.warn(e);
+    }
+    return [historyItem];
+  }
+  onHasTransactionHash({
+    eventLogs,
+    extrinsicHash,
+    id
+  }) {
+    // Write processing transaction history
+    this.updateTransaction(id, {
+      extrinsicHash,
+      status: ExtrinsicStatus.PROCESSING
+    });
+    this.historyService.insertHistories(this.transactionToHistories(id, eventLogs)).catch(console.error);
+    console.log(`Transaction "${id}" is submitted with hash ${extrinsicHash || ''}`);
+  }
+  handlePostProcessing(id) {
+    // must be done after success/failure to make sure the transaction is finalized
+    const transaction = this.getTransaction(id);
+    switch (transaction.extrinsicType) {
+      case ExtrinsicType.SEND_NFT:
+        {
+          const inputData = parseTransactionData(transaction.data);
+          const sender = keyring.getAccount(inputData.senderAddress);
+          const recipient = keyring.getAccount(inputData.recipientAddress);
+          sender && this.databaseService.handleNftTransfer(transaction.chain, [sender.address, ALL_ACCOUNT_KEY], inputData.nftItem).catch(console.error);
+          recipient && this.databaseService.addNft(recipient.address, {
+            ...inputData.nftItem,
+            owner: recipient.address
+          }).catch(console.error);
+        }
+    }
+  }
+  onSuccess({
+    blockHash,
+    blockNumber,
+    id
+  }) {
+    const transaction = this.getTransaction(id);
+    this.updateTransaction(id, {
+      status: ExtrinsicStatus.SUCCESS
+    });
+    console.log('Transaction completed', id, transaction.extrinsicHash);
+
+    // Write success transaction history
+    this.historyService.updateHistories(transaction.chain, transaction.extrinsicHash, {
+      status: ExtrinsicStatus.SUCCESS,
+      blockNumber: blockNumber || 0,
+      blockHash: blockHash || ''
+    }).catch(console.error);
+    this.notificationService.notify({
+      type: NotificationType.SUCCESS,
+      title: 'Transaction completed',
+      message: `Transaction ${transaction === null || transaction === void 0 ? void 0 : transaction.extrinsicHash} completed`,
+      action: {
+        url: this.getTransactionLink(id)
+      },
+      notifyViaBrowser: true
+    });
+    this.eventService.emit('transaction.done', transaction);
+  }
+  onFailed({
+    blockHash,
+    blockNumber,
+    errors,
+    id
+  }) {
+    const transaction = this.getTransaction(id);
+    if (transaction) {
+      this.updateTransaction(id, {
+        status: ExtrinsicStatus.FAIL,
+        errors
+      });
+      console.log('Transaction failed', id, transaction.extrinsicHash);
+
+      // Write failed transaction history
+      this.historyService.updateHistories(transaction.chain, transaction.extrinsicHash, {
+        status: ExtrinsicStatus.FAIL,
+        blockNumber: blockNumber || 0,
+        blockHash: blockHash || ''
+      }).catch(console.error);
+      this.notificationService.notify({
+        type: NotificationType.ERROR,
+        title: 'Transaction failed',
+        message: `Transaction ${transaction === null || transaction === void 0 ? void 0 : transaction.extrinsicHash} failed`,
+        action: {
+          url: this.getTransactionLink(id)
+        },
+        notifyViaBrowser: true
+      });
+    }
+    this.eventService.emit('transaction.failed', transaction);
+    // Log transaction errors
+    console.error(errors);
+  }
+  generateHashPayload(chain, transaction) {
+    const chainInfo = this.chainService.getChainInfoByKey(chain);
+    const txObject = {
+      nonce: transaction.nonce || 1,
+      from: transaction.from,
+      gasPrice: anyNumberToBN(transaction.gasPrice).toNumber(),
+      gasLimit: anyNumberToBN(transaction.gas).toNumber(),
+      to: transaction.to !== undefined ? transaction.to : '',
+      value: anyNumberToBN(transaction.value).toNumber(),
+      data: transaction.data ? transaction.data : '',
+      chainId: _getEvmChainId(chainInfo)
+    };
+    const data = [txObject.nonce, txObject.gasPrice, txObject.gasLimit, txObject.to, txObject.value, txObject.data, txObject.chainId, new Uint8Array([0x00]), new Uint8Array([0x00])];
+    const encoded = RLP.encode(data);
+    return u8aToHex(encoded);
+  }
+  async signAndSendEvmTransaction({
+    address,
+    chain,
+    id,
+    transaction,
+    url
+  }) {
+    const payload = transaction;
+    const evmApi = this.chainService.getEvmApi(chain);
+    const chainInfo = this.chainService.getChainInfoByKey(chain);
+    const accountPair = keyring.getPair(address);
+    const account = {
+      address,
+      ...accountPair.meta
+    };
+    if (!payload.account) {
+      payload.account = account;
+    }
+
+    // Allow sign transaction
+    payload.canSign = true;
+
+    // Fill contract info
+    if (!payload.parseData) {
+      const isToContract = await isContractAddress(payload.to || '', evmApi);
+      payload.isToContract = isToContract;
+      payload.parseData = isToContract ? payload.data ? (await parseContractInput(payload.data || '', payload.to || '', chainInfo)).result : '' : payload.data || '';
+    }
+
+    // Set unique nonce to avoid transaction errors
+    if (!payload.nonce) {
+      const evmApi = this.chainService.getEvmApi(chain);
+      payload.nonce = await evmApi.api.eth.getTransactionCount(address);
+    }
+    if (!payload.chainId) {
+      var _chainInfo$evmInfo$ev, _chainInfo$evmInfo;
+      payload.chainId = (_chainInfo$evmInfo$ev = (_chainInfo$evmInfo = chainInfo.evmInfo) === null || _chainInfo$evmInfo === void 0 ? void 0 : _chainInfo$evmInfo.evmChainId) !== null && _chainInfo$evmInfo$ev !== void 0 ? _chainInfo$evmInfo$ev : 1;
+    }
+
+    // Autofill from
+    if (!payload.from) {
+      payload.from = address;
+    }
+    const isExternal = !!account.isExternal;
+
+    // generate hashPayload for EVM transaction
+    payload.hashPayload = this.generateHashPayload(chain, payload);
+    const emitter = new EventEmitter();
+    const txObject = {
+      nonce: payload.nonce || 1,
+      from: payload.from,
+      gasPrice: anyNumberToBN(payload.gasPrice).toNumber(),
+      gasLimit: anyNumberToBN(payload.gas).toNumber(),
+      to: payload.to !== undefined ? payload.to : '',
+      value: anyNumberToBN(payload.value).toNumber(),
+      data: payload.data ? payload.data : '',
+      chainId: payload.chainId
+    };
+    const eventData = {
+      id,
+      errors: [],
+      warnings: []
+    };
+    this.requestService.addConfirmation(id, url || EXTENSION_REQUEST_URL, 'evmSendTransactionRequest', payload, {}).then(({
+      isApproved,
+      payload
+    }) => {
+      if (isApproved) {
+        let signedTransaction;
+        if (!payload) {
+          throw new EvmProviderError(EvmProviderErrorType.UNAUTHORIZED, 'Bad signature');
+        }
+        const web3Api = this.chainService.getEvmApi(chain).api;
+        if (!isExternal) {
+          signedTransaction = payload;
+        } else {
+          const signed = parseTxAndSignature(txObject, payload);
+          const recover = web3Api.eth.accounts.recoverTransaction(signed);
+          if (recover.toLowerCase() !== account.address.toLowerCase()) {
+            throw new EvmProviderError(EvmProviderErrorType.UNAUTHORIZED, 'Bad signature');
+          }
+          signedTransaction = signed;
+        }
+        signedTransaction && web3Api.eth.sendSignedTransaction(signedTransaction).once('transactionHash', hash => {
+          eventData.extrinsicHash = hash;
+          emitter.emit('extrinsicHash', eventData);
+        }).once('receipt', rs => {
+          eventData.blockHash = rs.blockHash;
+          eventData.blockNumber = rs.blockNumber;
+          emitter.emit('success', eventData);
+        }).once('error', e => {
+          eventData.errors.push(new TransactionError(BasicTxErrorType.SEND_TRANSACTION_FAILED, e.message));
+          emitter.emit('error', eventData);
+        }).catch(e => {
+          eventData.errors.push(new TransactionError(BasicTxErrorType.UNABLE_TO_SEND, e.message));
+          emitter.emit('error', eventData);
+        });
+      } else {
+        this.removeTransaction(id);
+        eventData.errors.push(new TransactionError(BasicTxErrorType.USER_REJECT_REQUEST));
+        emitter.emit('error', eventData);
+      }
+    }).catch(e => {
+      this.removeTransaction(id);
+      eventData.errors.push(new TransactionError(BasicTxErrorType.UNABLE_TO_SIGN, e.message));
+      emitter.emit('error', eventData);
+    });
+    return emitter;
+  }
+  signAndSendSubstrateTransaction({
+    address,
+    id,
+    transaction,
+    url
+  }) {
+    const emitter = new EventEmitter();
+    const eventData = {
+      id,
+      errors: [],
+      warnings: []
+    };
+    console.debug(address, transaction);
+    transaction.signAsync(address, {
+      signer: {
+        signPayload: async payload => {
+          const signing = await this.requestService.signInternalTransaction(id, address, url || EXTENSION_REQUEST_URL, payload);
+          return {
+            id: new Date().getTime(),
+            signature: signing.signature
+          };
+        }
+      }
+    }).then(rs => {
+      rs.send(txState => {
+        // handle events, logs, history
+        if (!txState || !txState.status) {
+          return;
+        }
+        if (txState.status.isInBlock) {
+          eventData.eventLogs = txState.events;
+          if (!eventData.extrinsicHash || eventData.extrinsicHash === '') {
+            eventData.extrinsicHash = txState.txHash.toHex();
+            emitter.emit('extrinsicHash', eventData);
+          }
+        }
+        if (txState.status.isFinalized) {
+          eventData.eventLogs = txState.events;
+          // TODO: push block hash and block number into eventData
+          txState.events.filter(({
+            event: {
+              section
+            }
+          }) => section === 'system').forEach(({
+            event: {
+              method,
+              data: [error]
+            }
+          }) => {
+            if (method === 'ExtrinsicFailed') {
+              eventData.errors.push(new TransactionError(BasicTxErrorType.SEND_TRANSACTION_FAILED, error.toString()));
+              emitter.emit('error', eventData);
+            } else if (method === 'ExtrinsicSuccess') {
+              emitter.emit('success', eventData);
+            }
+          });
+        }
+      }).catch(e => {
+        eventData.errors.push(new TransactionError(BasicTxErrorType.SEND_TRANSACTION_FAILED, e.message));
+        emitter.emit('error', eventData);
+      });
+    }).catch(e => {
+      this.removeTransaction(id);
+      eventData.errors.push(new TransactionError(BasicTxErrorType.UNABLE_TO_SIGN, e.message));
+      emitter.emit('error', eventData);
+    });
+    return emitter;
+  }
+}