conflux-web-core-method/dist/conflux-web-core-method.esm.js

import EventEmitter from 'eventemitter3';
import { NewHeadsSubscription } from 'conflux-web-core-subscriptions';
import isFunction from 'lodash/isFunction';
import isString from 'lodash/isString';
import cloneDeep from 'lodash/cloneDeep';
import { Observable } from 'rxjs';

function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
  try {
    var info = gen[key](arg);
    var value = info.value;
  } catch (error) {
    reject(error);
    return;
  }

  if (info.done) {
    resolve(value);
  } else {
    Promise.resolve(value).then(_next, _throw);
  }
}

function _asyncToGenerator(fn) {
  return function () {
    var self = this,
        args = arguments;
    return new Promise(function (resolve, reject) {
      var gen = fn.apply(self, args);

      function _next(value) {
        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
      }

      function _throw(err) {
        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
      }

      _next(undefined);
    });
  };
}

function _classCallCheck(instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
}

function _defineProperties(target, props) {
  for (var i = 0; i < props.length; i++) {
    var descriptor = props[i];
    descriptor.enumerable = descriptor.enumerable || false;
    descriptor.configurable = true;
    if ("value" in descriptor) descriptor.writable = true;
    Object.defineProperty(target, descriptor.key, descriptor);
  }
}

function _createClass(Constructor, protoProps, staticProps) {
  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
  if (staticProps) _defineProperties(Constructor, staticProps);
  return Constructor;
}

function _inherits(subClass, superClass) {
  if (typeof superClass !== "function" && superClass !== null) {
    throw new TypeError("Super expression must either be null or a function");
  }

  subClass.prototype = Object.create(superClass && superClass.prototype, {
    constructor: {
      value: subClass,
      writable: true,
      configurable: true
    }
  });
  if (superClass) _setPrototypeOf(subClass, superClass);
}

function _getPrototypeOf(o) {
  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
    return o.__proto__ || Object.getPrototypeOf(o);
  };
  return _getPrototypeOf(o);
}

function _setPrototypeOf(o, p) {
  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
    o.__proto__ = p;
    return o;
  };

  return _setPrototypeOf(o, p);
}

function _assertThisInitialized(self) {
  if (self === void 0) {
    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  }

  return self;
}

function _possibleConstructorReturn(self, call) {
  if (call && (typeof call === "object" || typeof call === "function")) {
    return call;
  }

  return _assertThisInitialized(self);
}

function _superPropBase(object, property) {
  while (!Object.prototype.hasOwnProperty.call(object, property)) {
    object = _getPrototypeOf(object);
    if (object === null) break;
  }

  return object;
}

function _get(target, property, receiver) {
  if (typeof Reflect !== "undefined" && Reflect.get) {
    _get = Reflect.get;
  } else {
    _get = function _get(target, property, receiver) {
      var base = _superPropBase(target, property);

      if (!base) return;
      var desc = Object.getOwnPropertyDescriptor(base, property);

      if (desc.get) {
        return desc.get.call(receiver);
      }

      return desc.value;
    };
  }

  return _get(target, property, receiver || target);
}

function _toConsumableArray(arr) {
  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();
}

function _arrayWithoutHoles(arr) {
  if (Array.isArray(arr)) {
    for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];

    return arr2;
  }
}

function _iterableToArray(iter) {
  if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
}

function _nonIterableSpread() {
  throw new TypeError("Invalid attempt to spread non-iterable instance");
}

var PromiEvent =
function () {
  function PromiEvent() {
    var _this = this;
    _classCallCheck(this, PromiEvent);
    this.promise = new Promise(function (resolve, reject) {
      _this.resolve = resolve;
      _this.reject = reject;
    });
    this.eventEmitter = new EventEmitter();
    return new Proxy(this, {
      get: this.proxyHandler
    });
  }
  _createClass(PromiEvent, [{
    key: "proxyHandler",
    value: function proxyHandler(target, name) {
      if (name === 'resolve' || name === 'reject') {
        return target[name];
      }
      if (name === 'then') {
        return target.promise.then.bind(target.promise);
      }
      if (name === 'catch') {
        return target.promise.catch.bind(target.promise);
      }
      if (target.eventEmitter[name]) {
        return target.eventEmitter[name];
      }
    }
  }]);
  return PromiEvent;
}();

var AbstractMethod =
function () {
  function AbstractMethod(rpcMethod, parametersAmount, utils, formatters, moduleInstance) {
    _classCallCheck(this, AbstractMethod);
    this.utils = utils;
    this.formatters = formatters;
    this.moduleInstance = moduleInstance;
    this._arguments = {
      parameters: []
    };
    this._rpcMethod = rpcMethod;
    this._parametersAmount = parametersAmount;
  }
  _createClass(AbstractMethod, [{
    key: "beforeExecution",
    value: function beforeExecution(moduleInstance) {}
  }, {
    key: "afterExecution",
    value: function afterExecution(response) {
      return response;
    }
  }, {
    key: "execute",
    value: function () {
      var _execute = _asyncToGenerator(
      regeneratorRuntime.mark(function _callee() {
        var response;
        return regeneratorRuntime.wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                this.beforeExecution(this.moduleInstance);
                if (!(this.parameters.length !== this.parametersAmount)) {
                  _context.next = 3;
                  break;
                }
                throw new Error("Invalid Arguments length: expected: ".concat(this.parametersAmount, ", given: ").concat(this.parameters.length));
              case 3:
                _context.prev = 3;
                _context.next = 6;
                return this.moduleInstance.currentProvider.send(this.rpcMethod, this.parameters);
              case 6:
                response = _context.sent;
                if (response) {
                  response = this.afterExecution(response);
                }
                if (this.callback) {
                  this.callback(false, response);
                }
                return _context.abrupt("return", response);
              case 12:
                _context.prev = 12;
                _context.t0 = _context["catch"](3);
                if (this.callback) {
                  this.callback(_context.t0, null);
                }
                throw _context.t0;
              case 16:
              case "end":
                return _context.stop();
            }
          }
        }, _callee, this, [[3, 12]]);
      }));
      function execute() {
        return _execute.apply(this, arguments);
      }
      return execute;
    }()
  }, {
    key: "setArguments",
    value: function setArguments(methodArguments) {
      var parameters = cloneDeep(_toConsumableArray(methodArguments));
      var callback = null;
      if (parameters.length > this.parametersAmount) {
        if (!isFunction(parameters[parameters.length - 1])) {
          throw new TypeError("The latest parameter should be a function otherwise it can't be used as callback");
        }
        callback = parameters.pop();
      }
      this._arguments = {
        callback: callback,
        parameters: parameters
      };
    }
  }, {
    key: "getArguments",
    value: function getArguments() {
      return this._arguments;
    }
  }, {
    key: "isHash",
    value: function isHash(parameter) {
      return isString(parameter) && parameter.startsWith('0x');
    }
  }, {
    key: "rpcMethod",
    set: function set(value) {
      this._rpcMethod = value;
    }
    ,
    get: function get() {
      return this._rpcMethod;
    }
  }, {
    key: "parametersAmount",
    set: function set(value) {
      this._parametersAmount = value;
    }
    ,
    get: function get() {
      return this._parametersAmount;
    }
  }, {
    key: "parameters",
    get: function get() {
      return this._arguments.parameters;
    }
    ,
    set: function set(value) {
      this._arguments.parameters = value;
    }
  }, {
    key: "callback",
    get: function get() {
      return this._arguments.callback;
    }
    ,
    set: function set(value) {
      this._arguments.callback = value;
    }
  }]);
  return AbstractMethod;
}();

