@parity/api/lib/provider/promise.js

The Parity Promise-based API library for interfacing with Ethereum over RPC

"use strict";
// Copyright 2015-2019 Parity Technologies (UK) Ltd.
// This file is part of Parity.
var __extends = (this && this.__extends) || (function () {
    var extendStatics = function (d, b) {
        extendStatics = Object.setPrototypeOf ||
            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
        return extendStatics(d, b);
    };
    return function (d, b) {
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
})();
// Parity is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// Parity is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with Parity.  If not, see <http://www.gnu.org/licenses/>.
var EventEmitter = require('eventemitter3');
var PromiseProvider = /** @class */ (function (_super) {
    __extends(PromiseProvider, _super);
    function PromiseProvider(provider) {
        var _this = _super.call(this) || this;
        _this.provider = provider;
        _this.provider.on('connected', function () { return _this.emit('connected'); });
        _this.provider.on('connecting', function () { return _this.emit('connecting'); });
        _this.provider.on('disconnected', function () { return _this.emit('disconnected'); });
        _this.send = _this.send.bind(_this);
        return _this;
    }
    Object.defineProperty(PromiseProvider.prototype, "isConnected", {
        get: function () {
            return this.provider.isConnected;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(PromiseProvider.prototype, "isParity", {
        get: function () {
            return !!this.provider.isParity;
        },
        enumerable: true,
        configurable: true
    });
    PromiseProvider.prototype.send = function (method) {
        var _this = this;
        var params = [];
        for (var _i = 1; _i < arguments.length; _i++) {
            params[_i - 1] = arguments[_i];
        }
        if (!this.provider.send) {
            // old-style transport interface for backwards compatibility
            return this.provider.execute(method, params);
        }
        return new Promise(function (resolve, reject) {
            _this.provider.send(method, params, function (error, result) {
                if (error) {
                    reject(error);
                }
                else {
                    resolve(result);
                }
            });
        });
    };
    return PromiseProvider;
}(EventEmitter));
module.exports = PromiseProvider;