Socket
Socket
Sign inDemoInstall

@ledgerhq/hw-transport-http

Package Overview
Dependencies
Maintainers
12
Versions
382
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@ledgerhq/hw-transport-http - npm Package Compare versions

Comparing version 4.74.2 to 4.74.3-alpha.6

227

lib/HttpTransport.js

@@ -6,15 +6,10 @@ "use strict";

});
exports.default = void 0;
var _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _hwTransport = _interopRequireDefault(require("@ledgerhq/hw-transport"));
var _hwTransport = require("@ledgerhq/hw-transport");
var _hwTransport2 = _interopRequireDefault(_hwTransport);
var _errors = require("@ledgerhq/errors");
var _axios = require("axios");
var _axios = _interopRequireDefault(require("axios"));
var _axios2 = _interopRequireDefault(_axios);
var _logs = require("@ledgerhq/logs");

@@ -24,185 +19,71 @@

function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
/**
* HTTP transport implementation
*/
var HttpTransport = function (_Transport) {
_inherits(HttpTransport, _Transport);
class HttpTransport extends _hwTransport.default {
// this transport is not discoverable
static async open(url, timeout) {
await HttpTransport.check(url, timeout);
return new HttpTransport(url);
}
_createClass(HttpTransport, null, [{
key: "open",
value: function () {
var _ref = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(url, timeout) {
return regeneratorRuntime.wrap(function _callee$(_context) {
while (1) {
switch (_context.prev = _context.next) {
case 0:
_context.next = 2;
return HttpTransport.check(url, timeout);
constructor(url) {
super();
this.url = void 0;
this.url = url;
}
case 2:
return _context.abrupt("return", new HttpTransport(url));
async exchange(apdu) {
const apduHex = apdu.toString("hex");
(0, _logs.log)("apdu", "=> " + apduHex);
const response = await (0, _axios.default)({
method: "POST",
url: this.url,
headers: {
Accept: "application/json",
"Content-Type": "application/json"
},
data: JSON.stringify({
apduHex
})
});
case 3:
case "end":
return _context.stop();
}
}
}, _callee, this);
}));
if (response.status !== 200) {
throw new _errors.TransportError("failed to communicate to server. code=" + response.status, "HttpTransportStatus" + response.status);
}
function open(_x, _x2) {
return _ref.apply(this, arguments);
}
const body = await response.data;
if (body.error) throw body.error;
(0, _logs.log)("apdu", "<= " + body.data);
return Buffer.from(body.data, "hex");
}
return open;
}()
setScrambleKey() {}
// this transport is not discoverable
}]);
function HttpTransport(url) {
_classCallCheck(this, HttpTransport);
var _this = _possibleConstructorReturn(this, (HttpTransport.__proto__ || Object.getPrototypeOf(HttpTransport)).call(this));
_this.url = url;
return _this;
close() {
return Promise.resolve();
}
_createClass(HttpTransport, [{
key: "exchange",
value: function () {
var _ref2 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2(apdu) {
var apduHex, response, body;
return regeneratorRuntime.wrap(function _callee2$(_context2) {
while (1) {
switch (_context2.prev = _context2.next) {
case 0:
apduHex = apdu.toString("hex");
}
(0, _logs.log)("apdu", "=> " + apduHex);
_context2.next = 4;
return (0, _axios2.default)({
method: "POST",
url: this.url,
headers: {
Accept: "application/json",
"Content-Type": "application/json"
},
data: JSON.stringify({ apduHex: apduHex })
});
exports.default = HttpTransport;
case 4:
response = _context2.sent;
HttpTransport.isSupported = () => Promise.resolve(typeof fetch === "function");
if (!(response.status !== 200)) {
_context2.next = 7;
break;
}
HttpTransport.list = () => Promise.resolve([]);
throw new _errors.TransportError("failed to communicate to server. code=" + response.status, "HttpTransportStatus" + response.status);
HttpTransport.listen = _observer => ({
unsubscribe: () => {}
});
case 7:
_context2.next = 9;
return response.data;
HttpTransport.check = async (url, timeout = 5000) => {
const response = await (0, _axios.default)({
url,
timeout
});
case 9:
body = _context2.sent;
if (!body.error) {
_context2.next = 12;
break;
}
throw body.error;
case 12:
(0, _logs.log)("apdu", "<= " + body.data);
return _context2.abrupt("return", Buffer.from(body.data, "hex"));
case 14:
case "end":
return _context2.stop();
}
}
}, _callee2, this);
}));
function exchange(_x3) {
return _ref2.apply(this, arguments);
}
return exchange;
}()
}, {
key: "setScrambleKey",
value: function setScrambleKey() {}
}, {
key: "close",
value: function close() {
return Promise.resolve();
}
}]);
return HttpTransport;
}(_hwTransport2.default);
HttpTransport.isSupported = function () {
return Promise.resolve(typeof fetch === "function");
if (response.status !== 200) {
throw new _errors.TransportError("failed to access HttpTransport(" + url + "): status " + response.status, "HttpTransportNotAccessible");
}
};
HttpTransport.list = function () {
return Promise.resolve([]);
};
HttpTransport.listen = function (_observer) {
return {
unsubscribe: function unsubscribe() {}
};
};
HttpTransport.check = function () {
var _ref3 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee3(url) {
var timeout = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 5000;
var response;
return regeneratorRuntime.wrap(function _callee3$(_context3) {
while (1) {
switch (_context3.prev = _context3.next) {
case 0:
_context3.next = 2;
return (0, _axios2.default)({ url: url, timeout: timeout });
case 2:
response = _context3.sent;
if (!(response.status !== 200)) {
_context3.next = 5;
break;
}
throw new _errors.TransportError("failed to access HttpTransport(" + url + "): status " + response.status, "HttpTransportNotAccessible");
case 5:
case "end":
return _context3.stop();
}
}
}, _callee3, undefined);
}));
return function (_x4) {
return _ref3.apply(this, arguments);
};
}();
exports.default = HttpTransport;
//# sourceMappingURL=HttpTransport.js.map

