@pezkuwi/extension-base 0.62.10 → 0.62.13

package/background/handlers/State.js

@@ -1,73 +1,3 @@
-// Copyright 2019-2025 @pezkuwi/extension-bg authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-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 __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-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));
-};
-var _State_authUrls, _State_lastRequestTimestamps, _State_maxEntries, _State_rateLimitInterval, _State_authRequests, _State_metaStore, _State_injectedProviders, _State_metaRequests, _State_notification, _State_providers, _State_signRequests, _State_windows, _State_connectedTabsUrl;
 import { BehaviorSubject } from 'rxjs';
 import { addMetadata, knownMetadata } from '@pezkuwi/extension-chains';
 import { knownGenesis } from '@pezkuwi/networks/defaults';
@@ -76,8 +6,8 @@ import { assert } from '@pezkuwi/util';
 import { MetadataStore } from '../../stores/index.js';
 import { getId } from '../../utils/getId.js';
 import { withErrorLog } from './helpers.js';
-var NOTIFICATION_URL = chrome.runtime.getURL('notification.html');
-var POPUP_WINDOW_OPTS = {
+const NOTIFICATION_URL = chrome.runtime.getURL('notification.html');
+const POPUP_WINDOW_OPTS = {
     focused: true,
     height: 621,
     left: 150,
@@ -86,7 +16,7 @@ var POPUP_WINDOW_OPTS = {
     url: NOTIFICATION_URL,
     width: 560
 };
-var NORMAL_WINDOW_OPTS = {
+const NORMAL_WINDOW_OPTS = {
     focused: true,
     type: 'normal',
     url: NOTIFICATION_URL
@@ -97,412 +27,254 @@ export var NotificationOptions;
     NotificationOptions[NotificationOptions["Normal"] = 1] = "Normal";
     NotificationOptions[NotificationOptions["PopUp"] = 2] = "PopUp";
 })(NotificationOptions || (NotificationOptions = {}));
-var AUTH_URLS_KEY = 'authUrls';
-var DEFAULT_AUTH_ACCOUNTS = 'defaultAuthAccounts';
-function extractMetadata(store) {
-    return __awaiter(this, void 0, void 0, function () {
-        var _this = this;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, store.allMap(function (map) { return __awaiter(_this, void 0, void 0, function () {
-                        var knownEntries, defs, removals, _i, removals_1, key;
-                        return __generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0:
-                                    knownEntries = Object.entries(knownGenesis);
-                                    defs = {};
-                                    removals = [];
-                                    Object
-                                        .entries(map)
-                                        .forEach(function (_a) {
-                                        var key = _a[0], def = _a[1];
-                                        var entry = knownEntries.find(function (_a) {
-                                            var hashes = _a[1];
-                                            return hashes.includes(def.genesisHash);
-                                        });
-                                        if (entry) {
-                                            var name_1 = entry[0], hashes = entry[1];
-                                            var index = hashes.indexOf(def.genesisHash);
-                                            // flatten the known metadata based on the genesis index
-                                            // (lower is better/newer)
-                                            if (!defs[name_1] || (defs[name_1].index > index)) {
-                                                if (defs[name_1]) {
-                                                    // remove the old version of the metadata
-                                                    removals.push(defs[name_1].key);
-                                                }
-                                                defs[name_1] = { def: def, index: index, key: key };
-                                            }
-                                        }
-                                        else {
-                                            // this is not a known entry, so we will just apply it
-                                            defs[key] = { def: def, index: 0, key: key };
-                                        }
-                                    });
-                                    _i = 0, removals_1 = removals;
-                                    _a.label = 1;
-                                case 1:
-                                    if (!(_i < removals_1.length)) return [3 /*break*/, 4];
-                                    key = removals_1[_i];
-                                    return [4 /*yield*/, store.remove(key)];
-                                case 2:
-                                    _a.sent();
-                                    _a.label = 3;
-                                case 3:
-                                    _i++;
-                                    return [3 /*break*/, 1];
-                                case 4:
-                                    Object.values(defs).forEach(function (_a) {
-                                        var def = _a.def;
-                                        return addMetadata(def);
-                                    });
-                                    return [2 /*return*/];
-                            }
-                        });
-                    }); })];
-                case 1:
-                    _a.sent();
-                    return [2 /*return*/];
+const AUTH_URLS_KEY = 'authUrls';
+const DEFAULT_AUTH_ACCOUNTS = 'defaultAuthAccounts';
+async function extractMetadata(store) {
+    await store.allMap(async (map) => {
+        const knownEntries = Object.entries(knownGenesis);
+        const defs = {};
+        const removals = [];
+        Object
+            .entries(map)
+            .forEach(([key, def]) => {
+            const entry = knownEntries.find(([, hashes]) => hashes.includes(def.genesisHash));
+            if (entry) {
+                const [name, hashes] = entry;
+                const index = hashes.indexOf(def.genesisHash);
+                // flatten the known metadata based on the genesis index
+                // (lower is better/newer)
+                if (!defs[name] || (defs[name].index > index)) {
+                    if (defs[name]) {
+                        // remove the old version of the metadata
+                        removals.push(defs[name].key);
+                    }
+                    defs[name] = { def, index, key };
+                }
+            }
+            else {
+                // this is not a known entry, so we will just apply it
+                defs[key] = { def, index: 0, key };
             }
         });
+        for (const key of removals) {
+            await store.remove(key);
+        }
+        Object.values(defs).forEach(({ def }) => addMetadata(def));
     });
 }
-var State = /** @class */ (function () {
-    function State(providers, rateLimitInterval) {
-        if (providers === void 0) { providers = {}; }
-        if (rateLimitInterval === void 0) { rateLimitInterval = 3000; }
-        var _this = this;
-        _State_authUrls.set(this, new Map());
-        _State_lastRequestTimestamps.set(this, new Map());
-        _State_maxEntries.set(this, 10);
-        _State_rateLimitInterval.set(this, 3000); // 3 seconds
-        _State_authRequests.set(this, {});
-        _State_metaStore.set(this, new MetadataStore());
-        // Map of providers currently injected in tabs
-        _State_injectedProviders.set(this, new Map());
-        _State_metaRequests.set(this, {});
-        _State_notification.set(this, settings.notification);
-        // Map of all providers exposed by the extension, they are retrievable by key
-        _State_providers.set(this, void 0);
-        _State_signRequests.set(this, {});
-        _State_windows.set(this, []);
-        _State_connectedTabsUrl.set(this, []);
-        this.authSubject = new BehaviorSubject([]);
-        this.metaSubject = new BehaviorSubject([]);
-        this.signSubject = new BehaviorSubject([]);
-        this.authUrlSubjects = {};
-        this.defaultAuthAccountSelection = [];
-        this.authComplete = function (id, resolve, reject) {
-            var complete = function () {
-                var args_1 = [];
-                for (var _i = 0; _i < arguments.length; _i++) {
-                    args_1[_i] = arguments[_i];
-                }
-                return __awaiter(_this, __spreadArray([], args_1, true), void 0, function (authorizedAccounts) {
-                    var _a, idStr, origin, url, strippedUrl, authInfo;
-                    if (authorizedAccounts === void 0) { authorizedAccounts = []; }
-                    return __generator(this, function (_b) {
-                        switch (_b.label) {
-                            case 0:
-                                _a = __classPrivateFieldGet(this, _State_authRequests, "f")[id], idStr = _a.idStr, origin = _a.request.origin, url = _a.url;
-                                strippedUrl = this.stripUrl(url);
-                                authInfo = {
-                                    authorizedAccounts: authorizedAccounts,
-                                    count: 0,
-                                    id: idStr,
-                                    origin: origin,
-                                    url: url
-                                };
-                                __classPrivateFieldGet(this, _State_authUrls, "f").set(strippedUrl, authInfo);
-                                if (!this.authUrlSubjects[strippedUrl]) {
-                                    this.authUrlSubjects[strippedUrl] = new BehaviorSubject(authInfo);
-                                }
-                                else {
-                                    this.authUrlSubjects[strippedUrl].next(authInfo);
-                                }
-                                return [4 /*yield*/, this.saveCurrentAuthList()];
-                            case 1:
-                                _b.sent();
-                                return [4 /*yield*/, this.updateDefaultAuthAccounts(authorizedAccounts)];
-                            case 2:
-                                _b.sent();
-                                delete __classPrivateFieldGet(this, _State_authRequests, "f")[id];
-                                this.updateIconAuth(true);
-                                return [2 /*return*/];
-                        }
-                    });
-                });
-            };
-            return {
-                // eslint-disable-next-line @typescript-eslint/no-misused-promises
-                reject: function (error) { return __awaiter(_this, void 0, void 0, function () {
-                    return __generator(this, function (_a) {
-                        switch (_a.label) {
-                            case 0:
-                                if (!(error.message === 'Cancelled')) return [3 /*break*/, 1];
-                                delete __classPrivateFieldGet(this, _State_authRequests, "f")[id];
-                                this.updateIconAuth(true);
-                                reject(new Error('Connection request was cancelled by the user.'));
-                                return [3 /*break*/, 3];
-                            case 1: return [4 /*yield*/, complete()];
-                            case 2:
-                                _a.sent();
-                                reject(new Error('Connection request was rejected by the user.'));
-                                _a.label = 3;
-                            case 3: return [2 /*return*/];
-                        }
-                    });
-                }); },
-                // eslint-disable-next-line @typescript-eslint/no-misused-promises
-                resolve: function (_a) { return __awaiter(_this, [_a], void 0, function (_b) {
-                    var authorizedAccounts = _b.authorizedAccounts, result = _b.result;
-                    return __generator(this, function (_c) {
-                        switch (_c.label) {
-                            case 0: return [4 /*yield*/, complete(authorizedAccounts)];
-                            case 1:
-                                _c.sent();
-                                resolve({ authorizedAccounts: authorizedAccounts, result: result });
-                                return [2 /*return*/];
-                        }
-                    });
-                }); }
-            };
-        };
-        this.metaComplete = function (id, resolve, reject) {
-            var complete = function () {
-                delete __classPrivateFieldGet(_this, _State_metaRequests, "f")[id];
-                _this.updateIconMeta(true);
-            };
-            return {
-                reject: function (error) {
-                    complete();
-                    reject(error);
-                },
-                resolve: function (result) {
-                    complete();
-                    resolve(result);
-                }
-            };
-        };
-        this.signComplete = function (id, resolve, reject) {
-            var complete = function () {
-                delete __classPrivateFieldGet(_this, _State_signRequests, "f")[id];
-                _this.updateIconSign(true);
-            };
-            return {
-                reject: function (error) {
-                    complete();
-                    reject(error);
-                },
-                resolve: function (result) {
-                    complete();
-                    resolve(result);
-                }
-            };
-        };
+export default class State {
+    #authUrls = new Map();
+    #lastRequestTimestamps = new Map();
+    #maxEntries = 10;
+    #rateLimitInterval = 3000; // 3 seconds
+    #authRequests = {};
+    #metaStore = new MetadataStore();
+    // Map of providers currently injected in tabs
+    #injectedProviders = new Map();
+    #metaRequests = {};
+    #notification = settings.notification;
+    // Map of all providers exposed by the extension, they are retrievable by key
+    #providers;
+    #signRequests = {};
+    #windows = [];
+    #connectedTabsUrl = [];
+    authSubject = new BehaviorSubject([]);
+    metaSubject = new BehaviorSubject([]);
+    signSubject = new BehaviorSubject([]);
+    authUrlSubjects = {};
+    defaultAuthAccountSelection = [];
+    constructor(providers = {}, rateLimitInterval = 3000) {
         assert(rateLimitInterval >= 0, 'Expects non-negative number for rateLimitInterval');
-        __classPrivateFieldSet(this, _State_providers, providers, "f");
-        __classPrivateFieldSet(this, _State_rateLimitInterval, rateLimitInterval, "f");
-    }
-    State.prototype.init = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var storageAuthUrls, authString, previousAuth, storageDefaultAuthAccounts, defaultAuthString, previousDefaultAuth;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, extractMetadata(__classPrivateFieldGet(this, _State_metaStore, "f"))];
-                    case 1:
-                        _a.sent();
-                        return [4 /*yield*/, chrome.storage.local.get(AUTH_URLS_KEY)];
-                    case 2:
-                        storageAuthUrls = _a.sent();
-                        authString = (storageAuthUrls === null || storageAuthUrls === void 0 ? void 0 : storageAuthUrls[AUTH_URLS_KEY]) || '{}';
-                        previousAuth = JSON.parse(authString);
-                        __classPrivateFieldSet(this, _State_authUrls, new Map(Object.entries(previousAuth)), "f");
-                        // Initialize authUrlSubjects for each URL
-                        __classPrivateFieldGet(this, _State_authUrls, "f").forEach(function (authInfo, url) {
-                            _this.authUrlSubjects[url] = new BehaviorSubject(authInfo);
-                        });
-                        return [4 /*yield*/, chrome.storage.local.get(DEFAULT_AUTH_ACCOUNTS)];
-                    case 3:
-                        storageDefaultAuthAccounts = _a.sent();
-                        defaultAuthString = (storageDefaultAuthAccounts === null || storageDefaultAuthAccounts === void 0 ? void 0 : storageDefaultAuthAccounts[DEFAULT_AUTH_ACCOUNTS]) || '[]';
-                        previousDefaultAuth = JSON.parse(defaultAuthString);
-                        this.defaultAuthAccountSelection = previousDefaultAuth;
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    Object.defineProperty(State.prototype, "knownMetadata", {
-        get: function () {
-            return knownMetadata();
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(State.prototype, "numAuthRequests", {
-        get: function () {
-            return Object.keys(__classPrivateFieldGet(this, _State_authRequests, "f")).length;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(State.prototype, "numMetaRequests", {
-        get: function () {
-            return Object.keys(__classPrivateFieldGet(this, _State_metaRequests, "f")).length;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(State.prototype, "numSignRequests", {
-        get: function () {
-            return Object.keys(__classPrivateFieldGet(this, _State_signRequests, "f")).length;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(State.prototype, "allAuthRequests", {
-        get: function () {
-            return Object
-                .values(__classPrivateFieldGet(this, _State_authRequests, "f"))
-                .map(function (_a) {
-                var id = _a.id, request = _a.request, url = _a.url;
-                return ({ id: id, request: request, url: url });
-            });
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(State.prototype, "allMetaRequests", {
-        get: function () {
-            return Object
-                .values(__classPrivateFieldGet(this, _State_metaRequests, "f"))
-                .map(function (_a) {
-                var id = _a.id, request = _a.request, url = _a.url;
-                return ({ id: id, request: request, url: url });
-            });
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(State.prototype, "allSignRequests", {
-        get: function () {
-            return Object
-                .values(__classPrivateFieldGet(this, _State_signRequests, "f"))
-                .map(function (_a) {
-                var account = _a.account, id = _a.id, request = _a.request, url = _a.url;
-                return ({ account: account, id: id, request: request, url: url });
-            });
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(State.prototype, "authUrls", {
-        get: function () {
-            return Object.fromEntries(__classPrivateFieldGet(this, _State_authUrls, "f"));
-        },
-        enumerable: false,
-        configurable: true
-    });
-    State.prototype.popupClose = function () {
-        __classPrivateFieldGet(this, _State_windows, "f").forEach(function (id) {
-            return withErrorLog(function () { return chrome.windows.remove(id); });
+        this.#providers = providers;
+        this.#rateLimitInterval = rateLimitInterval;
+    }
+    async init() {
+        await extractMetadata(this.#metaStore);
+        // retrieve previously set authorizations
+        const storageAuthUrls = await chrome.storage.local.get(AUTH_URLS_KEY);
+        const authString = storageAuthUrls?.[AUTH_URLS_KEY] || '{}';
+        const previousAuth = JSON.parse(authString);
+        this.#authUrls = new Map(Object.entries(previousAuth));
+        // Initialize authUrlSubjects for each URL
+        this.#authUrls.forEach((authInfo, url) => {
+            this.authUrlSubjects[url] = new BehaviorSubject(authInfo);
         });
-        __classPrivateFieldSet(this, _State_windows, [], "f");
-    };
-    State.prototype.popupOpen = function () {
-        var _this = this;
-        __classPrivateFieldGet(this, _State_notification, "f") !== 'extension' &&
-            chrome.windows.create(__classPrivateFieldGet(this, _State_notification, "f") === 'window'
+        // retrieve previously set default auth accounts
+        const storageDefaultAuthAccounts = await chrome.storage.local.get(DEFAULT_AUTH_ACCOUNTS);
+        const defaultAuthString = storageDefaultAuthAccounts?.[DEFAULT_AUTH_ACCOUNTS] || '[]';
+        const previousDefaultAuth = JSON.parse(defaultAuthString);
+        this.defaultAuthAccountSelection = previousDefaultAuth;
+    }
+    get knownMetadata() {
+        return knownMetadata();
+    }
+    get numAuthRequests() {
+        return Object.keys(this.#authRequests).length;
+    }
+    get numMetaRequests() {
+        return Object.keys(this.#metaRequests).length;
+    }
+    get numSignRequests() {
+        return Object.keys(this.#signRequests).length;
+    }
+    get allAuthRequests() {
+        return Object
+            .values(this.#authRequests)
+            .map(({ id, request, url }) => ({ id, request, url }));
+    }
+    get allMetaRequests() {
+        return Object
+            .values(this.#metaRequests)
+            .map(({ id, request, url }) => ({ id, request, url }));
+    }
+    get allSignRequests() {
+        return Object
+            .values(this.#signRequests)
+            .map(({ account, id, request, url }) => ({ account, id, request, url }));
+    }
+    get authUrls() {
+        return Object.fromEntries(this.#authUrls);
+    }
+    popupClose() {
+        this.#windows.forEach((id) => withErrorLog(() => chrome.windows.remove(id)));
+        this.#windows = [];
+    }
+    popupOpen() {
+        this.#notification !== 'extension' &&
+            chrome.windows.create(this.#notification === 'window'
                 ? NORMAL_WINDOW_OPTS
-                : POPUP_WINDOW_OPTS, function (window) {
+                : POPUP_WINDOW_OPTS, (window) => {
                 if (window) {
-                    __classPrivateFieldGet(_this, _State_windows, "f").push(window.id || 0);
+                    this.#windows.push(window.id || 0);
                 }
             });
+    }
+    authComplete = (id, resolve, reject) => {
+        const complete = async (authorizedAccounts = []) => {
+            const { idStr, request: { origin }, url } = this.#authRequests[id];
+            const strippedUrl = this.stripUrl(url);
+            const authInfo = {
+                authorizedAccounts,
+                count: 0,
+                id: idStr,
+                origin,
+                url
+            };
+            this.#authUrls.set(strippedUrl, authInfo);
+            if (!this.authUrlSubjects[strippedUrl]) {
+                this.authUrlSubjects[strippedUrl] = new BehaviorSubject(authInfo);
+            }
+            else {
+                this.authUrlSubjects[strippedUrl].next(authInfo);
+            }
+            await this.saveCurrentAuthList();
+            await this.updateDefaultAuthAccounts(authorizedAccounts);
+            delete this.#authRequests[id];
+            this.updateIconAuth(true);
+        };
+        return {
+            // eslint-disable-next-line @typescript-eslint/no-misused-promises
+            reject: async (error) => {
+                if (error.message === 'Cancelled') {
+                    delete this.#authRequests[id];
+                    this.updateIconAuth(true);
+                    reject(new Error('Connection request was cancelled by the user.'));
+                }
+                else {
+                    await complete();
+                    reject(new Error('Connection request was rejected by the user.'));
+                }
+            },
+            // eslint-disable-next-line @typescript-eslint/no-misused-promises
+            resolve: async ({ authorizedAccounts, result }) => {
+                await complete(authorizedAccounts);
+                resolve({ authorizedAccounts, result });
+            }
+        };
     };
     /**
    * @deprecated This method is deprecated in favor of {@link updateCurrentTabs} and will be removed in a future release.
    */
-    State.prototype.udateCurrentTabsUrl = function (urls) {
+    udateCurrentTabsUrl(urls) {
         this.updateCurrentTabsUrl(urls);
-    };
-    State.prototype.updateCurrentTabsUrl = function (urls) {
-        var _this = this;
-        var connectedTabs = urls.map(function (url) {
-            var strippedUrl = '';
+    }
+    updateCurrentTabsUrl(urls) {
+        const connectedTabs = urls.map((url) => {
+            let strippedUrl = '';
             // the assert in stripUrl may throw for new tabs with "chrome://newtab/"
             try {
-                strippedUrl = _this.stripUrl(url);
+                strippedUrl = this.stripUrl(url);
             }
             catch (e) {
                 console.error(e);
             }
             // return the stripped url only if this website is known
-            return !!strippedUrl && _this.authUrls[strippedUrl]
+            return !!strippedUrl && this.authUrls[strippedUrl]
                 ? strippedUrl
                 : undefined;
         })
-            .filter(function (value) { return !!value; });
-        __classPrivateFieldSet(this, _State_connectedTabsUrl, connectedTabs, "f");
-    };
-    State.prototype.getConnectedTabsUrl = function () {
-        return __classPrivateFieldGet(this, _State_connectedTabsUrl, "f");
-    };
-    State.prototype.deleteAuthRequest = function (requestId) {
-        delete __classPrivateFieldGet(this, _State_authRequests, "f")[requestId];
+            .filter((value) => !!value);
+        this.#connectedTabsUrl = connectedTabs;
+    }
+    getConnectedTabsUrl() {
+        return this.#connectedTabsUrl;
+    }
+    deleteAuthRequest(requestId) {
+        delete this.#authRequests[requestId];
         this.updateIconAuth(true);
+    }
+    async saveCurrentAuthList() {
+        await chrome.storage.local.set({ [AUTH_URLS_KEY]: JSON.stringify(Object.fromEntries(this.#authUrls)) });
+    }
+    async saveDefaultAuthAccounts() {
+        await chrome.storage.local.set({ [DEFAULT_AUTH_ACCOUNTS]: JSON.stringify(this.defaultAuthAccountSelection) });
+    }
+    async updateDefaultAuthAccounts(newList) {
+        this.defaultAuthAccountSelection = newList;
+        await this.saveDefaultAuthAccounts();
+    }
+    metaComplete = (id, resolve, reject) => {
+        const complete = () => {
+            delete this.#metaRequests[id];
+            this.updateIconMeta(true);
+        };
+        return {
+            reject: (error) => {
+                complete();
+                reject(error);
+            },
+            resolve: (result) => {
+                complete();
+                resolve(result);
+            }
+        };
     };
-    State.prototype.saveCurrentAuthList = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0: return [4 /*yield*/, chrome.storage.local.set((_a = {}, _a[AUTH_URLS_KEY] = JSON.stringify(Object.fromEntries(__classPrivateFieldGet(this, _State_authUrls, "f"))), _a))];
-                    case 1:
-                        _b.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    State.prototype.saveDefaultAuthAccounts = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0: return [4 /*yield*/, chrome.storage.local.set((_a = {}, _a[DEFAULT_AUTH_ACCOUNTS] = JSON.stringify(this.defaultAuthAccountSelection), _a))];
-                    case 1:
-                        _b.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    State.prototype.updateDefaultAuthAccounts = function (newList) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        this.defaultAuthAccountSelection = newList;
-                        return [4 /*yield*/, this.saveDefaultAuthAccounts()];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
+    signComplete = (id, resolve, reject) => {
+        const complete = () => {
+            delete this.#signRequests[id];
+            this.updateIconSign(true);
+        };
+        return {
+            reject: (error) => {
+                complete();
+                reject(error);
+            },
+            resolve: (result) => {
+                complete();
+                resolve(result);
+            }
+        };
     };
-    State.prototype.stripUrl = function (url) {
+    stripUrl(url) {
         try {
-            var parsedUrl = new URL(url);
+            const parsedUrl = new URL(url);
             if (!['http:', 'https:', 'ipfs:', 'ipns:'].includes(parsedUrl.protocol)) {
-                throw new Error("Invalid protocol ".concat(parsedUrl.protocol));
+                throw new Error(`Invalid protocol ${parsedUrl.protocol}`);
             }
             // For ipfs/ipns which don't have a standard origin, we handle it differently.
             if (parsedUrl.protocol === 'ipfs:' || parsedUrl.protocol === 'ipns:') {
                 // ipfs://<hash> | ipns://<hash>
-                return "".concat(parsedUrl.protocol, "//").concat(parsedUrl.hostname);
+                return `${parsedUrl.protocol}//${parsedUrl.hostname}`;
             }
             return parsedUrl.origin;
         }
@@ -510,223 +282,197 @@ var State = /** @class */ (function () {
             console.error(e);
             throw new Error('Invalid URL');
         }
-    };
-    State.prototype.updateIcon = function (shouldClose) {
-        var authCount = this.numAuthRequests;
-        var metaCount = this.numMetaRequests;
-        var signCount = this.numSignRequests;
-        var text = (authCount
+    }
+    updateIcon(shouldClose) {
+        const authCount = this.numAuthRequests;
+        const metaCount = this.numMetaRequests;
+        const signCount = this.numSignRequests;
+        const text = (authCount
             ? 'Auth'
             : metaCount
                 ? 'Meta'
-                : (signCount ? "".concat(signCount) : ''));
-        withErrorLog(function () { return chrome.action.setBadgeText({ text: text }); });
+                : (signCount ? `${signCount}` : ''));
+        withErrorLog(() => chrome.action.setBadgeText({ text }));
         if (shouldClose && text === '') {
             this.popupClose();
         }
-    };
-    State.prototype.removeAuthorization = function (url) {
-        return __awaiter(this, void 0, void 0, function () {
-            var entry;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        entry = __classPrivateFieldGet(this, _State_authUrls, "f").get(url);
-                        assert(entry, "The source ".concat(url, " is not known"));
-                        __classPrivateFieldGet(this, _State_authUrls, "f").delete(url);
-                        return [4 /*yield*/, this.saveCurrentAuthList()];
-                    case 1:
-                        _a.sent();
-                        if (this.authUrlSubjects[url]) {
-                            entry.authorizedAccounts = [];
-                            this.authUrlSubjects[url].next(entry);
-                        }
-                        return [2 /*return*/, this.authUrls];
-                }
-            });
-        });
-    };
-    State.prototype.updateIconAuth = function (shouldClose) {
+    }
+    async removeAuthorization(url) {
+        const entry = this.#authUrls.get(url);
+        assert(entry, `The source ${url} is not known`);
+        this.#authUrls.delete(url);
+        await this.saveCurrentAuthList();
+        if (this.authUrlSubjects[url]) {
+            entry.authorizedAccounts = [];
+            this.authUrlSubjects[url].next(entry);
+        }
+        return this.authUrls;
+    }
+    updateIconAuth(shouldClose) {
         this.authSubject.next(this.allAuthRequests);
         this.updateIcon(shouldClose);
-    };
-    State.prototype.updateIconMeta = function (shouldClose) {
+    }
+    updateIconMeta(shouldClose) {
         this.metaSubject.next(this.allMetaRequests);
         this.updateIcon(shouldClose);
-    };
-    State.prototype.updateIconSign = function (shouldClose) {
+    }
+    updateIconSign(shouldClose) {
         this.signSubject.next(this.allSignRequests);
         this.updateIcon(shouldClose);
-    };
-    State.prototype.updateAuthorizedAccounts = function (authorizedAccountsDiff) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        authorizedAccountsDiff.forEach(function (_a) {
-                            var url = _a[0], authorizedAccountDiff = _a[1];
-                            var authInfo = __classPrivateFieldGet(_this, _State_authUrls, "f").get(url);
-                            if (authInfo) {
-                                authInfo.authorizedAccounts = authorizedAccountDiff;
-                                __classPrivateFieldGet(_this, _State_authUrls, "f").set(url, authInfo);
-                                _this.authUrlSubjects[url].next(authInfo);
-                            }
-                        });
-                        return [4 /*yield*/, this.saveCurrentAuthList()];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
+    }
+    async updateAuthorizedAccounts(authorizedAccountsDiff) {
+        authorizedAccountsDiff.forEach(([url, authorizedAccountDiff]) => {
+            const authInfo = this.#authUrls.get(url);
+            if (authInfo) {
+                authInfo.authorizedAccounts = authorizedAccountDiff;
+                this.#authUrls.set(url, authInfo);
+                this.authUrlSubjects[url].next(authInfo);
+            }
         });
-    };
-    State.prototype.authorizeUrl = function (url, request) {
-        return __awaiter(this, void 0, void 0, function () {
-            var idStr, isDuplicate, authInfo;
-            var _this = this;
-            return __generator(this, function (_a) {
-                idStr = this.stripUrl(url);
-                isDuplicate = Object
-                    .values(__classPrivateFieldGet(this, _State_authRequests, "f"))
-                    .some(function (request) { return request.idStr === idStr; });
-                assert(!isDuplicate, "The source ".concat(url, " has a pending authorization request"));
-                if (__classPrivateFieldGet(this, _State_authUrls, "f").has(idStr)) {
-                    authInfo = __classPrivateFieldGet(this, _State_authUrls, "f").get(idStr);
-                    assert((authInfo === null || authInfo === void 0 ? void 0 : authInfo.authorizedAccounts) || (authInfo === null || authInfo === void 0 ? void 0 : authInfo.isAllowed), "The source ".concat(url, " is not allowed to interact with this extension"));
-                    return [2 /*return*/, {
-                            authorizedAccounts: [],
-                            result: false
-                        }];
-                }
-                return [2 /*return*/, new Promise(function (resolve, reject) {
-                        var id = getId();
-                        __classPrivateFieldGet(_this, _State_authRequests, "f")[id] = __assign(__assign({}, _this.authComplete(id, resolve, reject)), { id: id, idStr: idStr, request: request, url: url });
-                        _this.updateIconAuth();
-                        _this.popupOpen();
-                    })];
-            });
+        await this.saveCurrentAuthList();
+    }
+    async authorizeUrl(url, request) {
+        const idStr = this.stripUrl(url);
+        // Do not enqueue duplicate authorization requests.
+        const isDuplicate = Object
+            .values(this.#authRequests)
+            .some((request) => request.idStr === idStr);
+        assert(!isDuplicate, `The source ${url} has a pending authorization request`);
+        if (this.#authUrls.has(idStr)) {
+            // this url was seen in the past
+            const authInfo = this.#authUrls.get(idStr);
+            assert(authInfo?.authorizedAccounts || authInfo?.isAllowed, `The source ${url} is not allowed to interact with this extension`);
+            return {
+                authorizedAccounts: [],
+                result: false
+            };
+        }
+        return new Promise((resolve, reject) => {
+            const id = getId();
+            this.#authRequests[id] = {
+                ...this.authComplete(id, resolve, reject),
+                id,
+                idStr,
+                request,
+                url
+            };
+            this.updateIconAuth();
+            this.popupOpen();
         });
-    };
-    State.prototype.ensureUrlAuthorized = function (url) {
-        var entry = __classPrivateFieldGet(this, _State_authUrls, "f").get(this.stripUrl(url));
-        assert(entry, "The source ".concat(url, " has not been enabled yet"));
+    }
+    ensureUrlAuthorized(url) {
+        const entry = this.#authUrls.get(this.stripUrl(url));
+        assert(entry, `The source ${url} has not been enabled yet`);
         return true;
-    };
-    State.prototype.injectMetadata = function (url, request) {
-        var _this = this;
-        return new Promise(function (resolve, reject) {
-            var id = getId();
-            __classPrivateFieldGet(_this, _State_metaRequests, "f")[id] = __assign(__assign({}, _this.metaComplete(id, resolve, reject)), { id: id, request: request, url: url });
-            _this.updateIconMeta();
-            _this.popupOpen();
+    }
+    injectMetadata(url, request) {
+        return new Promise((resolve, reject) => {
+            const id = getId();
+            this.#metaRequests[id] = {
+                ...this.metaComplete(id, resolve, reject),
+                id,
+                request,
+                url
+            };
+            this.updateIconMeta();
+            this.popupOpen();
         });
-    };
-    State.prototype.getAuthRequest = function (id) {
-        return __classPrivateFieldGet(this, _State_authRequests, "f")[id];
-    };
-    State.prototype.getMetaRequest = function (id) {
-        return __classPrivateFieldGet(this, _State_metaRequests, "f")[id];
-    };
-    State.prototype.getSignRequest = function (id) {
-        return __classPrivateFieldGet(this, _State_signRequests, "f")[id];
-    };
+    }
+    getAuthRequest(id) {
+        return this.#authRequests[id];
+    }
+    getMetaRequest(id) {
+        return this.#metaRequests[id];
+    }
+    getSignRequest(id) {
+        return this.#signRequests[id];
+    }
     // List all providers the extension is exposing
-    State.prototype.rpcListProviders = function () {
-        var _this = this;
-        return Promise.resolve(Object.keys(__classPrivateFieldGet(this, _State_providers, "f")).reduce(function (acc, key) {
-            acc[key] = __classPrivateFieldGet(_this, _State_providers, "f")[key].meta;
+    rpcListProviders() {
+        return Promise.resolve(Object.keys(this.#providers).reduce((acc, key) => {
+            acc[key] = this.#providers[key].meta;
             return acc;
         }, {}));
-    };
-    State.prototype.rpcSend = function (request, port) {
-        var provider = __classPrivateFieldGet(this, _State_injectedProviders, "f").get(port);
+    }
+    rpcSend(request, port) {
+        const provider = this.#injectedProviders.get(port);
         assert(provider, 'Cannot call pub(rpc.subscribe) before provider is set');
         return provider.send(request.method, request.params);
-    };
+    }
     // Start a provider, return its meta
-    State.prototype.rpcStartProvider = function (key, port) {
-        var _this = this;
-        assert(Object.keys(__classPrivateFieldGet(this, _State_providers, "f")).includes(key), "Provider ".concat(key, " is not exposed by extension"));
-        if (__classPrivateFieldGet(this, _State_injectedProviders, "f").get(port)) {
-            return Promise.resolve(__classPrivateFieldGet(this, _State_providers, "f")[key].meta);
+    rpcStartProvider(key, port) {
+        assert(Object.keys(this.#providers).includes(key), `Provider ${key} is not exposed by extension`);
+        if (this.#injectedProviders.get(port)) {
+            return Promise.resolve(this.#providers[key].meta);
         }
         // Instantiate the provider
-        __classPrivateFieldGet(this, _State_injectedProviders, "f").set(port, __classPrivateFieldGet(this, _State_providers, "f")[key].start());
+        this.#injectedProviders.set(port, this.#providers[key].start());
         // Close provider connection when page is closed
-        port.onDisconnect.addListener(function () {
-            var provider = __classPrivateFieldGet(_this, _State_injectedProviders, "f").get(port);
+        port.onDisconnect.addListener(() => {
+            const provider = this.#injectedProviders.get(port);
             if (provider) {
-                withErrorLog(function () { return provider.disconnect(); });
+                withErrorLog(() => provider.disconnect());
             }
-            __classPrivateFieldGet(_this, _State_injectedProviders, "f").delete(port);
+            this.#injectedProviders.delete(port);
         });
-        return Promise.resolve(__classPrivateFieldGet(this, _State_providers, "f")[key].meta);
-    };
-    State.prototype.rpcSubscribe = function (_a, cb, port) {
-        var method = _a.method, params = _a.params, type = _a.type;
-        var provider = __classPrivateFieldGet(this, _State_injectedProviders, "f").get(port);
+        return Promise.resolve(this.#providers[key].meta);
+    }
+    rpcSubscribe({ method, params, type }, cb, port) {
+        const provider = this.#injectedProviders.get(port);
         assert(provider, 'Cannot call pub(rpc.subscribe) before provider is set');
         return provider.subscribe(type, method, params, cb);
-    };
-    State.prototype.rpcSubscribeConnected = function (_request, cb, port) {
-        var provider = __classPrivateFieldGet(this, _State_injectedProviders, "f").get(port);
+    }
+    rpcSubscribeConnected(_request, cb, port) {
+        const provider = this.#injectedProviders.get(port);
         assert(provider, 'Cannot call pub(rpc.subscribeConnected) before provider is set');
         cb(null, provider.isConnected); // Immediately send back current isConnected
-        provider.on('connected', function () { return cb(null, true); });
-        provider.on('disconnected', function () { return cb(null, false); });
-    };
-    State.prototype.rpcUnsubscribe = function (request, port) {
-        var provider = __classPrivateFieldGet(this, _State_injectedProviders, "f").get(port);
+        provider.on('connected', () => cb(null, true));
+        provider.on('disconnected', () => cb(null, false));
+    }
+    rpcUnsubscribe(request, port) {
+        const provider = this.#injectedProviders.get(port);
         assert(provider, 'Cannot call pub(rpc.unsubscribe) before provider is set');
         return provider.unsubscribe(request.type, request.method, request.subscriptionId);
-    };
-    State.prototype.saveMetadata = function (meta) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, __classPrivateFieldGet(this, _State_metaStore, "f").set(meta.genesisHash, meta)];
-                    case 1:
-                        _a.sent();
-                        addMetadata(meta);
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    State.prototype.setNotification = function (notification) {
-        __classPrivateFieldSet(this, _State_notification, notification, "f");
+    }
+    async saveMetadata(meta) {
+        await this.#metaStore.set(meta.genesisHash, meta);
+        addMetadata(meta);
+    }
+    setNotification(notification) {
+        this.#notification = notification;
         return true;
-    };
-    State.prototype.handleSignRequest = function (origin) {
-        var now = Date.now();
-        var lastTime = __classPrivateFieldGet(this, _State_lastRequestTimestamps, "f").get(origin) || 0;
-        if (now - lastTime < __classPrivateFieldGet(this, _State_rateLimitInterval, "f")) {
+    }
+    handleSignRequest(origin) {
+        const now = Date.now();
+        const lastTime = this.#lastRequestTimestamps.get(origin) || 0;
+        if (now - lastTime < this.#rateLimitInterval) {
             throw new Error('Rate limit exceeded. Try again later.');
         }
         // If we're about to exceed max entries, evict the oldest
-        if (!__classPrivateFieldGet(this, _State_lastRequestTimestamps, "f").has(origin) && __classPrivateFieldGet(this, _State_lastRequestTimestamps, "f").size >= __classPrivateFieldGet(this, _State_maxEntries, "f")) {
-            var oldestKey = __classPrivateFieldGet(this, _State_lastRequestTimestamps, "f").keys().next().value;
-            oldestKey && __classPrivateFieldGet(this, _State_lastRequestTimestamps, "f").delete(oldestKey);
+        if (!this.#lastRequestTimestamps.has(origin) && this.#lastRequestTimestamps.size >= this.#maxEntries) {
+            const oldestKey = this.#lastRequestTimestamps.keys().next().value;
+            oldestKey && this.#lastRequestTimestamps.delete(oldestKey);
         }
-        __classPrivateFieldGet(this, _State_lastRequestTimestamps, "f").set(origin, now);
-    };
-    State.prototype.sign = function (url, request, account) {
-        var _this = this;
-        var id = getId();
+        this.#lastRequestTimestamps.set(origin, now);
+    }
+    sign(url, request, account) {
+        const id = getId();
         try {
             this.handleSignRequest(url);
         }
         catch (error) {
             return Promise.reject(error);
         }
-        return new Promise(function (resolve, reject) {
-            __classPrivateFieldGet(_this, _State_signRequests, "f")[id] = __assign(__assign({}, _this.signComplete(id, resolve, reject)), { account: account, id: id, request: request, url: url });
-            _this.updateIconSign();
-            _this.popupOpen();
+        return new Promise((resolve, reject) => {
+            this.#signRequests[id] = {
+                ...this.signComplete(id, resolve, reject),
+                account,
+                id,
+                request,
+                url
+            };
+            this.updateIconSign();
+            this.popupOpen();
         });
-    };
-    return State;
-}());
-_State_authUrls = new WeakMap(), _State_lastRequestTimestamps = new WeakMap(), _State_maxEntries = new WeakMap(), _State_rateLimitInterval = new WeakMap(), _State_authRequests = new WeakMap(), _State_metaStore = new WeakMap(), _State_injectedProviders = new WeakMap(), _State_metaRequests = new WeakMap(), _State_notification = new WeakMap(), _State_providers = new WeakMap(), _State_signRequests = new WeakMap(), _State_windows = new WeakMap(), _State_connectedTabsUrl = new WeakMap();
-export default State;
+    }
+}