var AbstractGetBlockMethod =
function (_AbstractMethod) {
  _inherits(AbstractGetBlockMethod, _AbstractMethod);
  function AbstractGetBlockMethod(rpcMethod, utils, formatters, moduleInstance) {
    _classCallCheck(this, AbstractGetBlockMethod);
    return _possibleConstructorReturn(this, _getPrototypeOf(AbstractGetBlockMethod).call(this, rpcMethod, 2, utils, formatters, moduleInstance));
  }
  _createClass(AbstractGetBlockMethod, [{
    key: "beforeExecution",
    value: function beforeExecution(moduleInstance) {
      this.parameters[0] = this.formatters.inputBlockAddressFormatter(this.parameters[0]);
      if (isFunction(this.parameters[1])) {
        this.callback = this.parameters[1];
        this.parameters[1] = false;
      } else {
        this.parameters[1] = !!this.parameters[1];
      }
    }
  }, {
    key: "afterExecution",
    value: function afterExecution(response) {
      return this.formatters.outputBlockFormatter(response);
    }
  }]);
  return AbstractGetBlockMethod;
}(AbstractMethod);

var GetBlockByNumberMethod =
function (_AbstractGetBlockMeth) {
  _inherits(GetBlockByNumberMethod, _AbstractGetBlockMeth);
  function GetBlockByNumberMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, GetBlockByNumberMethod);
    return _possibleConstructorReturn(this, _getPrototypeOf(GetBlockByNumberMethod).call(this, 'eth_getBlockByNumber', utils, formatters, moduleInstance));
  }
  return GetBlockByNumberMethod;
}(AbstractGetBlockMethod);

var GetTransactionReceiptMethod =
function (_AbstractMethod) {
  _inherits(GetTransactionReceiptMethod, _AbstractMethod);
  function GetTransactionReceiptMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, GetTransactionReceiptMethod);
    return _possibleConstructorReturn(this, _getPrototypeOf(GetTransactionReceiptMethod).call(this, 'eth_getTransactionReceipt', 1, utils, formatters, moduleInstance));
  }
  _createClass(GetTransactionReceiptMethod, [{
    key: "afterExecution",
    value: function afterExecution(response) {
      if (response !== null) {
        return this.formatters.outputTransactionReceiptFormatter(response);
      }
      return response;
    }
  }]);
  return GetTransactionReceiptMethod;
}(AbstractMethod);

