@onekeyfe/blockchain-link
Version:
High-level javascript interface for blockchain communication
1,416 lines (1,331 loc) • 184 kB
JavaScript
(function webpackUniversalModuleDefinition(root, factory) {
if(typeof exports === 'object' && typeof module === 'object')
module.exports = factory();
else if(typeof define === 'function' && define.amd)
define([], factory);
else if(typeof exports === 'object')
exports["BlockchainLinkWorker"] = factory();
else
root["BlockchainLinkWorker"] = factory();
})(window, function() {
return /******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId]) {
/******/ return installedModules[moduleId].exports;
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ i: moduleId,
/******/ l: false,
/******/ exports: {}
/******/ };
/******/
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ // Flag the module as loaded
/******/ module.l = true;
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/******/
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/
/******/ // define getter function for harmony exports
/******/ __webpack_require__.d = function(exports, name, getter) {
/******/ if(!__webpack_require__.o(exports, name)) {
/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter });
/******/ }
/******/ };
/******/
/******/ // define __esModule on exports
/******/ __webpack_require__.r = function(exports) {
/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ }
/******/ Object.defineProperty(exports, '__esModule', { value: true });
/******/ };
/******/
/******/ // create a fake namespace object
/******/ // mode & 1: value is a module id, require it
/******/ // mode & 2: merge all properties of value into the ns
/******/ // mode & 4: return value when already ns object
/******/ // mode & 8|1: behave like require
/******/ __webpack_require__.t = function(value, mode) {
/******/ if(mode & 1) value = __webpack_require__(value);
/******/ if(mode & 8) return value;
/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
/******/ var ns = Object.create(null);
/******/ __webpack_require__.r(ns);
/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value });
/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
/******/ return ns;
/******/ };
/******/
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/ __webpack_require__.n = function(module) {
/******/ var getter = module && module.__esModule ?
/******/ function getDefault() { return module['default']; } :
/******/ function getModuleExports() { return module; };
/******/ __webpack_require__.d(getter, 'a', getter);
/******/ return getter;
/******/ };
/******/
/******/ // Object.prototype.hasOwnProperty.call
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "./";
/******/
/******/
/******/ // Load entry module and return exports
/******/ return __webpack_require__(__webpack_require__.s = 159);
/******/ })
/************************************************************************/
/******/ ({
/***/ 14:
/***/ (function(module, exports, __webpack_require__) {
"use strict";
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
var R = typeof Reflect === 'object' ? Reflect : null
var ReflectApply = R && typeof R.apply === 'function'
? R.apply
: function ReflectApply(target, receiver, args) {
return Function.prototype.apply.call(target, receiver, args);
}
var ReflectOwnKeys
if (R && typeof R.ownKeys === 'function') {
ReflectOwnKeys = R.ownKeys
} else if (Object.getOwnPropertySymbols) {
ReflectOwnKeys = function ReflectOwnKeys(target) {
return Object.getOwnPropertyNames(target)
.concat(Object.getOwnPropertySymbols(target));
};
} else {
ReflectOwnKeys = function ReflectOwnKeys(target) {
return Object.getOwnPropertyNames(target);
};
}
function ProcessEmitWarning(warning) {
if (console && console.warn) console.warn(warning);
}
var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {
return value !== value;
}
function EventEmitter() {
EventEmitter.init.call(this);
}
module.exports = EventEmitter;
module.exports.once = once;
// Backwards-compat with node 0.10.x
EventEmitter.EventEmitter = EventEmitter;
EventEmitter.prototype._events = undefined;
EventEmitter.prototype._eventsCount = 0;
EventEmitter.prototype._maxListeners = undefined;
// By default EventEmitters will print a warning if more than 10 listeners are
// added to it. This is a useful default which helps finding memory leaks.
var defaultMaxListeners = 10;
function checkListener(listener) {
if (typeof listener !== 'function') {
throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
}
}
Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
enumerable: true,
get: function() {
return defaultMaxListeners;
},
set: function(arg) {
if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {
throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + '.');
}
defaultMaxListeners = arg;
}
});
EventEmitter.init = function() {
if (this._events === undefined ||
this._events === Object.getPrototypeOf(this)._events) {
this._events = Object.create(null);
this._eventsCount = 0;
}
this._maxListeners = this._maxListeners || undefined;
};
// Obviously not all Emitters should be limited to 10. This function allows
// that to be increased. Set to zero for unlimited.
EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {
throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + '.');
}
this._maxListeners = n;
return this;
};
function _getMaxListeners(that) {
if (that._maxListeners === undefined)
return EventEmitter.defaultMaxListeners;
return that._maxListeners;
}
EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
return _getMaxListeners(this);
};
EventEmitter.prototype.emit = function emit(type) {
var args = [];
for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
var doError = (type === 'error');
var events = this._events;
if (events !== undefined)
doError = (doError && events.error === undefined);
else if (!doError)
return false;
// If there is no 'error' event listener then throw.
if (doError) {
var er;
if (args.length > 0)
er = args[0];
if (er instanceof Error) {
// Note: The comments on the `throw` lines are intentional, they show
// up in Node's output if this results in an unhandled exception.
throw er; // Unhandled 'error' event
}
// At least give some kind of context to the user
var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));
err.context = er;
throw err; // Unhandled 'error' event
}
var handler = events[type];
if (handler === undefined)
return false;
if (typeof handler === 'function') {
ReflectApply(handler, this, args);
} else {
var len = handler.length;
var listeners = arrayClone(handler, len);
for (var i = 0; i < len; ++i)
ReflectApply(listeners[i], this, args);
}
return true;
};
function _addListener(target, type, listener, prepend) {
var m;
var events;
var existing;
checkListener(listener);
events = target._events;
if (events === undefined) {
events = target._events = Object.create(null);
target._eventsCount = 0;
} else {
// To avoid recursion in the case that type === "newListener"! Before
// adding it to the listeners, first emit "newListener".
if (events.newListener !== undefined) {
target.emit('newListener', type,
listener.listener ? listener.listener : listener);
// Re-assign `events` because a newListener handler could have caused the
// this._events to be assigned to a new object
events = target._events;
}
existing = events[type];
}
if (existing === undefined) {
// Optimize the case of one listener. Don't need the extra array object.
existing = events[type] = listener;
++target._eventsCount;
} else {
if (typeof existing === 'function') {
// Adding the second element, need to change to array.
existing = events[type] =
prepend ? [listener, existing] : [existing, listener];
// If we've already got an array, just append.
} else if (prepend) {
existing.unshift(listener);
} else {
existing.push(listener);
}
// Check for listener leak
m = _getMaxListeners(target);
if (m > 0 && existing.length > m && !existing.warned) {
existing.warned = true;
// No error code for this since it is a Warning
// eslint-disable-next-line no-restricted-syntax
var w = new Error('Possible EventEmitter memory leak detected. ' +
existing.length + ' ' + String(type) + ' listeners ' +
'added. Use emitter.setMaxListeners() to ' +
'increase limit');
w.name = 'MaxListenersExceededWarning';
w.emitter = target;
w.type = type;
w.count = existing.length;
ProcessEmitWarning(w);
}
}
return target;
}
EventEmitter.prototype.addListener = function addListener(type, listener) {
return _addListener(this, type, listener, false);
};
EventEmitter.prototype.on = EventEmitter.prototype.addListener;
EventEmitter.prototype.prependListener =
function prependListener(type, listener) {
return _addListener(this, type, listener, true);
};
function onceWrapper() {
if (!this.fired) {
this.target.removeListener(this.type, this.wrapFn);
this.fired = true;
if (arguments.length === 0)
return this.listener.call(this.target);
return this.listener.apply(this.target, arguments);
}
}
function _onceWrap(target, type, listener) {
var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };
var wrapped = onceWrapper.bind(state);
wrapped.listener = listener;
state.wrapFn = wrapped;
return wrapped;
}
EventEmitter.prototype.once = function once(type, listener) {
checkListener(listener);
this.on(type, _onceWrap(this, type, listener));
return this;
};
EventEmitter.prototype.prependOnceListener =
function prependOnceListener(type, listener) {
checkListener(listener);
this.prependListener(type, _onceWrap(this, type, listener));
return this;
};
// Emits a 'removeListener' event if and only if the listener was removed.
EventEmitter.prototype.removeListener =
function removeListener(type, listener) {
var list, events, position, i, originalListener;
checkListener(listener);
events = this._events;
if (events === undefined)
return this;
list = events[type];
if (list === undefined)
return this;
if (list === listener || list.listener === listener) {
if (--this._eventsCount === 0)
this._events = Object.create(null);
else {
delete events[type];
if (events.removeListener)
this.emit('removeListener', type, list.listener || listener);
}
} else if (typeof list !== 'function') {
position = -1;
for (i = list.length - 1; i >= 0; i--) {
if (list[i] === listener || list[i].listener === listener) {
originalListener = list[i].listener;
position = i;
break;
}
}
if (position < 0)
return this;
if (position === 0)
list.shift();
else {
spliceOne(list, position);
}
if (list.length === 1)
events[type] = list[0];
if (events.removeListener !== undefined)
this.emit('removeListener', type, originalListener || listener);
}
return this;
};
EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
EventEmitter.prototype.removeAllListeners =
function removeAllListeners(type) {
var listeners, events, i;
events = this._events;
if (events === undefined)
return this;
// not listening for removeListener, no need to emit
if (events.removeListener === undefined) {
if (arguments.length === 0) {
this._events = Object.create(null);
this._eventsCount = 0;
} else if (events[type] !== undefined) {
if (--this._eventsCount === 0)
this._events = Object.create(null);
else
delete events[type];
}
return this;
}
// emit removeListener for all listeners on all events
if (arguments.length === 0) {
var keys = Object.keys(events);
var key;
for (i = 0; i < keys.length; ++i) {
key = keys[i];
if (key === 'removeListener') continue;
this.removeAllListeners(key);
}
this.removeAllListeners('removeListener');
this._events = Object.create(null);
this._eventsCount = 0;
return this;
}
listeners = events[type];
if (typeof listeners === 'function') {
this.removeListener(type, listeners);
} else if (listeners !== undefined) {
// LIFO order
for (i = listeners.length - 1; i >= 0; i--) {
this.removeListener(type, listeners[i]);
}
}
return this;
};
function _listeners(target, type, unwrap) {
var events = target._events;
if (events === undefined)
return [];
var evlistener = events[type];
if (evlistener === undefined)
return [];
if (typeof evlistener === 'function')
return unwrap ? [evlistener.listener || evlistener] : [evlistener];
return unwrap ?
unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
}
EventEmitter.prototype.listeners = function listeners(type) {
return _listeners(this, type, true);
};
EventEmitter.prototype.rawListeners = function rawListeners(type) {
return _listeners(this, type, false);
};
EventEmitter.listenerCount = function(emitter, type) {
if (typeof emitter.listenerCount === 'function') {
return emitter.listenerCount(type);
} else {
return listenerCount.call(emitter, type);
}
};
EventEmitter.prototype.listenerCount = listenerCount;
function listenerCount(type) {
var events = this._events;
if (events !== undefined) {
var evlistener = events[type];
if (typeof evlistener === 'function') {
return 1;
} else if (evlistener !== undefined) {
return evlistener.length;
}
}
return 0;
}
EventEmitter.prototype.eventNames = function eventNames() {
return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
};
function arrayClone(arr, n) {
var copy = new Array(n);
for (var i = 0; i < n; ++i)
copy[i] = arr[i];
return copy;
}
function spliceOne(list, index) {
for (; index + 1 < list.length; index++)
list[index] = list[index + 1];
list.pop();
}
function unwrapListeners(arr) {
var ret = new Array(arr.length);
for (var i = 0; i < ret.length; ++i) {
ret[i] = arr[i].listener || arr[i];
}
return ret;
}
function once(emitter, name) {
return new Promise(function (resolve, reject) {
function eventListener() {
if (errorListener !== undefined) {
emitter.removeListener('error', errorListener);
}
resolve([].slice.call(arguments));
};
var errorListener;
// Adding an error listener is not optional because
// if an error is thrown on an event emitter we cannot
// guarantee that the actual event we are waiting will
// be fired. The result could be a silent way to create
// memory or file descriptor leaks, which is something
// we should avoid.
if (name !== 'error') {
errorListener = function errorListener(err) {
emitter.removeListener(name, eventListener);
reject(err);
};
emitter.once('error', errorListener);
}
emitter.once(name, eventListener);
});
}
/***/ }),
/***/ 159:
/***/ (function(module, exports, __webpack_require__) {
// BlockchainLinkWorker: wrap whole worker file into function to allow multiple initializations
function initModule(postFn) {
// create missing references for worker globals
var onmessage;
var postMessage = postFn;
// worker content start
"use strict";
var __assign = (this && this.__assign) || function () {
__assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
var errors_1 = __webpack_require__(24);
var constants_1 = __webpack_require__(41);
var websocket_1 = __importDefault(__webpack_require__(160));
var utils = __importStar(__webpack_require__(163));
var common_1 = __importDefault(__webpack_require__(61));
var common = new common_1.default(postMessage);
var api;
var endpoints = [];
var cleanup = function () {
if (api) {
api.dispose();
api.removeAllListeners();
api = undefined;
}
endpoints = [];
common.removeAccounts(common.getAccounts());
common.removeAddresses(common.getAddresses());
common.clearSubscriptions();
};
var connect = function () { return __awaiter(void 0, void 0, void 0, function () {
var _a, server, timeout, pingTimeout, keepAlive, connection, error_1;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
if (api && api.isConnected())
return [2, api];
_a = common.getSettings(), server = _a.server, timeout = _a.timeout, pingTimeout = _a.pingTimeout, keepAlive = _a.keepAlive;
if (!server || !Array.isArray(server) || server.length < 1) {
throw new errors_1.CustomError('connect', 'Endpoint not set');
}
if (endpoints.length < 1) {
endpoints = common.shuffleEndpoints(server.slice(0));
}
common.debug('Connecting to', endpoints[0]);
connection = new websocket_1.default({
url: endpoints[0],
timeout: timeout,
pingTimeout: pingTimeout,
keepAlive: keepAlive,
});
_b.label = 1;
case 1:
_b.trys.push([1, 3, , 4]);
return [4, connection.connect()];
case 2:
_b.sent();
api = connection;
return [3, 4];
case 3:
error_1 = _b.sent();
common.debug('Websocket connection failed');
api = undefined;
endpoints.splice(0, 1);
if (endpoints.length < 1) {
throw new errors_1.CustomError('connect', 'All backends are down');
}
return [2, connect()];
case 4:
connection.on('disconnected', function () {
common.response({ id: -1, type: constants_1.RESPONSES.DISCONNECTED, payload: true });
cleanup();
});
common.response({
id: -1,
type: constants_1.RESPONSES.CONNECTED,
});
common.debug('Connected');
return [2, connection];
}
});
}); };
var getInfo = function (data) { return __awaiter(void 0, void 0, void 0, function () {
var socket, info, error_2;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
_a.trys.push([0, 3, , 4]);
return [4, connect()];
case 1:
socket = _a.sent();
return [4, socket.getServerInfo()];
case 2:
info = _a.sent();
common.response({
id: data.id,
type: constants_1.RESPONSES.GET_INFO,
payload: __assign({ url: socket.options.url }, utils.transformServerInfo(info)),
});
return [3, 4];
case 3:
error_2 = _a.sent();
common.errorHandler({ id: data.id, error: error_2 });
return [3, 4];
case 4: return [2];
}
});
}); };
var getBlockHash = function (data) { return __awaiter(void 0, void 0, void 0, function () {
var socket, info, error_3;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
_a.trys.push([0, 3, , 4]);
return [4, connect()];
case 1:
socket = _a.sent();
return [4, socket.getBlockHash(data.payload)];
case 2:
info = _a.sent();
common.response({
id: data.id,
type: constants_1.RESPONSES.GET_BLOCK_HASH,
payload: info.hash,
});
return [3, 4];
case 3:
error_3 = _a.sent();
common.errorHandler({ id: data.id, error: error_3 });
return [3, 4];
case 4: return [2];
}
});
}); };
var getAccountInfo = function (data) { return __awaiter(void 0, void 0, void 0, function () {
var payload, socket, info, error_4;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
payload = data.payload;
_a.label = 1;
case 1:
_a.trys.push([1, 4, , 5]);
return [4, connect()];
case 2:
socket = _a.sent();
return [4, socket.getAccountInfo(payload)];
case 3:
info = _a.sent();
common.response({
id: data.id,
type: constants_1.RESPONSES.GET_ACCOUNT_INFO,
payload: utils.transformAccountInfo(info),
});
return [3, 5];
case 4:
error_4 = _a.sent();
common.errorHandler({ id: data.id, error: error_4 });
return [3, 5];
case 5: return [2];
}
});
}); };
var getAccountUtxo = function (data) { return __awaiter(void 0, void 0, void 0, function () {
var payload, socket, utxos, error_5;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
payload = data.payload;
_a.label = 1;
case 1:
_a.trys.push([1, 4, , 5]);
return [4, connect()];
case 2:
socket = _a.sent();
return [4, socket.getAccountUtxo(payload)];
case 3:
utxos = _a.sent();
common.response({
id: data.id,
type: constants_1.RESPONSES.GET_ACCOUNT_UTXO,
payload: utils.transformAccountUtxo(utxos),
});
return [3, 5];
case 4:
error_5 = _a.sent();
common.errorHandler({ id: data.id, error: error_5 });
return [3, 5];
case 5: return [2];
}
});
}); };
var getAccountBalanceHistory = function (data) { return __awaiter(void 0, void 0, void 0, function () {
var payload, socket, history_1, error_6;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
payload = data.payload;
_a.label = 1;
case 1:
_a.trys.push([1, 4, , 5]);
return [4, connect()];
case 2:
socket = _a.sent();
return [4, socket.getAccountBalanceHistory(payload)];
case 3:
history_1 = _a.sent();
common.response({
id: data.id,
type: constants_1.RESPONSES.GET_ACCOUNT_BALANCE_HISTORY,
payload: history_1,
});
return [3, 5];
case 4:
error_6 = _a.sent();
common.errorHandler({ id: data.id, error: error_6 });
return [3, 5];
case 5: return [2];
}
});
}); };
var getCurrentFiatRates = function (data) { return __awaiter(void 0, void 0, void 0, function () {
var payload, socket, fiatRates, error_7;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
payload = data.payload;
_a.label = 1;
case 1:
_a.trys.push([1, 4, , 5]);
return [4, connect()];
case 2:
socket = _a.sent();
return [4, socket.getCurrentFiatRates(payload)];
case 3:
fiatRates = _a.sent();
common.response({
id: data.id,
type: constants_1.RESPONSES.GET_CURRENT_FIAT_RATES,
payload: fiatRates,
});
return [3, 5];
case 4:
error_7 = _a.sent();
common.errorHandler({ id: data.id, error: error_7 });
return [3, 5];
case 5: return [2];
}
});
}); };
var getFiatRatesForTimestamps = function (data) { return __awaiter(void 0, void 0, void 0, function () {
var payload, socket, tickers, error_8;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
payload = data.payload;
_a.label = 1;
case 1:
_a.trys.push([1, 4, , 5]);
return [4, connect()];
case 2:
socket = _a.sent();
return [4, socket.getFiatRatesForTimestamps(payload)];
case 3:
tickers = (_a.sent()).tickers;
common.response({
id: data.id,
type: constants_1.RESPONSES.GET_FIAT_RATES_FOR_TIMESTAMPS,
payload: { tickers: tickers },
});
return [3, 5];
case 4:
error_8 = _a.sent();
common.errorHandler({ id: data.id, error: error_8 });
return [3, 5];
case 5: return [2];
}
});
}); };
var getFiatRatesTickersList = function (data) { return __awaiter(void 0, void 0, void 0, function () {
var payload, socket, tickers, error_9;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
payload = data.payload;
_a.label = 1;
case 1:
_a.trys.push([1, 4, , 5]);
return [4, connect()];
case 2:
socket = _a.sent();
return [4, socket.getFiatRatesTickersList(payload)];
case 3:
tickers = _a.sent();
common.response({
id: data.id,
type: constants_1.RESPONSES.GET_FIAT_RATES_TICKERS_LIST,
payload: {
ts: tickers.ts,
availableCurrencies: tickers.available_currencies,
},
});
return [3, 5];
case 4:
error_9 = _a.sent();
common.errorHandler({ id: data.id, error: error_9 });
return [3, 5];
case 5: return [2];
}
});
}); };
var getTransaction = function (data) { return __awaiter(void 0, void 0, void 0, function () {
var payload, socket, tx, error_10;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
payload = data.payload;
_a.label = 1;
case 1:
_a.trys.push([1, 4, , 5]);
return [4, connect()];
case 2:
socket = _a.sent();
return [4, socket.getTransaction(payload)];
case 3:
tx = _a.sent();
common.response({
id: data.id,
type: constants_1.RESPONSES.GET_TRANSACTION,
payload: {
type: 'blockbook',
tx: tx,
},
});
return [3, 5];
case 4:
error_10 = _a.sent();
common.errorHandler({ id: data.id, error: error_10 });
return [3, 5];
case 5: return [2];
}
});
}); };
var pushTransaction = function (data) { return __awaiter(void 0, void 0, void 0, function () {
var socket, resp, error_11;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
_a.trys.push([0, 3, , 4]);
return [4, connect()];
case 1:
socket = _a.sent();
return [4, socket.pushTransaction(data.payload)];
case 2:
resp = _a.sent();
common.response({
id: data.id,
type: constants_1.RESPONSES.PUSH_TRANSACTION,
payload: resp.result,
});
return [3, 4];
case 3:
error_11 = _a.sent();
common.errorHandler({ id: data.id, error: error_11 });
return [3, 4];
case 4: return [2];
}
});
}); };
var estimateFee = function (data) { return __awaiter(void 0, void 0, void 0, function () {
var socket, resp, error_12;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
_a.trys.push([0, 3, , 4]);
return [4, connect()];
case 1:
socket = _a.sent();
return [4, socket.estimateFee(data.payload)];
case 2:
resp = _a.sent();
common.response({
id: data.id,
type: constants_1.RESPONSES.ESTIMATE_FEE,
payload: resp,
});
return [3, 4];
case 3:
error_12 = _a.sent();
common.errorHandler({ id: data.id, error: error_12 });
return [3, 4];
case 4: return [2];
}
});
}); };
var onNewBlock = function (event) {
common.response({
id: -1,
type: constants_1.RESPONSES.NOTIFICATION,
payload: {
type: 'block',
payload: {
blockHeight: event.height,
blockHash: event.hash,
},
},
});
};
var onTransaction = function (event) {
if (!event.tx)
return;
var descriptor = event.address;
var account = common.getAccount(descriptor);
common.response({
id: -1,
type: constants_1.RESPONSES.NOTIFICATION,
payload: {
type: 'notification',
payload: {
descriptor: account ? account.descriptor : descriptor,
tx: account
? utils.transformTransaction(account.descriptor, account.addresses, event.tx)
: utils.transformTransaction(descriptor, undefined, event.tx),
},
},
});
};
var onNewFiatRates = function (event) {
common.response({
id: -1,
type: constants_1.RESPONSES.NOTIFICATION,
payload: {
type: 'fiatRates',
payload: {
rates: event.rates,
},
},
});
};
var subscribeAccounts = function (accounts) { return __awaiter(void 0, void 0, void 0, function () {
var socket;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
common.addAccounts(accounts);
return [4, connect()];
case 1:
socket = _a.sent();
if (!common.getSubscription('notification')) {
socket.on('notification', onTransaction);
common.addSubscription('notification');
}
return [2, socket.subscribeAddresses(common.getAddresses())];
}
});
}); };
var subscribeAddresses = function (addresses) { return __awaiter(void 0, void 0, void 0, function () {
var socket;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
common.addAddresses(addresses);
return [4, connect()];
case 1:
socket = _a.sent();
if (!common.getSubscription('notification')) {
socket.on('notification', onTransaction);
common.addSubscription('notification');
}
return [2, socket.subscribeAddresses(common.getAddresses())];
}
});
}); };
var subscribeBlock = function () { return __awaiter(void 0, void 0, void 0, function () {
var socket;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (common.getSubscription('block'))
return [2, { subscribed: true }];
return [4, connect()];
case 1:
socket = _a.sent();
common.addSubscription('block');
socket.on('block', onNewBlock);
return [2, socket.subscribeBlock()];
}
});
}); };
var subscribeFiatRates = function (currency) { return __awaiter(void 0, void 0, void 0, function () {
var socket;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4, connect()];
case 1:
socket = _a.sent();
if (!common.getSubscription('fiatRates')) {
common.addSubscription('fiatRates');
socket.on('fiatRates', onNewFiatRates);
}
return [2, socket.subscribeFiatRates(currency)];
}
});
}); };
var subscribe = function (data) { return __awaiter(void 0, void 0, void 0, function () {
var payload, response, error_13;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
payload = data.payload;
_a.label = 1;
case 1:
_a.trys.push([1, 11, , 12]);
response = void 0;
if (!(payload.type === 'accounts')) return [3, 3];
return [4, subscribeAccounts(payload.accounts)];
case 2:
response = _a.sent();
return [3, 10];
case 3:
if (!(payload.type === 'addresses')) return [3, 5];
return [4, subscribeAddresses(payload.addresses)];
case 4:
response = _a.sent();
return [3, 10];
case 5:
if (!(payload.type === 'block')) return [3, 7];
return [4, subscribeBlock()];
case 6:
response = _a.sent();
return [3, 10];
case 7:
if (!(payload.type === 'fiatRates')) return [3, 9];
return [4, subscribeFiatRates(payload.currency)];
case 8:
response = _a.sent();
return [3, 10];
case 9: throw new errors_1.CustomError('invalid_param', '+type');
case 10:
common.response({
id: data.id,
type: constants_1.RESPONSES.SUBSCRIBE,
payload: response,
});
return [3, 12];
case 11:
error_13 = _a.sent();
common.errorHandler({ id: data.id, error: error_13 });
return [3, 12];
case 12: return [2];
}
});
}); };
var unsubscribeAccounts = function (accounts) { return __awaiter(void 0, void 0, void 0, function () {
var socket, subscribed;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
common.removeAccounts(accounts || common.getAccounts());
return [4, connect()];
case 1:
socket = _a.sent();
subscribed = common.getAddresses();
if (subscribed.length < 1) {
socket.removeListener('notification', onTransaction);
common.removeSubscription('notification');
return [2, socket.unsubscribeAddresses()];
}
return [2, socket.subscribeAddresses(subscribed)];
}
});
}); };
var unsubscribeAddresses = function (addresses) { return __awaiter(void 0, void 0, void 0, function () {
var socket, subscribed;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4, connect()];
case 1:
socket = _a.sent();
if (!addresses) {
common.removeAccounts(common.getAccounts());
}
subscribed = common.removeAddresses(addresses || common.getAddresses());
if (subscribed.length < 1) {
socket.removeListener('notification', onTransaction);
common.removeSubscription('notification');
return [2, socket.unsubscribeAddresses()];
}
return [2, socket.subscribeAddresses(subscribed)];
}
});
}); };
var unsubscribeBlock = function () { return __awaiter(void 0, void 0, void 0, function () {
var socket;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (!common.getSubscription('block'))
return [2, { subscribed: false }];
return [4, connect()];
case 1:
socket = _a.sent();
socket.removeListener('block', onNewBlock);
common.removeSubscription('block');
return [2, socket.unsubscribeBlock()];
}
});
}); };
var unsubscribeFiatRates = function () { return __awaiter(void 0, void 0, void 0, function () {
var socket;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (!common.getSubscription('fiatRates'))
return [2, { subscribed: false }];
return [4, connect()];
case 1:
socket = _a.sent();
socket.removeListener('fiatRates', onNewBlock);
common.removeSubscription('fiatRates');
return [2, socket.unsubscribeFiatRates()];
}
});
}); };
var unsubscribe = function (data) { return __awaiter(void 0, void 0, void 0, function () {
var payload, response, error_14;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
payload = data.payload;
_a.label = 1;
case 1:
_a.trys.push([1, 11, , 12]);
response = void 0;
if (!(payload.type === 'accounts')) return [3, 3];
return [4, unsubscribeAccounts(payload.accounts)];
case 2:
response = _a.sent();
return [3, 10];
case 3:
if (!(payload.type === 'addresses')) return [3, 5];
return [4, unsubscribeAddresses(payload.addresses)];
case 4:
response = _a.sent();
return [3, 10];
case 5:
if (!(payload.type === 'block')) return [3, 7];
return [4, unsubscribeBlock()];
case 6:
response = _a.sent();
return [3, 10];
case 7:
if (!(payload.type === 'fiatRates')) return [3, 9];
return [4, unsubscribeFiatRates()];
case 8:
response = _a.sent();
return [3, 10];
case 9: throw new errors_1.CustomError('invalid_param', '+type');
case 10:
common.response({
id: data.id,
type: constants_1.RESPONSES.UNSUBSCRIBE,
payload: response,
});
return [3, 12];
case 11:
error_14 = _a.sent();
common.errorHandler({ id: data.id, error: error_14 });
return [3, 12];
case 12: return [2];
}
});
}); };
var disconnect = function (data) { return __awaiter(void 0, void 0, void 0, function () {
var error_15;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (!api) {
common.response({ id: data.id, type: constants_1.RESPONSES.DISCONNECTED, payload: true });
return [2];
}
_a.label = 1;
case 1:
_a.trys.push([1, 3, , 4]);
return [4, api.disconnect()];
case 2:
_a.sent();
common.response({ id: data.id, type: constants_1.RESPONSES.DISCONNECTED, payload: true });
return [3, 4];
case 3:
error_15 = _a.sent();
common.errorHandler({ id: data.id, error: error_15 });
return [3, 4];
case 4: return [2];
}
});
}); };
onmessage = function (event) {
if (!event.data)
return;
var data = event.data;
var id = data.id, type = data.type;
common.debug('onmessage', data);
switch (data.type) {
case constants_1.MESSAGES.HANDSHAKE:
common.setSettings(data.settings);
break;
case constants_1.MESSAGES.CONNECT:
connect()
.then(function () {
common.response({ id: id, type: constants_1.RESPONSES.CONNECT, payload: true });
})
.catch(function (error) { return common.errorHandler({ id: id, error: error }); });
break;
case constants_1.MESSAGES.GET_INFO:
getInfo(data);
break;
case constants_1.MESSAGES.GET_BLOCK_HASH:
getBlockHash(data);
break;
case constants_1.MESSAGES.GET_ACCOUNT_INFO:
getAccountInfo(data);
break;
case constants_1.MESSAGES.GET_ACCOUNT_UTXO:
getAccountUtxo(data);
break;
case constants_1.MESSAGES.GET_TRANSACTION:
getTransaction(data);
break;
case constants_1.MESSAGES.GET_ACCOUNT_BALANCE_HISTORY:
getAccountBalanceHistory(data);
break;
case constants_1.MESSAGES.GET_CURRENT_FIAT_RATES:
getCurrentFiatRates(data);
break;
case constants_1.MESSAGES.GET_FIAT_RATES_FOR_TIMESTAMPS:
getFiatRatesForTimestamps(data);
break;
case constants_1.MESSAGES.GET_FIAT_RATES_TICKERS_LIST:
getFiatRatesTickersList(data);
break;
case constants_1.MESSAGES.ESTIMATE_FEE:
estimateFee(data);
break;
case constants_1.MESSAGES.PUSH_TRANSACTION:
pushTransaction(data);
break;
case constants_1.MESSAGES.SUBSCRIBE:
subscribe(data);
break;
case constants_1.MESSAGES.UNSUBSCRIBE:
unsubscribe(data);
break;
case constants_1.MESSAGES.DISCONNECT:
disconnect(data);
break;
case 'terminate':
cleanup();
break;
default:
common.errorHandler({
id: id,
error: new err