309

lib/WebSocketTransport.js

@@ -6,9 +6,6 @@ "use strict";

});
exports.default = void 0;
var _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _hwTransport = _interopRequireDefault(require("@ledgerhq/hw-transport"));
var _hwTransport = require("@ledgerhq/hw-transport");
var _hwTransport2 = _interopRequireDefault(_hwTransport);
var _errors = require("@ledgerhq/errors");

@@ -20,12 +17,3 @@

function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var WebSocket = global.WebSocket || require("ws");
const WebSocket = global.WebSocket || require("ws");
/**

@@ -35,229 +23,122 @@ * WebSocket transport implementation

var WebSocketTransport = function (_Transport) {
_inherits(WebSocketTransport, _Transport);
_createClass(WebSocketTransport, null, [{
key: "open",
value: function () {
var _ref = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(url) {
var exchangeMethods;
return regeneratorRuntime.wrap(function _callee$(_context) {
while (1) {
switch (_context.prev = _context.next) {
case 0:
_context.next = 2;
return new Promise(function (resolve, reject) {
try {
var socket = new WebSocket(url);
var _exchangeMethods = {
resolveExchange: function resolveExchange(_b) {},
rejectExchange: function rejectExchange(_e) {},
onDisconnect: function onDisconnect() {},
close: function close() {
return socket.close();
},
send: function send(msg) {
return socket.send(msg);
}
};
socket.onopen = function () {
socket.send("open");
};
socket.onerror = function (e) {
_exchangeMethods.onDisconnect();
reject(e);
};
socket.onclose = function () {
_exchangeMethods.onDisconnect();
reject(new _errors.TransportError("OpenFailed", "OpenFailed"));
};
socket.onmessage = function (e) {
if (typeof e.data !== "string") return;
var data = JSON.parse(e.data);
switch (data.type) {
case "opened":
return resolve(_exchangeMethods);
case "error":
reject(new Error(data.error));
return _exchangeMethods.rejectExchange(new _errors.TransportError(data.error, "WSError"));
case "response":
return _exchangeMethods.resolveExchange(Buffer.from(data.data, "hex"));
}
};
} catch (e) {
reject(e);
}
});
class WebSocketTransport extends _hwTransport.default {
// this transport is not discoverable
static async open(url) {
const exchangeMethods = await new Promise((resolve, reject) => {
try {
const socket = new WebSocket(url);
const exchangeMethods = {
resolveExchange: _b => {},
rejectExchange: _e => {},
onDisconnect: () => {},
close: () => socket.close(),
send: msg => socket.send(msg)
};
case 2:
exchangeMethods = _context.sent;
return _context.abrupt("return", new WebSocketTransport(exchangeMethods));
socket.onopen = () => {
socket.send("open");
};
case 4:
case "end":
return _context.stop();
}
}
}, _callee, this);
}));
socket.onerror = e => {
exchangeMethods.onDisconnect();
reject(e);
};
function open(_x) {
return _ref.apply(this, arguments);
}
socket.onclose = () => {
exchangeMethods.onDisconnect();
reject(new _errors.TransportError("OpenFailed", "OpenFailed"));
};
return open;
}()
socket.onmessage = e => {
if (typeof e.data !== "string") return;
const data = JSON.parse(e.data);
// this transport is not discoverable
switch (data.type) {
case "opened":
return resolve(exchangeMethods);
}]);
case "error":
reject(new Error(data.error));
return exchangeMethods.rejectExchange(new _errors.TransportError(data.error, "WSError"));
function WebSocketTransport(hook) {
_classCallCheck(this, WebSocketTransport);
case "response":
return exchangeMethods.resolveExchange(Buffer.from(data.data, "hex"));
}
};
} catch (e) {
reject(e);
}
});
return new WebSocketTransport(exchangeMethods);
}
var _this = _possibleConstructorReturn(this, (WebSocketTransport.__proto__ || Object.getPrototypeOf(WebSocketTransport)).call(this));
constructor(hook) {
super();
this.hook = void 0;
this.hook = hook;
_this.hook = hook;
hook.onDisconnect = function () {
_this.emit("disconnect");
_this.hook.rejectExchange(new _errors.TransportError("WebSocket disconnected", "WSDisconnect"));
hook.onDisconnect = () => {
this.emit("disconnect");
this.hook.rejectExchange(new _errors.TransportError("WebSocket disconnected", "WSDisconnect"));
};
return _this;
}
_createClass(WebSocketTransport, [{
key: "exchange",
value: function () {
var _ref2 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2(apdu) {
var _this2 = this;
async exchange(apdu) {
const hex = apdu.toString("hex");
(0, _logs.log)("apdu", "=> " + hex);
const res = await new Promise((resolve, reject) => {
this.hook.rejectExchange = e => reject(e);
var hex, res;
return regeneratorRuntime.wrap(function _callee2$(_context2) {
while (1) {
switch (_context2.prev = _context2.next) {
case 0:
hex = apdu.toString("hex");
this.hook.resolveExchange = b => resolve(b);
(0, _logs.log)("apdu", "=> " + hex);
_context2.next = 4;
return new Promise(function (resolve, reject) {
_this2.hook.rejectExchange = function (e) {
return reject(e);
};
_this2.hook.resolveExchange = function (b) {
return resolve(b);
};
_this2.hook.send(hex);
});
this.hook.send(hex);
});
(0, _logs.log)("apdu", "<= " + res.toString("hex"));
return res;
}
case 4:
res = _context2.sent;
setScrambleKey() {}
(0, _logs.log)("apdu", "<= " + res.toString("hex"));
return _context2.abrupt("return", res);
async close() {
this.hook.close();
return new Promise(success => {
setTimeout(success, 200);
});
}
case 7:
case "end":
return _context2.stop();
}
}
}, _callee2, this);
}));
}
function exchange(_x2) {
return _ref2.apply(this, arguments);
}
exports.default = WebSocketTransport;
return exchange;
}()
}, {
key: "setScrambleKey",
value: function setScrambleKey() {}
}, {
key: "close",
value: function () {
var _ref3 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee3() {
return regeneratorRuntime.wrap(function _callee3$(_context3) {
while (1) {
switch (_context3.prev = _context3.next) {
case 0:
this.hook.close();
return _context3.abrupt("return", new Promise(function (success) {
setTimeout(success, 200);
}));
WebSocketTransport.isSupported = () => Promise.resolve(typeof WebSocket === "function");
case 2:
case "end":
return _context3.stop();
}
}
}, _callee3, this);
}));
WebSocketTransport.list = () => Promise.resolve([]);
function close() {
return _ref3.apply(this, arguments);
}
WebSocketTransport.listen = _observer => ({
unsubscribe: () => {}
});
return close;
}()
}]);
WebSocketTransport.check = async (url, timeout = 5000) => new Promise((resolve, reject) => {
const socket = new WebSocket(url);
let success = false;
setTimeout(() => {
socket.close();
}, timeout);
return WebSocketTransport;
}(_hwTransport2.default);
socket.onopen = () => {
success = true;
socket.close();
};
WebSocketTransport.isSupported = function () {
return Promise.resolve(typeof WebSocket === "function");
};
WebSocketTransport.list = function () {
return Promise.resolve([]);
};
WebSocketTransport.listen = function (_observer) {
return {
unsubscribe: function unsubscribe() {}
socket.onclose = () => {
if (success) resolve();else {
reject(new _errors.TransportError("failed to access WebSocketTransport(" + url + ")", "WebSocketTransportNotAccessible"));
}
};
};
WebSocketTransport.check = function () {
var _ref4 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee4(url) {
var timeout = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 5000;
return regeneratorRuntime.wrap(function _callee4$(_context4) {
while (1) {
switch (_context4.prev = _context4.next) {
case 0:
return _context4.abrupt("return", new Promise(function (resolve, reject) {
var socket = new WebSocket(url);
var success = false;
setTimeout(function () {
socket.close();
}, timeout);
socket.onopen = function () {
success = true;
socket.close();
};
socket.onclose = function () {
if (success) resolve();else {
reject(new _errors.TransportError("failed to access WebSocketTransport(" + url + ")", "WebSocketTransportNotAccessible"));
}
};
socket.onerror = function () {
reject(new _errors.TransportError("failed to access WebSocketTransport(" + url + "): error", "WebSocketTransportNotAccessible"));
};
}));
case 1:
case "end":
return _context4.stop();
}
}
}, _callee4, undefined);
}));
return function (_x3) {
return _ref4.apply(this, arguments);
socket.onerror = () => {
reject(new _errors.TransportError("failed to access WebSocketTransport(" + url + "): error", "WebSocketTransportNotAccessible"));
};
}();
exports.default = WebSocketTransport;
});
//# sourceMappingURL=WebSocketTransport.js.map

184

lib/withStaticURLs.js

@@ -6,160 +6,62 @@ "use strict";

});
exports.default = void 0;
var _HttpTransport = require("./HttpTransport");
var _HttpTransport = _interopRequireDefault(require("./HttpTransport"));
var _HttpTransport2 = _interopRequireDefault(_HttpTransport);
var _WebSocketTransport = _interopRequireDefault(require("./WebSocketTransport"));
var _WebSocketTransport = require("./WebSocketTransport");
var _hwTransport = _interopRequireDefault(require("@ledgerhq/hw-transport"));
var _WebSocketTransport2 = _interopRequireDefault(_WebSocketTransport);
var _hwTransport = require("@ledgerhq/hw-transport");
var _hwTransport2 = _interopRequireDefault(_hwTransport);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
const getTransport = url => !url.startsWith("ws") ? _HttpTransport.default : _WebSocketTransport.default;
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
var getTransport = function getTransport(url) {
return !url.startsWith("ws") ? _HttpTransport2.default : _WebSocketTransport2.default;
const inferURLs = async urls => {
const r = await (typeof urls === "function" ? urls() : urls);
return typeof r === "string" ? [r] : r;
};
var inferURLs = function () {
var _ref = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(urls) {
var r;
return regeneratorRuntime.wrap(function _callee$(_context) {
while (1) {
switch (_context.prev = _context.next) {
case 0:
_context.next = 2;
return typeof urls === "function" ? urls() : urls;
var _default = urls => {
class StaticTransport extends _hwTransport.default {}
case 2:
r = _context.sent;
return _context.abrupt("return", typeof r === "string" ? [r] : r);
StaticTransport.isSupported = _HttpTransport.default.isSupported;
case 4:
case "end":
return _context.stop();
}
}
}, _callee, undefined);
}));
StaticTransport.list = () => inferURLs(urls).then(urls => Promise.all(urls.map(url => getTransport(url).check(url).then(() => [url]).catch(() => [])))).then(arrs => arrs.reduce((acc, a) => acc.concat(a), []));
return function inferURLs(_x) {
return _ref.apply(this, arguments);
};
}();
StaticTransport.listen = observer => {
let unsubscribed = false;
const seen = {};
exports.default = function (urls) {
var StaticTransport = function (_Transport) {
_inherits(StaticTransport, _Transport);
function StaticTransport() {
_classCallCheck(this, StaticTransport);
return _possibleConstructorReturn(this, (StaticTransport.__proto__ || Object.getPrototypeOf(StaticTransport)).apply(this, arguments));
}
return StaticTransport;
}(_hwTransport2.default);
StaticTransport.isSupported = _HttpTransport2.default.isSupported;
StaticTransport.list = function () {
return inferURLs(urls).then(function (urls) {
return Promise.all(urls.map(function (url) {
return getTransport(url).check(url).then(function () {
return [url];
}).catch(function () {
return [];
});
}));
}).then(function (arrs) {
return arrs.reduce(function (acc, a) {
return acc.concat(a);
}, []);
});
};
StaticTransport.listen = function (observer) {
var unsubscribed = false;
var seen = {};
function checkLoop() {
var _this2 = this;
if (unsubscribed) return;
inferURLs(urls).then(function (urls) {
return Promise.all(urls.map(function () {
var _ref2 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2(url) {
return regeneratorRuntime.wrap(function _callee2$(_context2) {
while (1) {
switch (_context2.prev = _context2.next) {
case 0:
if (!unsubscribed) {
_context2.next = 2;
break;
}
inferURLs(urls).then(urls => Promise.all(urls.map(async url => {
if (unsubscribed) return;
return _context2.abrupt("return");
try {
await getTransport(url).check(url);
if (unsubscribed) return;
case 2:
_context2.prev = 2;
_context2.next = 5;
return getTransport(url).check(url);
if (!seen[url]) {
seen[url] = 1;
observer.next({
type: "add",
descriptor: url
});
}
} catch (e) {
// nothing
if (seen[url]) {
delete seen[url];
observer.next({
type: "remove",
descriptor: url
});
}
}
}))).then(() => new Promise(success => setTimeout(success, 5000))).then(checkLoop);
}
case 5:
if (!unsubscribed) {
_context2.next = 7;
break;
}
return _context2.abrupt("return");
case 7:
if (!seen[url]) {
seen[url] = 1;
observer.next({ type: "add", descriptor: url });
}
_context2.next = 13;
break;
case 10:
_context2.prev = 10;
_context2.t0 = _context2["catch"](2);
// nothing
if (seen[url]) {
delete seen[url];
observer.next({ type: "remove", descriptor: url });
}
case 13:
case "end":
return _context2.stop();
}
}
}, _callee2, _this2, [[2, 10]]);
}));
return function (_x2) {
return _ref2.apply(this, arguments);
};
}()));
}).then(function () {
return new Promise(function (success) {
return setTimeout(success, 5000);
});
}).then(checkLoop);
}
checkLoop();
return {
unsubscribe: function unsubscribe() {
unsubscribe: () => {
unsubscribed = true;

@@ -170,8 +72,8 @@ }

StaticTransport.open = function (url) {
return getTransport(url).open(url);
};
StaticTransport.open = url => getTransport(url).open(url);
return StaticTransport;
};
exports.default = _default;
//# sourceMappingURL=withStaticURLs.js.map

10

package.json
{
"name": "@ledgerhq/hw-transport-http",
"version": "4.74.2",
"version": "4.74.3-alpha.6+0750e69",
"description": "Ledger Hardware Wallet communication layer over http",

@@ -28,5 +28,5 @@ "keywords": [

"dependencies": {
"@ledgerhq/errors": "^4.74.2",
"@ledgerhq/hw-transport": "^4.74.2",
"@ledgerhq/logs": "^4.72.0",
"@ledgerhq/errors": "^4.74.3-alpha.6+0750e69",
"@ledgerhq/hw-transport": "^4.74.3-alpha.6+0750e69",
"@ledgerhq/logs": "^4.74.3-alpha.6+0750e69",
"axios": "^0.19.0",

@@ -45,3 +45,3 @@ "ws": "6"

},
"gitHead": "5f74b291e1bfd836d23a829a5948f7273af16359"
"gitHead": "0750e6985bbd4a0faec44c9014352a46b094c66e"
}

2

test.js

@@ -1,2 +0,2 @@

require("babel-polyfill");
const wSU = require(".").default;

@@ -3,0 +3,0 @@ 

lib/HttpTransport.js.map

Sorry, the diff of this file is not supported yet

lib/WebSocketTransport.js.map

Sorry, the diff of this file is not supported yet

lib/withStaticURLs.js.map

Sorry, the diff of this file is not supported yet

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc