@subwallet/extension-base 0.8.4-0 → 1.0.1

package/cjs/services/transaction-service/index.js

@@ -0,0 +1,711 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _EvmProviderError = require("@subwallet/extension-base/background/errors/EvmProviderError");
+var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _TransactionWarning = require("@subwallet/extension-base/background/warnings/TransactionWarning");
+var _constants = require("@subwallet/extension-base/constants");
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _constants2 = require("@subwallet/extension-base/services/request-service/constants");
+var _eventParser = require("@subwallet/extension-base/services/transaction-service/event-parser");
+var _helpers = require("@subwallet/extension-base/services/transaction-service/helpers");
+var _utils2 = require("@subwallet/extension-base/services/transaction-service/utils");
+var _eth = require("@subwallet/extension-base/utils/eth");
+var _mergeTransactionAndSignature = require("@subwallet/extension-base/utils/eth/mergeTransactionAndSignature");
+var _parseTransaction = require("@subwallet/extension-base/utils/eth/parseTransaction");
+var _uiKeyring = _interopRequireDefault(require("@subwallet/ui-keyring"));
+var _eventemitter = _interopRequireDefault(require("eventemitter3"));
+var _rlp = _interopRequireDefault(require("rlp"));
+var _rxjs = require("rxjs");
+var _util = require("@polkadot/util");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class TransactionService {
+  transactionSubject = new _rxjs.BehaviorSubject({});
+  get transactions() {
+    return this.transactionSubject.getValue();
+  }
+  constructor(chainService, requestService, balanceService, historyService, notificationService, databaseService) {
+    this.chainService = chainService;
+    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 === _KoniTypes.ExtrinsicStatus.PENDING || t.status === _KoniTypes.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.TransactionError(_KoniTypes.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.TransactionError(_KoniTypes.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.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR, "Can't find network"));
+    } else {
+      const {
+        decimals,
+        symbol
+      } = (0, _utils._getChainNativeTokenBasicInfo)(chainInfo);
+      estimateFee.decimals = decimals;
+      estimateFee.symbol = symbol;
+      if (transaction) {
+        try {
+          if ((0, _helpers.isSubstrateTransaction)(transaction)) {
+            estimateFee.value = (await transaction.paymentInfo(address)).partialFee.toString();
+          } else {
+            const web3 = this.chainService.getEvmApi(chain);
+            if (!web3) {
+              validationResponse.errors.push(new _TransactionError.TransactionError(_KoniTypes.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 = _uiKeyring.default.getPair(address);
+    if (!pair) {
+      validationResponse.errors.push(new _TransactionError.TransactionError(_KoniTypes.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.TransactionError(_KoniTypes.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.TransactionError(_KoniTypes.BasicTxErrorType.NOT_ENOUGH_BALANCE));
+      } else {
+        if (balanceNum - (transferNativeNum + feeNum) <= edNum) {
+          if (edAsWarning) {
+            validationResponse.warnings.push(new _TransactionWarning.TransactionWarning(_KoniTypes.BasicTxWarningCode.NOT_ENOUGH_EXISTENTIAL_DEPOSIT, ''));
+          } else {
+            validationResponse.errors.push(new _TransactionError.TransactionError(_KoniTypes.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 || _constants2.EXTENSION_REQUEST_URL,
+      status: _KoniTypes.ExtrinsicStatus.PENDING,
+      isInternal,
+      id: (0, _helpers.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: _KoniTypes.ChainType.SUBSTRATE,
+      data: undefined,
+      extrinsicType: _KoniTypes.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.TransactionError(_KoniTypes.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 (0, _utils2.getTransactionLink)(chainInfo, transaction.extrinsicHash);
+  }
+  transactionToHistory(id, eventLogs) {
+    const transaction = this.getTransaction(id);
+    const historyItem = {
+      chain: transaction.chain,
+      direction: _KoniTypes.TransactionDirection.SEND,
+      type: transaction.extrinsicType,
+      from: transaction.address,
+      to: '',
+      chainType: transaction.chainType,
+      address: transaction.address,
+      status: _KoniTypes.ExtrinsicStatus.PROCESSING,
+      extrinsicHash: transaction.extrinsicHash,
+      time: transaction.createdAt.getTime(),
+      fee: transaction.estimateFee,
+      blockNumber: 0,
+      // TODO: to be added later
+      blockHash: '' // TODO: to be added later
+    };
+
+    const chainInfo = this.chainService.getChainInfoByKey(transaction.chain);
+    const nativeAsset = (0, _utils._getChainNativeTokenBasicInfo)(chainInfo);
+    const baseNativeAmount = {
+      value: '0',
+      decimals: nativeAsset.decimals,
+      symbol: nativeAsset.symbol
+    };
+
+    // Fill data by extrinsicType
+    switch (transaction.extrinsicType) {
+      case _KoniTypes.ExtrinsicType.TRANSFER_BALANCE:
+        {
+          const inputData = (0, _utils2.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 && (0, _eventParser.parseTransferEventLogs)(historyItem, eventLogs, transaction.chain, sendingTokenInfo, chainInfo);
+        }
+        break;
+      case _KoniTypes.ExtrinsicType.TRANSFER_TOKEN:
+        {
+          const inputData = (0, _utils2.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 && (0, _eventParser.parseTransferEventLogs)(historyItem, eventLogs, transaction.chain, sendingTokenInfo, chainInfo);
+        }
+        break;
+      case _KoniTypes.ExtrinsicType.TRANSFER_XCM:
+        {
+          const inputData = (0, _utils2.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 && (0, _eventParser.parseXcmEventLogs)(historyItem, eventLogs, transaction.chain, sendingTokenInfo, chainInfo);
+        }
+        break;
+      case _KoniTypes.ExtrinsicType.SEND_NFT:
+        {
+          const inputData = (0, _utils2.parseTransactionData)(transaction.data);
+          historyItem.to = inputData.recipientAddress;
+          historyItem.amount = {
+            decimals: 0,
+            symbol: 'NFT',
+            value: '1'
+          };
+        }
+        break;
+      case _KoniTypes.ExtrinsicType.STAKING_BOND:
+        {
+          const data = (0, _utils2.parseTransactionData)(transaction.data);
+          historyItem.amount = {
+            ...baseNativeAmount,
+            value: data.amount || '0'
+          };
+        }
+        break;
+      case _KoniTypes.ExtrinsicType.STAKING_JOIN_POOL:
+        {
+          const data = (0, _utils2.parseTransactionData)(transaction.data);
+          historyItem.amount = {
+            ...baseNativeAmount,
+            value: data.amount || '0'
+          };
+          historyItem.to = data.selectedPool.name || data.selectedPool.id.toString();
+        }
+        break;
+      case _KoniTypes.ExtrinsicType.STAKING_UNBOND:
+        {
+          const data = (0, _utils2.parseTransactionData)(transaction.data);
+          historyItem.to = data.validatorAddress || '';
+          historyItem.amount = {
+            ...baseNativeAmount,
+            value: data.amount || '0'
+          };
+        }
+        break;
+      case _KoniTypes.ExtrinsicType.STAKING_LEAVE_POOL:
+        {
+          const data = (0, _utils2.parseTransactionData)(transaction.data);
+          historyItem.to = data.nominatorMetadata.address || '';
+          historyItem.amount = {
+            ...baseNativeAmount,
+            value: data.amount || '0'
+          };
+        }
+        break;
+      case _KoniTypes.ExtrinsicType.STAKING_CLAIM_REWARD:
+        {
+          const data = (0, _utils2.parseTransactionData)(transaction.data);
+          historyItem.amount = {
+            ...baseNativeAmount,
+            value: data.unclaimedReward || '0'
+          };
+        }
+        break;
+      case _KoniTypes.ExtrinsicType.STAKING_WITHDRAW:
+        {
+          const data = (0, _utils2.parseTransactionData)(transaction.data);
+          historyItem.to = data.validatorAddress || '';
+        }
+        break;
+      case _KoniTypes.ExtrinsicType.EVM_EXECUTE:
+        // Todo: Update historyItem.to
+        break;
+      case _KoniTypes.ExtrinsicType.UNKNOWN:
+        break;
+    }
+    return historyItem;
+  }
+  onHasTransactionHash(_ref) {
+    let {
+      eventLogs,
+      extrinsicHash,
+      id
+    } = _ref;
+    // Write processing transaction history
+    this.updateTransaction(id, {
+      extrinsicHash,
+      status: _KoniTypes.ExtrinsicStatus.PROCESSING
+    });
+    this.historyService.insertHistory(this.transactionToHistory(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 _KoniTypes.ExtrinsicType.SEND_NFT:
+        {
+          const inputData = (0, _utils2.parseTransactionData)(transaction.data);
+          const sender = _uiKeyring.default.getAccount(inputData.senderAddress);
+          const recipient = _uiKeyring.default.getAccount(inputData.recipientAddress);
+          sender && this.databaseService.handleNftTransfer(transaction.chain, [sender.address, _constants.ALL_ACCOUNT_KEY], inputData.nftItem).catch(console.error);
+          recipient && this.databaseService.addNft(recipient.address, {
+            ...inputData.nftItem,
+            owner: recipient.address
+          }).catch(console.error);
+        }
+    }
+  }
+  onSuccess(_ref2) {
+    let {
+      blockHash,
+      blockNumber,
+      id
+    } = _ref2;
+    const transaction = this.getTransaction(id);
+    this.updateTransaction(id, {
+      status: _KoniTypes.ExtrinsicStatus.SUCCESS
+    });
+    console.log('Transaction completed', id, transaction.extrinsicHash);
+
+    // Write success transaction history
+    this.historyService.updateHistory(transaction.chain, transaction.extrinsicHash, {
+      status: _KoniTypes.ExtrinsicStatus.SUCCESS,
+      blockNumber: blockNumber || 0,
+      blockHash: blockHash || ''
+    }).catch(console.error);
+    this.notificationService.notify({
+      type: _KoniTypes.NotificationType.SUCCESS,
+      title: 'Transaction completed',
+      message: `Transaction ${transaction === null || transaction === void 0 ? void 0 : transaction.extrinsicHash} completed`,
+      action: {
+        url: this.getTransactionLink(id)
+      },
+      notifyViaBrowser: true
+    });
+  }
+  onFailed(_ref3) {
+    let {
+      blockHash,
+      blockNumber,
+      errors,
+      id
+    } = _ref3;
+    const transaction = this.getTransaction(id);
+    if (transaction) {
+      this.updateTransaction(id, {
+        status: _KoniTypes.ExtrinsicStatus.FAIL,
+        errors
+      });
+      console.log('Transaction failed', id, transaction.extrinsicHash);
+
+      // Write failed transaction history
+      this.historyService.updateHistory(transaction.chain, transaction.extrinsicHash, {
+        status: _KoniTypes.ExtrinsicStatus.FAIL,
+        blockNumber: blockNumber || 0,
+        blockHash: blockHash || ''
+      }).catch(console.error);
+      this.notificationService.notify({
+        type: _KoniTypes.NotificationType.ERROR,
+        title: 'Transaction failed',
+        message: `Transaction ${transaction === null || transaction === void 0 ? void 0 : transaction.extrinsicHash} failed`,
+        action: {
+          url: this.getTransactionLink(id)
+        },
+        notifyViaBrowser: true
+      });
+    }
+
+    // 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: (0, _eth.anyNumberToBN)(transaction.gasPrice).toNumber(),
+      gasLimit: (0, _eth.anyNumberToBN)(transaction.gas).toNumber(),
+      to: transaction.to !== undefined ? transaction.to : '',
+      value: (0, _eth.anyNumberToBN)(transaction.value).toNumber(),
+      data: transaction.data ? transaction.data : '',
+      chainId: (0, _utils._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.default.encode(data);
+    return (0, _util.u8aToHex)(encoded);
+  }
+  async signAndSendEvmTransaction(_ref4) {
+    let {
+      address,
+      chain,
+      id,
+      transaction,
+      url
+    } = _ref4;
+    const payload = transaction;
+    const evmApi = this.chainService.getEvmApi(chain);
+    const chainInfo = this.chainService.getChainInfoByKey(chain);
+    const accountPair = _uiKeyring.default.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 (0, _parseTransaction.isContractAddress)(payload.to || '', evmApi);
+      payload.isToContract = isToContract;
+      payload.parseData = isToContract ? payload.data ? (await (0, _parseTransaction.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.default();
+    const txObject = {
+      nonce: payload.nonce || 1,
+      from: payload.from,
+      gasPrice: (0, _eth.anyNumberToBN)(payload.gasPrice).toNumber(),
+      gasLimit: (0, _eth.anyNumberToBN)(payload.gas).toNumber(),
+      to: payload.to !== undefined ? payload.to : '',
+      value: (0, _eth.anyNumberToBN)(payload.value).toNumber(),
+      data: payload.data ? payload.data : '',
+      chainId: payload.chainId
+    };
+    const eventData = {
+      id,
+      errors: [],
+      warnings: []
+    };
+    this.requestService.addConfirmation(id, url || _constants2.EXTENSION_REQUEST_URL, 'evmSendTransactionRequest', payload, {}).then(_ref5 => {
+      let {
+        isApproved,
+        payload
+      } = _ref5;
+      if (isApproved) {
+        let signedTransaction;
+        if (!payload) {
+          throw new _EvmProviderError.EvmProviderError(_KoniTypes.EvmProviderErrorType.UNAUTHORIZED, 'Bad signature');
+        }
+        const web3Api = this.chainService.getEvmApi(chain).api;
+        if (!isExternal) {
+          signedTransaction = payload;
+        } else {
+          const signed = (0, _mergeTransactionAndSignature.parseTxAndSignature)(txObject, payload);
+          const recover = web3Api.eth.accounts.recoverTransaction(signed);
+          if (recover.toLowerCase() !== account.address.toLowerCase()) {
+            throw new _EvmProviderError.EvmProviderError(_KoniTypes.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.TransactionError(_KoniTypes.BasicTxErrorType.SEND_TRANSACTION_FAILED, e.message));
+          emitter.emit('error', eventData);
+        }).catch(e => {
+          eventData.errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNABLE_TO_SEND, e.message));
+          emitter.emit('error', eventData);
+        });
+      } else {
+        this.removeTransaction(id);
+        eventData.errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.USER_REJECT_REQUEST));
+        emitter.emit('error', eventData);
+      }
+    }).catch(e => {
+      this.removeTransaction(id);
+      eventData.errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNABLE_TO_SIGN, e.message));
+      emitter.emit('error', eventData);
+    });
+    return emitter;
+  }
+  signAndSendSubstrateTransaction(_ref6) {
+    let {
+      address,
+      id,
+      transaction,
+      url
+    } = _ref6;
+    const emitter = new _eventemitter.default();
+    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 || _constants2.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(_ref7 => {
+            let {
+              event: {
+                section
+              }
+            } = _ref7;
+            return section === 'system';
+          }).forEach(_ref8 => {
+            let {
+              event: {
+                method,
+                data: [error]
+              }
+            } = _ref8;
+            if (method === 'ExtrinsicFailed') {
+              eventData.errors.push(new _TransactionError.TransactionError(_KoniTypes.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.TransactionError(_KoniTypes.BasicTxErrorType.SEND_TRANSACTION_FAILED, e.message));
+        emitter.emit('error', eventData);
+      });
+    }).catch(e => {
+      this.removeTransaction(id);
+      eventData.errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNABLE_TO_SIGN, e.message));
+      emitter.emit('error', eventData);
+    });
+    return emitter;
+  }
+}
+exports.default = TransactionService;