var TransactionObserver =
function () {
  function TransactionObserver(provider, timeout, blockConfirmations, getTransactionReceiptMethod, getBlockByNumberMethod, newHeadsSubscription) {
    _classCallCheck(this, TransactionObserver);
    this.provider = provider;
    this.timeout = timeout;
    this.blockConfirmations = blockConfirmations;
    this.getTransactionReceiptMethod = getTransactionReceiptMethod;
    this.getBlockByNumberMethod = getBlockByNumberMethod;
    this.newHeadsSubscription = newHeadsSubscription;
    this.blockNumbers = [];
    this.lastBlock = false;
    this.confirmations = 0;
    this.confirmationChecks = 0;
    this.interval = false;
  }
  _createClass(TransactionObserver, [{
    key: "observe",
    value: function observe(transactionHash) {
      var _this = this;
      return Observable.create(function (observer) {
        if (_this.provider.supportsSubscriptions()) {
          _this.startSocketObserver(transactionHash, observer);
        } else {
          _this.startHttpObserver(transactionHash, observer);
        }
      });
    }
  }, {
    key: "startSocketObserver",
    value: function startSocketObserver(transactionHash, observer) {
      var _this2 = this;
      this.newHeadsSubscription.subscribe(
      function () {
        var _ref = _asyncToGenerator(
        regeneratorRuntime.mark(function _callee(error, newHead) {
          var receipt;
          return regeneratorRuntime.wrap(function _callee$(_context) {
            while (1) {
              switch (_context.prev = _context.next) {
                case 0:
                  _context.prev = 0;
                  if (!observer.closed) {
                    _context.next = 5;
                    break;
                  }
                  _context.next = 4;
                  return _this2.newHeadsSubscription.unsubscribe();
                case 4:
                  return _context.abrupt("return");
                case 5:
                  if (!error) {
                    _context.next = 7;
                    break;
                  }
                  throw error;
                case 7:
                  _this2.getTransactionReceiptMethod.parameters = [transactionHash];
                  _context.next = 10;
                  return _this2.getTransactionReceiptMethod.execute();
                case 10:
                  receipt = _context.sent;
                  if (_this2.blockNumbers.includes(newHead.number)) {
                    _context.next = 25;
                    break;
                  }
                  if (!receipt) {
                    _context.next = 19;
                    break;
                  }
                  _this2.confirmations++;
                  _this2.emitNext(receipt, observer);
                  if (!_this2.isConfirmed()) {
                    _context.next = 19;
                    break;
                  }
                  _context.next = 18;
                  return _this2.newHeadsSubscription.unsubscribe();
                case 18:
                  observer.complete();
                case 19:
                  _this2.blockNumbers.push(newHead.number);
                  _this2.confirmationChecks++;
                  if (!_this2.isTimeoutTimeExceeded()) {
                    _context.next = 25;
                    break;
                  }
                  _context.next = 24;
                  return _this2.newHeadsSubscription.unsubscribe();
                case 24:
                  _this2.emitError(new Error('Timeout exceeded during the transaction confirmation process. Be aware the transaction could still get confirmed!'), receipt, observer);
                case 25:
                  _context.next = 30;
                  break;
                case 27:
                  _context.prev = 27;
                  _context.t0 = _context["catch"](0);
                  _this2.emitError(_context.t0, false, observer);
                case 30:
                case "end":
                  return _context.stop();
              }
            }
          }, _callee, null, [[0, 27]]);
        }));
        return function (_x, _x2) {
          return _ref.apply(this, arguments);
        };
      }());
    }
  }, {
    key: "startHttpObserver",
    value: function startHttpObserver(transactionHash, observer) {
      var _this3 = this;
      var interval = setInterval(
      _asyncToGenerator(
      regeneratorRuntime.mark(function _callee2() {
        var receipt, block;
        return regeneratorRuntime.wrap(function _callee2$(_context2) {
          while (1) {
            switch (_context2.prev = _context2.next) {
              case 0:
                _context2.prev = 0;
                if (!observer.closed) {
                  _context2.next = 4;
                  break;
                }
                clearInterval(interval);
                return _context2.abrupt("return");
              case 4:
                _this3.getTransactionReceiptMethod.parameters = [transactionHash];
                _context2.next = 7;
                return _this3.getTransactionReceiptMethod.execute();
              case 7:
                receipt = _context2.sent;
                if (!receipt) {
                  _context2.next = 22;
                  break;
                }
                if (!_this3.lastBlock) {
                  _context2.next = 16;
                  break;
                }
                _context2.next = 12;
                return _this3.getBlockByNumber(_this3.increaseBlockNumber(_this3.lastBlock.number));
              case 12:
                block = _context2.sent;
                if (block && _this3.isValidConfirmation(block)) {
                  _this3.lastBlock = block;
                  _this3.confirmations++;
                  _this3.emitNext(receipt, observer);
                }
                _context2.next = 21;
                break;
              case 16:
                _context2.next = 18;
                return _this3.getBlockByNumber(receipt.blockNumber);
              case 18:
                _this3.lastBlock = _context2.sent;
                _this3.confirmations++;
                _this3.emitNext(receipt, observer);
              case 21:
                if (_this3.isConfirmed()) {
                  clearInterval(interval);
                  observer.complete();
                }
              case 22:
                _this3.confirmationChecks++;
                if (_this3.isTimeoutTimeExceeded()) {
                  clearInterval(interval);
                  _this3.emitError(new Error('Timeout exceeded during the transaction confirmation process. Be aware the transaction could still get confirmed!'), receipt, observer);
                }
                _context2.next = 30;
                break;
              case 26:
                _context2.prev = 26;
                _context2.t0 = _context2["catch"](0);
                clearInterval(interval);
                _this3.emitError(_context2.t0, false, observer);
              case 30:
              case "end":
                return _context2.stop();
            }
          }
        }, _callee2, null, [[0, 26]]);
      })), 1000);
    }
  }, {
    key: "emitNext",
    value: function emitNext(receipt, observer) {
      observer.next({
        receipt: receipt,
        confirmations: this.confirmations
      });
    }
  }, {
    key: "emitError",
    value: function emitError(error, receipt, observer) {
      observer.error({
        error: error,
        receipt: receipt,
        confirmations: this.confirmations,
        confirmationChecks: this.confirmationChecks
      });
    }
  }, {
    key: "getBlockByNumber",
    value: function getBlockByNumber(blockNumber) {
      this.getBlockByNumberMethod.parameters = [blockNumber];
      return this.getBlockByNumberMethod.execute();
    }
  }, {
    key: "isConfirmed",
    value: function isConfirmed() {
      return this.confirmations === this.blockConfirmations;
    }
  }, {
    key: "isValidConfirmation",
    value: function isValidConfirmation(block) {
      return this.lastBlock.hash === block.parentHash && this.lastBlock.number !== block.number;
    }
  }, {
    key: "isTimeoutTimeExceeded",
    value: function isTimeoutTimeExceeded() {
      return this.confirmationChecks === this.timeout;
    }
  }, {
    key: "increaseBlockNumber",
    value: function increaseBlockNumber(blockNumber) {
      return '0x' + (parseInt(blockNumber, 16) + 1).toString(16);
    }
  }]);
  return TransactionObserver;
}();

var GetTransactionCountMethod =
function (_AbstractMethod) {
  _inherits(GetTransactionCountMethod, _AbstractMethod);
  function GetTransactionCountMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, GetTransactionCountMethod);
    return _possibleConstructorReturn(this, _getPrototypeOf(GetTransactionCountMethod).call(this, 'eth_getTransactionCount', 2, utils, formatters, moduleInstance));
  }
  _createClass(GetTransactionCountMethod, [{
    key: "beforeExecution",
    value: function beforeExecution(moduleInstance) {
      this.parameters[0] = this.formatters.inputAddressFormatter(this.parameters[0]);
      if (isFunction(this.parameters[1])) {
        this.callback = this.parameters[1];
        this.parameters[1] = moduleInstance.defaultEpoch;
      }
      this.parameters[1] = this.formatters.inputDefaultEpochNumberFormatter(this.parameters[1], moduleInstance);
    }
  }, {
    key: "afterExecution",
    value: function afterExecution(response) {
      return this.utils.hexToNumber(response);
    }
  }]);
  return GetTransactionCountMethod;
}(AbstractMethod);

var ChainIdMethod =
function (_AbstractMethod) {
  _inherits(ChainIdMethod, _AbstractMethod);
  function ChainIdMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, ChainIdMethod);
    return _possibleConstructorReturn(this, _getPrototypeOf(ChainIdMethod).call(this, 'eth_chainId', 0, utils, formatters, moduleInstance));
  }
  _createClass(ChainIdMethod, [{
    key: "afterExecution",
    value: function afterExecution(response) {
      return this.utils.hexToNumber(response);
    }
  }]);
  return ChainIdMethod;
}(AbstractMethod);

