@nostrwatch/route66 0.0.1

package/dist/node/services/MonitorService.js

@@ -0,0 +1,1020 @@
+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 (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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 __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 = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["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 (g && (g = 0, op[0] && (_ = 0)), _) 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 __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { defaultWebsocketAdapterOptions } from '../core/WebsocketAdapter';
+import { MonitorManager } from '../managers/MonitorManager';
+import { Service } from './Service';
+import { StateManager } from '../managers/StateManager';
+var MonitorService = /** @class */ (function (_super) {
+    __extends(MonitorService, _super);
+    function MonitorService(adapters) {
+        var _this = _super.call(this, adapters) || this;
+        _this.DEFAULT_ENABLED_MONITORS = 3;
+        _this._manager = MonitorManager.getInstance();
+        _this.addRelay('route66', 'wss://relay.nostr.watch');
+        _this.addRelay('route66', 'wss://relaypag.es');
+        _this.addRelay('route66', 'wss://monitorlizard.nostr1.com/');
+        _this.addRelay('userMeta', 'wss://purplepag.es');
+        _this.addRelay('userMeta', 'wss://user.kindpag.es');
+        _this.addRelay('userMeta', 'wss://relay.nostr.band');
+        _this.init();
+        return _this;
+    }
+    MonitorService.prototype.init = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: 
+                    ////console.log('MonitorService init');
+                    return [4 /*yield*/, ((_a = this === null || this === void 0 ? void 0 : this.cacheAdapter) === null || _a === void 0 ? void 0 : _a.ready())];
+                    case 1:
+                        ////console.log('MonitorService init');
+                        _b.sent();
+                        ////console.log('cacheadapter ready')
+                        this._ready = true;
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    MonitorService.prototype.ready = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!!this._ready) return [3 /*break*/, 2];
+                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 100); })];
+                    case 1:
+                        _a.sent();
+                        return [3 /*break*/, 0];
+                    case 2: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Object.defineProperty(MonitorService.prototype, "manager", {
+        get: function () {
+            return this._manager;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MonitorService.prototype, "monitors", {
+        get: function () {
+            return this.manager.monitorsMap;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MonitorService.prototype, "array", {
+        get: function () {
+            return this.manager.array;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MonitorService.prototype, "map", {
+        get: function () {
+            return this.manager.monitorsMap;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MonitorService.prototype, "sortedMonitors", {
+        get: function () {
+            return this.manager.sortedMonitors;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MonitorService.prototype, "enabledMonitors", {
+        get: function () {
+            return this.manager.enabledMonitors;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MonitorService.prototype, "activeEnabledMonitors", {
+        get: function () {
+            return this.manager.enabledActiveMonitors;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MonitorService.prototype, "disabledMonitors", {
+        get: function () {
+            return this.manager.disabledMonitors;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MonitorService.prototype, "disabledActiveMonitors", {
+        get: function () {
+            return this.manager.disabledActiveMonitors;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MonitorService.prototype, "disabledInactiveMonitors", {
+        get: function () {
+            return this.manager.disabledInactiveMonitors;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(MonitorService.prototype, "activeMonitors", {
+        get: function () {
+            return this.manager.activeMonitors;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    MonitorService.prototype.loadMonitors = function (monitors) {
+        this.manager.loadMonitors(monitors);
+    };
+    MonitorService.prototype.fetch = function (args, callbacks) {
+        return __awaiter(this, void 0, void 0, function () {
+            var filters, relays, options, message;
+            return __generator(this, function (_a) {
+                filters = args.filters, relays = args.relays, options = args.options;
+                message = { filters: filters, relays: relays, options: options };
+                return [2 /*return*/, this._fetch(message, callbacks)];
+            });
+        });
+    };
+    MonitorService.prototype.fetchOperatorRelaysNotOnline = function (pubkey, args, callbacks) {
+        return __awaiter(this, void 0, void 0, function () {
+            var filters, relays, options;
+            return __generator(this, function (_a) {
+                filters = [];
+                this.activeMonitors.forEach(function (monitor) {
+                    filters.push(__assign(__assign({}, monitor.checkFilterNotOnline), { "#p": [pubkey] }));
+                });
+                relays = (args === null || args === void 0 ? void 0 : args.relays) || this.nip66Relays;
+                options = {
+                    stream: false,
+                    cache: true,
+                    returnResults: true,
+                    keepAlive: false
+                };
+                return [2 /*return*/, this.subscribe({ filters: filters, relays: relays, options: options }, callbacks)];
+            });
+        });
+    };
+    MonitorService.prototype.fetchOperatorRelaysDead = function (pubkey, args, callbacks) {
+        return __awaiter(this, void 0, void 0, function () {
+            var filters, relays, options;
+            return __generator(this, function (_a) {
+                filters = [];
+                this.activeMonitors.forEach(function (monitor) {
+                    filters.push(__assign(__assign({}, monitor.checkFilterDead), { "#p": [pubkey] }));
+                });
+                relays = (args === null || args === void 0 ? void 0 : args.relays) || this.nip66Relays;
+                options = {
+                    stream: false,
+                    cache: true,
+                    returnResults: true,
+                    keepAlive: false
+                };
+                return [2 /*return*/, this.fetch({ filters: filters, relays: relays, options: options }, callbacks)];
+            });
+        });
+    };
+    MonitorService.prototype.sync = function (args, callbacks) {
+        return __awaiter(this, void 0, void 0, function () {
+            var index, checkCounts, updateCounts, onevent, onevents, oneose, results;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        console.log('sync');
+                        index = 0;
+                        checkCounts = new Map();
+                        updateCounts = function (events) {
+                            for (var _i = 0, events_1 = events; _i < events_1.length; _i++) {
+                                var event_1 = events_1[_i];
+                                var pubkey = event_1.pubkey, kind = event_1.kind;
+                                var key = "".concat(pubkey, ":").concat(kind);
+                                var count = checkCounts.get(key) || 0;
+                                checkCounts.set(key, count + 1);
+                            }
+                        };
+                        onevent = function (event) {
+                            var _a;
+                            console.log('onevent', event);
+                            updateCounts([event]);
+                            (_a = callbacks === null || callbacks === void 0 ? void 0 : callbacks.onevent) === null || _a === void 0 ? void 0 : _a.call(callbacks, event);
+                        };
+                        onevents = function (events) {
+                            var _a;
+                            console.log('onevents', events.length);
+                            updateCounts(events);
+                            (_a = callbacks === null || callbacks === void 0 ? void 0 : callbacks.onevents) === null || _a === void 0 ? void 0 : _a.call(callbacks, events);
+                        };
+                        oneose = function () {
+                            var _a;
+                            console.log('oneose');
+                            _this.updateCheckpoint(args === null || args === void 0 ? void 0 : args.filters[index], checkCounts);
+                            index++;
+                            (_a = callbacks === null || callbacks === void 0 ? void 0 : callbacks.oneose) === null || _a === void 0 ? void 0 : _a.call(callbacks);
+                        };
+                        console.log('sync: args', args);
+                        return [4 /*yield*/, this._fetch(args, { onevents: onevents, oneose: oneose, onevent: onevent })];
+                    case 1:
+                        results = _a.sent();
+                        this.updateCheckpoints((args === null || args === void 0 ? void 0 : args.filters) || [], checkCounts);
+                        return [2 /*return*/, results];
+                }
+            });
+        });
+    };
+    MonitorService.prototype.updateCheckpoint = function (filter, counts) {
+        var authors = filter.authors, kinds = filter.kinds, since = filter.since, until = filter.until;
+        for (var _i = 0, _a = authors || []; _i < _a.length; _i++) {
+            var pubkey = _a[_i];
+            var monitor = this.monitors.get(pubkey);
+            if (!monitor) {
+                console.error("Monitor not found for pubkey: ".concat(pubkey));
+                continue;
+            }
+            for (var _b = 0, _c = kinds || []; _b < _c.length; _b++) {
+                var kind = _c[_b];
+                var key = "".concat(pubkey, ":").concat(kind);
+                var count = counts.get(key) || 0;
+                if (count > 0) {
+                    if (since) {
+                        monitor.setLastSync(kind, 'since', since);
+                    }
+                    if (until) {
+                        monitor.setLastSync(kind, 'until', until);
+                    }
+                }
+            }
+        }
+    };
+    MonitorService.prototype.updateCheckpoints = function (filters, counts) {
+        for (var _i = 0, _a = Array.from(filters); _i < _a.length; _i++) {
+            var filter = _a[_i];
+            this.updateCheckpoint(filter, counts);
+        }
+    };
+    MonitorService.prototype.modifyCacheFilters = function (filters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, filters.map(function (filter) {
+                        var authors = filter.authors, kinds = filter.kinds, requestedSince = filter.since, requestedUntil = filter.until;
+                        for (var _i = 0, _a = authors || []; _i < _a.length; _i++) {
+                            var pubkey = _a[_i];
+                            var monitor = _this.monitors.get(pubkey);
+                            for (var _b = 0, _c = kinds || []; _b < _c.length; _b++) {
+                                var kind = _c[_b];
+                                var cachedRange = monitor === null || monitor === void 0 ? void 0 : monitor.getLastSync(kind);
+                                if (cachedRange === null || cachedRange === void 0 ? void 0 : cachedRange.since) {
+                                    if (requestedSince && cachedRange.since < requestedSince) {
+                                        filter.since = cachedRange.since;
+                                    }
+                                }
+                                else {
+                                    ////console.log(`modifyCacheFilters: no cached range for kind: ${kind}`);
+                                }
+                            }
+                        }
+                        return filter;
+                    })];
+            });
+        });
+    };
+    MonitorService.prototype.modifyWebsocketFilters = function (filters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, filters.map(function (filter) {
+                        var authors = filter.authors, kinds = filter.kinds, requestedSince = filter.since, requestedUntil = filter.until;
+                        for (var _i = 0, _a = authors || []; _i < _a.length; _i++) {
+                            var pubkey = _a[_i];
+                            var monitor = _this.monitors.get(pubkey);
+                            for (var _b = 0, _c = kinds || []; _b < _c.length; _b++) {
+                                var kind = _c[_b];
+                                var cachedRange = monitor === null || monitor === void 0 ? void 0 : monitor.getLastSync(kind);
+                                if (cachedRange === null || cachedRange === void 0 ? void 0 : cachedRange.until) {
+                                    if (requestedSince && cachedRange.until > requestedSince) {
+                                        filter.since = cachedRange.until;
+                                    }
+                                    else {
+                                        ////console.log(`modifyWebsocketFilters: since unchanged`);
+                                    }
+                                }
+                            }
+                        }
+                        return filter;
+                    })];
+            });
+        });
+    };
+    MonitorService.prototype.bootstrapMonitors = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        console.log('bootstrapMonitors');
+                        return [4 /*yield*/, this.fetchMonitorRegistrations()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.fetchMonitorMeta()];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, this.ensureMonitorsActive()];
+                    case 3:
+                        _a.sent();
+                        this.maybeEnableMonitors();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    MonitorService.prototype.bootstrap = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.bootstrapMonitors()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.bootstrapMonitorsChecks()];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    MonitorService.prototype.bootstrapMonitorsChecks = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var value, onevent, onevents, result;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        console.log('bootstrapMonitorsChecks');
+                        StateManager.emit('activity', 'monitors/bootstrap/checks', 'begin');
+                        value = 0;
+                        onevent = function (event) {
+                            _this.manager.handleEvent(event);
+                            value++;
+                            StateManager.emit('activity', 'monitors/bootstrap/checks', 'update', { value: value });
+                        };
+                        onevents = function (events) {
+                            if (!(events === null || events === void 0 ? void 0 : events.length)) {
+                                console.warn('bootstrapMonitorsChecks: no events found');
+                                return;
+                            }
+                            events.forEach(onevent);
+                            StateManager.emit('activity', 'monitors/bootstrap/checks', 'update', { value: value });
+                        };
+                        return [4 /*yield*/, this.syncMonitorsChecks(options, true, { onevent: onevent, onevents: onevents })];
+                    case 1:
+                        result = _a.sent();
+                        StateManager.emit('activity', 'monitors/bootstrap/checks', 'finish', result);
+                        return [2 /*return*/, result];
+                }
+            });
+        });
+    };
+    MonitorService.prototype.fetchDisabledMonitorsChecks = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.syncMonitorsChecks({
+                        cache: true,
+                        // NOTE: `syncMonitorsChecks()` always supplies callbacks to the underlying
+                        // websocket adapter, which forces `stream=true`. With `returnResults=false`
+                        // the worker will *not* forward streamed events back to the adapter, so the
+                        // callbacks never fire and the GUI never receives these checks (they only
+                        // land in cache). We need results forwarded for streaming callbacks.
+                        returnResults: true,
+                        keepAlive: false,
+                        stream: false,
+                        batch: 20
+                    }, false)];
+            });
+        });
+    };
+    MonitorService.prototype.countMonitorChecksInCache = function (enabled) {
+        return __awaiter(this, void 0, void 0, function () {
+            var filters, result, promises, _loop_1, this_1, _i, filters_1, filter;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        filters = this.getMonitorCheckFilters(enabled);
+                        result = new Map();
+                        promises = [];
+                        _loop_1 = function (filter) {
+                            var monitorPk = (_a = filter.authors) === null || _a === void 0 ? void 0 : _a[0];
+                            if (!monitorPk)
+                                return "continue";
+                            promises.push(this_1.cacheAdapter.COUNT([filter])
+                                .then(function (count) {
+                                result.set(monitorPk, count);
+                            }));
+                        };
+                        this_1 = this;
+                        for (_i = 0, filters_1 = filters; _i < filters_1.length; _i++) {
+                            filter = filters_1[_i];
+                            _loop_1(filter);
+                        }
+                        return [4 /*yield*/, Promise.allSettled(promises)];
+                    case 1:
+                        _b.sent();
+                        return [2 /*return*/, result];
+                }
+            });
+        });
+    };
+    MonitorService.prototype.fetchMonitorRegistrations = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var totalFound, onevent, args, result;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        console.log('fetchMonitorRegistrations');
+                        StateManager.emit('activity', 'monitors/bootstrap/registrations', 'begin');
+                        totalFound = 0;
+                        onevent = function (event) {
+                            // console.log('onevent', event)
+                            if (event.kind !== 10166)
+                                return;
+                            _this.manager.handleEvent(event);
+                            totalFound++;
+                            StateManager.emit('activity', 'monitors/bootstrap/registrations', 'update', { value: totalFound });
+                        };
+                        args = {
+                            filters: [{ kinds: [10166] }],
+                            relays: this.nip66Relays,
+                            options: {
+                                cache: true,
+                                returnResults: true,
+                                keepAlive: false,
+                                stream: true,
+                            }
+                        };
+                        console.log('fetchMonitorRegistrations: args', args);
+                        return [4 /*yield*/, this.subscribe(args, { onevent: onevent })];
+                    case 1:
+                        result = _a.sent();
+                        StateManager.emit('activity', 'monitors/bootstrap/registrations', 'finish', result);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    MonitorService.prototype.fetchMonitorMeta = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var monitors, authors, totalEvents, onevent, onevents, filters, args;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        StateManager.emit('activity', 'monitors/bootstrap/meta', 'begin');
+                        monitors = __spreadArray([], this.array.map(function (m) { return m.registration; }), true).filter(function (registration) { return typeof registration !== 'undefined'; });
+                        authors = monitors.map(function (monitor) { return monitor.pubkey; });
+                        totalEvents = 0;
+                        onevent = function (event) {
+                            _this.manager.handleEvent(event);
+                            totalEvents++;
+                            StateManager.emit('activity', 'monitors/bootstrap/meta', 'update', { value: totalEvents });
+                        };
+                        onevents = function (events) {
+                            events.forEach(onevent);
+                            totalEvents += events.length;
+                            StateManager.emit('activity', 'monitors/bootstrap/meta', 'update', { value: totalEvents });
+                        };
+                        filters = authors.map(function (author) { return ({ authors: [author], kinds: [0, 10002] }); });
+                        args = {
+                            filters: filters,
+                            relays: this.userMetaRelays,
+                            options: {
+                                cache: true,
+                                returnResults: true,
+                                keepAlive: false,
+                                stream: true
+                            }
+                        };
+                        return [4 /*yield*/, this.subscribe(args, { onevent: onevent, onevents: onevents })];
+                    case 1:
+                        _a.sent();
+                        this.array.forEach(function (monitor) {
+                            monitor.relays.forEach(function (relay) { return _this.addRelay('route66', relay); });
+                        });
+                        StateManager.emit('activity', 'monitors/bootstrap/meta', 'finish');
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    MonitorService.prototype.isMonitorActive = function (pubkey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var monitor, checkFilter, filters, options, relays, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        monitor = this.monitors.get(pubkey);
+                        if (!monitor)
+                            return [2 /*return*/, false];
+                        checkFilter = __assign(__assign({}, monitor.checkFilter), { limit: 1 });
+                        filters = [checkFilter];
+                        options = defaultWebsocketAdapterOptions;
+                        relays = this.nip66Relays;
+                        return [4 /*yield*/, this.subscribe({ filters: filters, relays: relays, options: options })];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, (result instanceof Array) ? result.length > 0 : result];
+                }
+            });
+        });
+    };
+    MonitorService.prototype.syncMonitorsChecks = function (options, enabled, callbacks) {
+        return __awaiter(this, void 0, void 0, function () {
+            var filters, defaultOptions, count, onevent, onevents, relays, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        console.log('syncMonitorsChecks');
+                        filters = this.getMonitorCheckFilters(enabled);
+                        console.log('syncMonitorsChecks: filters', filters);
+                        defaultOptions = {
+                            cache: true,
+                            returnResults: true,
+                            keepAlive: false,
+                            stream: true,
+                            batch: 100
+                        };
+                        count = 0;
+                        onevent = function (event) {
+                            var _a;
+                            (_a = callbacks === null || callbacks === void 0 ? void 0 : callbacks.onevent) === null || _a === void 0 ? void 0 : _a.call(callbacks, event);
+                            StateManager.emit("event", event);
+                            // StateManager.emit(`event:${event.kind}`, event);
+                        };
+                        onevents = function (events) {
+                            var _a;
+                            // console.log('onevents', events.length)
+                            count += events.length;
+                            (_a = callbacks === null || callbacks === void 0 ? void 0 : callbacks.onevents) === null || _a === void 0 ? void 0 : _a.call(callbacks, events);
+                            StateManager.emit("events", events);
+                        };
+                        relays = this.nip66Relays;
+                        if (!options) {
+                            options = __assign({}, defaultOptions);
+                        }
+                        else {
+                            options = __assign(__assign({}, defaultOptions), options);
+                        }
+                        console.log('syncMonitorsChecks: options', options);
+                        return [4 /*yield*/, this.fetch({ relays: relays, filters: filters, options: options }, { onevent: onevent, onevents: onevents })];
+                    case 1:
+                        result = _a.sent();
+                        // StateManager.emit('bootstrap:checks:complete')
+                        return [2 /*return*/, result];
+                }
+            });
+        });
+    };
+    MonitorService.prototype.countMonitorChecksFromCache = function (pubkey, _options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var monitor, checkFilter, filters;
+            return __generator(this, function (_a) {
+                monitor = this.monitors.get(pubkey);
+                if (!monitor)
+                    return [2 /*return*/, 0];
+                checkFilter = __assign({}, monitor.checkFilter);
+                filters = [checkFilter];
+                return [2 /*return*/, this.countFromCache(filters)];
+            });
+        });
+    };
+    MonitorService.prototype.fetchMonitorChecksFromCache = function (pubkey, _options) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.fetchMonitorChecks(pubkey, _options, 'cache')];
+            });
+        });
+    };
+    MonitorService.prototype.fetchMonitorChecksFromWebsocket = function (pubkey, _options) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.fetchMonitorChecks(pubkey, _options, 'websocket')];
+            });
+        });
+    };
+    MonitorService.prototype.fetchMonitorChecks = function (pubkey_1, _options_1, from_1) {
+        return __awaiter(this, arguments, void 0, function (pubkey, _options, from, sync) {
+            var monitor, checkFilter, filters, options, relays, result, _a;
+            if (sync === void 0) { sync = false; }
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        monitor = this.monitors.get(pubkey);
+                        if (!monitor)
+                            return [2 /*return*/, []];
+                        checkFilter = __assign({}, monitor.checkFilter);
+                        filters = [checkFilter];
+                        options = (_options ? __assign(__assign(__assign({}, defaultWebsocketAdapterOptions), _options), { stream: false }) :
+                            defaultWebsocketAdapterOptions);
+                        relays = this.nip66Relays;
+                        _a = from;
+                        switch (_a) {
+                            case 'cache': return [3 /*break*/, 1];
+                            case 'websocket': return [3 /*break*/, 2];
+                        }
+                        return [3 /*break*/, 4];
+                    case 1: return [2 /*return*/, this.fetchFromCache(filters)];
+                    case 2: return [4 /*yield*/, this.fetchFromWebsocket({ filters: filters, relays: relays, options: options })];
+                    case 3: return [2 /*return*/, _b.sent()];
+                    case 4: return [2 /*return*/, this.fetch({ filters: filters, relays: relays, options: options })];
+                }
+            });
+        });
+    };
+    MonitorService.prototype.beginLiveSync = function (callbacks) {
+        return __awaiter(this, void 0, void 0, function () {
+            var startedAt, filters, hash, relays, options, highestTimestamp, onevents;
+            var _this = this;
+            return __generator(this, function (_a) {
+                startedAt = Math.round(Date.now() / 1000);
+                filters = [];
+                this.enabledMonitors.forEach(function (monitor) {
+                    var _a;
+                    var lastSyncUntil = (_a = monitor.getLastSync(30166)) === null || _a === void 0 ? void 0 : _a.until;
+                    filters.push({ kinds: [30166], authors: [monitor.pubkey], since: lastSyncUntil });
+                });
+                hash = 'liveSyncMonitorsChecks';
+                relays = this.nip66Relays;
+                options = {
+                    cache: true,
+                    keepAlive: true,
+                    returnResults: true,
+                    stream: true,
+                    batch: 10
+                };
+                highestTimestamp = 0;
+                onevents = function (events) {
+                    // console.log('!!! liveSync: onevents', events?.length);
+                    var _a;
+                    var now = Math.round(Date.now() / 1000);
+                    var highestTimestamp = startedAt; // Initialize to startedAt to avoid unnecessary checks later
+                    events.forEach(function (event) {
+                        var pubkey = event.pubkey, _a = event.created_at, created_at = _a === void 0 ? 0 : _a;
+                        created_at = created_at;
+                        var monitor = _this.monitors.get(pubkey);
+                        if (monitor) {
+                            var lastSyncUntil = monitor.getLastSyncUntil(30166) || 0;
+                            if (created_at > lastSyncUntil) {
+                                monitor.setLastSync(30166, 'since', now - monitor.frequency);
+                                monitor.setLastSync(30166, 'until', created_at);
+                            }
+                        }
+                        if (created_at > highestTimestamp) {
+                            highestTimestamp = created_at;
+                        }
+                    });
+                    if (highestTimestamp > startedAt) {
+                        StateManager.set('lastCompleteSync', now);
+                    }
+                    (_a = callbacks === null || callbacks === void 0 ? void 0 : callbacks.onevents) === null || _a === void 0 ? void 0 : _a.call(callbacks, events);
+                };
+                //console.log('HASH', hash)
+                return [2 /*return*/, this.subscribe({ filters: filters, relays: relays, options: options, hash: hash }, { onevents: onevents })];
+            });
+        });
+    };
+    MonitorService.prototype.stopLiveSync = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: 
+                    //console.log('!!! stopping live sync')
+                    return [4 /*yield*/, this.unsubscribe('liveSyncMonitorsChecks')];
+                    case 1:
+                        //console.log('!!! stopping live sync')
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    MonitorService.prototype.ensureMonitorsActive = function (pubkeys) {
+        return __awaiter(this, void 0, void 0, function () {
+            var MAX_FILTERS, monitors, filters, events, until, chunkArray, filterChunks, activePubkeys, onevent, callbacks, relays, _i, filterChunks_1, filterChunk, _a, events_2, event_2, pubkey, created_at, monitor;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        console.log('ensureMonitorsActive');
+                        StateManager.emit('activity', 'monitors/bootstrap/ensureActive', 'begin');
+                        MAX_FILTERS = 10;
+                        monitors = __spreadArray([], this.array, true);
+                        if (pubkeys) {
+                            if (typeof pubkeys === 'string')
+                                pubkeys = [pubkeys];
+                            monitors = monitors.filter(function (m) { return pubkeys.includes(m.pubkey); });
+                        }
+                        filters = [];
+                        events = [];
+                        until = Math.round(Date.now() / 1000);
+                        monitors.forEach(function (monitor) {
+                            filters.push(__assign(__assign({}, monitor.checkFilter), { until: until, limit: 1 }));
+                        });
+                        chunkArray = function (arr, size) {
+                            var chunks = [];
+                            for (var i = 0; i < arr.length; i += size) {
+                                chunks.push(arr.slice(i, i + size));
+                            }
+                            return chunks;
+                        };
+                        filterChunks = chunkArray(filters, MAX_FILTERS);
+                        activePubkeys = new Set();
+                        onevent = function (event) {
+                            events.push(event);
+                            activePubkeys.add(event.pubkey);
+                            StateManager.emit('activity', 'monitors/bootstrap/ensureActive', 'update', { value: activePubkeys.size });
+                        };
+                        callbacks = { onevent: onevent };
+                        relays = this.nip66Relays;
+                        _i = 0, filterChunks_1 = filterChunks;
+                        _b.label = 1;
+                    case 1:
+                        if (!(_i < filterChunks_1.length)) return [3 /*break*/, 4];
+                        filterChunk = filterChunks_1[_i];
+                        return [4 /*yield*/, this.websocketAdapter.subscribe({
+                                relays: relays,
+                                filters: filterChunk,
+                                options: {
+                                    cache: false,
+                                    returnResults: true,
+                                    keepAlive: false,
+                                    stream: false,
+                                },
+                            }, callbacks)];
+                    case 2:
+                        _b.sent();
+                        _b.label = 3;
+                    case 3:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 4:
+                        for (_a = 0, events_2 = events; _a < events_2.length; _a++) {
+                            event_2 = events_2[_a];
+                            pubkey = event_2.pubkey, created_at = event_2.created_at;
+                            monitor = this.monitors.get(pubkey);
+                            if (monitor === null || monitor === void 0 ? void 0 : monitor.registration) {
+                                if (created_at)
+                                    monitor.lastActive = created_at;
+                            }
+                        }
+                        StateManager.emit('activity', 'monitors/bootstrap/ensureActive', 'finish');
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    MonitorService.prototype.maybeEnableMonitors = function () {
+        if (this.enabledMonitors.length) {
+            return;
+        }
+        var monitorsWithRegistrations = Array.from(this.monitors.values())
+            .filter(function (m) { var _a, _b; return (_b = (_a = m === null || m === void 0 ? void 0 : m.registration) === null || _a === void 0 ? void 0 : _a.checks) === null || _b === void 0 ? void 0 : _b.length; });
+        // Prefer active monitors, then sort by number of checks
+        var sorted = monitorsWithRegistrations.sort(function (a, b) {
+            var _a, _b, _c, _d, _e, _f;
+            // Active monitors first
+            if (a.active && !b.active)
+                return -1;
+            if (!a.active && b.active)
+                return 1;
+            // Then by check count
+            var aChecks = (_c = (_b = (_a = a.registration) === null || _a === void 0 ? void 0 : _a.checks) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0;
+            var bChecks = (_f = (_e = (_d = b.registration) === null || _d === void 0 ? void 0 : _d.checks) === null || _e === void 0 ? void 0 : _e.length) !== null && _f !== void 0 ? _f : 0;
+            return bChecks - aChecks;
+        });
+        for (var i = 0; i < this.DEFAULT_ENABLED_MONITORS && i < sorted.length; i++) {
+            try {
+                sorted[i].enable();
+            }
+            catch (_a) {
+                sorted[i].enabled = true;
+            }
+        }
+    };
+    MonitorService.prototype.optimizeFilters = function (filters) {
+        var _a, _b, _c;
+        var filterMap = new Map();
+        for (var _i = 0, filters_2 = filters; _i < filters_2.length; _i++) {
+            var filter = filters_2[_i];
+            var key = JSON.stringify({
+                since: (_a = filter.since) !== null && _a !== void 0 ? _a : null,
+                until: (_b = filter.until) !== null && _b !== void 0 ? _b : null,
+                kinds: (_c = filter.kinds) !== null && _c !== void 0 ? _c : null,
+            });
+            if (filterMap.has(key)) {
+                var existingFilter = filterMap.get(key);
+                existingFilter.authors = __spreadArray([], Array.from(new Set(__spreadArray(__spreadArray([], (existingFilter.authors || []), true), (filter.authors || []), true))), true);
+            }
+            else {
+                filterMap.set(key, __assign(__assign({}, filter), { authors: __spreadArray([], (filter.authors || []), true) }));
+            }
+        }
+        return Array.from(filterMap.values());
+    };
+    MonitorService.prototype.getMonitorCheckFilters = function (enabled) {
+        var monitors = [];
+        if (enabled === undefined) {
+            monitors = this.enabledMonitors;
+        }
+        else if (typeof enabled === 'boolean') {
+            monitors = enabled ? this.enabledMonitors : this.disabledActiveMonitors;
+        }
+        var filters = [];
+        var until = Math.round(Date.now() / 1000);
+        monitors.forEach(function (monitor) {
+            filters.push(__assign(__assign({}, monitor.checkFilter), { until: until }));
+        });
+        return filters;
+    };
+    MonitorService.prototype.modifyReturnedEvents = function (events) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, events];
+            });
+        });
+    };
+    MonitorService.prototype.removeStaleChecks = function (events) {
+        return __awaiter(this, void 0, void 0, function () {
+            var monitors, deleteFilters, timelyChecks, _loop_2, this_2, _i, monitors_1, monitor;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        monitors = Array.from(this.monitors.values());
+                        deleteFilters = [];
+                        timelyChecks = [];
+                        _loop_2 = function (monitor) {
+                            var pubkey, frequency, until, onlineRelays;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        pubkey = monitor.pubkey, frequency = monitor.frequency;
+                                        if (!frequency) {
+                                            return [2 /*return*/, "continue"];
+                                        }
+                                        until = monitor.isOnlineAfter;
+                                        deleteFilters.push({ authors: [pubkey], until: until });
+                                        this_2.cacheAdapter.DELETE(deleteFilters);
+                                        return [4 /*yield*/, monitor.returnOnlineRelays(events.filter(function (event) { return event.pubkey === monitor.pubkey; }))];
+                                    case 1:
+                                        onlineRelays = _b.sent();
+                                        timelyChecks = __spreadArray(__spreadArray([], timelyChecks, true), onlineRelays, true);
+                                        return [2 /*return*/];
+                                }
+                            });
+                        };
+                        this_2 = this;
+                        _i = 0, monitors_1 = monitors;
+                        _a.label = 1;
+                    case 1:
+                        if (!(_i < monitors_1.length)) return [3 /*break*/, 4];
+                        monitor = monitors_1[_i];
+                        return [5 /*yield**/, _loop_2(monitor)];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/, timelyChecks];
+                }
+            });
+        });
+    };
+    MonitorService.prototype.getMonitor = function (pubkey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var monitorKinds, filter, options, relays;
+            return __generator(this, function (_a) {
+                if (this.monitors.has(pubkey)) {
+                    return [2 /*return*/, this.monitors.get(pubkey)];
+                }
+                monitorKinds = [10166, 0, 10002];
+                filter = { authors: [pubkey], kinds: monitorKinds };
+                options = {
+                    cache: true,
+                    returnResults: true,
+                    keepAlive: false,
+                    stream: false,
+                };
+                relays = __spreadArray(__spreadArray(__spreadArray([], this.nip66Relays, true), this.userMetaRelays, true), this.getMonitorRelays(pubkey), true);
+                // const events = await this.fetch({filters: [filter], options, relays}, this.manager.handleEvent.bind(this.manager) );
+                return [2 /*return*/, this.monitors.get(pubkey)];
+            });
+        });
+    };
+    // async getMonitorChecks(pubkey: string): Promise<ICheck[]> {
+    //   const monitor = await this.getMonitor(pubkey);
+    //   const filter: Filter = { authors: [pubkey], kinds: [30166] };
+    //   const options: WebsocketAdapterOptions = {
+    //     cache: true,
+    //     returnResults: true,
+    //     keepAlive: false,
+    //     stream: false,
+    //   };
+    //   const relays: string[] = [
+    //     ...this.nip66Relays,
+    //     ...this.userMetaRelays,
+    //     ...this.getMonitorRelays(pubkey),
+    //   ];
+    //   const events = await this.fetch({filters: [filter], options, relays});
+    //   const checks = events.map((event) => k30166ToICheck(event));
+    //   return checks
+    // }
+    MonitorService.prototype.getMonitorRelays = function (pubkey) {
+        var _a;
+        return ((_a = this.monitors.get(pubkey)) === null || _a === void 0 ? void 0 : _a.relays) || [];
+    };
+    MonitorService.prototype.getMonitorPubkeys = function () {
+        if (!this.sortedMonitors.length) {
+            console.warn('MonitorService getMonitorPubkeys: no monitors');
+            return [];
+        }
+        ////console.log(`total monitors in array: ${this.sortedMonitors.length}`)
+        return this.sortedMonitors.map(function (monitor) { return monitor.pubkey; });
+    };
+    return MonitorService;
+}(Service));
+export { MonitorService };
+//# sourceMappingURL=MonitorService.js.map