var AbstractMethodFactory =
function () {
  function AbstractMethodFactory(utils, formatters) {
    _classCallCheck(this, AbstractMethodFactory);
    this.utils = utils;
    this.formatters = formatters;
    this._methods = null;
  }
  _createClass(AbstractMethodFactory, [{
    key: "hasMethod",
    value: function hasMethod(name) {
      return typeof this.methods[name] !== 'undefined';
    }
  }, {
    key: "createMethod",
    value: function createMethod(name, moduleInstance) {
      var method = this.methods[name];
      if (method.Type === 'observed-transaction-method') {
        return new method(this.utils, this.formatters, moduleInstance, this.createTransactionObserver(moduleInstance));
      }
      if (method.Type === 'cfx-send-transaction-method') {
        return new method(this.utils, this.formatters, moduleInstance, this.createTransactionObserver(moduleInstance), new ChainIdMethod(this.utils, this.formatters, moduleInstance), new GetTransactionCountMethod(this.utils, this.formatters, moduleInstance));
      }
      return new method(this.utils, this.formatters, moduleInstance);
    }
  }, {
    key: "getTimeout",
    value: function getTimeout(moduleInstance) {
      var timeout = moduleInstance.transactionBlockTimeout;
      if (!moduleInstance.currentProvider.supportsSubscriptions()) {
        timeout = moduleInstance.transactionPollingTimeout;
      }
      return timeout;
    }
  }, {
    key: "createTransactionObserver",
    value: function createTransactionObserver(moduleInstance) {
      return new TransactionObserver(moduleInstance.currentProvider, this.getTimeout(moduleInstance), moduleInstance.transactionConfirmationBlocks, new GetTransactionReceiptMethod(this.utils, this.formatters, moduleInstance), new GetBlockByNumberMethod(this.utils, this.formatters, moduleInstance), new NewHeadsSubscription(this.utils, this.formatters, moduleInstance));
    }
  }, {
    key: "methods",
    get: function get() {
      if (this._methods) {
        return this._methods;
      }
      throw new Error('No methods defined for MethodFactory!');
    }
    ,
    set: function set(value) {
      this._methods = value;
    }
  }]);
  return AbstractMethodFactory;
}();

var MethodProxy =
function MethodProxy(target, methodFactory) {
  _classCallCheck(this, MethodProxy);
  return new Proxy(target, {
    get: function get(target, name) {
      if (methodFactory.hasMethod(name)) {
        var RpcMethod = function RpcMethod() {
          method.setArguments(arguments);
          return method.execute();
        };
        if (typeof target[name] !== 'undefined') {
          throw new TypeError("Duplicated method ".concat(name, ". This method is defined as RPC call and as Object method."));
        }
        var method = methodFactory.createMethod(name, target);
        RpcMethod.method = method;
        RpcMethod.request = function () {
          method.setArguments(arguments);
          return method;
        };
        return RpcMethod;
      }
      return target[name];
    }
  });
};

var GetProtocolVersionMethod =
function (_AbstractMethod) {
  _inherits(GetProtocolVersionMethod, _AbstractMethod);
  function GetProtocolVersionMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, GetProtocolVersionMethod);
    return _possibleConstructorReturn(this, _getPrototypeOf(GetProtocolVersionMethod).call(this, 'eth_protocolVersion', 0, utils, formatters, moduleInstance));
  }
  _createClass(GetProtocolVersionMethod, [{
    key: "afterExecution",
    value: function afterExecution(response) {
      return this.utils.hexToNumber(response);
    }
  }]);
  return GetProtocolVersionMethod;
}(AbstractMethod);

var VersionMethod =
function (_AbstractMethod) {
  _inherits(VersionMethod, _AbstractMethod);
  function VersionMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, VersionMethod);
    return _possibleConstructorReturn(this, _getPrototypeOf(VersionMethod).call(this, 'net_version', 0, utils, formatters, moduleInstance));
  }
  _createClass(VersionMethod, [{
    key: "afterExecution",
    value: function afterExecution(response) {
      return this.utils.hexToNumber(response);
    }
  }]);
  return VersionMethod;
}(AbstractMethod);

var ListeningMethod =
function (_AbstractMethod) {
  _inherits(ListeningMethod, _AbstractMethod);
  function ListeningMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, ListeningMethod);
    return _possibleConstructorReturn(this, _getPrototypeOf(ListeningMethod).call(this, 'net_listening', 0, utils, formatters, moduleInstance));
  }
  return ListeningMethod;
}(AbstractMethod);

var PeerCountMethod =
function (_AbstractMethod) {
  _inherits(PeerCountMethod, _AbstractMethod);
  function PeerCountMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, PeerCountMethod);
    return _possibleConstructorReturn(this, _getPrototypeOf(PeerCountMethod).call(this, 'net_peerCount', 0, utils, formatters, moduleInstance));
  }
  _createClass(PeerCountMethod, [{
    key: "afterExecution",
    value: function afterExecution(response) {
      return this.utils.hexToNumber(response);
    }
  }]);
  return PeerCountMethod;
}(AbstractMethod);

var GetNodeInfoMethod =
function (_AbstractMethod) {
  _inherits(GetNodeInfoMethod, _AbstractMethod);
  function GetNodeInfoMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, GetNodeInfoMethod);
    return _possibleConstructorReturn(this, _getPrototypeOf(GetNodeInfoMethod).call(this, 'web3_clientVersion', 0, utils, formatters, moduleInstance));
  }
  return GetNodeInfoMethod;
}(AbstractMethod);

var GetCoinbaseMethod =
function (_AbstractMethod) {
  _inherits(GetCoinbaseMethod, _AbstractMethod);
  function GetCoinbaseMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, GetCoinbaseMethod);
    return _possibleConstructorReturn(this, _getPrototypeOf(GetCoinbaseMethod).call(this, 'eth_coinbase', 0, utils, formatters, moduleInstance));
  }
  return GetCoinbaseMethod;
}(AbstractMethod);

var IsMiningMethod =
function (_AbstractMethod) {
  _inherits(IsMiningMethod, _AbstractMethod);
  function IsMiningMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, IsMiningMethod);
    return _possibleConstructorReturn(this, _getPrototypeOf(IsMiningMethod).call(this, 'eth_mining', 0, utils, formatters, moduleInstance));
  }
  return IsMiningMethod;
}(AbstractMethod);

var GetHashrateMethod =
function (_AbstractMethod) {
  _inherits(GetHashrateMethod, _AbstractMethod);
  function GetHashrateMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, GetHashrateMethod);
    return _possibleConstructorReturn(this, _getPrototypeOf(GetHashrateMethod).call(this, 'eth_hashrate', 0, utils, formatters, moduleInstance));
  }
  _createClass(GetHashrateMethod, [{
    key: "afterExecution",
    value: function afterExecution(response) {
      return this.utils.hexToNumber(response);
    }
  }]);
  return GetHashrateMethod;
}(AbstractMethod);

var IsSyncingMethod =
function (_AbstractMethod) {
  _inherits(IsSyncingMethod, _AbstractMethod);
  function IsSyncingMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, IsSyncingMethod);
    return _possibleConstructorReturn(this, _getPrototypeOf(IsSyncingMethod).call(this, 'eth_syncing', 0, utils, formatters, moduleInstance));
  }
  _createClass(IsSyncingMethod, [{
    key: "afterExecution",
    value: function afterExecution(response) {
      if (typeof response !== 'boolean') {
        return this.formatters.outputSyncingFormatter(response);
      }
      return response;
    }
  }]);
  return IsSyncingMethod;
}(AbstractMethod);

var GetGasPriceMethod =
function (_AbstractMethod) {
  _inherits(GetGasPriceMethod, _AbstractMethod);
  function GetGasPriceMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, GetGasPriceMethod);
    return _possibleConstructorReturn(this, _getPrototypeOf(GetGasPriceMethod).call(this, 'eth_gasPrice', 0, utils, formatters, moduleInstance));
  }
  _createClass(GetGasPriceMethod, [{
    key: "afterExecution",
    value: function afterExecution(response) {
      return this.formatters.outputBigNumberFormatter(response);
    }
  }]);
  return GetGasPriceMethod;
}(AbstractMethod);

var SubmitWorkMethod =
function (_AbstractMethod) {
  _inherits(SubmitWorkMethod, _AbstractMethod);
  function SubmitWorkMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, SubmitWorkMethod);
    return _possibleConstructorReturn(this, _getPrototypeOf(SubmitWorkMethod).call(this, 'eth_submitWork', 3, utils, formatters, moduleInstance));
  }
  return SubmitWorkMethod;
}(AbstractMethod);

var GetWorkMethod =
function (_AbstractMethod) {
  _inherits(GetWorkMethod, _AbstractMethod);
  function GetWorkMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, GetWorkMethod);
    return _possibleConstructorReturn(this, _getPrototypeOf(GetWorkMethod).call(this, 'eth_getWork', 0, utils, formatters, moduleInstance));
  }
  return GetWorkMethod;
}(AbstractMethod);

var GetAccountsMethod =
function (_AbstractMethod) {
  _inherits(GetAccountsMethod, _AbstractMethod);
  function GetAccountsMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, GetAccountsMethod);
    return _possibleConstructorReturn(this, _getPrototypeOf(GetAccountsMethod).call(this, 'cfx_accounts', 0, utils, formatters, moduleInstance));
  }
  _createClass(GetAccountsMethod, [{
    key: "afterExecution",
    value: function afterExecution(response) {
      var _this = this;
      return response.map(function (responseItem) {
        return _this.utils.toChecksumAddress(responseItem);
      });
    }
  }]);
  return GetAccountsMethod;
}(AbstractMethod);

var GetBalanceMethod =
function (_AbstractMethod) {
  _inherits(GetBalanceMethod, _AbstractMethod);
  function GetBalanceMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, GetBalanceMethod);
    return _possibleConstructorReturn(this, _getPrototypeOf(GetBalanceMethod).call(this, 'cfx_getBalance', 2, utils, formatters, moduleInstance));
  }
  _createClass(GetBalanceMethod, [{
    key: "beforeExecution",
    value: function beforeExecution(moduleInstance) {
      this.parameters[0] = this.formatters.inputAddressFormatter(this.parameters[0]);
      if (isFunction(this.parameters[1])) {
        this.callback = this.parameters[1];
        this.parameters[1] = moduleInstance.defaultEpoch;
      }
      this.parameters[1] = this.formatters.inputDefaultEpochNumberFormatter(this.parameters[1], moduleInstance);
    }
  }, {
    key: "afterExecution",
    value: function afterExecution(response) {
      return this.formatters.outputBigNumberFormatter(response);
    }
  }]);
  return GetBalanceMethod;
}(AbstractMethod);

var RequestAccountsMethod =
function (_AbstractMethod) {
  _inherits(RequestAccountsMethod, _AbstractMethod);
  function RequestAccountsMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, RequestAccountsMethod);
    return _possibleConstructorReturn(this, _getPrototypeOf(RequestAccountsMethod).call(this, 'eth_requestAccounts', 0, utils, formatters, moduleInstance));
  }
  return RequestAccountsMethod;
}(AbstractMethod);

var AbstractGetBlockTransactionCountMethod =
function (_AbstractMethod) {
  _inherits(AbstractGetBlockTransactionCountMethod, _AbstractMethod);
  function AbstractGetBlockTransactionCountMethod(rpcMethod, utils, formatters, moduleInstance) {
    _classCallCheck(this, AbstractGetBlockTransactionCountMethod);
    return _possibleConstructorReturn(this, _getPrototypeOf(AbstractGetBlockTransactionCountMethod).call(this, rpcMethod, 1, utils, formatters, moduleInstance));
  }
  _createClass(AbstractGetBlockTransactionCountMethod, [{
    key: "beforeExecution",
    value: function beforeExecution(moduleInstance) {
      this.parameters[0] = this.formatters.inputBlockAddressFormatter(this.parameters[0]);
    }
  }, {
    key: "afterExecution",
    value: function afterExecution(response) {
      return this.utils.hexToNumber(response);
    }
  }]);
  return AbstractGetBlockTransactionCountMethod;
}(AbstractMethod);

var GetBlockByHashMethod =
function (_AbstractGetBlockMeth) {
  _inherits(GetBlockByHashMethod, _AbstractGetBlockMeth);
  function GetBlockByHashMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, GetBlockByHashMethod);
    return _possibleConstructorReturn(this, _getPrototypeOf(GetBlockByHashMethod).call(this, 'eth_getBlockByHash', utils, formatters, moduleInstance));
  }
  return GetBlockByHashMethod;
}(AbstractGetBlockMethod);

var GetBlockTransactionCountByHashMethod =
function (_AbstractGetBlockTran) {
  _inherits(GetBlockTransactionCountByHashMethod, _AbstractGetBlockTran);
  function GetBlockTransactionCountByHashMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, GetBlockTransactionCountByHashMethod);
    return _possibleConstructorReturn(this, _getPrototypeOf(GetBlockTransactionCountByHashMethod).call(this, 'eth_getBlockTransactionCountByHash', utils, formatters, moduleInstance));
  }
  return GetBlockTransactionCountByHashMethod;
}(AbstractGetBlockTransactionCountMethod);

var GetBlockTransactionCountByNumberMethod =
function (_AbstractGetBlockTran) {
  _inherits(GetBlockTransactionCountByNumberMethod, _AbstractGetBlockTran);
  function GetBlockTransactionCountByNumberMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, GetBlockTransactionCountByNumberMethod);
    return _possibleConstructorReturn(this, _getPrototypeOf(GetBlockTransactionCountByNumberMethod).call(this, 'eth_getBlockTransactionCountByNumber', utils, formatters, moduleInstance));
  }
  return GetBlockTransactionCountByNumberMethod;
}(AbstractGetBlockTransactionCountMethod);

var AbstractGetTransactionFromBlockMethod =
function (_AbstractMethod) {
  _inherits(AbstractGetTransactionFromBlockMethod, _AbstractMethod);
  function AbstractGetTransactionFromBlockMethod(rpcMethod, utils, formatters, moduleInstance) {
    _classCallCheck(this, AbstractGetTransactionFromBlockMethod);
    return _possibleConstructorReturn(this, _getPrototypeOf(AbstractGetTransactionFromBlockMethod).call(this, rpcMethod, 2, utils, formatters, moduleInstance));
  }
  _createClass(AbstractGetTransactionFromBlockMethod, [{
    key: "beforeExecution",
    value: function beforeExecution(moduleInstance) {
      this.parameters[0] = this.formatters.inputBlockAddressFormatter(this.parameters[0]);
      this.parameters[1] = this.utils.numberToHex(this.parameters[1]);
    }
  }, {
    key: "afterExecution",
    value: function afterExecution(response) {
      return this.formatters.outputTransactionFormatter(response);
    }
  }]);
  return AbstractGetTransactionFromBlockMethod;
}(AbstractMethod);

var AbstractObservedTransactionMethod =
function (_AbstractMethod) {
  _inherits(AbstractObservedTransactionMethod, _AbstractMethod);
  function AbstractObservedTransactionMethod(rpcMethod, parametersAmount, utils, formatters, moduleInstance, transactionObserver) {
    var _this;
    _classCallCheck(this, AbstractObservedTransactionMethod);
    _this = _possibleConstructorReturn(this, _getPrototypeOf(AbstractObservedTransactionMethod).call(this, rpcMethod, parametersAmount, utils, formatters, moduleInstance));
    _this.transactionObserver = transactionObserver;
    _this.promiEvent = new PromiEvent();
    return _this;
  }
  _createClass(AbstractObservedTransactionMethod, [{
    key: "execute",
    value: function execute() {
      var _this2 = this;
      this.beforeExecution(this.moduleInstance);
      this.moduleInstance.currentProvider.send(this.rpcMethod, this.parameters).then(function (transactionHash) {
        if (_this2.callback) {
          _this2.promiEvent.resolve(_this2.callback(false, transactionHash));
          return;
        }
        _this2.promiEvent.resolve(transactionHash);
      }).catch(function (error) {
        if (_this2.callback) {
          _this2.callback(error, null);
          return;
        }
        _this2.handleError(error, false, 0);
      });
      return this.promiEvent;
    }
  }, {
    key: "handleError",
    value: function handleError(error, receipt, confirmations) {
      if (this.promiEvent.listenerCount('error') > 0) {
        this.promiEvent.emit('error', error, receipt, confirmations);
        this.promiEvent.removeAllListeners();
        return;
      }
      this.promiEvent.reject(error);
    }
  }], [{
    key: "Type",
    get: function get() {
      return 'observed-transaction-method';
    }
  }]);
  return AbstractObservedTransactionMethod;
}(AbstractMethod);

var SendTransactionMethod =
function (_AbstractObservedTran) {
  _inherits(SendTransactionMethod, _AbstractObservedTran);
  function SendTransactionMethod(utils, formatters, moduleInstance, transactionObserver) {
    _classCallCheck(this, SendTransactionMethod);
    return _possibleConstructorReturn(this, _getPrototypeOf(SendTransactionMethod).call(this, 'cfx_sendTransaction', 1, utils, formatters, moduleInstance, transactionObserver));
  }
  _createClass(SendTransactionMethod, [{
    key: "beforeExecution",
    value: function beforeExecution(moduleInstance) {
      this.parameters[0] = this.formatters.inputTransactionFormatter(this.parameters[0], moduleInstance);
    }
  }]);
  return SendTransactionMethod;
}(AbstractObservedTransactionMethod);

var CfxSendTransactionMethod =
function (_SendTransactionMetho) {
  _inherits(CfxSendTransactionMethod, _SendTransactionMetho);
  function CfxSendTransactionMethod(utils, formatters, moduleInstance, transactionObserver, chainIdMethod, getTransactionCountMethod) {
    var _this;
    _classCallCheck(this, CfxSendTransactionMethod);
    _this = _possibleConstructorReturn(this, _getPrototypeOf(CfxSendTransactionMethod).call(this, utils, formatters, moduleInstance, transactionObserver));
    _this.chainIdMethod = chainIdMethod;
    _this.getTransactionCountMethod = getTransactionCountMethod;
    return _this;
  }
  _createClass(CfxSendTransactionMethod, [{
    key: "beforeExecution",
    value: function beforeExecution(moduleInstance) {
      if (this.rpcMethod !== 'cfx_sendRawTransaction') {
        _get(_getPrototypeOf(CfxSendTransactionMethod.prototype), "beforeExecution", this).call(this, moduleInstance);
      }
    }
  }, {
    key: "execute",
    value: function execute() {
      var _this2 = this;
      if (!this.parameters[0].gas && this.moduleInstance.defaultGas) {
        this.parameters[0]['gas'] = this.moduleInstance.defaultGas;
      }
      if (!this.parameters[0].gasPrice && this.parameters[0].gasPrice !== 0) {
        if (!this.moduleInstance.defaultGasPrice) {
          this.moduleInstance.currentProvider.send('cfx_gasPrice', []).then(function (gasPrice) {
            _this2.parameters[0].gasPrice = gasPrice;
            _this2.execute();
          }).catch(function (error) {
            _this2.handleError(error, false, 0);
          });
          return this.promiEvent;
        }
        this.parameters[0]['gasPrice'] = this.moduleInstance.defaultGasPrice;
      }
      if (this.hasAccounts() && this.isDefaultSigner()) {
        if (this.moduleInstance.accounts.wallet[this.parameters[0].from]) {
          this.sendRawTransaction(this.moduleInstance.accounts.wallet[this.parameters[0].from].privateKey).catch(function (error) {
            _this2.handleError(error, false, 0);
          });
          return this.promiEvent;
        }
      }
      if (this.hasCustomSigner()) {
        this.sendRawTransaction().catch(function (error) {
          _this2.handleError(error, false, 0);
        });
        return this.promiEvent;
      }
      return _get(_getPrototypeOf(CfxSendTransactionMethod.prototype), "execute", this).call(this);
    }
  }, {
    key: "sendRawTransaction",
    value: function () {
      var _sendRawTransaction = _asyncToGenerator(
      regeneratorRuntime.mark(function _callee() {
        var privateKey,
            transaction,
            response,
            _args = arguments;
        return regeneratorRuntime.wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                privateKey = _args.length > 0 && _args[0] !== undefined ? _args[0] : null;
                this.beforeExecution(this.moduleInstance);
                if (this.parameters[0].chainId) {
                  _context.next = 6;
                  break;
                }
                _context.next = 5;
                return this.chainIdMethod.execute();
              case 5:
                this.parameters[0].chainId = _context.sent;
              case 6:
                if (!(!this.parameters[0].nonce && this.parameters[0].nonce !== 0)) {
                  _context.next = 11;
                  break;
                }
                this.getTransactionCountMethod.parameters = [this.parameters[0].from, 'latest_state'];
                _context.next = 10;
                return this.getTransactionCountMethod.execute();
              case 10:
                this.parameters[0].nonce = _context.sent;
              case 11:
                transaction = this.parameters[0];
                transaction.to = transaction.to || '0x';
                transaction.data = transaction.data || '0x';
                transaction.value = transaction.value || '0x';
                transaction.chainId = this.utils.numberToHex(transaction.chainId);
                delete transaction.from;
                _context.next = 19;
                return this.moduleInstance.transactionSigner.sign(transaction, privateKey);
              case 19:
                response = _context.sent;
                this.parameters = [response.rawTransaction];
                this.rpcMethod = 'cfx_sendRawTransaction';
                return _context.abrupt("return", _get(_getPrototypeOf(CfxSendTransactionMethod.prototype), "execute", this).call(this));
              case 23:
              case "end":
                return _context.stop();
            }
          }
        }, _callee, this);
      }));
      function sendRawTransaction() {
        return _sendRawTransaction.apply(this, arguments);
      }
      return sendRawTransaction;
    }()
  }, {
    key: "isDefaultSigner",
    value: function isDefaultSigner() {
      return this.moduleInstance.transactionSigner.type === 'TransactionSigner';
    }
  }, {
    key: "hasAccounts",
    value: function hasAccounts() {
      return this.moduleInstance.accounts && this.moduleInstance.accounts.wallet.accountsIndex > 0;
    }
  }, {
    key: "hasCustomSigner",
    value: function hasCustomSigner() {
      return this.moduleInstance.transactionSigner.type !== 'TransactionSigner';
    }
  }], [{
    key: "Type",
    get: function get() {
      return 'cfx-send-transaction-method';
    }
  }]);
  return CfxSendTransactionMethod;
}(SendTransactionMethod);

var GetTransactionMethod =
function (_AbstractMethod) {
  _inherits(GetTransactionMethod, _AbstractMethod);
  function GetTransactionMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, GetTransactionMethod);
    return _possibleConstructorReturn(this, _getPrototypeOf(GetTransactionMethod).call(this, 'eth_getTransactionByHash', 1, utils, formatters, moduleInstance));
  }
  _createClass(GetTransactionMethod, [{
    key: "afterExecution",
    value: function afterExecution(response) {
      return this.formatters.outputTransactionFormatter(response);
    }
  }]);
  return GetTransactionMethod;
}(AbstractMethod);

var GetTransactionByBlockHashAndIndexMethod =
function (_AbstractGetTransacti) {
  _inherits(GetTransactionByBlockHashAndIndexMethod, _AbstractGetTransacti);
  function GetTransactionByBlockHashAndIndexMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, GetTransactionByBlockHashAndIndexMethod);
    return _possibleConstructorReturn(this, _getPrototypeOf(GetTransactionByBlockHashAndIndexMethod).call(this, 'cfx_getTransactionByBlockHashAndIndex', utils, formatters, moduleInstance));
  }
  return GetTransactionByBlockHashAndIndexMethod;
}(AbstractGetTransactionFromBlockMethod);

var GetTransactionByBlockAddressAndIndexMethod =
function (_AbstractGetTransacti) {
  _inherits(GetTransactionByBlockAddressAndIndexMethod, _AbstractGetTransacti);
  function GetTransactionByBlockAddressAndIndexMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, GetTransactionByBlockAddressAndIndexMethod);
    return _possibleConstructorReturn(this, _getPrototypeOf(GetTransactionByBlockAddressAndIndexMethod).call(this, 'cfx_getTransactionByBlockAddressAndIndex', utils, formatters, moduleInstance));
  }
  return GetTransactionByBlockAddressAndIndexMethod;
}(AbstractGetTransactionFromBlockMethod);

var SendRawTransactionMethod =
function (_AbstractObservedTran) {
  _inherits(SendRawTransactionMethod, _AbstractObservedTran);
  function SendRawTransactionMethod(utils, formatters, moduleInstance, transactionObserver) {
    _classCallCheck(this, SendRawTransactionMethod);
    return _possibleConstructorReturn(this, _getPrototypeOf(SendRawTransactionMethod).call(this, 'cfx_sendRawTransaction', 1, utils, formatters, moduleInstance, transactionObserver));
  }
  return SendRawTransactionMethod;
}(AbstractObservedTransactionMethod);

var SignTransactionMethod =
function (_AbstractMethod) {
  _inherits(SignTransactionMethod, _AbstractMethod);
  function SignTransactionMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, SignTransactionMethod);
    return _possibleConstructorReturn(this, _getPrototypeOf(SignTransactionMethod).call(this, 'cfx_signTransaction', 1, utils, formatters, moduleInstance));
  }
  _createClass(SignTransactionMethod, [{
    key: "beforeExecution",
    value: function beforeExecution(moduleInstance) {
      this.parameters[0] = this.formatters.inputTransactionFormatter(this.parameters[0], moduleInstance);
    }
  }]);
  return SignTransactionMethod;
}(AbstractMethod);

var GetCodeMethod =
function (_AbstractMethod) {
  _inherits(GetCodeMethod, _AbstractMethod);
  function GetCodeMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, GetCodeMethod);
    return _possibleConstructorReturn(this, _getPrototypeOf(GetCodeMethod).call(this, 'eth_getCode', 2, utils, formatters, moduleInstance));
  }
  _createClass(GetCodeMethod, [{
    key: "beforeExecution",
    value: function beforeExecution(moduleInstance) {
      this.parameters[0] = this.formatters.inputAddressFormatter(this.parameters[0]);
      if (isFunction(this.parameters[1])) {
        this.callback = this.parameters[1];
        this.parameters[1] = moduleInstance.defaultEpoch;
      }
      this.parameters[1] = this.formatters.inputDefaultEpochNumberFormatter(this.parameters[1], moduleInstance);
    }
  }]);
  return GetCodeMethod;
}(AbstractMethod);

var SignMethod =
function (_AbstractMethod) {
  _inherits(SignMethod, _AbstractMethod);
  function SignMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, SignMethod);
    return _possibleConstructorReturn(this, _getPrototypeOf(SignMethod).call(this, 'cfx_sign', 2, utils, formatters, moduleInstance));
  }
  _createClass(SignMethod, [{
    key: "beforeExecution",
    value: function beforeExecution(moduleInstance) {
      this.parameters[0] = this.formatters.inputSignFormatter(this.parameters[0]);
      this.parameters[1] = this.formatters.inputAddressFormatter(this.parameters[1]);
      this.parameters.reverse();
    }
  }]);
  return SignMethod;
}(AbstractMethod);

var CallMethod =
function (_AbstractMethod) {
  _inherits(CallMethod, _AbstractMethod);
  function CallMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, CallMethod);
    return _possibleConstructorReturn(this, _getPrototypeOf(CallMethod).call(this, 'cfx_call', 2, utils, formatters, moduleInstance));
  }
  _createClass(CallMethod, [{
    key: "beforeExecution",
    value: function beforeExecution(moduleInstance) {
      this.parameters[0] = this.formatters.inputCallFormatter(this.parameters[0], moduleInstance);
      if (isFunction(this.parameters[1])) {
        this.callback = this.parameters[1];
        this.parameters[1] = moduleInstance.defaultEpoch;
      }
      this.parameters[1] = this.formatters.inputDefaultEpochNumberFormatter(this.parameters[1], moduleInstance);
    }
  }]);
  return CallMethod;
}(AbstractMethod);

var GetStorageAtMethod =
function (_AbstractMethod) {
  _inherits(GetStorageAtMethod, _AbstractMethod);
  function GetStorageAtMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, GetStorageAtMethod);
    return _possibleConstructorReturn(this, _getPrototypeOf(GetStorageAtMethod).call(this, 'eth_getStorageAt', 3, utils, formatters, moduleInstance));
  }
  _createClass(GetStorageAtMethod, [{
    key: "beforeExecution",
    value: function beforeExecution(moduleInstance) {
      this.parameters[0] = this.formatters.inputAddressFormatter(this.parameters[0]);
      this.parameters[1] = this.utils.numberToHex(this.parameters[1]);
      if (isFunction(this.parameters[2])) {
        this.callback = this.parameters[2];
        this.parameters[2] = moduleInstance.defaultEpoch;
      }
      this.parameters[2] = this.formatters.inputDefaultEpochNumberFormatter(this.parameters[2], moduleInstance);
    }
  }]);
  return GetStorageAtMethod;
}(AbstractMethod);

var EstimateGasMethod =
function (_AbstractMethod) {
  _inherits(EstimateGasMethod, _AbstractMethod);
  function EstimateGasMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, EstimateGasMethod);
    return _possibleConstructorReturn(this, _getPrototypeOf(EstimateGasMethod).call(this, 'eth_estimateGas', 1, utils, formatters, moduleInstance));
  }
  _createClass(EstimateGasMethod, [{
    key: "beforeExecution",
    value: function beforeExecution(moduleInstance) {
      this.parameters[0] = this.formatters.inputCallFormatter(this.parameters[0], moduleInstance);
    }
  }, {
    key: "afterExecution",
    value: function afterExecution(response) {
      return this.utils.hexToNumber(response);
    }
  }]);
  return EstimateGasMethod;
}(AbstractMethod);

var GetPastLogsMethod =
function (_AbstractMethod) {
  _inherits(GetPastLogsMethod, _AbstractMethod);
  function GetPastLogsMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, GetPastLogsMethod);
    return _possibleConstructorReturn(this, _getPrototypeOf(GetPastLogsMethod).call(this, 'eth_getLogs', 1, utils, formatters, moduleInstance));
  }
  _createClass(GetPastLogsMethod, [{
    key: "beforeExecution",
    value: function beforeExecution(moduleInstance) {
      this.parameters[0] = this.formatters.inputLogFormatter(this.parameters[0]);
    }
  }, {
    key: "afterExecution",
    value: function afterExecution(response) {
      var _this = this;
      return response.map(function (responseItem) {
        return _this.formatters.outputLogFormatter(responseItem);
      });
    }
  }]);
  return GetPastLogsMethod;
}(AbstractMethod);

var GetEpochNumberMethod =
function (_AbstractMethod) {
  _inherits(GetEpochNumberMethod, _AbstractMethod);
  function GetEpochNumberMethod(utils, formatters, moduleInstance) {
    _classCallCheck(this, GetEpochNumberMethod);
    return _possibleConstructorReturn(this, _getPrototypeOf(GetEpochNumberMethod).call(this, 'cfx_epochNumber', 0, utils, formatters, moduleInstance));
  }
  _createClass(GetEpochNumberMethod, [{
    key: "afterExecution",
    value: function afterExecution(response) {
      return this.utils.hexToNumber(response);
    }
  }]);
  return GetEpochNumberMethod;
}(AbstractMethod);

export { AbstractGetBlockMethod, AbstractGetBlockTransactionCountMethod, AbstractGetTransactionFromBlockMethod, AbstractMethod, AbstractMethodFactory, AbstractObservedTransactionMethod, CallMethod, CfxSendTransactionMethod, ChainIdMethod, EstimateGasMethod, GetAccountsMethod, GetBalanceMethod, GetBlockByHashMethod, GetBlockByNumberMethod, GetBlockTransactionCountByHashMethod, GetBlockTransactionCountByNumberMethod, GetCodeMethod, GetCoinbaseMethod, GetEpochNumberMethod, GetGasPriceMethod, GetHashrateMethod, GetNodeInfoMethod, GetPastLogsMethod, GetProtocolVersionMethod, GetStorageAtMethod, GetTransactionByBlockAddressAndIndexMethod, GetTransactionByBlockHashAndIndexMethod, GetTransactionCountMethod, GetTransactionMethod, GetTransactionReceiptMethod, GetWorkMethod, IsMiningMethod, IsSyncingMethod, ListeningMethod, MethodProxy, PeerCountMethod, PromiEvent, RequestAccountsMethod, SendRawTransactionMethod, SendTransactionMethod, SignMethod, SignTransactionMethod, SubmitWorkMethod, TransactionObserver, VersionMethod };